{"id":"doc:data-surfaces:0000","source":"doc","sourceId":"data-surfaces.md","title":"Alloy data surfaces — full upstream reference","text":"Detailed, honesty-doctrine-annotated reference for every REPORTED pass-through block served by the api-server. Every value is passed through EXACTLY as the upstream states it; missing values are `null`, failed blocks are `UNAVAILABLE` — never invented. Summary lives in `replit.md`; this file is the full detail.\n\n**Lineage** — the probe-history uptime bars (`/backbone/mesh/history`), the DECLARED price table + ESTIMATED cost path, the RunConsole routing waterfall, and the signed chain checkpoint (`/receipts/checkpoint`) are adapted from the public state of the art — status-page history bars (Stripe/Vercel/GitHub status), LLM-gateway price tables (OpenRouter/LiteLLM), observability trace latency waterfalls (LangSmith/Langfuse/Helicone/Braintrust), and transparency-log signed checkpoints (Sigstore/CT/Merkle) — reimplemented under Alloy's own honesty doctrine: MEASURED/DECLARED labels, counts = enumerated rows only, official sources cited, and nothing fabricated (a missing price or probe is honest silence, never a placeholder).","sha256":"829ff0d0aeadc23e3b726e6e328975add9a6a4ef7ceb1869659b0f455305e54b"}
{"id":"doc:data-surfaces:0001","source":"doc","sourceId":"data-surfaces.md","title":"`GET /frontier` (`src/routes/frontier.ts`)","text":"fetchFrontier fans out 77 blocks in parallel; per-block honest `UNAVAILABLE`; 10-min cache only when ALL blocks OK, else 30s; 20/min rate limit. All upstreams KEYLESS except where a token honestly improves egress (noted). Blocks 21–76 live in self-contained modules under `src/routes/frontierBlocks/` (shared helpers in `frontierBlocks/shared.ts` — incl. `decodeEntities()`, format-only HTML-entity decode).\n\n1. **Model lists** — Hugging Face model lists (`trending`/`downloads` global + `sovereign` = SZLHOLDINGS's own models).\n   - **`sovereignEvalAssets`** (REPORTED sub-block of the sovereign block) — KEYLESS HF `api/datasets?author=SZLHOLDINGS`, filtered to dataset ids matching `eval|bench|runs` (the estate's OWN eval/benchmark/run-log datasets, e.g. `k-verify-benchmark-v1` / `alloy-sovereign-eval-runs` / `energy-attested-runs`), passed through EXACTLY (id/downloads/lastModified/url, links to the real hf.co/datasets page); honest `UNAVAILABLE` on fetch failure. Shares the /frontier cache policy (10-min cache only when ALL blocks OK, else 30s; 20/min rate limit). Rendered in FrontierRadar's sovereign block so the \"we measure our own runs\" story sits beside the models (the models themselves carry no measured numbers — those stay UNKNOWN until the eval harness runs on metal).\n2. **Data frontier** — HF dataset lists (`trending`/`downloads`, keyless; id/downloads/likes/lastModified, links to the real hf.co/datasets page).\n3. **Code frontier** — GitHub repo search (`topic:llm`, sort=stars; sends `GITHUB_TOKEN` when present because anon GitHub search 403s from this egress, keyless fallback preserved) + GitLab public project search (keyless; `language` honestly left `null`, not guessed).\n4. **Publications frontier** — KEYLESS OpenAlex API (`filter=title_and_abstract.search`, capped at server-today via `to_publication_date` so forward-dated records don't leak into a newest-first view, deduped by title, trimmed to 8).","sha256":"38e43cfbbfc0944b214f960619a63637bd4df1d03fa0ac02d70d1d2576f5d82e"}
{"id":"doc:data-surfaces:0002","source":"doc","sourceId":"data-surfaces.md","title":"`GET /frontier` (`src/routes/frontier.ts`)","text":"5. **Preprint frontier** — KEYLESS arXiv Atom API (`cat:cs.CL OR cs.AI OR cs.LG`, `sortBy=submittedDate` desc, parsed with `fast-xml-parser`, trimmed to 8; abs ids normalised http→https, `primaryCategory` is arXiv's own and may cross-list outside the queried cats).\n6. **Signal frontier** — KEYLESS Hacker News Algolia API (`search_by_date?query=LLM&tags=story`, gated to the last 7 days + `points>30` so it's real signal not brand-new noise; Ask/Show text posts fall back to the HN item url).\n7. **Router frontier** — KEYLESS OpenRouter model catalog (`openrouter.ai/api/v1/models`, sorted newest-first by `created` unix→ISO, trimmed to 8; `context_length` + `pricing.prompt` passed through EXACTLY as REPORTED — the prompt price is a raw USD-per-token string, never converted, `contextLength`/`promptPrice` honestly `null` when absent, links to the real openrouter.ai/models page).\n8. **Formula codex** — szl-formula-ledger (`raw.githubusercontent.com`, formula statuses passed through EXACTLY — Λ = Conjecture-1, never \"proven\").\n9. **Thesis frontier** — the owner's own `szl-holdings/szl-papers` corpus (KEYLESS `raw.githubusercontent.com` README index; shape-based markdown-table parser `parseThesisIndex()` extracts author/ORCID, DOI-pinned Zenodo papers, arXiv packages honestly carried as `status: \"Submission-ready\"` — NOT posted to arXiv, so no live abs id is fabricated — the Ouroboros lineage v22→v26 with repo-tree links, and the umbrella concept DOI; block is `UNAVAILABLE` when `papers.length === 0` so a broken index shows nothing rather than a hollow corpus).\n10. **Frontier leaders** — 50 curated companies (18 Western AI labs + 14 Chinese frontier labs + 6 regional/national labs UAE·Japan·Korea·Israel + 3 sovereign Russia·Ukraine labs + 2 open-drone-autonomy projects [ArduPilot/PX4·Dronecode — open flight-control SOFTWARE only, NOT weapons, hf=NOT_TRACKED] + 5 defense-tech [incl. Skydio — drone-autonomy defense supplier, public GitHub is SDK/tooling only, autonomy proprietary] + 2 AI-for-science research institutes [Polymathic AI · Flatiron Institute — the doctrinal home of the agentic constrained-search approach; Flatiron has no HF org so hf=NOT_TRACKED]) via KEYLESS GitHub org REST (`/orgs/{org}` + `/orgs/{org}/repos?sort=pushed`, deliberately NOT the search API — sends `GITHUB_TOKEN` when present because anon org calls 403 from this egress, keyless fallback preserved) for repo count + latest-pushed repo, plus each company's top HF org model where one is tracked. Per-company EXPLICIT tri-state — github OK/UNAVAILABLE, hf OK/UNAVAILABLE/**NOT_TRACKED** (defense-tech + closed-weight labs like Anthropic publish no open weights, shown honestly as code-only, never credited with weights they don't publish; a reachable-but-empty HF org is honest OK + null topModel, distinct from UNAVAILABLE). Block is `UNAVAILABLE` only when EVERY company's GitHub fetch fails — individual failures degrade per-company; links to the real github.com/{org} + huggingface.co/{org} pages. The 50 orgs fan out with bounded concurrency (≤6, `mapWithConcurrency`) to avoid GitHub *secondary* (abuse) rate limits, and leaders has its OWN independent cache (`getLeaders()` wrapper / `leadersCache`: 10-min all-OK, 5-min degraded, NEVER the 30s negative window) so the 50-org fan-out can't collapse the whole /frontier cache under GitHub's hourly ceiling when a sibling block fails; leaders still contributes its block-level `leaders.status === \"OK\"` to the /frontier `allOk`.","sha256":"6cbcf9e6281c3f204f26a94eb746dfd41a3ed2bbc61e98755867e6a48fb50a85"}
{"id":"doc:data-surfaces:0003","source":"doc","sourceId":"data-surfaces.md","title":"`GET /frontier` (`src/routes/frontier.ts`)","text":"11. **Biomed frontier** — KEYLESS Europe PMC REST API (`webservices/rest/search`, `AI/ML in life sciences`, `sort=P_PDATE_D` newest-first, format=json, trimmed to 8; per-row id/title/url(doi.org when a DOI exists else europepmc.org/article/{source}/{id})/authors/source(venue)/pubYear/publishedDate/doi passed through EXACTLY, missing values `null`, never invented).\n12. **Curated-papers frontier** — KEYLESS Hugging Face daily papers feed (`api/daily_papers?limit=12`, community-curated + upvoted; per-row arXiv id/title/upvotes(REPORTED)/publishedAt passed through EXACTLY, link is the real hf.co/papers/{id} page, trimmed to 8).\n13. **Research-artifact frontier** — KEYLESS Zenodo API (`api/records?q=\"large language model\"&sort=newest`; the query is a QUOTED PHRASE — an unquoted query ORs the common words large/language/model and, sorted newest, floods the list with unrelated newest deposits like geology \"models\" — sorted by DEPOSIT recency so a depositor's forward-dated `publication_date` can't reorder the list, still passed through EXACTLY; per-row id/title/url(record DOI link → doi.org/{doi} → Zenodo record page, never synthesized)/doi/resourceType(Zenodo's own classification)/creators/publicationDate, trimmed to 8).\n14. **Practitioner frontier** — KEYLESS Stack Exchange API (`2.3/questions?order=desc&sort=creation&tagged=llm&site=stackoverflow`, newest first; per-row question_id/title(HTML-entity DECODED via `decodeEntities()` — numeric/hex first, `&` last)/link/score/answer_count/is_answered/creation_date(unix→ISO server-side)/tags passed through EXACTLY, trimmed to 8; SE always gzips, Node fetch/undici auto-decompresses).\n15. **Clinical frontier** — KEYLESS ClinicalTrials.gov v2 API (`api/v2/studies?query.term=\"large language model\"&sort=StudyFirstPostDate:desc`, newest first by the registry's OWN first-posted date; per-row nctId/title/url(the real clinicaltrials.gov/study/{id} page)/overallStatus/postedDate/conditions passed through EXACTLY, trimmed to 8 — a registered trial is a real regulatory artifact, never a claim the intervention works).","sha256":"3a9bf936e98986c9148625e3f832642bc61aabfa02a18a9629beab0686755712"}
{"id":"doc:data-surfaces:0004","source":"doc","sourceId":"data-surfaces.md","title":"`GET /frontier` (`src/routes/frontier.ts`)","text":"16. **Security frontier** — KEYLESS NVD CVE 2.0 API (keywordSearch \"large language model\", last-120-day publication window = NVD's max span, fetched in ONE 2000-row page because NVD's in-window ordering is NOT publication order, then sorted server-side by NVD's OWN `published` desc; per-row id/summary(en)/url(the real nvd.nist.gov/vuln/detail page)/published/cvss(v3.1 preferred, v4.0 fallback, honestly `null` while awaiting analysis — never invented)/severity, trimmed to 8; keyless NVD allows 5 req/30s — one call per cache refresh).\n17. **Funding frontier** — KEYLESS NSF Award Search API (quoted-phrase keyword, `dateStart` = last 365 days, rpp=25; the API exposes NO sort param so rows are sorted server-side by NSF's OWN award date desc; per-row id/title/url(the real nsf.gov/awardsearch page)/awardee/amount(the raw USD string EXACTLY as NSF states it — thousands separators added client-side as formatting only)/date(mm/dd/yyyy→ISO format translation only, null when unparseable), trimmed to 8).\n18. **Tooling frontier** — KEYLESS npm registry search API (`registry.npmjs.org/-/v1/search?text=llm&size=12`, in npm's OWN search ranking — the API exposes no date sort and rows are never re-ranked server-side; per-row name/version/url(registry's own links.npm, canonical npmjs.com page as fallback URL scheme)/description/publisher/date(last-publish EXACTLY as stated)/monthlyDownloads(REPORTED), trimmed to 8).\n19. **Policy frontier** — KEYLESS US Federal Register API (`conditions[term]=\"artificial intelligence\"&order=newest`, the register's OWN newest-first ordering; per-row id(document_number)/title/url(the real federalregister.gov document page)/docType/agencies(names EXACTLY as returned)/publicationDate, trimmed to 8 — a register entry is a real regulatory artifact, never a claim about what a rule will become).","sha256":"9f2d139fdb8319bf74c8f9afd033fab8157b18bab93a65aa03a1b90f86b18313"}
{"id":"doc:data-surfaces:0005","source":"doc","sourceId":"data-surfaces.md","title":"`GET /frontier` (`src/routes/frontier.ts`)","text":"20. **Capital frontier** — SEC EDGAR full-text search (`efts.sec.gov/LATEST/search-index?q=\"artificial intelligence\"&forms=10-K,10-Q,8-K`, startdt/enddt window; KEYLESS but a declared User-Agent with a contact address is REQUIRED — a generic UA is 403'd; EDGAR's in-window order is relevance NOT date AND one call returns at most 100 hits, so the window is PAGINATED with `from=` until EDGAR's own hits.total is exhausted (budget 5 pages = 500 docs, ≤~9 sequential calls per 10-min refresh), then sorted server-side by EDGAR's OWN file_date desc and de-duplicated to one document per filing (accession number); when a window holds more docs than the budget (filing season) the window SHRINKS down the 30→14→7→3→1-day ladder until fully enumerable, and the payload's `windowDays` carries the ACTUAL window so the UI caption never overclaims; per-row id(adsh:filename)/company(display_names pass-through)/form/fileDate/fileType/fileDescription/items(the SEC's OWN 8-K item codes, e.g. \"2.05\" — never our inference from a phrase match)/url(real sec.gov Archives doc URL assembled from EDGAR's own cik+adsh+filename id scheme, spot-verified resolving), trimmed to 8. Same upstream as the verticals `edgar` block but a separate fetch on the frontier cache.)","sha256":"513b8169b563f57dba955e4a78f1aea16928a20fc5292a1db09659e802a379ce"}
{"id":"doc:data-surfaces:0006","source":"doc","sourceId":"data-surfaces.md","title":"`GET /frontier` (`src/routes/frontier.ts`)","text":"21. **Standards frontier** (`frontierBlocks/standards.ts`) — KEYLESS IETF Datatracker API (`/api/v1/doc/document/?title__icontains=artificial+intelligence&order_by=-id`, limit 12 → trimmed to 8; the API REJECTS `order_by=-time` (\"The 'time' field does not allow ordering\") so ordering is by the Datatracker's own document id desc = newest TRACKED first, and the caption says \"newest tracked\" — never \"newest by date\"; per-row id(Datatracker `name`)/title/rev(null when absent)/pages(null when absent)/time(the Datatracker's own last-touch timestamp)/url(datatracker.ietf.org/doc/{name}/ from the Datatracker's own name scheme); `total` = the Datatracker's own meta.total_count, null on UNAVAILABLE).\n22. **Litigation frontier** (`frontierBlocks/litigation.ts`) — CourtListener v4 search API (anonymous works but is rate-limited, declared UA sent; `q=\"artificial intelligence\"&type=o&order_by=dateFiled desc` — CourtListener's OWN newest-filed ordering; ONE request per refresh, NO pagination because the anonymous quota is tight, first page trimmed to 8; per-row id(String(cluster_id))/caseName/court(court_citation_string || court)/dateFiled/docketNumber(null when absent)/url(courtlistener.com + CourtListener's own absolute_url); `total` = CourtListener's own count. NOT legal advice; not affiliated with Free Law Project).\n23. **Attention frontier** (`frontierBlocks/attention.ts`) — KEYLESS Wikimedia Pageviews REST API (per-article daily, `agent=user`, UA required; a DECLARED CURATED set of 8 AI topic pages — Artificial intelligence, ChatGPT, Large language model, OpenAI, Google Gemini, Anthropic, DeepSeek, Hugging Face — fetched SEQUENTIALLY, start=4 days ago → today, the LAST item per article is taken = the latest complete day Wikimedia reports (the API lags ~1 day, NEVER extrapolated); rows stay in curated declaration order — never re-ranked by views; a failed page is ABSENT (never fabricated), ALL-fail → UNAVAILABLE with the real last error; per-row article/views(Wikimedia's own count)/date(from Wikimedia's own timestamp)/url(en.wikipedia.org/wiki/{title})).","sha256":"f053b7cff5d31432514dbb2c5db06ee5ff2b603794f542b74c750781e87b7d6e"}
{"id":"doc:data-surfaces:0007","source":"doc","sourceId":"data-surfaces.md","title":"`GET /frontier` (`src/routes/frontier.ts`)","text":"24. **Demo frontier** (`frontierBlocks/demos.ts`) — KEYLESS Hugging Face Spaces API (`api/spaces?search=llm&sort=createdAt&direction=-1&limit=12`, HF's OWN createdAt-desc ordering; `private !== true` filtered, trimmed to 8; per-row id/sdk(HF's own field, null when omitted)/likes/createdAt/url(huggingface.co/spaces/{id} from HF's own id scheme); the HF list endpoint returns NO total so none is claimed).\n24b. **Trending-Spaces frontier** (`frontierBlocks/hftrending.ts`, response key `hfTrending`) — KEYLESS Hugging Face Spaces API (`api/spaces?sort=trendingScore&direction=-1&limit=12`, HF's OWN trendingScore-desc ordering — their momentum signal, a DIFFERENT lens than the newest-LLM demos block (#24), the two named apart `HF_TRENDING_SOURCE` vs `HF_SPACES_SOURCE` so their source links never collide; `private !== true` filtered, trimmed to 8; per-row id/sdk(HF's own field, null when omitted)/likes/trendingScore(HF's OWN momentum number, passed through, NEVER computed here, null when HF omits it)/createdAt(null when omitted)/url(huggingface.co/spaces/{id} from HF's own id scheme); the HF list endpoint returns NO total so none is claimed; caption \"trending now · HF trendingScore\"). Client: `HfTrendingGroup` under the shared \"Demo frontier\" section, after `DemosGroup`.\n25. **Health-grants frontier** (`frontierBlocks/grants.ts`) — KEYLESS NIH RePORTER v2 API (POST `/v2/projects/search`, project-title phrase \"artificial intelligence\", limit 12; the response meta flags `sorted_by_relevance:true` EVEN with `sort_field` set, so rows are re-sorted server-side by NIH's OWN `project_start_date` desc — the upstream's own field, never our ranking — null start dates last, trimmed to 8; local POST-JSON helper because `shared.ts fetchJson` is GET-only; per-row id(String(appl_id))/title/organization(org_name, null when absent)/startDate(NIH's own, passed through even when future-dated — NIH's scheduled starts)/amount(NIH's own award_amount integer, null when omitted — display separators are client-side formatting only)/projectNum/url(reporter.nih.gov/project-details/{appl_id} from NIH's own id scheme); `total` = NIH's own meta.total).","sha256":"e746fe818ae13a0b433ef3f1812c18ce2a88a10e8fbed81cede8411647f04c5f"}
{"id":"doc:data-surfaces:0008","source":"doc","sourceId":"data-surfaces.md","title":"`GET /frontier` (`src/routes/frontier.ts`)","text":"26. **Crates frontier** (`frontierBlocks/crates.ts`) — KEYLESS crates.io API (`/api/v1/crates?q=llm&sort=new&per_page=12`, a declared User-Agent is REQUIRED; sort=new = the registry's OWN newest-created ordering, never re-ranked, trimmed to 8; per-row id/name/description(null when absent)/version(newest_version, null when absent)/downloads(registry's own all-time count, null when absent; genuine 0 shown as 0, only null shows \"—\")/createdAt/url(crates.io/crates/{id} from the registry's own id scheme); `total` = the registry's own meta.total).\n27. **Books frontier** (`frontierBlocks/books.ts`) — KEYLESS Open Library search API (`search.json?q=artificial+intelligence&sort=new&limit=12&fields=key,title,author_name,first_publish_year`; sort=new is Open Library's OWN newest-first ordering, never re-ranked, trimmed to 8; per-row id(work key)/title/authors(author_name array, EMPTY when absent — never \"Unknown author\")/firstPublishYear(null when absent)/url(openlibrary.org{key} from Open Library's own key scheme); `total` = Open Library's own numFound, captioned \"matches\").\n28. **Audio frontier** (`frontierBlocks/audio.ts`) — KEYLESS iTunes Search API (`itunes.apple.com/search?term=artificial+intelligence&media=podcast&limit=12`; Apple's search is RELEVANCE-ranked and resultCount is just the page size, so NO total exists in the schema and none is EVER claimed; rows are the top-matching set sorted server-side by Apple's OWN `releaseDate` (latest-episode timestamp) desc, nulls last, trimmed to 8, and the caption says \"top-matching · by latest episode\" — NEVER \"newest podcasts\"; per-row id(String(collectionId))/name/artist(null when absent)/latestRelease(Apple's own releaseDate, null when absent)/episodes(trackCount, null when absent)/url(Apple's own collectionViewUrl — rows missing it are skipped, never synthesized)).","sha256":"adaf24bcdbe6d4e89ec36cab03608bf200712741988dc1603a975bb93f0403f0"}
{"id":"doc:data-surfaces:0009","source":"doc","sourceId":"data-surfaces.md","title":"`GET /frontier` (`src/routes/frontier.ts`)","text":"29. **UK-government frontier** (`frontierBlocks/govuk.ts`) — KEYLESS GOV.UK Search API (`www.gov.uk/api/search.json?q=\"artificial intelligence\"&order=-public_timestamp&count=12&fields=…`; `order=-public_timestamp` IS GOV.UK's own ordering and public_timestamp is the LAST-SIGNIFICANT-UPDATE time (not first publication), never re-ranked, trimmed to 8; caption \"newest updated\" — never \"newest published\"; per-row id(GOV.UK's own link path)/title/docType(content_store_document_type, null when absent)/organisation(first organisations[] acronym || title, null when absent)/publishedAt(public_timestamp passed through verbatim — even when GOV.UK forward-dates it)/url(`https://www.gov.uk{link}` from GOV.UK's own link scheme); rows missing title or link are skipped; `total` = GOV.UK's own total).\n30. **Extensions frontier** (`frontierBlocks/extensions.ts`) — KEYLESS Visual Studio Marketplace gallery API (POST `extensionquery`, Accept `api-version=3.0-preview.1`, criteria \"llm\" + VS Code target, `sortBy=10` (PublishedDate) `sortOrder=2` (desc) = the Marketplace's OWN newest-published ordering, `flags=914` for statistics; local POST-JSON helper because `shared.ts fetchJson` is GET-only; caption \"newest published\"; per-row id(publisherName.extensionName)/name(displayName || extensionName)/publisher/installs(the Marketplace's own `install` statistic, Math.trunc, null when absent — genuine 0 stays 0)/publishedAt(publishedDate, null when absent)/url(`marketplace.visualstudio.com/items?itemName={id}` — the Marketplace's own itemName scheme); rows missing publisher or extensionName are skipped; `total` = the Marketplace's own resultMetadata TotalCount — NOTE it nests under `resultMetadata[].metadataItems[]`, null when absent, never a page size).\n31. **Images frontier** (`frontierBlocks/images.ts`) — KEYLESS Docker Hub search API (`hub.docker.com/v2/search/repositories/?query=llm&page_size=12`, declared UA required; the rows carry NO date fields (only repo_name/short_description/star_count/pull_count/is_official) and the order is the registry's OWN search ranking — never re-ranked by us (no stars/pulls sort), trimmed to 8, and the caption says \"top-matching · registry's own search ranking\" — NEVER \"newest\"; per-row id+name(repo_name)/description(short_description, \"\"→null)/stars/pulls(genuine 0 shown as 0, null only when absent)/official(is_official)/url(hub.docker.com/_/{name} for official — handles both `library/x` and bare names — else /r/{repo_name}, Docker Hub's own name scheme); rows missing repo_name are skipped; `total` = Docker Hub's own count).","sha256":"c7a3c0fa25a806878abff2be94a6ffbeafcdee83faf7a38b0c09b911fe408f4a"}
{"id":"doc:data-surfaces:0010","source":"doc","sourceId":"data-surfaces.md","title":"`GET /frontier` (`src/routes/frontier.ts`)","text":"32. **Journals frontier** (`frontierBlocks/journals.ts`) — KEYLESS DOAJ search API (`doaj.org/api/search/articles/\"artificial intelligence\"?pageSize=12&sort=created_date:desc`; created_date is the date DOAJ INDEXED the record, NOT the publication date, so the caption says \"newest indexed\" — NEVER \"newest published\"; DOAJ's own ordering, never re-ranked, trimmed to 8; per-row id(DOAJ record id)/title(bibjson.title)/journal(bibjson.journal.title, null when absent)/indexedAt(created_date, null when absent)/url(`doaj.org/article/{id}` from DOAJ's own id scheme — DOI links are never synthesized even though identifiers exist in the response); rows missing id or title are skipped; `total` = DOAJ's own total).\n33. **Development frontier** (`frontierBlocks/worldbank.ts`) — KEYLESS World Bank Documents & Reports API (`search.worldbank.org/api/v3/wds?format=json&qterm=\"artificial intelligence\"&rows=12&srt=docdt&order=desc&fl=…`; the Bank's OWN document-date-descending ordering, never re-ranked, trimmed to 8; matching is FULL-TEXT — most hits merely MENTION AI (procurement plans etc), so the caption says \"newest by document date · full-text AI mentions\" and NEVER claims the docs are AI-focused; NOTE `documents` is an OBJECT keyed `D{id}` (not an array) with a junk `facets` entry — iterated via Object.values, entries missing id/display_title skipped; NOTE the `count` field is the COUNTRY name (misleading key); per-row id/title(display_title, whitespace-normalized)/docType(docty, null when absent)/country(count, null when absent)/date(docdt, null when absent)/url(the Bank's own url, http→https upgraded); `total` = the Bank's own total; source link = the browsable Documents & Reports search UI for the same query/ordering because the API root itself 404s).\n34. **Archive frontier** (`frontierBlocks/archive.ts`) — KEYLESS Internet Archive advancedsearch API (`archive.org/advancedsearch.php?q=\"artificial intelligence\"&sort[]=publicdate+desc&rows=12&output=json`; publicdate is the date the item was ADDED to the archive, so the caption says \"newest added · by archive publicdate\" — NEVER \"newest published\"/\"newest created\"; IA's own ordering, never re-ranked, trimmed to 8; per-row id(identifier)/title(can be missing on rare items — rows missing identifier or title are skipped)/mediatype(null when absent)/addedAt(publicdate, null when absent)/url(`archive.org/details/{identifier}` from IA's own id scheme); `total` = IA's own numFound).","sha256":"ef6e7d671c8261c9ef1ed9f4205fb54b22679371a60055da1d48d650fd22f136"}
{"id":"doc:data-surfaces:0011","source":"doc","sourceId":"data-surfaces.md","title":"`GET /frontier` (`src/routes/frontier.ts`)","text":"35. **Add-ons frontier** (`frontierBlocks/addons.ts`) — KEYLESS Mozilla Add-ons (AMO) search API (`addons.mozilla.org/api/v5/addons/search/?q=llm&sort=created&page_size=12`; sort=created is AMO's OWN newest-created ordering, never re-ranked, trimmed to 8; caption \"newest created · AMO's own ordering\"; NOTE `name` and author names are LOCALIZED objects (`{\"en-US\": …}`) or bare strings — en-US preferred, else first value, never invented; per-row id(String(id))/name/author(authors[0].name, null when absent)/createdAt(created, null when absent)/users(average_daily_users, labelled \"avg daily users\" exactly as AMO states it, null when absent)/url(AMO's own detail-page url); rows missing id, name or url are skipped; `total` = AMO's own count).\n36. **Apps frontier** (`frontierBlocks/apps.ts`) — KEYLESS iTunes Search API (`itunes.apple.com/search?term=AI+assistant&media=software&entity=software&limit=12`; Apple's search is RELEVANCE-ranked and resultCount is just the page size, so NO total exists in the schema and none is EVER claimed (same doctrine as the audio block); rows are the top-matching set sorted server-side by Apple's OWN `currentVersionReleaseDate` desc, nulls last, trimmed to 8, and the caption says \"top-matching · by latest release\" — NEVER \"newest apps\"; per-row id(String(trackId))/name(trackName)/developer(artistName, null when absent)/genre(primaryGenreName, null when absent)/releasedAt(currentVersionReleaseDate, null when absent)/url(Apple's own trackViewUrl — rows missing it are skipped, never synthesized)).\n37. **UK-grants frontier** (`frontierBlocks/ukri.ts`) — KEYLESS UKRI Gateway to Research API (`gtr.ukri.org/gtr/api/projects?q=\"artificial intelligence\"&p=1&s=12&sf=pro.sd&so=D` with vendor header `Accept: application/vnd.rcuk.gtr.json-v7`; the page-size minimum is 10 (s<10 is rejected); `sf=pro.sd&so=D` is GtR's OWN project-start-date-descending ordering — live-verified strictly descending via the FUND-link period, trimmed to 8; matching is FULL-TEXT so rows include projects that merely MENTION AI — caption \"newest by project start date · full-text AI matches\", NEVER \"AI projects\"; NOTE the v7 rows' top-level start/end are NULL — the real fund period is `links.link[rel=\"FUND\"].start/end` in epoch ms, translated FORMAT-only to ISO dates; NOTE the row `created` field is a bulk re-index timestamp identical across rows — never surfaced; FUTURE start dates are real newly-awarded projects, passed through verbatim; titles arrive HTML-entity encoded → `decodeEntities()`; per-row id/title/funder(leadFunder)/category(grantCategory)/status/start/end/url(`gtr.ukri.org/projects?ref={identifiers.identifier[0].value}` — GtR's own grant-reference scheme, rows without a reference are skipped); `total` = GtR's own totalSize).","sha256":"a74fb6c3bb786101c961859d6793208ae23739eca6dd61837636bad8af7c911b"}
{"id":"doc:data-surfaces:0012","source":"doc","sourceId":"data-surfaces.md","title":"`GET /frontier` (`src/routes/frontier.ts`)","text":"38. **Forum frontier** (`frontierBlocks/forum.ts`) — KEYLESS Hugging Face Discourse forum (`discuss.huggingface.co/latest.json?order=created`; the forum's OWN newest-created-topics listing — a real creation-time ordering, caption \"newest created topics\"; trimmed to 8; NO total exists in latest.json so none is EVER claimed (no total field in the schema); per-row id(String(id))/title/createdAt(created_at)/posts(posts_count)/views/url(Discourse's own `/t/{slug}/{id}` canonical scheme — rows missing slug or id are skipped)).\n39. **JVM frontier** (`frontierBlocks/maven.ts`) — KEYLESS Maven Central search API (`search.maven.org/solrsearch/select?q=llm&rows=12&wt=json`; Central OVERRIDES caller sort params with its own dismax ranking (score desc, timestamp tiebreak — live-verified: the response echoes `sort=score desc` regardless of the request), so Central's own order is preserved and the caption says \"top-matching · Maven Central's own ranking\" — NEVER \"newest\" (same doctrine as the Docker Hub images block); trimmed to 8; per-row id(g:a)/group/artifact/latestVersion(null when absent)/updatedAt(Central's own timestamp epoch ms → ISO, format-only, null when absent)/url(`central.sonatype.com/artifact/{g}/{a}` — Sonatype Central's own coordinate scheme); `total` = Central's own numFound).\n40. **Community frontier** (`frontierBlocks/lobsters.ts`) — KEYLESS Lobsters tag feed (`lobste.rs/t/ai.json`; the feed's ordering contract is UNDOCUMENTED so rows are re-sorted server-side by Lobsters' OWN `created_at` desc as a safety net (same doctrine as the NIH grants block), nulls last, trimmed to 8; caption \"newest ai-tagged stories · by story creation date\"; NO total exists in the feed so none is EVER claimed (no total field in the schema); per-row id(short_id)/title/createdAt/score/comments(comment_count)/url(the story's own submitted link, empty for text posts → falls back to Lobsters' own comments_url, both feed-provided — rows with neither are skipped)/commentsUrl).","sha256":"138e1c1278645b3e11380d25820db95b557f7824267315369c0383422039e04a"}
{"id":"doc:data-surfaces:0013","source":"doc","sourceId":"data-surfaces.md","title":"`GET /frontier` (`src/routes/frontier.ts`)","text":"41. **Open-science frontier** (`frontierBlocks/osf.ts`) — KEYLESS OSF (Open Science Framework) API (`api.osf.io/v2/nodes/?filter[title]=artificial intelligence&sort=-date_created&page[size]=12`; `sort=-date_created` is OSF's OWN newest-created ordering, never re-ranked, trimmed to 8; matching is TITLE-only so the caption says \"OSF's own newest-created ordering · title matches\"; per-row id/title/description(null when absent)/category(null when absent)/createdAt(attributes.date_created)/url(OSF's own `links.html` for the node — rows missing id, title or url are skipped, never synthesized); `total` = OSF's own `links.meta.total`).\n42. **Zenodo title-match frontier** (`frontierBlocks/zenodo.ts`) — KEYLESS Zenodo records API (`zenodo.org/api/records?q=title:\"artificial intelligence\"&sort=mostrecent&size=12`, declared UA; the query is a TITLE-field match — `q=title:\"…\"`, not full text — so the caption says \"title matches\"; `sort=mostrecent` is Zenodo's OWN newest-deposit ordering by each record's own `created` timestamp (live-verified strictly descending), never re-ranked, so the caption is \"title matches · Zenodo's own mostrecent sort\"; trimmed to 8; per-row id(DOI, falling back to Zenodo's recid)/title(metadata.title, falling back to top-level title, whitespace-normalized)/url(`links.self_html` — Zenodo's own record page, never synthesized)/doi/resourceType(metadata.resource_type.title, null when absent)/publicationDate(metadata.publication_date, null when absent)/createdAt(record `created` — the deposit timestamp `mostrecent` sorts by)/creators(metadata.creators[].name, empty when absent); rows missing id, title or url are skipped; `total` = Zenodo's own hits.total. NOTE this is a DIFFERENT lens than the research-artifact block (#13), which is full-text \"large language model\" by deposit recency — the two are named apart (`ZENODO_RECENT_SOURCE` vs `ZENODO_SOURCE`) so their source links never collide.","sha256":"d6b25b8ec4d0a4a4fec311f24c5e196b5f73a7d0a3ce4b5fb539cf806c9fb579"}
{"id":"doc:data-surfaces:0014","source":"doc","sourceId":"data-surfaces.md","title":"`GET /frontier` (`src/routes/frontier.ts`)","text":"43. **Crossref frontier** (`frontierBlocks/crossref.ts`) — KEYLESS Crossref REST works API (`api.crossref.org/works?query.title=artificial+intelligence&sort=created&order=desc&rows=12&mailto=ops@a-11-oy.com`, polite-pool mailto + declared UA; `sort=created&order=desc` is Crossref's OWN ordering, live-verified strictly descending by each work's `created.date-time`, never re-ranked; trimmed to 8. CRITICAL HONESTY: Crossref's `created` is the date the DOI was REGISTERED/INDEXED with Crossref — NOT the publication date — so the caption is \"newest indexed · by Crossref created date\", NEVER \"newest published\"; per-row id(DOI)/title(title[0], whitespace-normalized)/url(resource.primary.URL, else the DOI's own resolvable `doi.org/{DOI}` link — the DOI's own scheme, never a synthesized guess)/type(null when absent)/container(container-title[0], null when absent)/publisher(null when absent)/createdAt(created.date-time — the registration timestamp, the sort key); rows missing id, title or url are skipped; `total` = Crossref's own message.total-results — a REPORTED pass-through that varies between calls, never claimed to be exact.\n44. **DataCite frontier** (`frontierBlocks/datacite.ts`) — KEYLESS DataCite REST API (`api.datacite.org/dois?query=titles.title:\"artificial intelligence\"&sort=-created&page[size]=12`, `Accept: application/vnd.api+json` + declared UA; a TITLE-field match; `sort=-created` is DataCite's OWN ordering, live-verified 2026-07-11 strictly descending by each DOI's own `created` timestamp, never re-ranked; trimmed to 8). CRITICAL HONESTY: DataCite's `created` is the date the DOI was REGISTERED with DataCite — NOT the publication date — so the caption is \"newest registered · by DataCite created date\", NEVER \"newest published\". A DIFFERENT registry than the Crossref block (DataCite mints DOIs for datasets/software/preprints; Crossref for journal articles) — a complementary lens, not a duplicate. Per-row id(doi)/title(titles[0].title, whitespace-normalized)/url(DataCite's own `url` attribute, else the DOI's own resolvable `doi.org/{DOI}` link)/publisher(null when absent)/resourceType(types.resourceTypeGeneral, null when absent)/createdAt(the registration timestamp, the sort key); rows missing id, title or url are skipped; `total` = DataCite's own meta.total.","sha256":"71fcab46d3fa55c3a51ca794910720cab289a597b0cb5abc283000c4e0709d2e"}
{"id":"doc:data-surfaces:0015","source":"doc","sourceId":"data-surfaces.md","title":"`GET /frontier` (`src/routes/frontier.ts`)","text":"45. **Westminster frontier** (`frontierBlocks/westminster.ts`) — KEYLESS UK Parliament Bills API (`bills-api.parliament.uk/api/v1/Bills?SearchTerm=artificial intelligence&SortOrder=DateUpdatedDescending&Take=12`; Parliament's OWN DateUpdatedDescending ordering, live-verified descending by each bill's own `lastUpdate`; trimmed to 8). HONESTY: `lastUpdate` is the bill's last-updated timestamp — NOT an introduction or enactment date — captioned \"newest updated · Parliament's own ordering\"; SearchTerm is Parliament's own search so the caption says \"search matches\" without claiming title-only precision; `totalResults` was live-verified 2026-07-11 to be a REAL match total (independent of the Take page size — Take=2 still reported the full count), so it IS claimed as `total`. Per-row id(billId)/title(shortTitle)/url(`bills.parliament.uk/bills/{billId}` — Parliament's own public bill page scheme)/house(currentHouse)/stage(currentStage.description)/isAct/updatedAt; rows missing billId or shortTitle are skipped.\n46. **NuGet frontier** (`frontierBlocks/nuget.ts`) — KEYLESS NuGet search API (`azuresearch-usnc.nuget.org/query?q=llm&take=12&prerelease=false` — the registry's own official search service; trimmed to 8). CRITICAL HONESTY: NuGet search is RELEVANCE-ranked and rows carry NO dates (live-verified 2026-07-11) — captioned \"top-matching · NuGet's own search ranking\", NEVER \"newest\" (the Maven / Docker Hub precedent). Per-row id/url(`nuget.org/packages/{id}` — NuGet's own package page scheme)/version(null when absent)/description(whitespace-normalized, truncated 200 chars, null when absent)/downloads(totalDownloads, null when absent); rows missing id are skipped; `total` = NuGet's own totalHits.\n47. **Hansard frontier** (`frontierBlocks/hansard.ts`) — KEYLESS UK Parliament Hansard search API (`hansard-api.parliament.uk/search/contributions/Spoken.json?queryParameters.searchTerm=\"artificial intelligence\"&queryParameters.take=12&queryParameters.orderBy=SittingDateDesc`; Hansard's OWN SittingDateDesc ordering, live-verified 2026-07-12 descending by each contribution's own SittingDate; trimmed to 8). CRITICAL HONESTY: matches are FULL-TEXT over the SPOKEN CONTRIBUTION TEXT — proven live by matches whose debate titles are unrelated (the phrase appears in what was said, not the title) — captioned \"newest by sitting date · full-text matches in spoken contributions\", never \"AI debates\"; SittingDate is the sitting DAY (no time component). `TotalResultCount` was live-verified to be a REAL match total (identical across take=3 and take=10), so it IS claimed as `total`. Per-row id(ContributionExtId)/member(MemberName)/debate(DebateSection, null when absent)/house/section(null when absent)/sittingDate(the sort key)/snippet(ContributionTextFull, whitespace-normalized, truncated 200 chars, null when absent)/url(`hansard.parliament.uk/{House}/{yyyy-mm-dd}/debates/{DebateSectionExtId}#contribution-{ContributionExtId}` — Parliament's own Hansard debate page scheme, built only from Hansard's own identifiers); rows missing any url part (id, debateExtId, house, sittingDate) or member are skipped, never guessed. The debate page bot-blocks curl with a 403 (bills.parliament.uk precedent) — real in a browser.","sha256":"c68067823b1b47d102065a77cdf62b82ee8b2803e9df04c818646dade5093b4b"}
{"id":"doc:data-surfaces:0016","source":"doc","sourceId":"data-surfaces.md","title":"`GET /frontier` (`src/routes/frontier.ts`)","text":"48. **Packagist frontier** (`frontierBlocks/packagist.ts`) — KEYLESS Packagist search API (`packagist.org/search.json?q=llm&per_page=12` — the PHP registry's own search; trimmed to 8). CRITICAL HONESTY: Packagist search is RELEVANCE-ranked and rows carry NO dates (live-verified 2026-07-12) — captioned \"top-matching · Packagist's own search ranking\", NEVER \"newest\" (the Maven / Docker Hub / NuGet precedent). Per-row id(name, vendor/package)/url(the registry's OWN `url` field, passed through, never synthesized)/description(whitespace-normalized, truncated 200 chars, null when absent)/downloads(null when absent)/favers(null when absent); rows missing name or url are skipped; `total` = Packagist's own total — live-verified identical across per_page=2 and per_page=3, a real match total.\n49. **RubyGems frontier** (`frontierBlocks/rubygems.ts`) — KEYLESS RubyGems search API (`rubygems.org/api/v1/search.json?query=llm&page=1` — the Ruby registry's own search; trimmed to 8). CRITICAL HONESTY: RubyGems search is RELEVANCE-ranked, rows carry NO dates, and the response is a PLAIN ARRAY with NO total (live-verified 2026-07-12) — captioned \"top-matching · RubyGems' own search ranking\", NEVER \"newest\", and NO total is EVER claimed (the block schema has no `total` field at all — the Lobsters/demos no-total precedent). Per-row id(name)/url(the registry's OWN `project_uri`, passed through, never synthesized)/version(null when absent)/description(info, whitespace-normalized, truncated 200 chars, null when absent)/downloads(null when absent); rows missing name or project_uri are skipped.","sha256":"cfb21b94ca259894f44ff857885bbf69bee1b89558d4dfc661fa78d4e9e394ad"}
{"id":"doc:data-surfaces:0017","source":"doc","sourceId":"data-surfaces.md","title":"`GET /frontier` (`src/routes/frontier.ts`)","text":"50. **Flathub frontier** (`frontierBlocks/flathub.ts`) — KEYLESS Flathub search API (`POST flathub.org/api/v2/search` with body `{query:\"llm\",filters:[]}` — the Linux desktop app store's own search; trimmed to 8). CRITICAL HONESTY: Flathub search is RELEVANCE-ranked — captioned \"top-matching · Flathub's own search ranking\", NEVER \"newest\" (the Maven / Docker Hub / NuGet / Packagist precedent). Per-row id(app_id)/name/url(`flathub.org/apps/{app_id}` — the store's OWN canonical app-page scheme built from its own id, the npm-canonical-URL precedent)/summary(whitespace-normalized, truncated 200 chars, null when absent)/updatedAt(the store's own `updated_at` — EPOCH SECONDS upstream, converted format-only to ISO, null when absent)/verified(the store's own verification flag, passed through — `false` shown as nothing, only `true` renders a badge)/installsLastMonth(null when absent); rows missing app_id or name are skipped. `total` = Flathub's own `totalHits` — live-verified 2026-07-12 identical across page sizes, a real match total, so it IS claimed. Client: `FlathubGroup` in its own \"Desktop frontier\" section after Apps.\n51. **Mastodon frontier** (`frontierBlocks/mastodon.ts`) — KEYLESS Mastodon public hashtag timeline (`mastodon.social/api/v1/timelines/tag/ai?limit=20` — ONE instance's public view of #ai; trimmed to 8). CRITICAL HONESTY: a hashtag timeline is a WINDOW not a search — the response is a plain array with NO total, so NONE is ever claimed (the Lobsters/demos/RubyGems no-total precedent); it is NEVER captioned \"all of Mastodon\" — captioned \"newest by created_at · public #ai timeline on mastodon.social\" (the timeline's own newest-first ordering, live-verified 2026-07-12). Post `content` arrives as HTML — stripped to plain text server-side (format-only, tags removed + entities decoded, truncated 240 chars); posts flagged `sensitive` (content-warning) are SKIPPED, never unwrapped — a declared curation rule, stated here. Per-row id/url(the post's own `url`, falling back to its `uri` — federation-sourced, so only http(s) schemes pass, rows failing that or missing both skipped, never synthesized)/text/acct(author handle, null when absent)/createdAt/language(null when absent). Client: `MastodonGroup` in its own \"Fediverse frontier\" section after Community.","sha256":"0841b7d90e7db1f623fbff583adae9af025330d8f4eb44025f3117ed0e907a13"}
{"id":"doc:data-surfaces:0018","source":"doc","sourceId":"data-surfaces.md","title":"`GET /frontier` (`src/routes/frontier.ts`)","text":"52. **DBLP frontier** (`frontierBlocks/dblp.ts`) — KEYLESS DBLP computer-science bibliography search (`dblp.org/search/publ/api?q=large+language+model&format=json&h=8` — the CS bibliography's own publication search). CRITICAL HONESTY: DBLP search is RELEVANCE-ranked — captioned \"top-matching · DBLP's own search ranking\", NEVER \"newest\"; rows carry YEAR ONLY (DBLP's own granularity — a year is shown, a full date is never invented). Titles arrive entity-encoded — decoded format-only via `decodeEntities()`. `authors.author` is single-OR-array of `{text}` objects — normalized format-only to a string array. Per-row id(the DBLP `key`)/url(the publication's own `ee` electronic-edition link, falling back to `info.url` — the DBLP record page — never synthesized; rows missing both skipped)/title/authors/venue(null when absent)/year(null when absent)/type(DBLP's own publication type, null when absent). `total` = DBLP's own `@total` — live-verified 2026-07-12 identical across h=2 and h=8 (38,896 at verification), a real match total, so it IS claimed. Client: `DblpGroup` in its own \"Bibliography frontier\" section after Open-science.\n53. **Hex frontier** (`frontierBlocks/hex.ts`) — KEYLESS Hex.pm package search (`hex.pm/api/packages?search=llm&sort=inserted_at&page=1` — the Elixir package registry's own API). CRITICAL HONESTY: `sort=inserted_at` is Hex's OWN newest-created-first ordering (live-verified 2026-07-12 descending by each row's own inserted_at) — captioned \"newest by inserted_at · Hex's own sort\"; inserted_at is the date the package was ADDED to the registry, shown as \"created\", never called a release/publication date. The response is a PLAIN ARRAY with NO total field — none is ever claimed (no `total` in the schema at all). Per-row id(name)/url(`meta.links.hex` falling back to `hex.pm/packages/{name}` — Hex's own package-page scheme from its own name)/description(meta.description, null when absent)/insertedAt/version(`latest_stable_version` falling back to `latest_version`, null when absent — labelled just \"v\", never \"newest release\" since sort is by insertion). Rows missing name skipped, trimmed to 8. Client: `HexGroup` in its own \"Elixir frontier\" section after Ruby.","sha256":"a2044db861cb9f7237372267edd90c8cc45f886809621d93def78a7b0bfde816"}
{"id":"doc:data-surfaces:0019","source":"doc","sourceId":"data-surfaces.md","title":"`GET /frontier` (`src/routes/frontier.ts`)","text":"54. **PLOS frontier** (`frontierBlocks/plos.ts`) — KEYLESS PLOS search API (`api.plos.org/search?q=title:\"artificial intelligence\"&sort=publication_date desc&rows=12&wt=json` — the open-access publisher's own Solr search). CRITICAL HONESTY: `sort=publication_date desc` is a GENUINE newest-published ordering (live-verified 2026-07-12 descending) — one of the few blocks where \"newest published\" is EARNED — but it is a TITLE-field match over ONE publisher's corpus, so the caption is \"newest published · PLOS's own date sort · PLOS journals only\", never \"all of science\". `total` = Solr's own numFound (live-verified identical across rows=1 and rows=12 — 444 at verification — a real total, so it IS claimed, captioned \"title matches · PLOS's own count\"). Per-row id(PLOS's own DOI)/url(`doi.org/{id}` — the DOI's own resolver, crossref precedent, never guessed)/title/journal(null when absent)/publishedAt(publication_date, null when absent)/authors(author_display capped at 8, may be empty). Rows missing id or title skipped, trimmed to 8. REPLACED a Semantic Scholar block pre-ship: S2's keyless shared pool 429s persistently from this egress (MEASURED 2026-07-12, 3 consecutive direct probes) — a near-permanently-UNAVAILABLE block is honest but worthless. Client: `PlosGroup` in its own \"Open-access frontier\" section after Bibliography.\n55. **F-Droid frontier** (`frontierBlocks/fdroid.ts`) — KEYLESS F-Droid search API (`search.f-droid.org/api/search_apps?q=ai` — the FOSS Android repository's own search). CRITICAL HONESTY: ranking is F-Droid's OWN search ranking (no sort parameter exposed) — captioned \"top-matching · F-Droid's own search ranking\", NEVER \"newest\"; rows carry NO dates and the response has NO total — neither is ever shown or claimed (neither field exists in the schema). Also NOTE the `q=ai` substring match is broad (matches any app whose name/summary contains \"ai\"). Per-row id(url — the ONLY unique field F-Droid returns)/url(F-Droid's own packages page, passed through)/name/summary(null when absent); the upstream's icon field is DROPPED server-side, not surfaced. Rows missing name or url skipped, trimmed to 8. Client: `FdroidGroup` in its own \"FOSS-mobile frontier\" section after Apps.","sha256":"88fc8728d2371dd33d159a9efc5020b6a37cae00afbab9822dd63c0589e53d40"}
{"id":"doc:data-surfaces:0020","source":"doc","sourceId":"data-surfaces.md","title":"`GET /frontier` (`src/routes/frontier.ts`)","text":"56. **CRAN frontier** (`frontierBlocks/cran.ts`) — KEYLESS crandb release feed (`crandb.r-pkg.org/-/pkgreleases?limit=12&descending=true` — the r-pkg.org CRAN mirror's own release stream). CRITICAL HONESTY: ordering is the feed's OWN descending-by-date release order, never re-ranked — but the feed covers the WHOLE registry with NO AI/LLM filter and the caption says so (\"whole registry · no AI filter · feed's own date order\"); `date` is crandb's own release timestamp captioned \"released\", never a publication date; NO total exists upstream so none is in the schema. Per-row name/version(package's own Version, null when absent)/title(package's own DESCRIPTION Title, whitespace-normalized ONLY — CRAN titles carry hard line-wraps — FORMAT-only, null when absent)/date/url(CRAN's own canonical `cran.r-project.org/package={name}` scheme). Rows missing name or date skipped, trimmed to 8. Client: `CranGroup` in the shared \"Registry-pulse frontier\" section.\n57. **PyPI frontier** (`frontierBlocks/pypi.ts`) — KEYLESS PyPI newest-packages RSS (`pypi.org/rss/packages.xml` — the index's own feed of newly REGISTERED project names). CRITICAL HONESTY: feed's OWN order preserved, never re-ranked; the feed covers the WHOLE index with NO AI/LLM filter and the caption says so (\"whole index · no AI filter · feed's own order\"); `pubDate` is the feed's registration-announcement timestamp captioned \"registered\" — NEVER a release or publication date; NO total exists upstream so none is in the schema. Parsed with `fast-xml-parser` (arXiv precedent). Per-row name(item title with ONLY the feed's fixed \" added to PyPI\" suffix stripped — FORMAT-only, raw title kept when suffix absent)/description(feed's own, null when absent)/pubDate/url(the feed's own link, never assembled). Rows missing name or link skipped, trimmed to 8. Client: `PypiGroup` in the shared \"Registry-pulse frontier\" section.","sha256":"8b1a74895aee945da44ab48d86e41aec7c78c52938af807ecffb379edefa782c"}
{"id":"doc:data-surfaces:0021","source":"doc","sourceId":"data-surfaces.md","title":"`GET /frontier` (`src/routes/frontier.ts`)","text":"58. **Homebrew frontier** (`frontierBlocks/brew.ts`) — KEYLESS Homebrew analytics (`formulae.brew.sh/api/analytics/install-on-request/30d.json` — the project's own 30-day install-on-request board). CRITICAL HONESTY: counts are OPT-IN telemetry — captioned \"opt-in telemetry\", NEVER \"total installs\"; the window is HOMEBREW'S OWN (`start_date`/`end_date` passed through verbatim and shown in the caption), never ours; NO AI filter — it is the whole package manager's top installs; `count` arrives comma-grouped (\"305,539\") and is parsed to a number FORMAT-only (same digits, no rescaling); `percent` passed through as the project's own raw string; totalItems/totalCount are the project's own totals shown only as \"Homebrew's own totals\". Per-row rank(project's own)/name/count/percent(null when absent)/url(formulae.brew.sh's own `/formula/{name}` scheme). Rows missing name/rank/count skipped, trimmed to 8. Client: `BrewGroup` in the shared \"Registry-pulse frontier\" section.\n59. **Artifact Hub frontier** (`frontierBlocks/artifacthub.ts`) — KEYLESS Artifact Hub search API (`artifacthub.io/api/v1/packages/search?ts_query_web=llm&limit=12&offset=0` — the CNCF cloud-native package hub's own full-text search over Helm charts, operators, policies and plugins). CRITICAL HONESTY: `ts_query_web` is RELEVANCE-ranked — rows are in Artifact Hub's OWN search ranking (all \"llm\" hits are Helm charts, kind 0), never re-ranked, captioned \"top-matching · Artifact Hub's own search ranking\", NEVER \"newest\"; `ts` is the package's OWN last-update timestamp surfaced as \"updated\" (unix→ISO, FORMAT-only) — it is NOT the ordering key; `total` is Artifact Hub's OWN `pagination-total-count` response HEADER (a REAL query count — the module does a local `fetch` to read the header, not shared `fetchJson`), captioned \"matches\", never a page size. Per-row name/description(null when absent)/version(null when absent)/repository(repository.name, null when absent)/stars(genuine 0 shown as 0, null when absent)/updatedAt/url(Artifact Hub's OWN documented `/packages/{kind}/{repo}/{name}` scheme, using its published repository-kind→path map — a row whose kind is not in that map is skipped, never given a fabricated URL). Rows missing name or a derivable URL skipped, trimmed to 8. Client: `ArtifacthubGroup` in the shared \"Infra-registry frontier\" section (with Terraform).","sha256":"40be1f5544b096ee133b20e313f337c871466f86ee0b2f4e5c6b7433ab99536d"}
{"id":"doc:data-surfaces:0022","source":"doc","sourceId":"data-surfaces.md","title":"`GET /frontier` (`src/routes/frontier.ts`)","text":"60. **Terraform frontier** (`frontierBlocks/terraform.ts`) — KEYLESS HashiCorp Terraform Registry module search API (`registry.terraform.io/v1/modules/search?q=ai&limit=12` — the IaC registry's own module search). CRITICAL HONESTY: the search is RELEVANCE-ranked — rows are in the registry's OWN search ranking (live-verified: `published_at` is NOT descending — 2025/2022/2026/2023 — proving relevance not date), never re-ranked, captioned \"top-matching · Terraform Registry's own search ranking\", NEVER \"newest\"; `published_at` is the module version's OWN publish timestamp surfaced as \"published\" — it is NOT the ordering key; the search `meta` exposes NO total (only pagination cursors) so NONE is claimed and the schema has no total field. Per-row id/namespace/name/provider/version(null when absent)/description(null when absent)/downloads(registry's own all-time count, genuine 0 shown as 0, null when absent)/verified(registry's own flag, null when absent)/url(the registry's OWN `/modules/{namespace}/{name}/{provider}` scheme). Rows missing namespace, name or provider skipped, trimmed to 8. Client: `TerraformGroup` in the shared \"Infra-registry frontier\" section (with Artifact Hub).\n61. **MetaCPAN frontier** (`frontierBlocks/metacpan.ts`) — KEYLESS MetaCPAN release search API (`fastapi.metacpan.org/v1/release/_search?q=status:latest&sort=date:desc&size=12&_source=distribution,version,date,abstract,author,name` — the CPAN mirror's own Elasticsearch release index; the ES `fields=` param is REJECTED so `_source=` is used). CRITICAL HONESTY: `sort=date:desc` IS a genuine newest-by-release-date ordering (live-verified strictly descending via the `sort` epoch-ms array) — one of the few blocks where \"newest released\" is EARNED — but `q=status:latest` covers the WHOLE CPAN registry with NO AI/LLM filter and the caption says so (\"whole registry · no AI filter · newest released\"); `date` is the release's OWN release timestamp captioned \"released\"; NO total is claimed because MetaCPAN's `hits.total` is the Elasticsearch `track_total_hits` default ceiling (10000), NOT a real count — so the schema has no total field. Per-row distribution/name(distribution-version)/version(null when absent)/abstract(whitespace-normalized ONLY — FORMAT-only, null when absent)/author(PAUSE id)/date/url(MetaCPAN's OWN `/release/{author}/{name}` scheme). Rows missing distribution, name, author or date skipped, trimmed to 8. Client: `MetacpanGroup` in the shared \"Registry-pulse frontier\" section (with CRAN / PyPI / Homebrew — the whole-registry newest feeds).","sha256":"52278f7948cf71d0b715eb7a4d6f2fa62eb14e7de5c65b2181825bc2ccf8706a"}
{"id":"doc:data-surfaces:0023","source":"doc","sourceId":"data-surfaces.md","title":"`GET /frontier` (`src/routes/frontier.ts`)","text":"62. **Go module-index frontier** (`frontierBlocks/golang.ts`) — KEYLESS index.golang.org module-index feed (`index.golang.org/index?since=<RFC3339>&limit=2000`, PAGINATED — the Go module index's OWN chronological ingestion stream). CRITICAL HONESTY: the feed covers the WHOLE Go ecosystem — it has NO AI/LLM filter, and the caption says \"whole ecosystem · no AI filter\"; it is JSONL (one JSON object per line: Path/Version/Timestamp), parsed line-by-line, in the index's OWN ASCENDING ingestion-time order (live-verified strictly ascending) so the newest are at the END. The index ingests far more rows per hour than one page holds, so a single page after `since` would be the OLDEST slice of the window, NOT the newest — the module therefore PAGINATES TO THE FEED'S END (start ~30min back, full 2000-row pages advance `since` past the last timestamp, boundary rows deduped by strict timestamp comparison, bounded 6-page budget); ONLY a short (non-full) page proves the end was reached — if the budget runs out first the block is honest UNAVAILABLE (\"feed end not reached\") rather than presenting a stale page as newest. The LAST 8 rows are then reversed to present newest-first — an EARNED \"newest ingested\". `timestamp` is the index's OWN INGESTION time (when the index saw the version), captioned \"indexed\" / \"index ingestion\" and NEVER a release date; the feed exposes NO total so NONE is claimed and the schema has no total field. Per-row path/version(null when absent)/timestamp/url(pkg.go.dev's OWN `/{Path}` scheme, live-verified 200 — Path carries its own slashes, not encoded). Rows missing path or timestamp skipped, trimmed to 8. Client: `GolangGroup` in the \"Language-registry frontier\" section.\n63. **pub.dev frontier** (`frontierBlocks/pubdev.ts`) — KEYLESS pub.dev (Dart/Flutter) package search API (`pub.dev/api/search?q=llm` — the official Dart package registry's own search). CRITICAL HONESTY: the search is RELEVANCE-ranked — rows are in pub.dev's OWN search order (live-verified: \"llm\" itself ranks first), never re-ranked, captioned \"top-matching · pub.dev's own ranking\", NEVER \"newest\"; the response carries ONLY package NAMES (`packages[].package`) — there are NO descriptions, versions or dates in the response, so the schema has none of those fields and nothing is invented; the response exposes NO total (only a `next` page cursor) so NONE is claimed and the schema has no total field. Per-row name/url(pub.dev's OWN `/packages/{name}` scheme, live-verified 200). Rows missing a name skipped, trimmed to 8. Client: `PubdevGroup` in the \"Language-registry frontier\" section (with Go index / jsr).","sha256":"c470e4bfc99c2298a92e4d9eae86e2ebb3a8bd429c2ec1d66bc79fbf31f521b0"}
{"id":"doc:data-surfaces:0024","source":"doc","sourceId":"data-surfaces.md","title":"`GET /frontier` (`src/routes/frontier.ts`)","text":"64. **JSR frontier** (`frontierBlocks/jsr.ts`) — KEYLESS JSR (the modern TypeScript/JS registry) package search API (`api.jsr.io/packages?query=llm&limit=12`). CRITICAL HONESTY: the search is RELEVANCE-ranked — rows are in JSR's OWN search order (live-verified: name \"llm\" ranks first, `score` null), never re-ranked, captioned \"top-matching · JSR's own ranking\", NEVER \"newest\"; `updatedAt` is the package's OWN last-update timestamp surfaced as \"updated\" — it is NOT the ordering key; `description` arrives as \"\" for many packages and is normalised to null (FORMAT-only); `total` is JSR's OWN meta total (live-verified 46), passed through. Per-row scope/name/description(null when empty)/latestVersion(null when no version published)/updatedAt(null when absent)/url(JSR's OWN `/@{scope}/{name}` scheme, live-verified 200). Rows missing scope or name skipped, trimmed to 8. Client: `JsrGroup` in the \"Language-registry frontier\" section (with Go index / pub.dev).\n65. **Bluesky frontier** (`frontierBlocks/bluesky.ts`) — KEYLESS Bluesky AppView searchPosts API (`app.bsky.feed.searchPosts?q=AI&sort=latest&limit=12`). CRITICAL HONESTY: this is a SEARCH over the network's public posts — captioned \"AI matches\", NEVER \"all of Bluesky\"; `sort=latest` is the AppView's OWN newest-first ordering by its own index time, never re-ranked. Egress note: the documented `public.api.bsky.app` host 403s from this egress (Bluesky's own edge block), so the module fetches the SAME AppView on `api.bsky.app` (keyless, 200) and the source link is Bluesky's own browsable search UI `bsky.app/search?q=AI`. Two timestamps, each called exactly what it is: `indexedAt` is Bluesky's OWN index timestamp = the sort key (surfaced as \"indexed\"); `createdAt` is the AUTHOR's self-declared post time (spoofable/future-datable), carried but NEVER presented as Bluesky's measurement. DECLARED CURATION: any post carrying a moderation label — post-level `labels[]` OR author-level `author.labels[]` — is SKIPPED, never unwrapped (caption \"labeled posts skipped\"). The upstream `hitsTotal` is a capped estimate (10000), NOT a real count, so NONE is claimed and the schema has no total field. Per-row text(record text verbatim)/handle(author's own)/createdAt(author-declared, null when absent)/indexedAt(Bluesky's own index time, the sort key)/url(bsky.app's OWN `/profile/{handle}/post/{rkey}` scheme, rkey = last segment of the post's at:// uri — one live-verified resolving 200). Rows missing uri/handle/text/indexedAt/rkey skipped, trimmed to 8. Client: `BlueskyGroup` in the shared \"Attention frontier\" section (with Wikimedia Pageviews). NOT affiliated with or endorsed by Bluesky.","sha256":"6ea53f343fe375ddfe8658d20a6f080a959ca1897761d331bf46ab2fcca01ec2"}
{"id":"doc:data-surfaces:0025","source":"doc","sourceId":"data-surfaces.md","title":"`GET /frontier` (`src/routes/frontier.ts`)","text":"66. **Thesis version-ledger surface** (`frontierBlocks/thesisVersions.ts`) — SZL's OWN corpus record ledger: the FULL Zenodo version history for the Ouroboros thesis CONCEPT, parent.id-pinned to record 19944926 (concept DOI 10.5281/zenodo.19944926). KEYLESS Zenodo records API (`api/records?q=parent.id:19944926&allversions=true&sort=mostrecent`); Zenodo caps UNAUTHENTICATED `size` at 25 (size>25 → 400) so the ledger is PAGINATED `page=1,2,…` at size=25 until Zenodo's OWN `hits.total` rows are enumerated (a short page ends the walk; 10-page / 15s budget; ANY page failure → honest UNAVAILABLE, never a partial ledger shown as complete). NOTE `conceptrecid:` queries and the `/versions` endpoint both return 0 for this record — the `parent.id:` query is the ONLY one that enumerates the ledger. Rows in Zenodo's OWN mostrecent order (newest version first), each mapped VERBATIM: version(metadata.version, null when the record has none)/doi(metadata.doi)/publicationDate(metadata.publication_date — a Zenodo publication date)/title(metadata.title, whitespace-normalized). `total` = Zenodo's OWN hits.total (36 as of 2026-07-12); `fetchedAt` discloses the probe time; source link is the concept DOI doi.org/10.5281/zenodo.19944926 (resolves to the latest version). DISTINCT from block \"Zenodo title-match frontier\" (`frontierBlocks/zenodo.ts`): that is a keyless title search across ALL of Zenodo; THIS is our own concept's own version records. Has its OWN 10-min cache (`getThesisVersions()`, 30s negative window). Client: collapsible full-version list in `ThesisCorpus.tsx`.","sha256":"f5bf968c9aad1739954abcb6e02b0b9d1b8d0dfc2b089c9834415f82461ae0e8"}
{"id":"doc:data-surfaces:0026","source":"doc","sourceId":"data-surfaces.md","title":"`GET /frontier` (`src/routes/frontier.ts`)","text":"67. **Software Heritage frontier** (`frontierBlocks/softwareheritage.ts`) — KEYLESS Software Heritage origin-search API (`archive.softwareheritage.org/api/1/origin/search/llm/?limit=12` — the universal source-code archive's own origin search; trimmed to 8). CRITICAL HONESTY: the search is RELEVANCE-ranked (SWH paginates by an internal relevance score, live-verified 2026-07-12 via the `Link: rel=\"next\"` cursor) — captioned \"top-matching · Software Heritage's own ranking\", NEVER \"newest\"; `lastVisitDate` is the time SWH last ARCHIVED the origin, NOT the ordering key. Response is a PLAIN top-level ARRAY (no `{items}` wrapper). Per-row originUrl(the origin's own url — a git/npm/pypi/… repository, passed through)/url(the origin's OWN archive page under SWH's canonical `browse/origin/?origin_url={url}` scheme, built format-only via encodeURIComponent, never synthesized)/visitType(`visit_types[0]`, null when absent)/lastVisitDate(null when never visited)/nbVisits(SWH's own visit count, genuine 0 kept); rows missing url skipped. `total` = SWH's OWN `X-Total-Count` RESPONSE HEADER (not the body) — live-verified 2026-07-12 stable across page sizes (141,746) and query-specific (`tensorflow` → 521,958 — not a global constant/ES ceiling/page-size echo), a real match total so it IS claimed; because it lives in the HTTP header, `shared.ts fetchJson` (body-only) cannot reach it — the module uses a LOCAL fetch reading `res.headers.get(\"X-Total-Count\")` (Artifact Hub header-total precedent). Client: `SoftwareheritageGroup` in its own \"Source-archive frontier\" section after Code. NOT affiliated with or endorsed by Software Heritage / Inria.\n68. **ROR frontier** (`frontierBlocks/ror.ts`) — KEYLESS ROR (Research Organization Registry) v2 organizations search API (`api.ror.org/v2/organizations?query=artificial%20intelligence` — the community registry of research-org identifiers; trimmed to 8). CRITICAL HONESTY: RELEVANCE-ranked — rows in ROR's OWN default relevance order, never re-ranked, captioned \"top-matching · ROR's own ranking\", NEVER \"newest\". `total` = ROR's OWN `number_of_results` — live-verified 2026-07 stable across page params (135; a different query → 238 — a real match total, not a page-size echo), so it IS claimed. Per-row id(ROR's OWN canonical ROR URL, passed through — ALSO the org's landing page, used directly as the link)/name(ROR's declared `ror_display` name, rows without one skipped)/country(geonames `country_name`, null when absent)/types(ROR's own organization-type tags, passed through). Client: `RorGroup` in its own \"Research-registry frontier\" section after Open-science.","sha256":"e71dd0973149e63021b78a827db439527b903a21d7b1104ee19b5f5a3779687e"}
{"id":"doc:data-surfaces:0027","source":"doc","sourceId":"data-surfaces.md","title":"`GET /frontier` (`src/routes/frontier.ts`)","text":"69. **OpenAIRE frontier** (`frontierBlocks/openaire.ts`) — KEYLESS OpenAIRE legacy Search API (`api.openaire.eu/search/publications?keywords=\"large language model\"&format=json&sortBy=resultdateofacceptance,descending` — a dnet `$`-wrapped legacy JSON; the quoted keywords are an AND-match of the tokens, not a strict phrase; trimmed to 8). CRITICAL HONESTY: ordered by each record's OWN `dateofacceptance` desc and CAPPED at server-today because a naked descending sort floods the top with placeholder `9999-01-01` / forward-dated acceptance dates (OpenAlex forward-dating precedent) — captioned \"newest accepted\"; the acceptance date is NOT the publication/index date. `total` = OpenAIRE's own header total, live-verified stable across page sizes (REAL, claimed). Per-row title(entity-decoded)/authors/publisher/access(bestaccessright classname)/doi/acceptedAt passed through EXACTLY; url = `doi.org/{doi}` when a DOI exists else OpenAIRE Explore's own record page keyed by OpenAIRE's own objIdentifier, never synthesized. Client: `OpenaireGroup` in the \"Open-access frontier\" section after PLOS.\n70. **DOAJ articles frontier** (`frontierBlocks/doaj.ts`) — KEYLESS DOAJ article search (`doaj.org/api/search/articles/\"large language model\"?pageSize=12&sort=created_date:desc`; trimmed to 8). CRITICAL HONESTY: `created_date` is the date DOAJ INDEXED the article — NOT the publication date — and the descending order is EARNED only by DOAJ's OWN colon-syntax `sort=created_date:desc` (live-verified strictly descending 2026-07-12; the `sortBy=…&sortDirection=…` form is SILENTLY IGNORED and falls back to relevance, so only the colon form is sent) — captioned \"newest indexed · by DOAJ created date · open-access journals\", NEVER \"newest published\". DISTINCT from the Journals block (#33): same upstream, DIFFERENT query (\"large language model\" vs \"artificial intelligence\") and this block adds DOI links. Per-row id/url(the article's OWN DOI via `doi.org/{doi}` else DOAJ's own bibjson fulltext link passed through verbatim)/title(whitespace-normalized)/journal(null when absent)/createdDate(the index date)/authors(DOAJ's own names, capped 6); rows missing id, title, or a linkable url skipped. `total` = DOAJ's own total (live-verified 4,725, identical across pageSize 1/12/50 — a real match total, claimed). Client: `DoajGroup` in the \"Open-access frontier\" section after OpenAIRE.","sha256":"ea0c388e51cda08e08dbf21cb73e09935e98966e5d8911e5bfa3f05b22e6583d"}
{"id":"doc:data-surfaces:0028","source":"doc","sourceId":"data-surfaces.md","title":"`GET /frontier` (`src/routes/frontier.ts`)","text":"71. **Dataverse frontier** (`frontierBlocks/dataverse.ts`) — KEYLESS Harvard Dataverse search API (`dataverse.harvard.edu/api/search?q=\"large language model\"&type=dataset&sort=date&order=desc&per_page=12`; trimmed to 8). CRITICAL HONESTY: `sort=date&order=desc` IS a genuine newest-by-release-date ordering — live-verified 2026-07-12 strictly descending by each dataset's own `published_at`, and per Dataverse docs `sort=date` is the RELEASE/PUBLICATION date — so \"newest published · Harvard Dataverse's own release date\" is EARNED (one of the few blocks where it is). Per-row name/globalId(Dataverse's own `global_id`, e.g. `doi:10.7910/...`, null when absent)/url(Dataverse's OWN resolvable `url` field — already a doi.org link — passed through, else derived from the DOI global_id via the doi.org resolver; rows without a resolvable url skipped, never synthesized)/publishedAt(the sort key)/description(whitespace-normalized, truncated 200, null when absent)/fileCount(null when absent); rows missing name or url skipped. `total` = Dataverse's own `total_count` — live-verified identical (220) across per_page sizes, a real match total, claimed. Client: `DataverseGroup` in the \"Open-science frontier\" section after DataCite. NOT affiliated with or endorsed by Harvard Dataverse or Harvard University.\n72. **figshare frontier** (`frontierBlocks/figshare.ts`) — KEYLESS figshare articles search (POST `api.figshare.com/v2/articles/search`, body `search_for:\"\\\"large language model\\\"\"` quoted-phrase full-text, `order:published_date`+`order_direction:desc`; LOCAL POST-JSON helper because `shared.ts fetchJson` is GET-only (darpa POST precedent); trimmed to 8). CRITICAL HONESTY: the ordering is figshare's OWN published_date-descending (live-verified: desc→2026 rows, asc→2022 rows) so \"newest · by figshare's published date\" is EARNED — but published_date is the date the item was made public ON FIGSHARE (its own timeline.posted), NOT necessarily the journal publication date, and the caption says so. The response is a bare ARRAY with NO total — NO total field exists in the schema (Mastodon/Lobsters no-total precedent). Titles carry figshare's own embedded `<b>` markup + literal newlines → tags stripped, entities decoded, whitespace normalized (FORMAT-only, words never rewritten). Per-row id(String of figshare's numeric id)/title/doi(figshare's own DOI, null when absent)/publishedDate(the sort key)/definedTypeName(figshare's own artifact classification)/url(figshare's OWN `url_public_html` landing page, passed through verbatim). Client: `FigshareGroup` in the \"Open-science frontier\" section after Dataverse.","sha256":"b25c0ceb30758b1109b97b04682f94085a29f0a300131b2fcf4d93df382ab573"}
{"id":"doc:data-surfaces:0029","source":"doc","sourceId":"data-surfaces.md","title":"`GET /frontier` (`src/routes/frontier.ts`)","text":"73. **Docker Hub frontier** (`frontierBlocks/dockerhub.ts`) — KEYLESS Docker Hub search API (`hub.docker.com/v2/search/repositories/?query=llm&page_size=12`; trimmed to 8). CRITICAL HONESTY: RELEVANCE-ranked and rows carry NO dates (live-verified 2026-07-12) — captioned \"top-matching · Docker Hub's own ranking\", NEVER \"newest\" (Maven/NuGet/Flathub precedent). Per-row name(repo_name)/url(`hub.docker.com/_/{name}` for official images, `hub.docker.com/r/{name}` otherwise — Docker Hub's OWN canonical page scheme built from its own repo_name + is_official flag)/description(empty \"\" → null)/stars(star_count, null when absent)/pulls(pull_count, null when absent)/official(is_official passed through — only `true` renders a badge); rows missing repo_name skipped. `total` = Docker Hub's own `count` — live-verified identical across page_size 2/5/12/25 (11,803 at verification), a real match total, claimed. Client: `DockerhubGroup` in the shared \"Infra-registry frontier\" section after Terraform.\n74. **Snapcraft frontier** (`frontierBlocks/snapcraft.ts`) — KEYLESS Snap Store find search (`api.snapcraft.io/v2/snaps/find?q=llm&fields=title,summary,store-url` — Canonical's own snap search; REQUIRES the `Snap-Device-Series: 16` header; trimmed to 8). CRITICAL HONESTY: RELEVANCE-ranked — captioned \"top-matching · Snapcraft's own search ranking\", NEVER \"newest\"; the response carries NO dates and NO total (top-level object has ONLY `results`, live-verified 2026-07-12) so neither is claimed (neither field exists in the schema). Per-row name/title(the store's own display title, null when absent)/summary(whitespace-normalized, truncated 200, null when absent)/url(the store's OWN `store-url` canonical page, passed through, never synthesized); rows missing name or store-url skipped. Client: `SnapcraftGroup` in the \"Desktop frontier\" section after Flathub.","sha256":"88c6c341b173d20a63cf81d23a20bbfbd6f6e470ac3f20f1911e5ffdd01e9861"}
{"id":"doc:data-surfaces:0030","source":"doc","sourceId":"data-surfaces.md","title":"`GET /frontier` (`src/routes/frontier.ts`)","text":"75. **USAspending frontier** (`frontierBlocks/usaspending.ts`) — KEYLESS USAspending spending_by_award API (POST `api.usaspending.gov/api/v2/search/spending_by_award/`, body: `keywords:[\"artificial intelligence\"]`, time_period = last ~180 days, contract award types A–D, `sort:\"Start Date\"` `order:\"desc\"`, limit 12; LOCAL POST helper (figshare/darpa precedent); trimmed to 8). CRITICAL HONESTY: `keywords` is a FULL-TEXT match — rows are \"artificial intelligence\" MATCHES in federal award records, NOT a curated AI list — captioned \"newest by award start date · AI award matches\"; the date sort is USAspending's OWN, live-verified 2026-07-12 descending. `Start Date` is the award's period-of-performance start exactly as USAspending states it — it CAN be a FUTURE date (e.g. 2027) and is shown RAW, never \"corrected\". `Award Amount` is obligated USD passed through raw, never summed or reformatted. NO total is EVER claimed: `page_metadata` carries only page/hasNext ids, NO count — the schema has no `total` field. Per-row awardId/recipient/amount/startDate(the sort key)/awardingAgency/url(`usaspending.gov/award/{generated_internal_id}` — USAspending's OWN canonical award-page scheme from its own id); rows missing Award ID or generated_internal_id skipped. DISTINCT from the Capital/EDGAR block: EDGAR surfaces SEC FILINGS, this surfaces federal SPENDING AWARDS. NOT affiliated with or endorsed by the U.S. Government. Client: `UsaspendingGroup` in the \"Capital frontier\" section after EDGAR.\n76. **Wikipedia 7-day attention frontier** (`frontierBlocks/wikipedia.ts`) — KEYLESS Wikimedia Pageviews REST API (`wikimedia.org/api/rest_v1/metrics/pageviews/per-article/en.wikipedia/all-access/all-agents/{Article}/daily/{start}/{end}`, UA required; en.wikipedia ONLY — captioned so) for a DECLARED fixed roster of 6 AI pages (Large_language_model · ChatGPT · Artificial_intelligence · Generative_artificial_intelligence · Anthropic · OpenAI), kept in declaration order, NEVER re-ranked by views. CRITICAL HONESTY: today's row is a PARTIAL day so it is EXCLUDED (the API also lags ~1 day) — only complete days are summed/shown; the API carries NO overall total so NONE is claimed. Per-row article/date/url(`en.wikipedia.org/wiki/{Article}` — the article's own title, never guessed)/views(Wikimedia's OWN count for the latest COMPLETE day — REPORTED pass-through)/weekViews(DERIVED — a plain sum WE compute from the API's OWN daily rows, labelled DERIVED)/weekDays(how many complete daily rows the sum covers, ≤7 — discloses gaps). Pages whose fetch fails are simply absent; UNAVAILABLE only when NO page could be fetched. DISTINCT from the Attention block (#23): that shows a single latest-day count for an 8-page all-access/user set; this adds a 6-page all-agents 7-day trend. Client: `WikipediaGroup` in the shared \"Attention frontier\" section before Bluesky.","sha256":"e9026965d54fe376aae5614be7db461f162d2914380c0786db9286caae1c509d"}
{"id":"doc:data-surfaces:0031","source":"doc","sourceId":"data-surfaces.md","title":"`GET /frontier` (`src/routes/frontier.ts`)","text":"77. **GLEIF LEI-record frontier** (`frontierBlocks/gleif.ts`) — KEYLESS GLEIF JSON:API fulltext LEI-record search (`api.gleif.org/api/v1/lei-records?filter[fulltext]=artificial intelligence&page[size]=12`, trimmed to 8). Ordering: GLEIF's DEFAULT order (NO sort param — deliberately matches the registry's own search experience; a \"newest by LEI registration date\" caption COULD be earned but is not used) — captioned \"matching LEI records · GLEIF's own order\", NEVER \"newest\". Total is REAL: `meta.pagination.total` stable across page sizes 2/12/25 (139 live-verified 2026-07-12) — surfaced; null on UNAVAILABLE. Dates: `initialRegistrationDate`/`lastUpdateDate` are LEI REGISTRATION/RECORD dates — captioned so, NEVER company founding dates. Per-row lei+legalName (identity+URL — rows missing either skipped, name whitespace-normalised FORMAT-only)/country/city/url (`search.gleif.org/#/record/{lei}` — GLEIF's OWN record-page scheme from the LEI). NOT affiliated with or endorsed by GLEIF — disclaimer rendered. Client: `GleifGroup`, NEW \"Corporate-registry frontier\" section after Capital.\n78. **Open VSX extensions** (`frontierBlocks/openvsx.ts`) — KEYLESS Open VSX search (`open-vsx.org/api/-/search?query=llm&size=12`, trimmed to 8) — the Eclipse Foundation's OPEN VS Code-extension registry, DISTINCT from the `extensions` block (#30), which is the Microsoft VS Code Marketplace. Ordering: relevance default (proven: neither timestamp- nor downloads-monotonic) — captioned \"top-matching · Open VSX's own ranking\", NEVER \"newest\". Total is REAL: `totalSize` stable across sizes 2/5/25 (419 live-verified 2026-07-12) — surfaced; null on UNAVAILABLE. Per-row namespace+name (identity+URL — rows missing either skipped)/displayName/description (200-char FORMAT-only)/version/publishedAt (the shown version's own Open VSX publish time, RAW — NOT the ordering key)/downloads (Open VSX's OWN counter)/url (`open-vsx.org/extension/{namespace}/{name}`). Client: `OpenvsxGroup` in the shared \"Extensions frontier\" section after ExtensionsGroup.","sha256":"6c3021ed692d58b9e286268719122d1cb39b9ced8d1f7aa1254f7c77f27eebc4"}
{"id":"doc:data-surfaces:0032","source":"doc","sourceId":"data-surfaces.md","title":"`GET /frontier` (`src/routes/frontier.ts`)","text":"79. **JetBrains Marketplace plugins** (`frontierBlocks/jetbrains.ts`) — KEYLESS Marketplace search (`plugins.jetbrains.com/api/searchPlugins?search=llm&max=12`, trimmed to 8). Ordering: the Marketplace's own relevance DEFAULT (no order param; `&orderBy=downloads` provably reorders the page entirely, so the default IS a distinct relevance ranking) — captioned relevance/\"top-matching\", NEVER \"newest\". `cdate` is an index/creation epoch — NOT the ordering key, not a publication date → NO date surfaced. Total is REAL (`total` = 171 live-verified 2026-07-12, stable across page sizes and query-specific) — surfaced; null on UNAVAILABLE. Per-row name+link (identity+URL — rows missing either skipped; url = the Marketplace's OWN site-relative `link` resolved against its canonical host, never synthesized)/description (preview, 200-char)/downloads (its OWN counter)/rating (null when unrated — a genuine 0 stays 0)/vendor. Client: `JetbrainsGroup` in \"Extensions frontier\" after Openvsx.\n80. **WordPress.org plugins** (`frontierBlocks/wordpress.ts`) — KEYLESS Plugin Directory `query_plugins` (`api.wordpress.org/plugins/info/1.2/?action=query_plugins&request[search]=llm&request[per_page]=12`; GET via LOCAL fetch with the shared UA+timeout; trimmed to 8). Ordering: relevance (no sort param sent; live proof: `last_updated`, `rating`, and `active_installs` are ALL non-monotonic down the page) — captioned \"top-matching · WordPress.org's own ranking\", NEVER \"newest\". Total: `info.results` (443 live-verified 2026-07-12, stable across per_page=2/5/25/50) surfaced with a 10000-CEILING GUARD — broad queries hit the index's 10000 cap, so any value ≥10000 is the ceiling, not a count, and is surfaced as null, never a fake total. Per-row name (HTML entities decoded FORMAT-only)+slug (identity+URL — rows missing either skipped)/version/author (`<a>` anchor stripped to plain text)/rating (WordPress's own 0-100 percentage)/numRatings/activeInstalls (its own counters)/lastUpdated (its own human GMT string, RAW — NOT the ordering key, never called a publication date)/url (`wordpress.org/plugins/{slug}/`). Client: `WordpressGroup` in \"Extensions frontier\" after Jetbrains.","sha256":"75b945529eaf1e4f2fc6da5e4b1a68860e4bb202583a4f5050141583eb28075a"}
{"id":"doc:data-surfaces:0033","source":"doc","sourceId":"data-surfaces.md","title":"`GET /frontier` (`src/routes/frontier.ts`)","text":"81. **Civitai creative models** (`frontierBlocks/civitai.ts`) — KEYLESS Civitai model search (`civitai.com/api/v1/models?query=llm&limit=12&nsfw=false`, trimmed to 8). `nsfw=false` is a DECLARED SFW-only view using Civitai's OWN param (its curation, not ours) — captioned as such. Ordering: relevance (downloads non-monotonic down the page proves no date/stat sort) — captioned \"top-matching · Civitai's own ranking\", NEVER \"newest\". NO total is EVER claimed: query-search `metadata` carries ONLY `nextCursor`/`nextPage` — no `totalItems` at any page size (live-verified limit=3/12/24) → the schema has no total field. NO dates surfaced (upstream carries index/registration timestamps only, never publication dates). Per-row id+name (identity+URL — rows missing either skipped)/modelType (Civitai's own Checkpoint/LORA/… type)/description (HTML stripped, 200-char)/downloads+thumbsUp (Civitai's OWN counters)/creator (the owner's own username)/tags (its own strings, non-strings dropped)/url (`civitai.com/models/{id}` — its OWN canonical scheme from its own numeric id). Client: `CivitaiGroup`, NEW \"Creative-model frontier\" section after Images.\n82. **Anaconda.org packages** (`frontierBlocks/anaconda.ts`) — KEYLESS Anaconda.org search (`api.anaconda.org/search?name=llm`, trimmed to 8). The response is a BARE JSON ARRAY — there is nowhere for a total to live; `limit` is a page-size TRIM, not a count (live-verified: 2/5/12 rows; `per_page` ignored; no total in headers either) → the schema has NO total field. Ordering: Anaconda.org's own name-match order (approximately alphabetical — NOT date-sorted; no date field and no time-sort param exist, so a \"newest\" caption is unearnable) — captioned \"matching packages · anaconda.org's own order\", NEVER \"newest\". Per-row name+owner (identity+URL — rows missing either skipped)/summary (200-char FORMAT-only)/latestVersion (the registry's own stated version)/packageTypes (its own array, string entries only)/url (`anaconda.org/{owner}/{name}`). Client: `AnacondaGroup` in the shared \"Registry-pulse frontier\" section after MetacpanGroup.","sha256":"652f8c47298dc144f29104c16381da9665dc3f219084fc9f778f9270b0e4f259"}
{"id":"doc:data-surfaces:0034","source":"doc","sourceId":"data-surfaces.md","title":"`GET /frontier` (`src/routes/frontier.ts`)","text":"83. **AUR packages** (`frontierBlocks/aur.ts`) — KEYLESS Arch User Repository RPC v5 search (`aur.archlinux.org/rpc/v5/search/llm`, trimmed to 8). Ordering: the RPC's result set is not usefully ordered, so the block re-sorts by AUR's OWN `LastModified` field DESCENDING, nulls last (the NIH-grants own-field re-sort precedent) — captioned \"by AUR last-modified\", NEVER \"newest published\" (`LastModified` is the AUR package-UPDATE time, not an upstream publication date). Total is REAL: `resultcount` (353 live-verified 2026-07-12) — surfaced; null on UNAVAILABLE. Per-row name (identity+URL — rows missing it skipped)/description (entity-decoded FORMAT-only, 200-char)/version/votes+popularity (AUR's OWN counters, REPORTED as-is)/maintainer (null = ORPHANED package — passed through, never patched)/url (`aur.archlinux.org/packages/{name}`). Client: `AurGroup` in the \"Desktop frontier\" section after Snapcraft.\n84. **Quay.io repositories** (`frontierBlocks/quay.ts`) — KEYLESS Quay find API (`quay.io/api/v1/find/repositories?query=llm`; the endpoint returns one 10-row page, trimmed to 8). Ordering: relevance — every row on the page carries the SAME uniform `score` (live-verified all 4s), so no finer ordering claim is earnable — captioned \"top-matching · Quay's own ranking\", NEVER \"newest\"; NO dates upstream → none surfaced. NO total is EVER claimed: the top level carries only `has_additional` — a BOOLEAN (\"more pages exist\"), NOT a count → the schema has no total field. `stars`/`popularity` are ABSENT from the response — NOT surfaced (never fabricated). Per-row namespace+name (identity — rows missing either skipped)/description (200-char FORMAT-only)/isPublic (Quay's own flag, pass-through, null when absent — never assumed)/url (Quay's OWN `href` resolved against quay.io; canonical `/repository/{ns}/{name}` fallback from the row's own ids). Client: `QuayGroup` in the shared \"Infra-registry frontier\" section after Dockerhub.","sha256":"6930ef53cc7e29f2544424e71c007e81d236f16f377bfd3e26e88ab2dfef8327"}
{"id":"doc:data-surfaces:0035","source":"doc","sourceId":"data-surfaces.md","title":"`GET /frontier` (`src/routes/frontier.ts`)","text":"85. **EU Open Data datasets** (`frontierBlocks/eudata.ts`) — KEYLESS data.europa.eu hub search (`data.europa.eu/api/hub/search/search?q=artificial intelligence&limit=12`, trimmed to 8). Ordering: the portal's own relevance — the documented `sort` param is provably INERT (`modified+desc` vs `+asc` vs default all return the IDENTICAL non-monotonic row order, live-verified), so a \"newest\" caption is NOT earned — captioned \"top-matching · data.europa.eu's own ranking\". Total is REAL: `result.count` (6986 live-verified 2026-07-12) — surfaced; null on UNAVAILABLE. Titles are MULTILINGUAL objects — the `.en` title is used and rows WITHOUT an English title are skipped rather than machine-translated. `issued`/`modified` are CATALOG-METADATA dates (portal record issued/last-modified) — NOT data-collection dates, passed through raw. Per-row id (identity+URL)/title (200-char)/publisher/catalog (the source catalogue's own title)/country (the row's own label)/url (`data.europa.eu/data/datasets/{id}` — the portal's OWN scheme, live-verified to resolve). Client: `EudataGroup`, NEW \"EU-data frontier\" section after UK-government.\n86. **HF community papers** (`frontierBlocks/hfpapers.ts`) — KEYLESS Hugging Face papers search (`huggingface.co/api/papers/search?q=llm`, bare JSON array — trimmed to 8) — HF's OWN community paper index with community upvotes and discussion counts, DISTINCT from the Preprint frontier (#5 — the arXiv API) and the Publications frontier. Ordering: HF's own relevance (live proof: `upvotes` are non-monotonic down the page — not an upvote sort; not date-sorted either) — captioned \"top-matching · Hugging Face's own ranking\", NEVER \"newest\". NO total (bare array, no envelope) → the schema has no total field. Per-row id+title (identity+URL — rows missing either skipped)/summary (200-char FORMAT-only)/publishedAt (the paper's publication date AS HF REPORTS IT — arXiv metadata pass-through, RAW, NOT the ordering key)/upvotes (HF's OWN community count, genuine 0 kept)/numComments (HF's OWN discussion count)/url (`huggingface.co/papers/{id}` — HF's OWN scheme from the paper's own id). Client: `HfpapersGroup`, NEW \"Community-papers frontier\" section after Curated papers.","sha256":"f0f129f5091a6ad3859ac3071c602e975651268ed72784f9e83c48b214e5f86e"}
{"id":"doc:data-surfaces:0036","source":"doc","sourceId":"data-surfaces.md","title":"FrontierRadar render order (`artifacts/alloy/src/components/FrontierRadar.tsx`)","text":"- LeadersGroup: AI labs + AI for science + Chinese frontier + Regional·national + Sovereign + Open drone autonomy + Defense-tech groups, after the Router frontier.\n- Scholarly/community cluster order: Publications → Preprint → **Curated papers** (`CuratedGroup`) → Biomed → **Clinical** (`ClinicalGroup`) → **Research artifacts** (`ResearchGroup`) → **Funding** (`FundingGroup`) → **Policy** (`PolicyGroup`) → **Capital** (`CapitalGroup`) → **Standards** (`frontier/StandardsGroup`) → **Litigation** (`frontier/LitigationGroup`) → **Attention** (`frontier/AttentionGroup` + `frontier/BlueskyGroup`, one shared \"Attention frontier\" section) → **Demos** (`frontier/DemosGroup`) → **Health-grants** (`frontier/GrantsGroup`) → **Crates** (`frontier/CratesGroup`) → **Books** (`frontier/BooksGroup`) → **Audio** (`frontier/AudioGroup`) → **UK-government** (`frontier/GovukGroup`) → **Parliament bills** (`frontier/WestminsterGroup`, same \"UK-government frontier\" section) → **Hansard spoken** (`frontier/HansardGroup`, same \"UK-government frontier\" section) → **Extensions** (`frontier/ExtensionsGroup`) → **Images** (`frontier/ImagesGroup`) → **Journals** (`frontier/JournalsGroup`) → **Development** (`frontier/WorldbankGroup`) → **Archive** (`frontier/ArchiveGroup`) → **Add-ons** (`frontier/AddonsGroup`) → **Apps** (`frontier/AppsGroup`) → **FOSS-mobile** (`frontier/FdroidGroup`) → **Registry-pulse** (`frontier/CranGroup` + `frontier/PypiGroup` + `frontier/BrewGroup` + `frontier/MetacpanGroup`, one shared \"Registry-pulse frontier\" section) → **Infra-registry** (`frontier/ArtifacthubGroup` + `frontier/TerraformGroup`, one shared \"Infra-registry frontier\" section) → **Language-registry** (`frontier/GolangGroup` + `frontier/PubdevGroup` + `frontier/JsrGroup`, one shared \"Language-registry frontier\" section) → **Desktop** (`frontier/FlathubGroup`) → **UK-grants** (`frontier/UkriGroup`) → **Forum** (`frontier/ForumGroup`) → **JVM** (`frontier/MavenGroup`) → **.NET** (`frontier/NugetGroup`) → **PHP** (`frontier/PackagistGroup`) → **Ruby** (`frontier/RubygemsGroup`) → **Elixir** (`frontier/HexGroup`) → **Community** (`frontier/LobstersGroup`) → **Fediverse** (`frontier/MastodonGroup`) → **Open-science** (`frontier/OsfGroup`) → **Zenodo deposits** (`frontier/ZenodoGroup`) → **Crossref works** (`frontier/CrossrefGroup`) → **DataCite DOIs** (`frontier/DataciteGroup`) → **Bibliography** (`frontier/DblpGroup`) → **Open-access** (`frontier/PlosGroup`) → Signal → **Practitioner Q&A** (`QaGroup`) → **Tooling** (`ToolingGroup`) → **Security** (`SecurityGroup`) → Router. (ZenodoGroup + CrossrefGroup + DataciteGroup render inside the same \"Open-science frontier\" section, immediately after OsfGroup.)","sha256":"a441f6bba4490cfe51bc625f50dc90620f3e72121b5d3460df3dc428b247c04e"}
{"id":"doc:data-surfaces:0037","source":"doc","sourceId":"data-surfaces.md","title":"FrontierRadar render order (`artifacts/alloy/src/components/FrontierRadar.tsx`)","text":"- Wave-5 placements (2026-07-12): **Source-archive** (`frontier/SoftwareheritageGroup`, own section after Code) → **Wikipedia 7-day** (`frontier/WikipediaGroup`, in the shared \"Attention frontier\" section before Bluesky) → **USAspending** (`frontier/UsaspendingGroup`, in the \"Capital frontier\" section after CapitalGroup) → **Docker Hub** (`frontier/DockerhubGroup`, in the shared \"Infra-registry frontier\" section after Terraform) → **Snapcraft** (`frontier/SnapcraftGroup`, in the \"Desktop frontier\" section after Flathub) → **Dataverse** + **figshare** (`frontier/DataverseGroup` + `frontier/FigshareGroup`, in the \"Open-science frontier\" section after DataCite) → **Research-registry** (`frontier/RorGroup`, own section after Open-science) → **OpenAIRE** + **DOAJ articles** (`frontier/OpenaireGroup` + `frontier/DoajGroup`, in the \"Open-access frontier\" section after PLOS).\n- Wave-6 placements (2026-07-12): **GLEIF** (`frontier/GleifGroup`, NEW \"Corporate-registry frontier\" section after Capital) → **Open VSX** + **JetBrains** + **WordPress** (`frontier/OpenvsxGroup` + `frontier/JetbrainsGroup` + `frontier/WordpressGroup`, in the shared \"Extensions frontier\" section after ExtensionsGroup, in that order) → **Civitai** (`frontier/CivitaiGroup`, NEW \"Creative-model frontier\" section after Images) → **Anaconda** (`frontier/AnacondaGroup`, in the \"Registry-pulse frontier\" section after MetaCPAN) → **AUR** (`frontier/AurGroup`, in the \"Desktop frontier\" section after Snapcraft) → **Quay** (`frontier/QuayGroup`, in the shared \"Infra-registry frontier\" section after Docker Hub) → **EU data** (`frontier/EudataGroup`, NEW \"EU-data frontier\" section after UK-government) → **HF community papers** (`frontier/HfpapersGroup`, NEW \"Community-papers frontier\" section after Curated papers).\n- The newest groups (sixty-five as of wave 6) live as standalone components in `artifacts/alloy/src/components/frontier/` with shared honest-state helpers (`BlockUnavailable`, `SourceLinks`) in `frontier/shared.tsx`.","sha256":"38033e194c12b99b5f827c784e98bb7721d567f55fafa2c0159235a42a7e988f"}
{"id":"doc:data-surfaces:0038","source":"doc","sourceId":"data-surfaces.md","title":"`GET /verticals` (`src/routes/verticals.ts`)","text":"Wires every business vertical declared on the a-11-oy.com estate homepage to a live KEYLESS public data surface. 10-min cache only when ALL blocks OK else 30s negative window, in-flight dedup, 20/min rate limit.\n\n- **`kev`** (Defense · counter-UAS threat context) — CISA Known Exploited Vulnerabilities catalog, newest by CISA's own dateAdded, with its own 60-min sub-cache because the ~1.5MB catalog updates ~daily; NVD detail-page links.\n- **`fema`** (Insurance) — FEMA disaster declarations newest-first, $top=60 then deduped to one row per disasterNumber because the summaries dataset returns one row PER DESIGNATED AREA; fema.gov/disaster/{n} links.\n- **`nws`** (Insurance) — live NWS active alerts, `status=actual&message_type=alert` — the API has NO limit param — filtered to Extreme/Severe severity (a filter, never a rewrite), newest by sent, `activeTotal` = pre-filter count.\n- **`edgar`** (Finance) — SEC EDGAR full-text search `\"artificial intelligence\"`, last-30-day startdt/enddt window; fetches EDGAR's default relevance page only, so the list is honestly captioned \"top-matching\" (date-sorted WITHIN that page — NOT newest-of-window; the frontier `capital` block is the paginated newest-of-window surface), `totalHits` shown as REPORTED; real Archives doc URLs from cik+adsh+filename; descriptive UA required.\n- **`treasury`** (Finance) — debt to the penny, `sort=-record_date`, USD amounts passed through as RAW strings EXACTLY as Treasury states them, thousands separators are client-side formatting only.\n- **`property`** (Real estate) — HM Land Registry UK House Price Index, 5 regions UK/England/Scotland/Wales/NI, latest PUBLISHED month walked back from current-2 to current-5 because publication lags ~2-3 months and the refMonth is shown; the per-transaction PPD feed was REJECTED — `_sort=-transactionDate` exceeds 40s.","sha256":"0fcde231007d633ee3713626350484e7687622bb3621d488d6986adfa5b44c3e"}
{"id":"doc:data-surfaces:0039","source":"doc","sourceId":"data-surfaces.md","title":"`GET /verticals` (`src/routes/verticals.ts`)","text":"- **`space`** (Space/SDA) — Celestrak GP objects launched last 30 days, newest catalogued first by NORAD id desc (the catalog's own monotone, never an invented rank), real Celestrak SATCAT page links, `windowCount` = pre-trim count.","sha256":"9767a6ca63b09988cd5661f8e5367fca414a8a24713646d0b0b47cc6e6c7c02c"}
{"id":"doc:data-surfaces:0040","source":"doc","sourceId":"data-surfaces.md","title":"VerticalsRadar rendering (`artifacts/alloy/src/components/VerticalsRadar.tsx`)","text":"Right column after DarpaRadar: 5 vertical groups (Defense·counter-UAS, Insurance, Finance, Real estate, Space·domain awareness), each with CURATED leader chips — static hand-chosen reference links (Anduril/DroneShield/Dedrone/Fortem/Epirus; Verisk/CoreLogic/Cape Analytics/ZestyAI; Feedzai/ComplyAdvantage/Nasdaq Verafin/Zest AI; Zillow/CoStar/HouseCanary/Cherre; LeoLabs/Slingshot/ExoAnalytic/COMSPOC/True Anomaly) explicitly labeled CURATED, never presented as live data or ranked.","sha256":"3f11db80f527749a59a8ee199818bc082c26326bbf3191789e1b5b5ef82293db"}
{"id":"doc:data-surfaces:0041","source":"doc","sourceId":"data-surfaces.md","title":"`GET /estate` (`src/routes/estate.ts`)","text":"The sovereign estate window — the ENTIRE public estate enumerated from the upstreams' OWN registries, plus a fourth-wall `self` block. 10-min cache only when ALL blocks OK else 30s negative window, in-flight dedup, 20/min rate limit, `honestyPeek` wired into `/honesty` (8th window).\n\n- **`self`** (fourth wall, `MEASURED+DECLARED`) — the cockpit identifying itself as one of the artifacts it lists: `buildHash`, `serverTimeUtc`, `pid`, `nodeVersion`, `uptimeSeconds`, `rssBytes` MEASURED by the serving process **fresh on every request** (never cached — a stale server clock would be a fabrication); `sourceRepo` (Carlota-1/Machine-Innovate) + `productionDomain` (a11oy.net) DECLARED — the source repo is PRIVATE so it is stated, never fetched, and the payload says so verbatim (`sourceRepoNote`).\n- **`observer`** (fourth wall, other direction, `MEASURED`) — what the process sees on the caller's OWN request: `seenAt`, `userAgent` (verbatim header, null when absent), `address` (`req.ip` after one trusted proxy hop — honestly framed as \"what it sees, may be a proxy\"). Computed per request, echoed only to the requester it describes, never stored or cached — serving another requester's user-agent from cache would be fabrication.\n- **`repos`** — ALL szl-holdings GitHub org repos, GitHub's own `sort=pushed` ordering, paginated `per_page=100` up to 5 pages to full enumeration (`count` + `archivedCount` = rows actually enumerated). Sends `GITHUB_TOKEN` Bearer when present (anon GitHub API 403s from this egress — same as organism); keyless fallback preserved. **`type=public` is load-bearing**: with a token the endpoint returns everything the token can see — private repos leaked into the public payload until the cross-check caught it (MEASURED 2026-07-11: 50 enumerated vs 46 claimed); belt-and-braces `private !== true` filter behind it. **Cross-check**: `claimedTotal` = GitHub's own `public_repos` from the org meta endpoint (null when that fetch fails, never fails the block); enumerated ≠ claimed sets an honest mismatch `reason`, rendered amber; a match renders \"GitHub claims N ✓\".","sha256":"4500d53095c3d5b0bcec2139801d7ade7220384704f055adf660ccfc2696b02e"}
{"id":"doc:data-surfaces:0042","source":"doc","sourceId":"data-surfaces.md","title":"`GET /estate` (`src/routes/estate.ts`)","text":"- **`models`** — ALL SZLHOLDINGS HF models, the Hub's own `sort=lastModified` ordering, keyless, `limit=500`; uses `expand[]=downloads/likes/lastModified/pipeline_tag` because the default model list omits lastModified.\n- **`datasets`** — ALL SZLHOLDINGS HF datasets, the Hub's own `sort=lastModified`, keyless, `limit=500`.\n- **`spaces`** — ALL SZLHOLDINGS HF Spaces, the Hub's own `sort=createdAt` (newest created), keyless, `limit=500`; `private !== true` filtered defensively (keyless calls only see public Spaces anyway — the filter guarantees no leak if a token is ever added).\n- **`collections`** — ALL SZLHOLDINGS HF collections, listed exactly as the Hub returns them (no re-ranking), `limit=100`.\n- **`alignment`** (`DECLARED`) — a DERIVED cross-check (`computeAlignment`, never a fetch) between the GitHub `repos` side and the HF `models`+`datasets`+`spaces` side, matched by a `name-normalization heuristic`: `normalizeName` takes each id's LAST path segment (HF ids are `SZLHOLDINGS/<name>`, GitHub repo names carry no slash), lowercases it, and strips every non-alphanumeric. The `basis` string — surfaced verbatim as the block caption — is `\"name-normalization heuristic (lowercase, strip non-alphanumerics) — not a verified link\"`, so the match is NEVER claimed as a real link. Emits `matched` (GitHub↔HF pairs, each tagged `hfKind` model/dataset/space — one repo can match a model AND a dataset AND a space, all surfaced), `githubOnly` (repo names no HF asset name-matched), `hfOnly` (HF assets no repo name-matched); counts (`matchedCount`/`githubOnlyCount`/`hfOnlyCount`) are the array lengths ONLY, no invented totals. If ANY of `repos`/`models`/`datasets`/`spaces` is not OK the block is honest `UNAVAILABLE` with a `reason` naming the side that failed (\"a partial cross-check would be a partial fake\") — its counts go `null`. NOTE the alignment block does NOT gate the window cache TTL (`allOk` counts only `repos`/`models`/`datasets`/`spaces`/`collections`) — it is a view over those blocks, not a sixth enumeration.","sha256":"8a89f03b37ec76a05031ea0b84386279dc0cdda1bc9c5b3fa31eeae44388ea37"}
{"id":"doc:data-surfaces:0043","source":"doc","sourceId":"data-surfaces.md","title":"`GET /estate` (`src/routes/estate.ts`)","text":"Counts are rows actually enumerated — the HF list APIs claim no totals and none is invented. **Cap confession**: every capped fetch (GitHub 5×100 pages, HF lists limit=500, collections limit=100) detects when the upstream returned exactly its cap and sets an OK-block `reason` (\"enumeration cap reached … list may be incomplete\") so the \"ALL\" claim can never silently go stale; the client renders it as an amber note. Rendered by `SovereignEstate.tsx` (left column after OrganismPanel): fourth-wall banner first, then all five full enumerations in scrollable lists (nothing truncated), then the `alignment` cross-check block (`AlignmentBlock`, title \"Estate alignment\", caption = `basis` verbatim, matched-pairs / GitHub-only / HF-only lists), honest per-block UNAVAILABLE.","sha256":"25339dbf1747da43c941139dd1571c95d3a7c6e54fda739ef70447a7714383c2"}
{"id":"doc:data-surfaces:0044","source":"doc","sourceId":"data-surfaces.md","title":"`GET /estate/fit` (`src/routes/fit.ts`) — Layer-Fit Codex","text":"AirLLM ingest (wave 4, lyogavin/airllm, Apache-2.0) applied to SZL's own metal: \"peak VRAM ≈ one decoder layer when layers are streamed disk→GPU\". Query `?model=org/name` — the id is validated against a STRICT allow-list regex (`^[A-Za-z0-9_-][A-Za-z0-9_.\\-]*/[A-Za-z0-9_-][A-Za-z0-9_.\\-]*$`, ≤120 chars, enforced in the OpenAPI spec AND re-checked in the route) before any upstream URL is built, so it can never inject path/query syntax — each segment must START with an alphanumeric/`_`/`-`, which rejects dot-only segments (`..`/`.`): architect review 2026-07-12 live-probed `?model=../spaces` traversing to a different HF API path under the old `[A-Za-z0-9_.\\-]+` pattern (host-pinned, GET-only — but it falsified this exact guarantee, hence the tightening). Three honesty grades, never blended:\n\n- **REPORTED `params`** — HF Hub safetensors metadata pass-through (`api/models/{id}`): per-dtype parameter counts + total, the Hub's OWN numbers. `totalBytes` DERIVED as Σ(count × declared bytes/dtype) from a fixed known-dtype table — an unrecognized dtype makes it null, never guessed. Repos without safetensors metadata (GGUF-only, metadata-less — includes current SZLHOLDINGS models) get an honest null + reason.\n- **REPORTED `config`** — the repo's own `config.json` (`resolve/main`, fetch follows the Hub's CDN redirect): `num_hidden_layers` / `hidden_size` / `vocab_size` / `torch_dtype` / `tie_word_embeddings` verbatim; absent fields null. Gated repos 401 → config null with the reason stated (params can still be OK — the metadata API is public for gated repos; live-verified meta-llama/Llama-3.1-70B 2026-07-12).\n- **DERIVED `perLayer`** — `(total − vocab×hidden×(tied ? 1 : 2)) / num_hidden_layers × weighted avg bytes/param`. Computed ONLY when every input is present; `tie_word_embeddings` absent → indeterminate (transformers' default is NEVER assumed). Basis states verbatim: AVERAGE decoder layer = LOWER bound of the true streamed peak (MoE especially); KV cache, activations, embed/lm_head shards EXCLUDED.","sha256":"64e530efa392bad956759744f222202c37046b3c626dbb69a6e439a9564186cd"}
{"id":"doc:data-surfaces:0045","source":"doc","sourceId":"data-surfaces.md","title":"`GET /estate/fit` (`src/routes/fit.ts`) — Layer-Fit Codex","text":"- **DECLARED `nodes`** — one row per configured sovereign node. `vramBytes` from owner-declared env `A11OY_NODE_VRAM_GB[_2/_3]` (GiB interpretation ×1024³; `registry.ts` `declaredVramGb`) or null — the szl-meter exporters expose NO NVML memory gauge (live-verified 2026-07-12), so node VRAM is never MEASURED and never guessed from GPU marketing specs. Verdict `fits-layer-streamed-est` / `over-est` / `indeterminate` (any missing input → indeterminate); every row carries a `guard` string (\"VRAM-only estimate … never a plain 'fits'\").\n- **Standing caveats on every response** — `servingCaveat` (AirLLM's OWN tradeoff, REPORTED: per-token disk re-reads make this offline-batch tooling, not chat serving), `diskNote` (disk headroom UNKNOWN — no node disk telemetry), `attribution` (AirLLM/Gavin Li + SimJeg lineage; AirLLM's VRAM figures never restated as SZL results).\n\nPer-model cache: 10-min positive / 30s negative (status UNAVAILABLE), hard cap 100 entries with oldest-eviction (hostile id churn cannot grow memory), in-flight dedup per id; `fitLimiter` 15/min. `status: UNAVAILABLE` only when BOTH upstream fetches failed. Payload validated through `GetEstateFitResponse` (Zod). Rendered by `LayerFitCodex.tsx` (band-2 RIGHT column after ModesAnatomy): NOTHING fetches until the operator picks a preset (non-gated Qwen/Qwen2.5-3B-Instruct, Qwen2.5-72B-Instruct — NOT meta-llama, gated configs 401) or submits a free id (same regex client-side); honest idle/loading/UNAVAILABLE states; verdict colors green/amber/muted with the guard + caveats always visible. Verified live 2026-07-12: Qwen 3B → 147 MiB avg layer (tied, 36 layers), 72B → 1.63 GiB (untied); gated → params OK + config null + indeterminate; bogus id → 400.","sha256":"3379654adfe4e6e1f73fbb467b62e04754911b68223eaf10bf37f23c066a616d"}
{"id":"doc:data-surfaces:0046","source":"doc","sourceId":"data-surfaces.md","title":"`GET /ingest` (`src/routes/ingest.ts`)","text":"The ingest codex — the upstream sources SZL deliberately studied. Wave 1 (2026-07-12): kvcache-ai/ktransformers, zml/zml, GitHub profiles glesmyno + yunawyner. Wave 2 (2026-07-12, org Lean/proof estate — first-party repos, study notes still DECLARED): szl-holdings/lutar-lean, lean-kernel, szl-formula-ledger, szl-lake (the szl-lake entry explicitly resolves the name collision with Lean's `lake` build tool). Wave 3 (2026-07-12, first `article` kind): the NVIDIA Vera \"max single-threaded CPU at scale\" blog post (© NVIDIA, principles studied, no content re-used) — its agent-loop thesis is APPLIED as the MEASURED loop-tax split on every run (see \"Per-run loop tax\" below); every Vera perf number in the takeaways stays NVIDIA-REPORTED/partner-REPORTED, never adopted as an SZL measurement. Wave 4 (2026-07-12): lyogavin/airllm (Apache-2.0), applied as the Layer-Fit Codex + loop peak-vs-sum fields. Wave 5 (2026-07-12, two `article` kinds — commercial defense-AI product sites, principles studied, NO assets/content/fonts/copy re-used): **palantir-security-forge** (© Palantir — Security Forge product page) and **lumbra** (© Lumbra — lumbra.ai/mission/technology). Both are studied like the NVIDIA article: every capability/customer/deployment/market claim on those pages is Palantir/Lumbra/press-REPORTED and NEVER restated as SZL fact (Accenture 700k-person, \"closes in a single automated loop\", Lumbra's IC/DoD production deployments, the Bloomberg $338B figure). Several of their stated convictions are recorded as CONVERGENCE, not adoption — model-family-agnostic pipelines and receipt-backed provenance were already load-bearing in Alloy (multi-provider failover; the ed25519 receipt chain) before the study, so they corroborate rather than seed. The Lumbra entry additionally carries the \"fashion thinking\" takeaway (`appliesTo: frontend`): Lumbra's visual language (dark canvas, geometric-sans + monospace, 0px corners, oversized headlines, receipts/pass-fail as first-class motifs) is studied as INSPIRATION only — Alloy keeps its own #3af4c8 identity and re-uses no Lumbra amber (#F5C94A), fonts, logo, or copy; the honest lesson is to make Alloy's EXISTING truth-surfaces (receipt chain, honesty labels, pass/fail verdicts) more prominent, not to repaint. The wave also anchors the REAL, checkable field leaders SZL tracks with evidence — arXiv CVE-Bench (2503.17332), SEC-bench (2506.11791, NeurIPS 2025), PatchEval (2511.11019), ExploitBench (2605.14153), and open repos usestrix/strix, vxcontrol/pentagi, SEC-bench/SEC-bench — as the publications/leaders a MEASURED/REPORTED surface may cite instead of marketing. Wave 6 (2026-07-12, `article` kind — **seed-iq**, © AIX Global Innovations, Inc., a quantum concept): the honesty doctrine forces THREE labels never blended. (a) The physics PRIMITIVES the source cites are REAL peer-reviewed literature, verified with DOIs (no-cloning Wootters & Zurek Nature 299:802 1982; teleportation Bennett et al. PRL 70:1895 1993; GKLS/Lindblad Commun.Math.Phys. 48:119 1976; dissipative stabilization Mirrahimi et al. arXiv:1312.2017 2014; + Shor/Steane/Gottesman/Knill QEC). (b) The Seed IQ™ SYNTHESIS that fuses them into a governed teleportation-assisted \"restoration\" runtime — plus AIX's broader claims (adaptive multiagent control layer, Active Inference, the patented ΑΩ FoB HMC engine, quantum/data-center deployments) — is AIX-DECLARED: SZL audited no code, reproduced no result, measured nothing; the Zenodo report (zenodo.org/records/20585365) is AIX-authored and unaudited by SZL, never restated as SZL fact. (c) **Alloy is a CLASSICAL orchestrator with NO quantum hardware and claims none** — every mapping is an explicit ANALOGY / design inspiration held on the SZL side of the line, sharpening only how Alloy talks about and renders its OWN classical provenance (the (output, receipt) pair mirrors Seed IQ's (ρᴸ, Mₜ); recompute-per-request receipts mirror \"restore, don't copy\"; UNAVAILABLE/self-verify damping mirrors dissipation-as-restoring-force; chainStatus VERIFIED/PARTIAL/BROKEN/EMPTY mirrors Mₜ admissibility) and changing NONE of its actual mechanism. The `frontend` \"fashion thinking\" takeaway takes the governed-value/restore/commit/admissibility VOCABULARY as inspiration only — no AIX asset/logo/colour/trademark treatment re-used, Alloy keeps #3af4c8. Wave 7 (2026-07-12, `repo` kind — **omnigent** = omnigent-ai/omnigent, Apache-2.0, alpha): an open-source meta-harness orchestrating Claude Code/Codex/Cursor/OpenCode/Hermes/Pi + custom YAML agents with policy governance, OS (bwrap/seatbelt + L7 egress) and cloud (Modal/Daytona/E2B/CoreWeave/K8s/Databricks) sandboxing, session portability and live collaboration. Studied honestly: SZL has NOT run it, audited no code, reproduced no benchmark, re-uses no code/logo/asset — only its live GitHub meta (stars/pushedAt/SPDX) is REPORTED. Convergences recorded as CONVERGENCE not adoption (Alloy's multi-provider router + failover already generalize the meta-harness idea one level down; the ed25519 receipt chain already embodies governed accountability). The one genuinely-new idea — a first-class policy engine (per-action approval gates, enforced spend caps, tool allow-lists) — was recorded as a DECLARED gap at study time, then closed for real in two same-day steps (2026-07-12): spend cap + provider allow-list first, per-action approval gates after — the registry entry now records the gap as FULLY CLOSED with the E2E evidence, and the `GET /policy` section above documents all three gates. OS-sandboxing is noted as LIMITED-applicability (Alloy orchestrates bounded model calls, not arbitrary shell). Wave 8 (2026-07-12, `repo` kind — **neuro-jepa** = NYUMedML/Neuro-JEPA, arXiv 2606.14957, built on V-JEPA 2): a 3D ViT + MoE (2 shared + 16 experts, 6 active) foundation model self-supervised over 1,551,862 brain scans with the JEPA latent-predictive objective (predict the latent representations of masked regions from visible context — online encoder + EMA target, never voxel reconstruction). **Split license, recorded verbatim and never blended**: code MIT (© 2026 The NeuroJEPA Authors), weights CC-BY-NC-ND-4.0 (gated, HF card 401), GitHub SPDX NOASSERTION, paper CC BY 4.0. EVERY performance/accuracy/dataset number stays paper-REPORTED — SZL ran nothing, downloaded no gated weights, reproduced no benchmark, re-uses no code/weights/figure/asset; only the live GitHub meta (stars/pushedAt/SPDX) is REPORTED. The defining JEPA move — verify/predict in a compact DERIVED latent space rather than the raw object — is OPERATIONALIZED as the `latentVerification` MEASURED coverage block on `GET /invariants` (see that section): honest ANALOGY only, Alloy's \"latent space\" is a cryptographic digest+signature, NOT a learned embedding, nothing trained or predictive, changes no mechanism and does not upgrade Λ. Wave 9 (2026-07-12, `article` kind — **compute-pillars**, an OWNER-SUPPLIED UNATTRIBUTED PASTE): a CPU/GPU/LPU/NPU \"4 pillars of modern computing\" cheat sheet pasted with NO author, byline, publication, date, or URL — so authorship and license are UNKNOWN, recorded verbatim, and the entry renders with NO source link (`url: \"\"` — `IngestCodex.tsx` renders an honest non-link span, never a fabricated href; its GitHub meta is `NOT_APPLICABLE` like every article). The honesty split: the four silicon CLASSES are real checkable product categories (CPUs/GPUs universally; \"LPU\" is Groq's marketing name for its inference ASIC; NPUs ship in phone/laptop SoCs), but ALL of the piece's framing — the analogies, the CPU→GPU→NPU→LPU \"evolution\" arrow, \"one-size-fits-all is officially dead\", \"burning your budget\", the un-benchmarked LPU speed claims — is the anonymous author's editorial viewpoint, author-REPORTED at best, never SZL fact. APPLIED exactly as far as evidence reaches: the **fleet substrate ledger** on `GET /backbone/status` (see \"Other windows\") — own metal is the only claimable substrate (\"GPU\", DERIVED from the szl-meter's NVML evidence; class only, never a die/SKU claim); every cloud provider is honestly UNKNOWN (silicon unobservable through an OpenAI-compatible API — Google's TPU marketing stays Google-REPORTED, OpenRouter is doubly unobservable); LPU/NPU are honestly ABSENT from the fleet and never claimed. The \"ecosystem of specialists\" conclusion is CONVERGENCE with Alloy's pre-existing multi-provider router (one layer up the stack), not adoption. Two labels, split explicitly:","sha256":"33c93e8fdefc2786c9a08a029046d10df55ebcc22afce189779fce96a7a3e7a8"}
{"id":"doc:data-surfaces:0047","source":"doc","sourceId":"data-surfaces.md","title":"`GET /ingest` (`src/routes/ingest.ts`)","text":"Wave 10 (2026-07-12, agent-memory study — one `article` + three Apache-2.0 `repo` kinds): **perplexity-brain** (© Perplexity, \"Self-improving Memory for Agents\" blog, Jun 18 2026 — Brain is a CLOSED product SZL cannot inspect; its load-bearing reframe is the work-memory axis: remember what the AGENT did, what worked/failed/got corrected, not user-profile memory; every headline figure (+25% correctness on seen-before tasks, +16% recall, −13% cost on historical-context tasks) stays Perplexity-REPORTED \"early measurement\", methodology undisclosed, NEVER an SZL number), **zep-graphiti** (getzep/graphiti — bi-temporal never-overwrite invalidation with valid-time + provenance; structural cousin of the append-only receipt ledger, CONVERGENCE), **mem0** (mem0ai/mem0 — consolidation write-path add/update/merge/noop; SZL's doctrine forbids the silent delete/overwrite branch — any future synthesis pass PROPOSES with provenance, never rewrites; LOCOMO benchmark wins stay Mem0-REPORTED and publicly contested), and **letta-memgpt** (letta-ai/letta — LLM-as-OS tiered context paging; \"self-improving\" honestly read as memory-EDITING, not weight training). Key honesty findings recorded in the entries: Alloy's run ledger + receipts ALREADY constitute a provenance-linked work-memory store (CONVERGENCE, not adoption — Brain names the axis Alloy was on); the genuine gap is a scheduled synthesis pass, and the shipped `GET /memory` organ (see its section below) does the honest request-time version. Full leader survey (10 systems incl. MemOS, A-MEM, Reflexion, Voyager) + the SZL Brain design brief live in `.local/reports/brain-push/memory-leaders.md`.","sha256":"70b138c372925d8f53ebda7fdcfc384a57e8aa22ada357bb1e4b4eb28b216d32"}
{"id":"doc:data-surfaces:0048","source":"doc","sourceId":"data-surfaces.md","title":"`GET /ingest` (`src/routes/ingest.ts`)","text":"Wave 11 (2026-07-12, hallucination/decay study — two `article` + four `repo` kinds): **ferguson-decay-ledger** (© John Ferguson, \"The Hallucination Was Peer-Reviewed\" — his \"Decay Ledger\" coinage is credited wherever the term is used; his hop-decay node model is studied as HIS thesis and applied only as a labeled ANALOGY in `/decay`'s anti-decay map), **topaz-fabricated-citations** (© the authors — the Lancet fabricated-citation audit, PRIMARY; its figures carried with primary-vs-press status preserved, including the Retraction Watch 4,406-vs-4,046 transposition recorded VERBATIM as a demonstration of the thesis inside its own coverage), **semantic-uncertainty** (Farquhar et al. semantic-entropy repo — studied; `/decay`'s probe is ANALOGY ONLY to it: no NLI clustering, no sequence probabilities), **selfcheckgpt** (Manakul et al. — the sampling-consistency family the probe actually belongs to), **hallucination-tooling-survey** (Vectara leaderboard et al. — tooling landscape, scores stay THEIR scores), and **provenance-frontiers** (Sigstore/Rekor transparency-log lineage — CONVERGENCE with the receipt chain, not adoption). Applied surface: `GET /decay` + `DecayLedger.tsx` (see its section below).","sha256":"0c30a22b06d7012d2f816c54506c2c1c68c053ba64f911d634bf6943706e10c5"}
{"id":"doc:data-surfaces:0049","source":"doc","sourceId":"data-surfaces.md","title":"`GET /ingest` (`src/routes/ingest.ts`)","text":"Wave 13 (2026-07-14, frontier-retrieval study — one `article` + five `repo` kinds, `appliesTo: second-brain`/`honesty-doctrine`): **rrf-cormack2009** (© ACM 2009, Cormack/Clarke/Büttcher SIGIR 2009, DOI 10.1145/1571941.1572114 — the ONE technique ADOPTED in code: `/brain/ask` display order is now the RRF fusion, k=60 DECLARED from the paper, of BM25 + distinct-term coverage; equation re-implemented from the text, no code re-used; the paper's effectiveness wins stay the paper's — fixture tests pin implementation exactness, never quality), **graphrag** (microsoft/graphrag MIT — retrieval-through-relations thesis; convergence with the Brain Atlas is labeled ANALOGY: SZL edges are shared-rare-words, theirs are LLM-extracted; LLM community summaries baked into the index = generated prose in a MEASURED lane → DECLARED roadmap gap, blocker named), **splade** (naver/splade, license VERBATIM CC BY-NC-SA 4.0 © NAVER Corp. — NON-COMMERCIAL: study ONLY, no code touched; learned sparse expansion names the vocabulary-mismatch ceiling of the lexical lane, and needs a trained expander SZL does not have — un-adopted on both legal and evidentiary grounds), **raptor-rag** (parthsarthi03/raptor MIT — recursive-summary tree; its internal nodes are generated prose that gets CITED = worst-case taint under the citation gate; DECLARED gap, not adopted; SZL's honest abstraction layer is its hand-authored doc chunks), **colbert** (stanford-futuredata/ColBERT MIT — late-interaction MaxSim; per-query-term-evidence shape is ANALOGY to the coverage ranker, token identity not token meaning; neural encoder = the dependency wall the lane is DEFINED by staying behind — verifiability over ceiling, now a DECLARED design position), **bm25s** (xhluca/bm25s MIT — eager sparse scoring = the named MIT-licensed optimization path if the corpus ever grows; adopt-when-measured, not adopt-because-frontier; their 500x figures stay THEIR benchmarks). Corpus stays 269; nothing trains/evaluates/upgrades Λ.","sha256":"74609783856d17ce94fe9d56996e1c25ad31230a57e4f0e537cfae6af21d63dd"}
{"id":"doc:data-surfaces:0050","source":"doc","sourceId":"data-surfaces.md","title":"`GET /ingest` (`src/routes/ingest.ts`)","text":"Wave 14 (2026-07-14, open-weights-frontier — six `article` kinds, HF model cards where each vendor declares its own license, `appliesTo: frontier`/`honesty-doctrine`): **glm-5-2** (zai-org/GLM-5.2, MIT — card tag license:mit verbatim), **kimi-k2-6** (moonshotai/Kimi-K2.6, Modified-MIT — the lane-truth study: Alloy's moonshot lane pins `kimi-k2.6`, and wave 14 verifies that id EXISTS with this identity and license on the primary source; \"verified\" is precisely bounded — the model exists, Alloy has never served it, the lane stays honestly offline until MOONSHOT_API_KEY lands, and no capability claim transfers from card to app), **deepseek-v4** (deepseek-ai/DeepSeek-V4-Pro + DeepSeek-V4-Flash as ONE family entry, MIT — the alias lesson: the deepseek lane pins the `deepseek-chat` serving alias, so the served model is UNKNOWN until the provider response names it; the run receipt reports the SERVED id verbatim and the UI never captions the lane \"DeepSeek V4\" — an alias pin buys currency at the price of not knowing the model until the response arrives), **minimax-m3** (MiniMaxAI/MiniMax-M3, license recorded VERBATIM as HF license:other + license_name minimax-community + LICENSE link — no \"effectively Apache\" paraphrase; the wave-13 SPLADE precedent stands: license TEXT, not license vibe, gates any step beyond study), **mistral-large-3** (mistralai/Mistral-Large-3-675B-Instruct-2512, Apache-2.0), **qwen3-235b-a22b** (Qwen/Qwen3-235B-A22B, Apache-2.0 + on-repo LICENSE link). ZERO adoptions — every benchmark/price/positioning figure (e.g. DeepSeek's SWE-bench Verified 80.6% Pro number) stays the vendor's/reviewers' REPORTED claim, never SZL fact. Corpus stays 269; nothing trains/evaluates/upgrades Λ.","sha256":"3ba634ae9326a5fa4fdd86205f1b0b41a5ab7f284f0f5c6a9aeb4f778fa67a19"}
{"id":"doc:data-surfaces:0051","source":"doc","sourceId":"data-surfaces.md","title":"`GET /ingest` (`src/routes/ingest.ts`)","text":"- **DECLARED** — the registry itself (`src/data/ingestRegistry.ts`, generated from the ingest-wave clone packets): SZL's OWN authored distillations of each upstream's techniques. Each source carries its upstream `license` and `attribution` VERBATIM (\"Apache-2.0\", \"MIT\"; profile study notes marked as observational; first-party org repos say so outright). The takeaway notes are our own writing ABOUT the upstream — NEVER a claim of authorship over upstream code, nothing re-badged; `evidence` points at the upstream's own files, or — when the lesson came from a probe rather than a file (e.g. the Lumbra branding extract) — states that probe basis verbatim (null when the packet recorded none); `appliesTo` names the SZL surface each lesson targets (szl-nemo / sovereign-serving / forge-training / frontier / lean-ledger / backbone-loop / honesty-doctrine / frontend — the client `IngestCodex.tsx` has a per-value chip color and a neutral fallback, so a new value never breaks rendering). The profile entries honestly record the negative finding (synthetic template-repo farms) — an honest negative is a finding, not a smear: stated as observation with the enumeration basis.\n- **REPORTED** — live GitHub metadata fetched per request-cycle: repos get `stargazers_count`/`pushed_at`/`license.spdx_id` from `GET /repos/{id}`, profiles get `public_repos` from `GET /users/{id}` (Bearer `GITHUB_TOKEN` when present — same egress note as frontier — keyless fallback preserved; 8s timeout). Per-source honest `UNAVAILABLE` with the real failure reason and null numbers — one dead lookup never poisons the others and numbers are never invented. Sources of kind `article` have NO GitHub identity: their meta block is `NOT_APPLICABLE` (reason \"web article — no GitHub identity to fetch\") — no fetch is EVER attempted, it is a healthy terminal state distinct from `UNAVAILABLE`, and it never shortens the cache window.","sha256":"67a90218da1a88167c966d55feae7e472994f90913a3023d693dbe7a9727cc36"}
{"id":"doc:data-surfaces:0052","source":"doc","sourceId":"data-surfaces.md","title":"`GET /ingest` (`src/routes/ingest.ts`)","text":"10-min cache only when NO source's GitHub meta is `UNAVAILABLE` (`NOT_APPLICABLE` counts as healthy), else 30s negative window; in-flight dedup; 30/min rate limit. Payload validated through `GetIngestResponse` (Zod) before serving. Rendered by `IngestCodex.tsx` (full-width band below FormulaCodex|ThesisCorpus, above the footer — never in a narrow column): per-source header (link, license chip, REPORTED meta line or amber UNAVAILABLE), attribution verbatim in italics, collapsible DECLARED takeaway list with appliesTo chips + evidence links, and the doctrine note rendered verbatim.","sha256":"a3fd19ef609972f020297f4618f4e0d5ec9b7f272de1182ee824abd6d0dc87e0"}
{"id":"doc:data-surfaces:0053","source":"doc","sourceId":"data-surfaces.md","title":"`GET /velocity` (`src/routes/velocity.ts` + `src/data/velocitySnapshot.ts`) — Terminal Velocity tracker","text":"The agentic-frontier tracker answering \"who leads *terminal velocity*\". Doctrine split, three labels never blended:\n\n- **DECLARED** — the snapshot itself (`src/data/velocitySnapshot.ts`): hand-captured on the stated `capturedAt` dates, NOT live-fetched (tbench.ai is JS-rendered, Artificial Analysis is gated), so there is **no upstream call and no cache** — the source URLs are the live truth and the block says so. Edit deliberately and bump the `capturedAt` fields on refresh.\n- **REPORTED** — every leaderboard SCORE is the upstream board's OWN published number, copied verbatim (`basis: \"REPORTED\"` on each board). A blank upstream cell is `null` (rendered \"no number\"), **NEVER a fabricated figure** — e.g. Claude Fable 5 and GPT-5.6 Terra carry `score: null` on the TB 2.1 board because the captured table published no number for them.\n- **MEASURED / NOT_EVALUATED honesty** — the two Terminal-Bench harnesses are **SEPARATE boards** (`tb-2-1-official` self-reported vs `tb-hard-artificialanalysis` independent, ~26 pts apart) and are **never merged, averaged, or unified** into one ranking; each caveat states what THAT board measures and why its scale differs. Inference-speed leaders (Cerebras/SambaNova/Groq, tokens/sec) are a DISTINCT axis from capability scores and captioned as such. Alloy's sovereign model is `NOT_EVALUATED` — no Terminal-Bench run exists, it is never assigned a score, and the note states Alloy **TRACKS** the frontier and routes toward it, it does not beat it. `sovereign.eval` carries the **reproducible path to a real score**: the OFFICIAL Terminal-Bench harness shipped at `docs/forge/eval-terminalbench.ps1` (Harbor / terminus-2 agent), run on owner metal (Docker + a reachable sovereign endpoint — the Alloy container has no Docker, so it cannot run here); `runStatus` is `RUN_PENDING` and `result` stays `null` until a REAL signed run lands, at which point it renders as its OWN board (never merged with the two upstream boards — a low score is honest, never faked). `gapNote` records the MEASURED reality that the frontier moved to the GPT-5.6 family while the Replit AI gateway measured those ids UNSUPPORTED (2026-07-12), so Alloy pins GPT-5.5 + Gemini 3.5 Flash.","sha256":"04e882be9311bbc3cdde8065ebf831cb03019683ea1d815292d035891364e4b1"}
{"id":"doc:data-surfaces:0054","source":"doc","sourceId":"data-surfaces.md","title":"`GET /velocity` (`src/routes/velocity.ts` + `src/data/velocitySnapshot.ts`) — Terminal Velocity tracker","text":"No live fetch, so no cache/dedup; 60/min rate limit; static `no-store`. Payload validated through `GetVelocityResponse` (Zod) before serving. Rendered by `TerminalVelocity.tsx` (full-width band immediately below `FrontierRadar`, never a narrow column): two-column masonry of the SEPARATE boards, each row rank/model/provider + REPORTED score (or \"no number\"); a **live pin-join** overlays an \"Alloy pin\" badge on rows whose model matches Alloy's currently-pinned provider models (read live from `GET /backbone/status` `providers[].model`, normalized lowercase / spaces-hyphens-underscores-stripped so \"GPT-5.5\"↔\"gpt-5.5\" — dots kept; empty when the status is unavailable, an honest absence never a fabricated pin); then the tokens/sec speed leaders, the NOT_EVALUATED sovereign callout, the \"Make the run\" eval-harness panel (`block-velocity-sovereign-eval`) — RUN_PENDING with the runnerPath while `result` is null, upgrading to a MEASURED result board once a real signed run lands — the MEASURED `gapNote`, and the doctrine note verbatim.","sha256":"c8a93a20d87b082bd6d2ad663a9411f0e5497eb6f5cdf99da3af1cb35f9aa648"}
{"id":"doc:data-surfaces:0055","source":"doc","sourceId":"data-surfaces.md","title":"`GET /leaders` (`src/routes/fieldLeaders.ts` + `src/data/fieldLeadersRegistry.ts`) — Field Leaders radar","text":"The per-field leader radar — the generalization of the one-off Terminal Velocity wall. Three honesty grades, never blended:\n\n- **REPORTED rows** — per field, the current leading repos on the Hugging Face Hub, fetched LIVE keyless and passed through verbatim (`/api/models?search=…|pipeline_tag=…&sort=downloads&direction=-1&limit=5`; the datasets field uses `/api/datasets?sort=downloads`). `downloads`/`likes` are the Hub's OWN counters (missing → `null`, never invented). **Caption doctrine (binding)**: each field's caption states EXACTLY what its ordering means — a `search=` query is a **NAME-MATCH** (\"popularity of repos whose name matches the term — never capability, never field leadership\"); `pipeline_tag=` is the Hub's own task taxonomy; the datasets field is \"most-downloaded, all domains\". Fields: agentic (search=agent, links `/velocity` for the real benchmark picture instead of duplicating scores) · reasoning (search=math) · quantization (search=gguf) · retrieval (pipeline_tag=sentence-similarity) · multimodal (pipeline_tag=image-text-to-text) · biomed (search=medical) · security (search=security) · datasets (Hub downloads).\n- **DECLARED `szl` stance** — per field, SZL's OWN position (`stance: LEADS | TRACKS | ATTEMPTED | NOT_EVALUATED`, `label` always DECLARED, falsifiable `basis`, live `evidenceUrls`). **SZL is NEVER inserted into anyone else's ranking** — the UI renders the stance in a visually separate band captioned \"DECLARED stance — not a row in this list\". LEADS is claimed on exactly TWO fields where receipt-backed evidence exists (sovereign-serving: own-metal default routing + MEASURED NVML energy + full-ledger; verifiable orchestration: Ed25519 hash-chained receipts + browser-verified Living Paper claims + trustless offline verifier), each basis scoped \"among our studied set\" and naming what would falsify it. Everywhere else: TRACKS / ATTEMPTED / plain NOT_EVALUATED (agentic stays NOT_EVALUATED — no Terminal-Bench run; reasoning ATTEMPTED never upgrades Λ).","sha256":"f443b60507329bd105412e066bb5470992c80212b4396035db3d156631271c2e"}
{"id":"doc:data-surfaces:0056","source":"doc","sourceId":"data-surfaces.md","title":"`GET /leaders` (`src/routes/fieldLeaders.ts` + `src/data/fieldLeadersRegistry.ts`) — Field Leaders radar","text":"- **NOT_TRACKED ≠ UNAVAILABLE** — the two differentiator fields (sovereign-serving, verifiable) have `query: null` because no meaningful public query exists: honest `NOT_TRACKED` with an intentionally EMPTY leaders list (the DECLARED basis carries the weight). A failed upstream fetch is `UNAVAILABLE` with empty rows — never invented ones.\n\nCache: whole window 10 min when every fetchable field is OK, 5 min when some degraded, 30 s only when ALL fetchable fields failed (negative window); in-flight dedup; bounded fan-out ≤6 (~8 Hub calls/refresh); 60/min limiter. Payload validated through `GetFieldLeadersResponse` (Zod). Rendered by `FieldLeaders.tsx` — full-width wall directly after TerminalVelocity: 2/3-column masonry of field cards (leader rows with Hub numbers verbatim + ordering caption + separate stance band + Hub source link), doctrine footer verbatim from the payload.","sha256":"ecada06aa6c46ed380125a86be9b686d74cec691568e3ed47ac0b78ae89f4e95"}
{"id":"doc:data-surfaces:0057","source":"doc","sourceId":"data-surfaces.md","title":"`GET /forge/family` (`src/routes/forgeFamily.ts` + `src/data/szlModelFamily.ts`) — SZL Forge Family","text":"The DECLARED model-family roadmap for the owner's Codex-designed sovereign agent family, joined against the live Hugging Face Hub. Never-blended bands (DECLARED registry · REPORTED Hub · DERIVED model-join · ReceiptAgent + Khipu release-contract/forge-evidence · DERIVED Second-Brain DATASET):\n\n- **DECLARED `declared.models`** (static registry, `src/data/szlModelFamily.ts` — fetches NOTHING) — 4 entries: two `WEIGHT_MODEL` (SZL-Forge-1.5B-ReceiptAgent, SZL-Khipu-1.5B — Hub repo renamed 2026-07 from SZL-Khipu-1.5B-BrainNavigator, old links redirect; the join matches the LIVE id) + two orchestration planes (Ayllu `COUNCIL_PLANE`, Yupaq `COMPUTE_PLANE`; `trainingStatus: DECLARED_PLAN` — a plan, NOT a weight artifact). The static registry keeps every weight model at the honest floor (`trainingStatus: UNTRAINED`, `evalStatus: NOT_EVALUATED`); at serve time the route's `reconcileDeclared()` upgrades a weight-model row to `TRAINED_RECEIPT_VERIFIED` / `EVAL_RECEIPT_VERIFIED` ONLY when that model's OWN fail-closed forge-evidence band (committed owner-signed receipts, ed25519-verified per request) reports it — planes pass through untouched, a model with no verified receipt stays UNTRAINED, and zero eval numbers are ever invented (eval figures live in the verified eval receipt, never typed into the registry). Per-entry `base`/`adapter`/`capabilityProfile`/flags (`proposalOnly`/`receiptBound`/`failClosed`) + `reportedClaims[]` are DECLARED design intent; owner-laptop figures are carried as REPORTED strings VERBATIM (the label lives in the string, never re-badged as fact). Only the two weight models carry an `expectedHfRepoId` (a reserved id — existence is DERIVED in the JOIN band, never asserted). **Ayllu (this DECLARED 11-persona model-routing council) is DISTINCT from the deployed Ayul 10-role research council in `/council` — different plane, different count, never conflated.**","sha256":"739cda1e6d5bb64d47cdc9d68491766aac10bb7cc97cbd1e3852d920be4f265a"}
{"id":"doc:data-surfaces:0058","source":"doc","sourceId":"data-surfaces.md","title":"`GET /forge/family` (`src/routes/forgeFamily.ts` + `src/data/szlModelFamily.ts`) — SZL Forge Family","text":"- **REPORTED `hub`** — a LIVE keyless probe of the SZLHOLDINGS org's models (`huggingface.co/api/models?author=SZLHOLDINGS&limit=100`, UA-stamped, `AbortSignal.timeout`), passed through EXACTLY (per-repo id/pipelineTag/downloads/lastModified, the Hub's OWN counters — missing → null). `status: OK` with the enumerated repos, or honest `status: UNAVAILABLE` + `note` on any fetch failure (zero invented repos). The Hub claims no total so none is invented.\n- **DERIVED `join`** — publish state for each weight model, DERIVED by matching its `expectedHfRepoId` against the live `hub` repos: `PUBLISHED` = a repo with that id EXISTS (repo existence ONLY — NEVER a trained/serving claim; `matchedRepoId` names it), `NOT_PUBLISHED` = Hub healthy + no match, `UNKNOWN` = the Hub probe failed (publish state cannot be determined — never fabricated). Planes are not joined (no reserved id).\n- **DERIVED `brainDataset`** — the Second-Brain in-repo lane's public projection, published to the Hub as a **DATASET** (DATA, never a model — so it lives OUTSIDE the model `join` and has its OWN keyless probe: `huggingface.co/api/datasets?author=SZLHOLDINGS&limit=100`, own 10-min/30 s cache + in-flight dedup). `publishStatus` is DERIVED against that datasets probe (`PUBLISHED`/`NOT_PUBLISHED`/`UNKNOWN`, repo-existence ONLY, `matchedRepoId` names it; `datasetUrl` set ONLY when PUBLISHED). `corpusBinding` compares the COMMITTED dataset manifest's superset fingerprint (`BRAIN_DATASET_MANIFEST.supersetCorpusSha256`, from the fs-free `src/data/brainDataset.data.ts`) against the SERVED corpus fingerprint (`BRAIN_CORPUS_MANIFEST.corpusSha256`): `BOUND` when equal, `DRIFTED` when not (flagged LOUDLY — amber). **This is a committed-manifest ↔ served-corpus binding, NOT a Hub byte verification** — Hub bytes are never fetched, so PUBLISHED is repo-existence only, never a synced-bytes/serving/trained/eval claim. `projection` carries the MEASURED public counts (publicChunkCount = doc chunks + the 269-formula corpus + DECLARED ingest takeaways, MINUS the excluded owner-infra OWNER-SETUP.md chunks; supersetChunkCount / excludedChunkCount / projectionSha256 / a `secretScan` verdict are all DERIVED at gen time). **The exact figures live ONLY in the committed manifest, never transcribed into this prose** — this doc is itself ingested into the corpus, so hardcoding a corpus-derived count here would drift it the moment the doc changes. The committed `brainDataset.data.ts` is byte-parity-tested against the generator (`renderDatasetDataModule`) + the manifest is `toEqual`-tested vs `buildPublicDatasetProjection().manifest`, so it can never silently drift from the served corpus. A BM25 score over these chunks is lexical relevance, NEVER correctness; the two Brain lanes never blend; the owner's private Brain is never published.","sha256":"2a4a316c1957d6aa1eee5c6805d56cd329cb90b856a017344a7656bb54f0b833"}
{"id":"doc:data-surfaces:0059","source":"doc","sourceId":"data-surfaces.md","title":"`GET /forge/family` (`src/routes/forgeFamily.ts` + `src/data/szlModelFamily.ts`) — SZL Forge Family","text":"Cache: 10-min positive / 30 s negative window (keyed on hub status), in-flight dedup; the datasets probe has its OWN identical cache. Both probes run in parallel (`Promise.all`). Payload validated through `GetForgeFamilyResponse` (Zod). Rendered by `SzlForgeFamily.tsx` — full-width wall directly after CouncilRegistry: verbatim doctrine, a DERIVED posture summary (`models.every(...)` — never asserted), the DECLARED model grid, the live Hub band, the publish-join table, the ReceiptAgent + Khipu release-contract/forge-evidence bands, and the Second-Brain DATASET band (BAND 8 — DERIVED publishStatus, DERIVED corpusBinding with DRIFT loud/amber, projection counts, Hub link only when PUBLISHED). Cross-referenced from `SecondBrain.tsx` via the SAME `useGetForgeFamily` hook (react-query dedupes by query key — no extra fetch, no `/brain` churn): a link surfaces ONLY when `publishStatus === PUBLISHED` && `matchedRepoId`. UNTRAINED/UNKNOWN/DRIFTED render amber (pending — never red as failure, never green as success); receipt-verified statuses render as good ONLY because the payload derived them from verified receipts; even the wall's footer prose is DERIVED (the blanket \"weights UNTRAINED\" clause renders only while no verified receipt has flipped any weight model); PUBLISHED never upgrades training; nothing here upgrades Λ.","sha256":"1d456fb8a0b68f1a20c4cf4b211eec53eb16cbe2775819ff46a4b6b4eed36faf"}
{"id":"doc:data-surfaces:0060","source":"doc","sourceId":"data-surfaces.md","title":"`GET /quant` (`src/routes/quant.ts` + `src/lib/quantMath.ts` + `src/data/quantClaims.ts`) — Quant engine","text":"Real quant-finance math run for real over the estate's OWN series — the honest answer to \"find the top quant repos/arXiv and make it ours\": study the leaders (REPORTED, cited), run their methods for real (DERIVED), claim no advantage not MEASURED (ROADMAP). Deterministic and DB-free (pure math + a seeded panel), so the whole window is stable per boot — nothing fetched, nothing persisted.\n\n- **SIMULATED panel** — `simulatedPricePanel()` in `quantMath.ts` builds a deterministic price panel (mulberry32 PRNG, one latent market factor + idiosyncratic noise; 24 assets × 252 observations at a fixed seed). It is a **labeled simulation, disclosed everywhere** (provider.name/label/status/note, panel.label, doctrine, OpenAPI description, and a UI provider band + an `OVER SIMULATED PANEL` header chip) so DERIVED-over-SIMULATED can never be mistaken for DERIVED-over-live-market-data. Wiring a real market-data provider replaces ONLY the panel — the math below is unchanged and stays DERIVED.\n- **DERIVED math** (all computed in-process from the panel's own returns, never a claimed benchmark):\n  - **Ledoit-Wolf (2004) shrinkage** — `ledoitWolfShrinkage()` returns the data-estimated intensity δ ∈ [0,1] toward a scaled-identity target μI (analytic, no tuning parameter).\n  - **RMT eigen-cleaning** — sample covariance → correlation (unit diagonal → σ²=1) → Jacobi eigenvalues (validated: trace preserved, known matrices exact) → Marchenko-Pastur edge λ± = (1±√q)² with q = assets/observations. Eigenvalues strictly above λ₊ are signal (kept verbatim); the sub-edge bulk is replaced by its average, **preserving total trace exactly** (Laloux/Bouchaud/Potters 1999 convention). `signalEigenvalues`, `bulkAverage`, `cleanedEigenvalues`, `varianceExplainedBySignal` all DERIVED.\n  - **0-dim topological persistence** — `persistence0()` runs single-linkage (union-find) over the Mantegna metric √(2(1−ρ)); n points → **n−1 finite bars + 1 infinite bar** (death:null), the exact H₀ barcode. `longestFinite`, `finiteBars` DERIVED.","sha256":"00e071724bb3d9d94982f48d191e8f4202fd2a91758fa5dbe13172d255e18b7a"}
{"id":"doc:data-surfaces:0061","source":"doc","sourceId":"data-surfaces.md","title":"`GET /quant` (`src/routes/quant.ts` + `src/lib/quantMath.ts` + `src/data/quantClaims.ts`) — Quant engine","text":"- **REPORTED claims** (`quantClaims.ts`, `QUANT_CLAIMS[7]`) — the leaders in the space carried verbatim WITH citations, never as SZL results: Ledoit-Wolf 2004, Marchenko-Pastur 1967, Laloux-Bouchaud 1999, Gidea-Katz 2018 (arXiv:1703.04385), Mantegna 1999, giotto-tda 2021 (arXiv:2004.02551), NVIDIA RAPIDS/cuML. **Every row has `szlMeasured: null` and `status: ROADMAP`** — SZL asserts NO measured advantage and NO GPU speedup (a GPU speedup cannot be MEASURED on this container — typing a number would be fabrication). Each carries an honest `szlPosture` (implemented-as-DERIVED / partially-implemented / reference-tool / not-measured).\n- **Formula corpus tie-in** — `total` = `FORMULA_CORPUS.length` (MEASURED at runtime, 269), `lockedProven` = 8 (DECLARED — mirrored from the Lean no-axiom `locked_count_eight`, never re-derived here). The note explicitly rejects the \"180 formulas\" over-claim as having no verified source. Nothing here upgrades Λ (stays Conjecture-1).\n\n`quantLimiter` 20/min; payload validated through `GetQuantResponse` (Zod). Rendered by `QuantEngine.tsx` — full-width wall directly after FieldLeaders (before the FormulaCodex|ThesisCorpus band): DERIVED + `OVER SIMULATED PANEL` header chips, SIMULATED provider/panel band, three DERIVED math cards (shrinkage δ bar, RMT eigenvalue spectrum with signal bars accented above the MP edge, H₀ persistence barcode), a MEASURED/DECLARED formula-corpus band, the REPORTED cited-leaders list (each with a `cite` link + `szlPosture`), a rendered provenance legend, and the doctrine footer verbatim.","sha256":"6118344c34f8ee4e4b2d95cb1b4eddc7bc71a12e076ad0e32624d899034ed0fc"}
{"id":"doc:data-surfaces:0062","source":"doc","sourceId":"data-surfaces.md","title":"`GET /lean` (`src/routes/lean.ts`)","text":"The Lean proof ledger window for szl-holdings/lutar-lean — three honesty grades in one payload, never blended:\n\n- **REPORTED `ci`** — the repo's OWN latest GitHub Actions verdict per workflow (`lake-build.yml`, `lean.yml`): `GET /repos/szl-holdings/lutar-lean/actions/workflows/{wf}/runs?per_page=1&branch=main` (Bearer `GITHUB_TOKEN` when present, same egress note as frontier; 8s timeout). Verdicts pass through EXACTLY as GitHub returns them — a `failure` conclusion renders red as-is (at capture 2026-07-12: lake-build #499 `failure` and lean #757 `success` on the SAME sha 85dee499 — both shown; cherry-picking the green one or re-polling an older sha until green would be fabrication by omission). Honest `UNAVAILABLE` with the real reason when the fetch fails.\n- **REPORTED `numbers`** — the repo's own machine-generated corpus counts fetched from its committed `.github/data/lean_numbers.json` (raw.githubusercontent.com): declarations / axiomsUnique / sorriesRaw / sorriesNoncomment + the `ref` the counter ran at, all VERBATIM — the server never recounts, never rounds, never re-attributes them to a different ref. `lockedProven` = the frozen DECLARED set of 8 {F1,F4,F7,F11,F12,F18,F19,F22} (matches FormulaCodex's locked-proven chips; changes only by explicit re-lock — last re-lock 2026-06-10 when F4/F7 were upgraded from vacuous placeholders to genuine proofs, machine-enforced by the no-axiom theorem `Lutar.Wave8.AxiomDisclosure.locked_count_eight`).\n- **MEASURED `localKernelCheck`** — the verdict of an actual `lake build` of the Λ-relevant targets (Lutar.Invariant, Lutar.Uniqueness, Lutar.Uniqueness.TheoremU, Lutar.Round13.Lambda_Uniqueness, Lutar.Puriq.Formulas.ProvedFormulas) run in THIS container by `.local/lean-lab/run-lean-lab.sh` (elan → clone → `lake exe cache get` → targeted build; Mathlib compiled from source is infeasible on 2 vCPU, hence the cache). The verdict lives in `src/data/leanKernelCheck.ts` as a committed constant transcribed VERBATIM from the lab's `kernel-check.json` — sha, toolchain, lean version, targets, build seconds, host, checkedAt. In dev, a guarded fs read prefers a fresher `.local/lean-lab/kernel-check.json` when present (lab output visible without redeploy); prod serves the committed constant only. A FAIL is transcribed as FAIL — never retried at an older sha until green. `UNAVAILABLE` (with note) until a run completes; PASS means exactly \"these targets kernel-checked at this sha on this hardware\", nothing more. First completed run 2026-07-12T06:01:08Z: **PASS** @ sha 85dee499, toolchain v4.18.0, 2761/2761 lake jobs, 15s targeted build after `lake exe cache get` (6471/6471 files), host replit-workspace-2vcpu — transcribed into `leanKernelCheck.ts`. Lab quirks: the platform strips nested `.git` dirs shortly after clone (sha pinned to `.local/lean-lab/pinned-sha` immediately), and long detached processes get reaped — the lab must run as a temporary managed workflow, not `nohup`.","sha256":"0fee6f54c6e829c126d9d838d24a4d77022edbdb4241e582f646266f4e9200d0"}
{"id":"doc:data-surfaces:0063","source":"doc","sourceId":"data-surfaces.md","title":"`GET /lean` (`src/routes/lean.ts`)","text":"- **`conjectures`** — doctrine locks rendered from the payload: Conjecture-1 (Λ uniqueness — unconditional uniqueness machine-checked FALSE via the maxAgg counterexample; only conditional Theorem U holds; NO ci pass or kernel-check PASS can upgrade it) and Conjecture-2 (Khipu BFT liveness, Wave23 conditional). Evidence links to the repo's own BOUNTY.md / khipu-consensus.\n\n10-min cache when ci AND numbers are OK, else 30s negative window; in-flight dedup; 15/min (`leanLimiter`); payload validated through `GetLeanResponse` (Zod). Rendered by `LeanLedger.tsx` (full-width band between FormulaCodex|ThesisCorpus and IngestCodex): 3-column grid (CI verdicts / corpus counts + locked-proven chips / local kernel check with provenance lines), conjecture lock rows, doctrine footer verbatim.","sha256":"11002dfa60f3b3735a9a1ed7f5eda5a66dd86c469d0220020b99019c0f97f021"}
{"id":"doc:data-surfaces:0064","source":"doc","sourceId":"data-surfaces.md","title":"`GET /lean/factory` (`src/routes/leanFactory.ts`) — Conjecture Factory","text":"The Conjecture Factory batch ledger — 180 machine-generated Lean 4 candidates, every one judged by the real Lean kernel on THIS container. Despite the name, **the batch contains ZERO conjectures**: every candidate is an INTEGERIZED concrete instance of an already-SYMBOLIC corpus identity, with declared lineage per candidate; CONJECTURE-class corpus items (Conjecture-1 Λ-uniqueness, Conjecture-2 BFT) are DECLARED excluded with reasons and stay open.\n\n- **Pipeline** (`.local/lean-lab/factory/`): `generate.py` — deterministic template generator (sha256 recorded in the payload; double-run diff clean), 160 candidates across 10 integer families (bft-quorum-overlap, rs-singleton-mds, kraft-integer, amgm-square, quadratic-completion, cauchy-schwarz-2d-int, euler-polyhedra, horus-geometric, additivity-linear, quantum-code-params) + 20 sovereign slots + 19 explicit exclusions. `sovereign.py` — drafts ONLY the tactic line for the 20 sovereign candidates via the sovereign chain (tower first, laptop next; one attempt per node, 60s; every attempt recorded honestly incl. HTTP 530s); the STATEMENT stays canonical from the manifest, so a kernel accept certifies exactly the requested statement — a model can never get credit for proving something else. `judge.py` — per-file core-Lean `lean` check from the lutar-lean lab cwd (Mathlib-import checks measured >115s/file → core-only batch; lakefile untouched), incremental `status.jsonl`, final `factory-run.json`.\n- **Verdicts** (MEASURED): `KERNEL_ACCEPTED` / `KERNEL_REJECTED` (stderr excerpt verbatim) / `NO_OUTPUT` / `UNAVAILABLE` / `UNATTEMPTED` — failures and offline nodes shown as-is, never backfilled. Run of 2026-07-12T14:41:34Z: **180/180 KERNEL_ACCEPTED** (160 template + 20 sovereign, all 20 tactics drafted by laptop qwen2.5:3b — tower recorded HTTPError 530 per attempt), judge pass 29s, toolchain v4.18.0.","sha256":"abb4ebadd35a4e4027e385e07a8e1d564af25387d6f74ecb3c8f25ad1b86de05"}
{"id":"doc:data-surfaces:0065","source":"doc","sourceId":"data-surfaces.md","title":"`GET /lean/factory` (`src/routes/leanFactory.ts`) — Conjecture Factory","text":"- **Serving**: committed constant `src/data/conjectureFactory.ts` transcribed VERBATIM from the lab's `factory-run.json` (same pattern as `leanKernelCheck.ts`); in dev a guarded fs read prefers a fresher lab file (shape-validated, malformed → warn + fall through), prod serves the committed constant ONLY. Honest `UNAVAILABLE` (run null) until a completed run is transcribed. Own limiter 15/min — deliberately NOT coupled to `/lean`'s GitHub-fetch caching. Payload validated through `GetLeanFactoryResponse` (Zod).\n- **Doctrine**: accepts NEVER expand locked-proven (stays exactly 8), NEVER upgrade Conjecture-1/2, and are pipeline evidence, not new mathematics; counts are MEASURED tallies of real verdicts.\n\nRendered by `ConjectureFactory.tsx` — full-width wall between LeanLedger and OuroborosInvariants: verdict tally pills, provenance line (batch/judge seconds/toolchain/lab sha/generator sha256/host/checkedAt), template vs sovereign tier cards, 10-family grid, candidate rows (non-accepted + sovereign tier by default, all 180 on demand; sovereign rows state \"tactic drafted by node · model — statement stayed canonical\"), collapsible DECLARED exclusions, doctrine footer verbatim.","sha256":"415188f527cb2564b2c26f934acdc518de750acdb5f597515045366670ebbee3"}
{"id":"doc:data-surfaces:0066","source":"doc","sourceId":"data-surfaces.md","title":"`GET /formulas/answers` (`src/routes/formulaAnswers.ts`) — Formula Answers","text":"The combined estate formula corpus, answered by the estate's OWN sovereign model, each answer backed by a signed `/run` receipt. Directly serves the owner's directive: put the formulas up and have SZL-1 answer them, and that's the receipts.\n\n- **Corpus** (`scripts/src/formula-corpus-build.ts` → `src/data/formulaAnswersCorpus.ts`): a DETERMINISTIC 269-entry corpus combining ALL formula sources the estate carries — szl-formula-ledger (30), szl-forge index (80), and the formal-block statements (160, deduped to 159) — each entry keyed by a stable id with `source`/`sourceId`/`statement`/`truncated`. Rebuilt by `pnpm --filter @workspace/scripts run formula-corpus-build`; `corpusSha256` is stable across runs (double-run diff clean). **Formal-block statements are TRUNCATED fragments** carried honestly as `truncated: true` — the UI badges them \"fragment\" so a partial statement is never shown as the whole formula.\n- **Answering** (`scripts/src/formula-answers-run.ts`, `pnpm --filter @workspace/scripts run formula-answers-run`): each formula is posed to the backbone via `POST /run` with the prompt shape `Formula: <statement>\\n\\nExplain this formula… Answer directly.` (a bare \"state X\" makes the model punt — the explain-directly shape gets real answers). **Doctrine gate — ACCEPTED only when the run was sovereign-served**: `receipt.payload.ok`, `servedProvider === \"sovereign\"`, `servedNode` a non-empty string, `chosen` starts with `sovereign#`, and non-empty output. A cloud fallback is REJECTED → the formula stays UNANSWERED (a cloud model must never be recorded answering the estate's own corpus). Canary + 3-consecutive-failure abort; resume-safe incremental writes to `.local/formula-lab/answers-run.json`.\n- **Answers are ANSWERS, not proofs**: an ANSWERED entry means the sovereign model produced verbatim text for that statement — it is NOT a correctness claim and NOT a proof. Punts/declines are shown VERBATIM (no decline-detector scrubbing). Recording an answer NEVER changes a FormulaCodex CHECKED status, NEVER expands locked-proven (stays exactly 8), and NEVER upgrades Λ (stays Conjecture-1). Counts are labelled PROVENANCE (\"answered by sovereign\"), never accuracy. \"SZL-1\" is displayed ONLY when the served model id is `szl1`; any other served id is shown verbatim.","sha256":"f67357833c22e1e82bf2097659b957a0728329f895d9fd87bceac1d154455036"}
{"id":"doc:data-surfaces:0067","source":"doc","sourceId":"data-surfaces.md","title":"`GET /formulas/answers` (`src/routes/formulaAnswers.ts`) — Formula Answers","text":"- **Serving**: committed constant `src/data/formulaAnswers.ts` (`FORMULA_ANSWERS_RUN`) transcribed VERBATIM from the lab's `answers-run.json` (same pattern as `conjectureFactory.ts` / `leanKernelCheck.ts`); in dev a guarded fs read prefers a fresher lab file (shape-validated, malformed → warn + fall through), prod serves the committed constant ONLY. The route RECOMPUTES `counts`/`bySource`/`byModel` from the results (never trusts stored tallies) and re-applies the doctrine gate so a non-sovereign row can never surface as ANSWERED. Honest `UNAVAILABLE` (run null) until a completed run is transcribed. Own limiter 15/min. Payload validated through `GetFormulaAnswersResponse` (Zod). Each answer carries its `receiptId`/`receiptStatus` (SIGNED/UNSIGNED)/`servedProvider`/`servedNode`/`model`/`goalSha256`/`outputSha256`/`latencyMs` — the run receipt IS the provenance.\n\nRendered by `FormulaAnswers.tsx` — full-width wall between ConjectureFactory and OuroborosInvariants: MEASURED+DECLARED label chip, provenance count pills (answered by sovereign / unanswered / corpus total), corpus-sha/host/apiBase/attemptedAt line, by-source answered/total grid, by-model served-by line, and per-formula rows (unanswered-first, then first 12 answered, all 269 on demand) — each expandable to the verbatim answer text plus the receipt line (answered by <model> on <provider>#<node>, receipt <id>… signed, goal/output digests). Doctrine footer verbatim from the payload.","sha256":"216bfab20c714a055c19009b6311d4c7d0fd76826210dec01274296ea371b3ea"}
{"id":"doc:data-surfaces:0068","source":"doc","sourceId":"data-surfaces.md","title":"`GET /paper` (`src/routes/paper.ts` + `src/data/paperClaims.ts`) — Living Paper","text":"The DECLARED spine of the unifying paper \"Honesty by Construction\" served as a claim-to-source MAP, not as computed data. **`/paper` computes NOTHING and fetches NOTHING** — it returns a static, Zod-validated document: `PAPER_TITLE` / `PAPER_SUBTITLE` / `PAPER_DOCTRINE` plus 8 sections (thesis, doctrine, formal-core, attestation, receipts, invariants, stress-test, limitations) carrying 13 claims. Each claim has `claimId`, DECLARED `text`, a `claimLabel` stating the PROVENANCE of the value it points at (MEASURED / DECLARED / CONJECTURE / ATTEMPTED / NOT_EVALUATED), and a `verify {source, metric, expected, kind, detail}` binding it to the LIVE endpoint that substantiates it. Own limiter; payload validated through the generated Zod schema. The route asserts nothing about correctness — the verdict is computed CLIENT-SIDE.\n\n**The verdict is the reader's, not the server's.** `LivingPaper.tsx` (full-width wall after OuroborosInvariants, before IngestCodex) resolves each claim by reusing the EXISTING shared react-query keys for its source (`/lean`, `/invariants`, `/formulas/answers`, `/receipts/checkpoint`, `/backbone/status`) — NO per-chip fetch (rate-limit safe). `resolveVerdict()` passes each source's own honesty label through:\n- **MATCHES** (teal `#3af4c8`): an `EQUALS`/`STATUS_OK`/`CHAIN_VERIFIED` check that holds — e.g. lean `lockedProven.length === 8`, `localKernelCheck.status === \"PASS\"`, invariants `summary.violated === 0`.\n- **LIVE** (accent): a `LIVE_VALUE` surfaced verbatim (e.g. corpus `total`/`answered`, invariants `holds`, Λ conjecture id) — no assertion, just the measured number.\n- **PARTIAL** (amber): the receipt `chainStatus === \"PARTIAL\"` — earliest rows predate the hash chain but NO link is broken; rendered \"intact · PARTIAL\", **never red**, because representing a non-failure as a failure would itself violate the doctrine. Only `BROKEN`/unknown reads as DIVERGES.","sha256":"44899eb0db3a37679c8bb97ec00d4e0d9a4a3f89d58ff78e147c3ffda0489497"}
{"id":"doc:data-surfaces:0069","source":"doc","sourceId":"data-surfaces.md","title":"`GET /paper` (`src/routes/paper.ts` + `src/data/paperClaims.ts`) — Living Paper","text":"- **DIVERGES** (red, EQUAL visual weight to a pass): live value ≠ expected. A failure reads as a failure.\n- **UNAVAILABLE** (amber): source `isError`/`status === \"UNAVAILABLE\"` — withheld, never invented.\n- **DECLARED** (muted): `source: \"none\"` doctrine statements (honesty label lattice, ten-problems-ATTEMPTED, verification ceiling) — a statement, not a live number.\n\n**Fourth-wall claim** (`receipt-browser`, kind `BROWSER_ED25519`): the flagship `BrowserVerifyChip` runs WebCrypto Ed25519 IN THE READER'S BROWSER over the exact `/receipts/checkpoint` `canonical` + `signature` against the SPKI key from `/receipts/pubkey` — the same verifier extracted to `alloy/src/lib/browserVerify.ts` and shared with `ReceiptChain.tsx`. Honest terminal states only: verified / signature-invalid (equal weight) / \"this browser cannot run Ed25519\" (never a fake pass) / pubkey-unavailable. The server is never asked to vouch for itself.\n\n**Companion artifacts** (outside the API): `docs/paper/honesty-by-construction.tex` is the ~22pp arXiv-style LaTeX paper whose every quantitative claim is snapshot-dated (12 Jul 2026) and live-checkable against these same endpoints; DOI deposit is an owner action. `scripts/src/verify-checkpoint.ts` (`pnpm --filter @workspace/scripts run verify-checkpoint`) is a trustless OFFLINE verifier — node-stdlib ONLY, zero server/workspace imports — that verifies an archived `{canonical, signature}` against a pinned SPKI key (`--pubkey`/`--checkpoint` files, or `--url` convenience mode which prints a trust-note that the keyId must be pinned out-of-band via `--expect-keyid`). This is the first step of the stated frontier: moving verification OFF the issuing server.","sha256":"8812ca16d1ef17b3117ba425552e228147472030f8c169c249837df1fbd1727d"}
{"id":"doc:data-surfaces:0070","source":"doc","sourceId":"data-surfaces.md","title":"`GET /decay` (`src/routes/decay.ts` + `src/data/decayLedger.ts` + `src/data/consistencyProbe.ts`) — Decay Ledger (ingest wave 11)","text":"The truth-decay wall — Ferguson's \"Decay Ledger\" thesis (coinage credited), this estate's countermap, and a real self-consistency measurement. **Three bands, each self-labeled, NEVER blended**:\n\n- **REPORTED `thesis`** (`decayLedger.ts` `DECAY_THESIS_CLAIMS`) — the studied decay literature, every claim staying its AUTHOR'S claim: Ferguson's essay (ESSAY), the Topaz et al. Lancet fabricated-citation audit (PRIMARY), Resnik & Hosseini (PRIMARY, normative), and the press layer. `sourceKind` (PRIMARY / ESSAY / PRESS) preserves the primary-vs-press distinction — that distinction IS the thesis. `numbersStatus` is `PRIMARY_CONFIRMED` only where figures were checked against the primary release; UNVERIFIED figures are flagged or omitted, never silently carried. The Retraction Watch **4,406-vs-4,046 transposition** is recorded verbatim (a two-digit press-hop error demonstrating the thesis inside its own coverage); the Nature ~110,000 figure and the GroundedAI count are kept SEPARATE claims, never conflated. `coinage` credits Ferguson explicitly.\n- **DECLARED `antiDecayMap`** (`DECAY_ANTI_MAP_HOPS`, 6 hops) — where THIS estate places verification at each hop of its own pipeline (Zod validation at ingress, provenance labels, the Ed25519 receipt chain, in-browser verification, the offline verifier, the honesty audit). Each hop carries its real `mechanism` and a `falsifiableCheck` a reader can run RIGHT NOW. The node framing is a labeled ANALOGY to Ferguson's node model (`analogyNote`), credited — never an adoption of his claims as ours. A design claim, not a measurement.\n- **MEASURED `consistencyProbe`** (`consistencyProbe.ts` `CONSISTENCY_PROBE_RUN`, committed-constant pattern like `leanKernelCheck.ts` / `conjectureFactory.ts`) — one completed self-consistency batch transcribed VERBATIM from the lab file (`.local/ingest-lab/wave11/consistency-run.json`; dev prefers a fresher shape-validated lab file, prod serves the constant ONLY; the server never recomputes or re-runs). Batch of 2026-07-12 via `scripts/src/consistency-probe-run.ts` (429-aware: a rate-limited api-server gets a 65s backoff ×5 — a 429 is NOT a node-down): 8 fixed short-answer probes × k=5 samples through `POST /run`, **40/40 sovereign-served** (node laptop, model `szl1:latest` — served ids verbatim). **Only sovereign-served samples count**: a cloud-served attempt is `excludedNotSovereign`, never a sample; errors are `failed`, recorded honestly. Aggregates only — plaintext answers reduced to lexically-normalized clusters (`normalizationSpec` verbatim in the payload — falsifiability requirement, as is each exact `prompt`). `agreementRatio` = top-cluster share (HEADLINE metric); `discreteEntropy` (bits) secondary — coarse at small k. `INSUFFICIENT` (<2 sovereign samples) means agreement is UNDEFINED, not zero. **Family honesty**: sampling-consistency family (SelfCheckGPT, Manakul et al.); ANALOGY ONLY to semantic entropy (Farquhar et al., Nature 2024) — no NLI clustering, no sequence probabilities. **Agreement is NEVER correctness** — probe p2 proves it in the shipped data: 4/5 samples agreed on a WRONG product (491 for 17×23), recorded verbatim as 0.8 agreement; a consistent model can be consistently wrong. `null` run = honest UNAVAILABLE band, never a fabricated batch.","sha256":"676516a5938b9433105bb8c6a77a8ef25232ddd56d3ff5d902bd0958caa6baa9"}
{"id":"doc:data-surfaces:0071","source":"doc","sourceId":"data-surfaces.md","title":"`GET /decay` (`src/routes/decay.ts` + `src/data/decayLedger.ts` + `src/data/consistencyProbe.ts`) — Decay Ledger (ingest wave 11)","text":"`legend` names every label used (REPORTED / PRIMARY-ESSAY-PRESS / DECLARED / MEASURED / ANALOGY / UNAVAILABLE). Nothing here upgrades Λ (stays Conjecture-1) or expands locked-proven (stays 8). Static data + committed constant → no upstream fetch, no cache; own limiter 15/min; payload validated through `GetDecayResponse` (Zod). Rendered by `DecayLedger.tsx` — full-width wall directly after LivingPaper, before IngestCodex: three labeled band cards in doctrine order (thesis claims with sourceKind chips + numbersStatus flags + verbatim quotes, numbered hop map with mechanism/falsify lines, probe rows with cluster chips + headline agreement% + entropy/served-node metadata + collapsible normalization spec), the legend strip, and the doctrine + coinage-credit notes verbatim.","sha256":"1f55c46b028487d3fb5fbaa0fee126e8a8a47a797d8a358f0215b7eb2c3fc043"}
{"id":"doc:data-surfaces:0072","source":"doc","sourceId":"data-surfaces.md","title":"`GET /brain` + `POST /brain/ask` (`src/routes/brain.ts` + `src/lib/brainIndex.ts` + `src/data/brainCorpus.*` + `src/data/brainAskContract.ts` + `src/data/brainIndexEvidence.ts`) — Second Brain (grounded RAG)","text":"The knowledge wall — grounded retrieval-augmented answering under the estate's honesty doctrine. **Two lanes that NEVER blend**: an in-repo lane that is MEASURED and actually served, and the owner's real private Brain that stays UNAVAILABLE (fail-closed) until a signed manifest verifies in-app. A BM25 score is MEASURED lexical relevance, **NEVER** correctness; the loop cites retrieved chunks or **abstains** — it never fabricates. Nothing here trains, evaluates, or upgrades Λ (stays Conjecture-1) / expands locked-proven (stays 8).\n\n- **MEASURED `inRepo` lane** (`buildInRepoLane()` over `brainCorpus.data.ts` `BRAIN_CORPUS_MANIFEST` + `brainIndex.ts` `BRAIN_INDEX_STATS`) — the committed, deterministic corpus that is the ONLY lane that answers. Built-time generated (`brainCorpus.gen.ts`, mirroring `khipuCurriculum.gen.ts`), committed, **NO runtime fs read** (prod gates fs off); the corpus distils curated `docs/*.md` + the 269-formula corpus + ingest takeaways into chunks. `corpusSha256` is a real content fingerprint that changes iff the chunk set or any chunk text changes (determinism test enforces this). Reported counts are enumerated: `chunkCount`, `bySource` (doc / formula / ingest), `formulaCount`, `ingestTakeawayCount`, and per-`docFiles` `{name, sha256, chunks}`. Retrieval (wave-13 adoption, 2026-07-14): the candidate set is exactly the BM25 (k1=1.5, b=0.75) match set, display-ordered by **Reciprocal Rank Fusion** (`RRF_K=60`, a DECLARED constant from Cormack, Clarke & Büttcher SIGIR 2009 — studied in ingest wave 13) of two MEASURED lexical rankers: classic BM25 + distinct-term coverage. Fusion reorders which grounding surfaces first; it NEVER manufactures a hit BM25 did not find, never drops one, and the retrieval floor still gates on the best RAW BM25 score, so abstention behavior is unchanged — GUARANTEED, not assumed: `searchBrain` force-includes the global BM25 rank-1 chunk in the returned top-k (deterministic last-slot swap), so the gate basis is provably the global BM25 max, and a test pins this for every query/k. Each hit's `score` stays the raw BM25 number. Fixture tests pin IMPLEMENTATION exactness of the published equation — never a retrieval-quality claim (the paper's effectiveness wins stay the paper's). Still dependency-free, with MEASURED `vocabSize` / `avgDocLen` and a DECLARED `retrievalFloor`. The `/brain/graph` adjacency deliberately stays PURE BM25 (`rankBM25`) — the graph's doctrine promise is \"top-k BM25 nearest neighbors\"; fusion is an ask-ranking choice, not an adjacency re-definition. `served: true` — this lane is real.","sha256":"6214ba75774547b861c0f31532264b3f88c177996e850dd24a8c57dcefbd08ad"}
{"id":"doc:data-surfaces:0073","source":"doc","sourceId":"data-surfaces.md","title":"`GET /brain` + `POST /brain/ask` (`src/routes/brain.ts` + `src/lib/brainIndex.ts` + `src/data/brainCorpus.*` + `src/data/brainAskContract.ts` + `src/data/brainIndexEvidence.ts`) — Second Brain (grounded RAG)","text":"- **Fail-closed `realBrain` lane** (`brainIndexEvidence.ts` `computeBrainIndexEvidence()`, a COPY of `khipuEvidence.ts` — not a refactor) — the owner's private knowledge graph whose content is NOT in this repo. Status is DERIVED from evidence, never asserted: `NO_OWNER_KEY` (no committed `owner_pubkey.json`), `INDEX_MANIFEST_UNAVAILABLE` (no signed manifest), `INDEX_MANIFEST_INVALID` / a divergence reason (any of the 5 checks fail — flagged LOUDLY), or `INDEX_MANIFEST_VERIFIED` (owner-signed, ed25519-verified against the committed key + pinned `A11OY_BRAININDEX_OWNER_KEYID`). The 5 checks: `payload-shape` (Zod `IndexManifestPayloadSchema`: kind `szl-brain-index-manifest`, v 1, int≥0 counts), `wrapper-keyid-matches-owner`, `embedded-key-matches-owner`, `canonical-matches-payload` (the Python signer's `canonical_json` byte-matches TS `canonicalJson` — strings+ints only, NO floats), `ed25519-signature`. **Even a VERIFIED manifest does not wire live serving** — `serving` stays `NOT_WIRED_IN_REPO` (`keyTrust: REPO_DECLARED`); node/edge/chunk counts are the manifest's REPORTED owner-metal figures, never invented here. Verified end-to-end 2026-07-13 in a throwaway dir (keygen → index → sign → verifier flips to `INDEX_MANIFEST_VERIFIED`, all 5 checks pass, serving unchanged); the committed kit ships with **no** `owner_pubkey.json` on purpose (honest `NO_OWNER_KEY`, not a placeholder that would trip the verifier). Kit: `docs/forge/brainindex/` (`index_brain.py`, `sign_manifest.py`, `RUNBOOK-BRAININDEX.md`, `.gitignore`).\n- **`POST /brain/ask`** — a grounded, cited answer over the **in-repo lane only**, gated by the SAME policy path as `/run` BEFORE any provider call (run-key required via `requireRunKey`; the policy engine — spend cap + provider allow-list + approvals — refuses first; denied ≠ ledger row) — but a brain-ask is NOT a `/run`: it is never written to the run ledger, so its own cost is not self-billed against the rolling-24h spend cap. Loop: (1) retrieve top-k (`DEFAULT_K` 5, `MAX_K` 8) — BM25 candidate set, RRF-fused display order (see the inRepo lane above); **if the best raw BM25 score is below the DECLARED retrieval floor → `ABSTAINED` immediately**, the provider is never called and nothing is billed (fusion reorders grounding, never manufactures it). (2) Otherwise pose the question to `runBackbone` with ONLY those chunks as numbered `[S#]` sources, instructing cite-or-abstain. (3) Parse `[S#]` citations — the gate is **FAIL-CLOSED**: every cited source must be one of the retrieved chunks, so ANY cite to a non-retrieved chunk (a **hallucinated citation**) forces `ABSTAINED` on the whole answer rather than being silently dropped (a rendered dangling cite would be a fabrication). `ANSWERED` requires ≥1 valid citation AND zero out-of-range ones, else `ABSTAINED`. A demo run (no live provider) can't self-cite and thus honestly `ABSTAINS` rather than present ungrounded output. (4) The result is gated through `BrainAskResultSchema` (`brainAskContract.ts`) — a dishonest instance is unrepresentable (`groundedOnly` structural, `citedChunkIds ⊆ retrieved`, answer null unless ANSWERED) — and carries `corpusScope` (`BRAIN_CORPUS_SCOPE`), the MEASURED `retrieved` rows (chunkId / source / sha256 / BM25 `score` / `matchedTerms`), and the `retrievalFloor`.","sha256":"f40e64580753baca2fe0ca099f64c128159b62139f56b25052beddb4573835d8"}
{"id":"doc:data-surfaces:0074","source":"doc","sourceId":"data-surfaces.md","title":"`GET /brain` + `POST /brain/ask` (`src/routes/brain.ts` + `src/lib/brainIndex.ts` + `src/data/brainCorpus.*` + `src/data/brainAskContract.ts` + `src/data/brainIndexEvidence.ts`) — Second Brain (grounded RAG)","text":"- **`brain-ask` receipt** (`buildBrainAskReceipt()` in `lib/receipts.ts`) — a distinct receipt kind, ed25519-signed via the SAME HKDF-from-`SESSION_SECRET` key, over a canonical binding the corpus fingerprint, the retrieved chunk hashes, the cited subset, the decision, and the answer hash (plaintext never leaves the runner). **Does NOT mutate the run-receipt v1 canonical** — reuses `canonicalJson`/`sha256Hex` only; honestly `UNSIGNED` when `SESSION_SECRET` is unset. In-browser Ed25519 re-verify in the wall via `AskReceipt`.\n\n`legend` names every label used (MEASURED / BM25 score / ANSWERED / ABSTAINED / UNAVAILABLE); the verbatim `doctrine` and `note` strings are served on `GET /brain`. Static corpus + committed constant → no upstream fetch, no cache; status limiter 30/min, ask limiter 15/min; payloads validated through `GetBrainResponse` / `AskBrainResponse` (Zod). Rendered by `SecondBrain.tsx` — full-width wall directly after DecayLedger, before IngestCodex: the two lanes side-by-side (in-repo MEASURED stats + per-source counts + docFiles fingerprints; real-Brain fail-closed status card, amber when UNAVAILABLE, with the derived reason and the 5-check breakdown), an ask box (run-key aware), and the `AskResult` (cited answer with `[S#]` chips linking to `RetrievedRow` BM25-score rows, abstain state with the honest reason, and the `AskReceipt` in-browser verify). Amber is SEMANTIC (UNAVAILABLE / ABSTAINED / pending) — never swept to teal.","sha256":"409e48e2f0fb8310abce2702c5ca195d6f39a8ae87f37b751f87f1ddf0cd4b1a"}
{"id":"doc:data-surfaces:0075","source":"doc","sourceId":"data-surfaces.md","title":"Other windows","text":"- **`GET /backbone/status` — fleet substrate ledger (ingest wave 9)** — every provider in the payload carries `substrate` / `substrateLabel` / `substrateBasis` (all required in the `Provider` schema; the hand-maintained SSE mirror `alloy/src/lib/backbone.ts` `BackboneProvider` changed in lockstep). Only two labels exist ON PURPOSE: `DERIVED` solely for the sovereign provider (`substrate: \"GPU\"` — the szl-meter exporters sample NVML energy counters on the serving nodes and NVML exists only on NVIDIA GPUs; class evidence derived from MEASURED samples, NEVER a die/SKU/model claim) and `UNKNOWN` for every cloud provider (serving silicon is unobservable through an OpenAI-compatible API and is never guessed — gemini's basis records that Google markets TPU serving as Google-REPORTED and unverifiable; openrouter's basis records the per-request vendor roulette as doubly unobservable; huggingface's the router fan-out). No LPU/NPU is claimed anywhere. `ProviderFleet.tsx` renders a Substrate row per provider (basis on hover/title, accent color only for DERIVED) plus a wave-9 caption stating the ledger's rules; the offline mock roster claims NO substrate at all.\n- **`GET /grid`** (`src/routes/grid.ts`) — GB grid window, KEYLESS UK Carbon Intensity API (`intensity` + `generation`), server-side 5-min in-memory cache, 30/min limit; honest `UNAVAILABLE` when the upstream fetch fails.\n- **`GET /orbital`** (`src/routes/orbital.ts`) — live ISS fix (`api.wheretheiss.at`, NORAD 25544) + NASA POWER daily surface solar irradiance (`ALLSKY_SFC_SW_DWN`, kWh/m²/day; `-999` fill → `null`, never faked). Anchor point env `ORBITAL_LAT`/`ORBITAL_LON` (default Killinchy NI 54.533/-5.664). 5-min cache only when ALL blocks OK — any failed block drops TTL to the 30s negative window. 30/min limit.\n- **`GET /organism`** (`src/routes/organism.ts`) — live organ status for 11 curated SZL organs: brain = `khipu-consensus` GitHub repo `pushed_at` (uses `GITHUB_TOKEN` when present — anon GitHub API 403s from this egress — keyless fallback preserved), the rest = public HF Space `runtime.stage` (keyless). Per-organ honest `UNAVAILABLE`, 5-min all-OK / 30s negative cache, in-flight dedup, 20/min limit. Rendered by `OrganismPanel.tsx` (left column; brain + anatomy top-billed).","sha256":"252645c6df414900766d5c162e4f0201d405b3b854a005599784cff96acfa437"}
{"id":"doc:data-surfaces:0076","source":"doc","sourceId":"data-surfaces.md","title":"Other windows","text":"- **`GET /backbone/mesh/probe`** (`src/routes/mesh.ts`) — MEASURED live reachability of all 5 own-metal hosts (gpu/gpu2/gateway/meter/meter2). Per-node verdicts: `LIVE` (2xx), `GATED` (401/403 — reachable but auth-walled, e.g. gpu2 behind CF Access), `NO_ROUTE` (404 — tunnel up but nothing serving that path, e.g. gateway), `TUNNEL_DOWN` (530), `SERVICE_DOWN` (≥500), `UNREACHABLE` (network error). 15s cache. Rendered by `EstateMesh.tsx`.\n- **`GET /backbone/mesh/history`** (`src/routes/mesh.ts`, status-page pattern, MEASURED) — the last 24h of RECORDED probe rows (cap 2000), grouped per host, each row `{probedAt, httpStatus, status, latencyMs}` in chronological order. `count` = enumerated rows ONLY — no fabricated buckets; gaps in time are just gaps. **CRITICAL cache-honesty**: rows are written by `recordMeshProbes()` fire-and-forget (lazy guarded `import(\"@workspace/db\")` exactly like `runLedger.ts`, so a missing `DATABASE_URL` logs \"ledger disabled\" and never crashes boot or breaks a probe) called ONLY from `runProbe()` — a real upstream probe. The 15s cache-hit path and in-flight-dedup awaiters NEVER record, so every row is a distinct real observation and `probedAt` is the real probe time (`checkedAt`), not insert time. Persisted in the Drizzle `meshProbesTable` (`mesh_probes`: id / probedAt / host / httpStatus / status / latencyMs). Honest empty state: a fresh DB returns `hosts: []`, `count: 0`. Honest `UNAVAILABLE` with a `reason` when the ledger DB cannot be read (no bars invented). Retention: rows older than 7 days are pruned fire-and-forget after each real probe record (storage hygiene only — the read window is 24h, so nothing servable is ever deleted; a prune failure is logged, never surfaced). `meshLimiter` = 15/min. Rendered by `EstateMesh.tsx` as a per-host uptime strip (one bar per enumerated row, same LIVE/GATED/… palette, `no probes recorded yet` when empty, caption \"MEASURED · recorded real probes only · gaps are gaps\").","sha256":"c6a9ff108057d7509435ffdd9b2f8a1eddbb685034e4fa1580485634558a9b61"}
{"id":"doc:data-surfaces:0077","source":"doc","sourceId":"data-surfaces.md","title":"Notarized receipts, flywheel, honesty audit (one-of-one surfaces)","text":"- **Notarized run receipts** (`src/lib/receipts.ts`, `src/routes/receipts.ts`) — every `/run` + `/run/stream` result (success AND failure) carries a `receipt` block: ed25519 signature over a canonical JSON payload containing ONLY sha256 hashes of goal/output (plaintext never leaves the runner), the full routing-attempt trail (provider/model/node/ok/error/latency), servedNode, demo flag, and a hash-chain `prevHash` linking stored receipts (genesis for the first). Signing key derives deterministically from `SESSION_SECRET` (HKDF); when unset the receipt is honestly `UNSIGNED` with a note — never a fake signature. `GET /receipts/pubkey` (public verify key + keyId), `POST /receipts/verify` (verifies the EXACT canonical string + base64 signature — never re-canonicalizes; also `receiptId` lookup of stored receipts). Receipts persist in Postgres `receiptsTable`; storage failure never fails the run.\n- **`GET /flywheel/status` + `GET /flywheel/export.jsonl`** (`src/routes/flywheel.ts`) — sovereign flywheel: MEASURED count of training samples captured from runs actually served by own metal (`servedNode != null`, non-demo, ok). Status public; `export.jsonl` is run-key gated (401 without key). Honest zero when nothing captured; `UNAVAILABLE` when the DB is unreadable. Rendered by `FlywheelPanel.tsx` (left column after Telemetry).\n- **`GET /honesty`** (`src/routes/honesty.ts`) — live honesty audit: the server reports on its OWN caches via `honestyPeek()` exported from the 8 REPORTED windows (grid/frontier/verticals/organism/orbital/darpa/mesh/estate). Cache-only — the endpoint NEVER triggers upstream fetches (an audit that changed the system would be dishonest); per-block `OK` / `UNAVAILABLE` / `NOT_YET_FETCHED` + lastFetchedAt + sources + verbatim doctrine text + `signingConfigured`. Rendered by `HonestyAudit.tsx` (right column, top).","sha256":"a9092453d5df27bd1f8a64c8dd19b0c4c1aa9d5d3a9d451b68e02b23abbb0d36"}
{"id":"doc:data-surfaces:0078","source":"doc","sourceId":"data-surfaces.md","title":"Notarized receipts, flywheel, honesty audit (one-of-one surfaces)","text":"- **Public routing proof (UI)** — `RunConsole.tsx` renders the per-attempt routing trail from the `done` event (✓/✗, provider·node, model, latency, the REAL upstream error string) plus the receipt block (receiptId, keyId, copy canonical+signature bundle, verify endpoints). The routing pill shows `signed · ed25519` when the receipt is signed, `unsigned-honest` otherwise.\n- **Routing waterfall (UI, observability pattern)** — `RoutingWaterfall.tsx` (imported by `RunConsole.tsx`) draws the SAME per-attempt trail as a horizontal latency waterfall: one row per attempt, bar length proportional to that attempt's MEASURED server-side `latency_ms`, scaled to the total run `latencyMs` (or, on the error path where no total exists, the slowest measured attempt — both derived only from measured numbers, never guessed). The served attempt (matching `decision.chosen`, or the last `ok` attempt) is highlighted (`bg-accent` + `served` badge); failed attempts keep the destructive/dim treatment with their honest `error` text. Client-only render of data already in the `done`/error payload — NO server change, NO new fetch. **No fabricated segments**: an attempt without a finite `latency_ms` renders `no timing` and an empty bar track, never a default width. Block header labelled `MEASURED server-side latencies`; demo runs pass their `demo` flag through to the caption. Empty attempt list → renders nothing.\n- **Public receipt chain** (`GET /receipts/recent`, `runLedger.ts getReceiptChain`) — the last 20 run-ledger rows in chain order with the tamper-evident sha256 chain RECOMPUTED server-side over the returned window on EVERY request (MEASURED — the content hash re-derives from the stored signed receipt JSON, else the canonical core-facts rendering, exactly mirroring the insert path; link continuity checked newest-first against each older row's rowHash). Per-row `verified` is true/false/null — null means the row PREDATES the hash chain, stated never guessed. `chainStatus`: VERIFIED (every link recomputes) / PARTIAL (pre-chain rows present) / BROKEN (a link failed) / EMPTY. Entries carry hashes + routing facts only — goal/output/error plaintext NEVER leaves the ledger. Public, 60/min rate limit, honest UNAVAILABLE when the DB is unreadable. Rendered by `ReceiptChain.tsx` (left column, after FlywheelPanel).","sha256":"fc13c0c760a57dc46c9fbc3d3868a53d031125a26bbd0065c164b550798a4097"}
{"id":"doc:data-surfaces:0079","source":"doc","sourceId":"data-surfaces.md","title":"Notarized receipts, flywheel, honesty audit (one-of-one surfaces)","text":"- **Signed chain checkpoint** (`GET /receipts/checkpoint`, transparency-log pattern) — recomputes the receipt hash chain over the ledger window PER REQUEST via the existing `getReceiptChain(10000)` machinery (NEVER trusts a stored flag), then builds the canonical string `a11oy-checkpoint\\ncount:<n>\\nhead:<headHash|EMPTY>\\nchain:<VERIFIED|PARTIAL|BROKEN|EMPTY>\\nat:<iso>` and ed25519-signs it via `signCheckpoint()` (`lib/receipts.ts`), reusing the SAME HKDF-from-`SESSION_SECRET` key as run receipts. Response: `{label:\"MEASURED\", canonical, signature|null, signingConfigured, count, headHash, chainStatus, generatedAt, verifyHint}`. `count` = enumerated rows only; `headHash` = the chain tip (EMPTY when no rows). Honest **UNSIGNED** (signature null, stated in `verifyHint`) when `SESSION_SECRET` is unset; honest **UNAVAILABLE** (no canonical fabricated) when the ledger DB is unreachable. Anyone re-verifies by POSTing the EXACT `{canonical, signature}` to `POST /receipts/verify` — which for a non-JSON checkpoint canonical simply skips the receipt keyId cross-check and verifies ed25519 over the exact bytes (JSON receipts still get the keyId rotation hint). `receiptsLimiter` = 60/min. Rendered by `ReceiptChain.tsx` as a top \"SIGNED CHECKPOINT\" block: chainStatus badge, count, truncated head hash (full in title), honest signed/unsigned state, the server's own `verifyHint`, and the exact `canonical` in a collapsible monospace block for independent verification.","sha256":"96cfff997c64571341d199d38fabe8b2cdb8f5df9cd44fd13ac8e4cdb69cf46b"}
{"id":"doc:data-surfaces:0080","source":"doc","sourceId":"data-surfaces.md","title":"`GET /memory` (`src/routes/memory.ts`) — Memory organ (ingest wave 10)","text":"Alloy's honest answer to the \"self-improving agent memory\" pattern (Perplexity Brain, wave 10): a WORK-memory window — what the agent DID — derived 100% from surfaces already measured, nothing invented. All MEASURED over the enumerated ledger window (window cap 250, reads via `runLedger.ts getMemoryRunRows` — bounded, invariants-style; plaintext goal/output/error NEVER selected, that surface stays key-gated). Blocks:\n\n- **`episodic`** — last ≤30 runs summarized (endpoint/mode/requested→served provider/node/model/ok/demo/errorFamily/latency/costStatus), each carrying `provenance {receiptId, signed, keyId}` — the field's \"every memory links back\" pattern, ours cryptographic (ed25519 receipt), never a hyperlink-only claim. `errorFamily` is a keyword bucket (timeout/rate_limit/auth/quota/network/upstream_5xx/all_providers_failed/other), null on ok.\n- **`lessons`** — per-provider AND per-node MEASURED tallies (served/failed counts, top error families, mean latency). These are COUNTS honestly labeled — never \"insights\" or fabricated learning claims. Attribution honesty: failed runs carry no servedProvider (ledger invariant), so provider failures are attributed only when a specific provider was requested; `auto` failures name no provider.\n- **`corrections`** — persisted `requested≠served` failover events only (demo runs excluded). The per-run `routing_decision.attempts` chain is NOT persisted as a column, so intra-run upstream-failure counts are deliberately NOT claimed — the block's `note` states this ledger gap outright.\n- **`selfReview`** — `{synthesizedAt, windowSize, basis, doctrine}`: synthesis is computed PER REQUEST over the enumerated rows — the doctrine line says plainly that Alloy does request-time synthesis, NOT an overnight \"memory consolidation\" pass, and `windowSize` is enumerated rows only, never a claimed lifetime total.","sha256":"5f52ac59103f5422c51506f7a6f5d25ff94019ea87f5828ba8f56026a92b7362"}
{"id":"doc:data-surfaces:0081","source":"doc","sourceId":"data-surfaces.md","title":"`GET /memory` (`src/routes/memory.ts`) — Memory organ (ingest wave 10)","text":"Honest top-level `UNAVAILABLE` + reason when the ledger DB is unreachable. `memoryLimiter` = 15/min; payload validated through `GetMemoryResponse` (Zod). Rendered by `MemoryPanel.tsx` (right column, first band, directly after HonestyAudit — full-width wall order untouched): per-block MEASURED/UNAVAILABLE chips, signed/unsigned provenance per episode, lessons as counts, corrections events or honest \"no delta\". No mechanism changed; `/run` shape and the hand-maintained SSE mirror untouched.","sha256":"b2f1d7f0b0a4b62a0988071252bfce2d62dc2da5598881bb22c941c1b91c3aba"}
{"id":"doc:data-surfaces:0082","source":"doc","sourceId":"data-surfaces.md","title":"`GET /invariants` (`src/routes/invariants.ts`) — Ouroboros invariants","text":"MEASURED runtime self-consistency invariants, recomputed per request over the enumerated ledger window (`INVARIANT_LIMIT = 10_000`; count = enumerated rows ONLY, never a claimed total). Public (hashes + row ids only — plaintext goal/output/error is NEVER selected; that surface stays key-gated on `/runs/recent`). `invariantsLimiter` = 15/min. Honest top-level `UNAVAILABLE` (with `reason`) when the run-ledger DB is unreachable; nothing fabricated.\n\n**Doctrine (binding).** Every invariant here is FALSIFIABLE — it can be VIOLATED by real ledger corruption, receipt tamper, or a write-path regression. A check that is TRUE BY CONSTRUCTION (cannot fail) is verification THEATER and is deliberately EXCLUDED — this is why the loop-tax reconciliation identities (`overheadMs = max(0, wall−modelMs)`, `serializationTaxMs = max(0, modelMs−peak)`) are NOT surfaced here, and why the loop check asserts only the lower bound `loopSteps ≥ 1` (the per-run upper bound `targets.length` is not persisted, so any fixed ceiling would be an invented number). These are RUNTIME consistency checks and are DISTINCT from the Lean proof corpus (`/lean`, `LeanLedger.tsx`): NONE of them prove or upgrade Λ, which stays **Conjecture-1**. Each invariant is labelled with its own doctrine line only — NEVER paired with the LOCKED_PROVEN Lean set {F1,F4,F7,F11,F12,F18,F19,F22} (those are Λ-aggregator theorems with no relation to ledger predicates; pairing would imply \"proven formulas running live\", exactly the theater the doctrine forbids).","sha256":"0879b6206264f86409bfaecdd2442435badf1400dae2555a51c6528d8090c2d3"}
{"id":"doc:data-surfaces:0083","source":"doc","sourceId":"data-surfaces.md","title":"`GET /invariants` (`src/routes/invariants.ts`) — Ouroboros invariants","text":"Per-invariant shape: `{id, title, predicate (verbatim), doctrineRef, basis:\"MEASURED\", status, checked, violations, worstRowId, detail}`. `status`: `HOLDS` (every checked row satisfies the predicate) / `VIOLATED` (≥1 does not; `worstRowId` = one offending row's serial id as a concrete example — no ordering/severity claim, `violations` carries the full count) / `KEY_ROTATED` (signed rows exist that were signed under a rotated key — honest, NOT a tamper verdict) / `NO_DATA` (no rows matched the predicate's precondition) / `UNAVAILABLE` (the check could not run, e.g. no signing key to verify). Window summary `{total, holds, violated, indeterminate}` (indeterminate = KEY_ROTATED + NO_DATA + UNAVAILABLE).\n\nThe eight invariants (all from persisted data in `runsTable` / `training_samples`; reads in `runLedger.ts` `getInvariantRunRows` + `getFlywheelLineage`, chain reused verbatim from `getReceiptChain`):\n\n1. **receipt-chain-continuity** — REUSES `getReceiptChain(10000)` verbatim (no second implementation — a re-impl would be drift risk and near-theater): chain sha256 links RECOMPUTED; `chainStatus` VERIFIED→HOLDS, PARTIAL→HOLDS (pre-chain rows stated, not a failure), BROKEN→VIOLATED, EMPTY→NO_DATA. `worstRowId` null by design (chain entries carry hashes, not serial ids). The literal Ouroboros — the chain recomputing its own tail.\n2. **ledger-failure-shape** — for `ok=false` rows: `servedProvider IS NULL AND latencyMs IS NULL`. Caption states it catches corruption / a write-path regression, NOT runtime correctness.\n3. **served-run-has-model** — for `ok=true AND demo=false` rows: `model IS NOT NULL` (a real serve records what served it; demo excluded since demo runs legitimately have no served model).\n4. **signed-columns-atomic** — for every row: `(receiptId, signature, keyId, receiptJson)` are ALL present or ALL absent (no half-signed row).","sha256":"f0da189a4a922aeca56114387ef2c4658947e82cc24997e5a36483b0d10daac2"}
{"id":"doc:data-surfaces:0084","source":"doc","sourceId":"data-surfaces.md","title":"`GET /invariants` (`src/routes/invariants.ts`) — Ouroboros invariants","text":"5. **loop-steps-positive** — for `ok=true AND demo=false` rows: `loopSteps ≥ 1` (LOOP_DOCTRINE lower bound only, upper bound deliberately not asserted — see doctrine above).\n6. **receipt-ed25519-verify** — for every signed row: `verifyReceipt(receiptJson, signature)` valid under the current key. A row whose stored `keyId` differs from the current signing key and fails is counted `KEY_ROTATED`, never `VIOLATED`. `UNAVAILABLE` when `SESSION_SECRET` is unset (no key to verify — honest, not a judgment). `NO_DATA` when no signed rows.\n7. **receipt-columns-consistent** — for every row with a stored receipt: `parse(receiptJson).{receiptId, goalSha256, outputSha256, keyId}` equals the indexed columns (catches canonical/column drift or tamper; a JSON parse failure counts as a violation).\n8. **flywheel-lineage** (highest value) — every `training_samples` row that HAS a `receiptId` LEFT-JOINs to a `runs` row with `demo=false AND servedNode IS NOT NULL`. Samples with a null `receiptId` are excluded and the count stated (link honestly unavailable, per the table's own doctrine). The literal Ouroboros of the flywheel: the training loop eating ONLY its own verified own-metal tail.","sha256":"ffe2d4217f24838fdbb8ed314c7a7dff697c1abed7dadc6a9d320e949f7954cb"}
{"id":"doc:data-surfaces:0085","source":"doc","sourceId":"data-surfaces.md","title":"`GET /invariants` (`src/routes/invariants.ts`) — Ouroboros invariants","text":"**`latentVerification` — MEASURED coverage ratio (NOT an invariant), ingest wave 8 (Neuro-JEPA).** Alongside the eight invariants the payload carries a `latentVerification` block: `{status: MEASURED|UNAVAILABLE, reason?, enumerated, verified, verifiedRatio (nullable), rotated, unsigned, tamperFailed, note}`. It is the fraction of the enumerated ledger window whose trust is established purely in **hash/signature space** — `verified` = rows whose ed25519 signature validates over the sha256 canonical bytes under the current key (the ed25519 tally is computed ONCE in invariant #6 and reused; no second verification pass), `verifiedRatio = verified / enumerated`. Honest complements: `rotated` (signed under a rotated key), `unsigned` (rows predating signing / no receipt columns) — neither is a failure; `tamperFailed` (ed25519 hard-fail under the current key) genuinely lowers the ratio. **This is an explicit ANALOGY to the JEPA family's latent-space predictive objective** (Neuro-JEPA / V-JEPA 2 verify over a compact DERIVED space, not the raw object) — but Alloy's \"latent space\" is a CRYPTOGRAPHIC DIGEST + SIGNATURE, **NOT a learned embedding**: nothing here is trained, predicted, or a model, and it does not prove or upgrade Λ. It is deliberately a coverage metric, NOT a HOLDS/VIOLATED invariant, so it never claims to be a falsifiable predicate it is not. `UNAVAILABLE` when the signing key is unset (verification cannot run) or the ledger DB is unreachable. Live 2026-07-12: 22 enumerated / 20 verified (91%) / 2 unsigned (predate signing) / 0 rotated / 0 tamper.","sha256":"20ae2cd5ed90217322d55afd181378e2666e860ff9ca72e943f278604f1e6765"}
{"id":"doc:data-surfaces:0086","source":"doc","sourceId":"data-surfaces.md","title":"`GET /invariants` (`src/routes/invariants.ts`) — Ouroboros invariants","text":"Rendered by `OuroborosInvariants.tsx` (full-width band between `LeanLedger` and `IngestCodex`; ∞ icon, #3af4c8 accent): summary line (holds/violated/indeterminate + enumerated runs/samples + window cap), the `latentVerification` coverage strip (percentage + verified/enumerated + progress bar + tamper/rotated/unsigned counts + verbatim note), one row per invariant (title, verbatim predicate, status badge, checked/violations/first-offender-row, doctrineRef, detail), the doctrine footer verbatim, and the falsifiability note. Payload typed via generated `InvariantsWindow`/`InvariantCheck`/`InvariantsWindowLatentVerification`; hook `useGetInvariants` (60s stale, 5-min refetch). Live 2026-07-12: 22 runs / 7 samples enumerated, 7 HOLD, 0 VIOLATED, failure-shape NO_DATA (no failed rows in window) — every serving invariant green on the owner's real ledger.","sha256":"bbd3ddc31eed7516f67ffa89e78907acd99ae7c4885ee08ee1cc3c6ccf0a2cd3"}
{"id":"doc:data-surfaces:0087","source":"doc","sourceId":"data-surfaces.md","title":"`GET /fourthwall` (`src/routes/fourthwall.ts`) — Fourth Wall (the app observing itself)","text":"The final full-width wall (after IngestCodex, before the footer; `FourthWall.tsx`) — the cockpit turning its labeling discipline on itself. It EXPANDS the small `EstateSelf` fourth-wall block on `/estate` (which stays authoritative in its estate context); this wall adds the process and route census, it does NOT restate the estate block's build-hash prose. Bands, never blended:\n\n- **MEASURED `process`** — direct syscalls at request time: pid, `process.version`, `process.uptime()`, `process.memoryUsage()` rss/heapUsed/heapTotal bytes; `startedAt` is now − uptime at assembly. Nothing cached, nothing typed in — every request re-measures.\n- **MEASURED `routes`** — a census enumerated by recursively WALKING the live Express router stack per request (`req.app.router.stack` with `_router` fallback; nested routers via `layer.handle.stack`), deduped `METHOD path` pairs, sorted; `total` and `byMethod` are counted from that same enumerated list, never typed in. The census IS the mounted surface — there is no maintained list to go stale. Express's internal `_all` method key surfaces verbatim as `_ALL` — honest, not renamed. Scope caveat (binding): Express does not store `router.use(\"/prefix\", sub)` mount prefixes on `route.path`, so the census is complete only while every sub-router in `routes/index.ts` stays prefix-free (as today); a path-prefixed mount would render prefix-stripped paths — the walker must be extended to carry prefixes before one is ever added.\n- **DECLARED `identity`** — authored sentences labeled as authored (product / org / repo / builtBy / doctrine); the repo is stated, never fetched. The builtBy line breaks the fourth wall honestly: built and maintained by an AI coding agent pair-working with the SZL Holdings owner — the same kind of agentic loop the cockpit orchestrates.","sha256":"2dc80c5b52c71faadbf653b95aafa1191fe778342b74c409e90f626057c3ec6e"}
{"id":"doc:data-surfaces:0088","source":"doc","sourceId":"data-surfaces.md","title":"`GET /fourthwall` (`src/routes/fourthwall.ts`) — Fourth Wall (the app observing itself)","text":"- **DECLARED `crossChecks`** — \"identity here is asserted, not proven\": links to `/api/build-info` (signed ed25519 build attestation) and `/api/honesty` (self-report). Links, NEVER duplicates — two sources of self-truth would eventually disagree. Client-side, `FourthWall.tsx` composes the cross-check chips from those endpoints' OWN responses (build hash + attestation status; honesty block count + signing flag) — rendered from the responses, never retyped.\n\nNOT added to the `/honesty` WINDOWS list; `/build-info` remains the sole signed build-identity source. No upstream fetch, no cache, no persistence; payload validated through `GetFourthwallResponse` (Zod) before serving.","sha256":"c7699952b30dea2a3c36cca52aaa52ac07949c2afdfcf4aa57536318e95f52f8"}
{"id":"doc:data-surfaces:0089","source":"doc","sourceId":"data-surfaces.md","title":"Cost accounting (gateway pattern, `src/lib/backbone.ts` + `src/lib/pricing.ts`)","text":"`computeCost()` attaches a `cost` block to every `/run` + `/run/stream` result (they share the result builder, so the `done` SSE event mirrors it). The cost is NOT part of the signed receipt canonical — `receipts.ts` has no `cost` field, so this accounting never changes a receipt's shape or hash.\n\n- **DECLARED price table** (`pricing.ts`, LLM-gateway pattern) — a per-model rate card with entries ONLY for models this backbone actually serves (keyed to the exact served model id from `registry.ts`): `gpt-5.5` (default pin since 2026-07-12), `gpt-5.4` (kept for env override), `gemini-3.5-flash`, `deepseek-chat`, `qwen-plus`, `kimi-k2.6`. The gpt-5.6 family (`gpt-5.6` alias → `-sol`, plus `-terra`/`-luna`) is priced on OpenAI's official page but deliberately absent: the Replit AI gateway 400s all four ids (MEASURED 2026-07-12, chat-completions AND responses endpoints), and the table only carries models the backbone can actually serve. Each entry carries `{usdPerMTokIn, usdPerMTokOut, source, asOf}` where `source` is the PROVIDER'S OWN official pricing page (never a blog/aggregator/guess) and `asOf` is the date it was confirmed. Rates are the standard pay-as-you-go per-1M-token cache-MISS in/out rates — no cache/batch/promo discount is assumed. **Omit-if-unverified doctrine**: if a provider's official price cannot be fetched/confirmed, the entry is OMITTED and that model stays `UNKNOWN` (a missing price is honest silence, never a fabricated number). `getPriceEntry(model)` is an exact-id lookup, so an env-overridden/unverified model returns `undefined` and stays UNKNOWN, never priced against a sibling.\n- **CostStatus** `ZERO | UNKNOWN | ESTIMATED`. Precedence in `computeCost`: demo → `ZERO` (no provider call made); `openai` → `ZERO` (Replit-AI credit basis — usage consumes paid Replit workspace credits, $0.00 direct vendor charge); `sovereign` → `UNKNOWN` (own-metal, energy metered elsewhere). A keyed vendor with BOTH a DECLARED price for the EXACT served model AND numeric MEASURED usage tokens (`usage.prompt_tokens`/`usage.completion_tokens`, captured at the live call site) → `ESTIMATED`: `amountUsd = (in/1e6·rateIn)+(out/1e6·rateOut)` (rounded to 8dp), with `source`+`asOf` and the basis string EXACTLY `DECLARED <model> pricing (<source>, as of <asOf>) × MEASURED <in>+<out> tokens — estimate, not an invoice`. `vendorCharge` stays `null` on ESTIMATED — it is an estimate, not the vendor's actual bill. Anything without both a declared price and measured tokens stays `UNKNOWN`. `RunLedgerRow.costStatus` (string, nullable — no enum) already accepts `\"ESTIMATED\"` with no schema change.","sha256":"c607ccb4cf1f9f862697ec059ef7d76b46693b8b3f3314bfebd67cb205558ef3"}
{"id":"doc:data-surfaces:0090","source":"doc","sourceId":"data-surfaces.md","title":"Cost accounting (gateway pattern, `src/lib/backbone.ts` + `src/lib/pricing.ts`)","text":"- **UI** — `RunConsole.tsx` renders the cost line: `ESTIMATED` → `<$amount> · estimate` (via `formatEstimateUsd`: ≥1¢ → 2dp like `$0.02`, sub-cent → up to 8dp with trailing zeros trimmed, e.g. `$0.00042`) with the verbatim basis (carrying source + as-of); a number is NEVER formatted when `amountUsd` is absent. `ZERO` → `<currency> <vendorCharge>` (green); `UNKNOWN` → `UNKNOWN` (amber) — both unchanged from before. Spec: `CostBlock` schema in `openapi.yaml` has `status` enum `[ZERO, UNKNOWN, ESTIMATED]` + optional `amountUsd`/`source`/`asOf`.","sha256":"1f1ce2daa0da413279f4d450820ed30fd575aa64097ab2b50f58311160615abf"}
{"id":"doc:data-surfaces:0091","source":"doc","sourceId":"data-surfaces.md","title":"`GET /policy` + run-path policy gate (`src/lib/policy.ts` + `src/routes/policy.ts`)","text":"The omnigent-study (ingest wave 7) DECLARED gap, built for real 2026-07-12 and FULLY closed the same day: an **enforced spend cap**, a **provider allow-list**, and **per-action human-approval gates** over the run loop.\n\n- **DECLARED policy (env, verbatim)** — `A11OY_SPEND_CAP_USD_DAY` (rolling-24h USD cap over ESTIMATED run costs; unset/invalid/≤0 = no cap) and `A11OY_PROVIDER_ALLOWLIST` (csv of provider ids, lowercased; unset/empty = no list). Unset env = the gate is honestly **OPEN**, exactly like `authMode` when `A11OY_RUN_KEY` is unset — never a silently invented default cap.\n- **Gate (`gateRun()`)** — runs in both `POST /run` and `POST /run/stream` handlers BEFORE `runBackbone`: a policy rejection means nothing ran, nothing was billed, and **no run-ledger row is written** (denied requests are policy rejections, not runs — keeps `/invariants` predicates untouched). `/run` refuses with JSON `{error, policy:{code, detail}}`; `/run/stream` delivers the same as an SSE `error` event (headers already streaming). Codes: `403 POLICY_PROVIDER_DENIED` (explicit provider outside the list, or `auto` when the list excludes every configured provider), `429 POLICY_SPEND_CAPPED`.\n- **Allow-list filters the WHOLE chain** — `RunOptions.allowedProviders` filters the failover chain in `runBackbone` before target expansion, and for `auto` the primary is re-picked to the first configured allowed provider (so neither live failover nor the demo fallback ever serves from outside the list). A list that only checked the requested head while `auto` routed anywhere would be theater.\n- **Spend tally (MEASURED, of estimates)** — `runLedger.getSpendWindow(24)`: `SUM(cost_usd)` over the trailing window plus estimated/unknown/zero/total run counts. `cost_usd` (nullable double) is persisted per run ONLY when `costStatus === \"ESTIMATED\"` (the DECLARED-pricing × MEASURED-tokens amount); ZERO/UNKNOWN rows stay null. The tally is **a sum of estimates, never billing truth** — the basis string says so verbatim; UNKNOWN-cost runs add $0 and their count is surfaced, never hidden. Rows predating the column add $0 (honest: their estimates were never persisted).","sha256":"243bd230babd71035e81f8e09a951de8d8ffa93f75db56b5b32b6be92215e1a8"}
{"id":"doc:data-surfaces:0092","source":"doc","sourceId":"data-surfaces.md","title":"`GET /policy` + run-path policy gate (`src/lib/policy.ts` + `src/routes/policy.ts`)","text":"- **Soft cap, stated not hidden** — the cap is checked PRE-run against already-persisted estimates (ledger inserts are fire-and-forget after the run), so N concurrent in-flight runs can each pass under the cap and briefly overshoot it (bounded by the 20/min run rate limit × per-run estimate). `POLICY_NOTE` says this verbatim; it is never presented as a hard guarantee.\n- **`POST /trials` is policy-gated too** — each fleet trial is a REAL provider call (bounded to 512 tokens/provider). The allow-list applies per row: a disallowed provider is an honest `SKIPPED` with the policy named in `error`, no call attempted. A reached spend cap refuses the whole fan-out with the same 429 shape as `/run`. Caveat stated: trial spend itself is NOT ledgered (trials are not runs), so it never enters the tally — the cap gates trials, trials do not feed the cap.\n- **Ledger-down honesty** — cap declared but DB unreachable → enforcement `SUSPENDED_UNMEASURABLE`: runs proceed and `/policy` surfaces the suspension (blocking every run on a DB blip would be enforcing a cap against a number the server does not have; the suspension is public, never silent).\n- **Per-action approval gates** (`src/lib/approvals.ts` + `POST /policy/approvals`, built 2026-07-12) — env `A11OY_APPROVAL_MODE=required` turns on a human-in-the-loop gate: every `/run` and `/run/stream` call must present a **single-use approval ticket** in header `x-a11oy-approval`, minted by the run-key holder via `POST /policy/approvals` (key-gated exactly like `/run` — sha256 + timingSafeEqual; 401 on wrong/missing key). Tickets are `apv_`-prefixed random ids stored **hashed (sha256), in-memory only**: 10-min TTL, max 200 outstanding (mint refuses 503 when full — never over-issued), spent atomically check-and-delete BEFORE any provider call — one mint = one explicit human approval for one action; a restart clears them (stated in refusal text). Refusal is `403 POLICY_APPROVAL_REQUIRED` (JSON on `/run`, SSE `error` on `/run/stream`) with a detail that distinguishes \"no ticket presented\" from \"unknown or already spent\". Denied requests are never ledger rows (nothing ran). Env states, all stated never silent: unset → gates honestly **OPEN** (exactly like `authMode` without a run key; minting refuses 400 — a ticket for an unenforced gate would be theater); `required` with a run key → **ENFORCED**; `required` WITHOUT a run key → **MISCONFIGURED** (tickets unmintable → mint 503, ALL runs refused with that exact reason — fail closed, never silently open).","sha256":"a607c4b7b3be09288c9eed5e5c7277921961dc240318073ef9587123d90de2c9"}
{"id":"doc:data-surfaces:0093","source":"doc","sourceId":"data-surfaces.md","title":"`GET /policy` + run-path policy gate (`src/lib/policy.ts` + `src/routes/policy.ts`)","text":"- **`GET /policy`** (public, 30/min) — `PolicyReport`: `declared` (env verbatim + source, incl. `approvalMode`), `enforcement` (`spendCap` ENFORCED/OPEN/SUSPENDED_UNMEASURABLE, `providerAllowlist` ENFORCED/OPEN, `approvalGates` ENFORCED/OPEN/MISCONFIGURED), `spend` (MEASURED window or honest UNAVAILABLE), `verdict` (OPEN/WITHIN_CAP/CAPPED/UNMEASURABLE + detail).\n- **UI** — `PolicyPanel.tsx` (band 1 right column, under HonestyAudit): verdict dot, declared cap + tally + usage bar, allow-list, three enforcement chips (approval-gates chip live ENFORCED/OPEN/MISCONFIGURED), a MintApproval block when ENFORCED (mint with the run key, ticket shown once with TTL — never stored client-side), a MISCONFIGURED explainer when applicable, verbatim verdict detail, doctrine footer. `RunConsole.tsx` carries an approval-ticket input (sent as `x-a11oy-approval`, never persisted, cleared after the run that spends it).\n- **Verified live 2026-07-12** — dev: `/policy` honest OPEN + mint 400 when mode unset; E2E on a second instance with test env: explicit `openai` vs allow-list `[gemini]` → 403 POLICY_PROVIDER_DENIED; tiny cap $0.000001 with a real $0.00168 ESTIMATED gemini run in the window → 429 POLICY_SPEND_CAPPED + verdict CAPPED. Approval gates same day: `A11OY_APPROVAL_MODE=required` → ENFORCED; run without ticket → 403; mint with wrong key → 401; mint → run spends the ticket (served by real provider); same ticket again → 403 \"already spent\"; `required` with empty run key → MISCONFIGURED, mint 503, run refused with the misconfiguration named.\n- **Prod checklist** — republish picks up the code; the prod DB needs the `cost_usd` column on `runs` (dev pushed 2026-07-12); policy env vars are OPTIONAL (unset = honestly OPEN); approval gates activate only if the owner sets `A11OY_APPROVAL_MODE=required` in production.","sha256":"5048efba43dcd686b29c1108bd12803a1d1267c352ead14c04bbc0ada82f9ef7"}
{"id":"doc:data-surfaces:0094","source":"doc","sourceId":"data-surfaces.md","title":"`POST /arena/run` — Proving Ground (`src/routes/arena.ts`)","text":"One goal fanned across **2–4 explicitly selected lanes**, each lane ONE pinned provider run through the FULL backbone — agent loop, MEASURED `loop` timing, honest `cost` block, its own run-ledger row, and its own notarized receipt (same `wireReceipt` shape as `/run`, exported from `routes/backbone.ts` so verification tooling never sees two formats). Run-key-gated like `/run`; own 6/min limiter (each click is 2–4 real runs).\n\n- **No demo lanes** — every lane must name a CONFIGURED provider or the WHOLE request refuses 400 before anything runs (`validateLanes`, a pure exported function with its own vitest suite). If credentials vanish mid-flight and the backbone demo-falls-back anyway, the lane is returned FAILED with that stated reason and is NOT ledgered (nothing real ran) — a demo lane would be a fabricated comparison.\n- **Failover DISABLED across lanes** — `runBackbone` is called with `allowedProviders` as the singleton of the lane's provider, so the failover chain IS that one provider. A failed lane reports `FAILED` with the real error (AllProvidersFailed → failure receipt + failure ledger row, exactly like `/run`); it is never rerouted.\n- **Sovereign model pins need MEASURED evidence** — a lane may pin a model ONLY when the live per-node `/v1/models` probe (`lib/forgeProbe.ts`, extracted from `/forge/models`, 60 s cache + in-flight dedup) lists it on an OK node; the lane is then pinned to the EXACT served id on the EXACT evidencing node via `RunOptions.sovereignTarget` (expands to that single node/model target). Unproven ids refuse 400 (\"never assumes one\"); tag-prefix resolution (`szl1` → `szl1:latest`) never crosses model ids. Cloud model overrides are refused — the DECLARED price table is per registry-pinned model, so an override would break honest cost estimation.","sha256":"3673c0b5a91fd14e73dfc486f1350d07332ceccea9d460713618af23737db310"}
{"id":"doc:data-surfaces:0095","source":"doc","sourceId":"data-surfaces.md","title":"`POST /arena/run` — Proving Ground (`src/routes/arena.ts`)","text":"- **Policy** — `gateRun(\"auto\", ticket)` runs ONCE before any lane (one approval ticket approves the one fan-out; spend cap applies). The provider allow-list is enforced **all-or-nothing**: any lane outside it → 403 for the whole arena, nothing runs — silently running \"just the permitted lanes\" would change the comparison the caller asked for.\n- **No winner, ever** — the response is `{label: MEASURED, goal, mode, ranAt, wallMs, doctrine, lanes[]}` with per-lane `{provider, model (the SERVED model from the ok attempt, never just the requested pin), node, status OK|FAILED, output, latencyMs, modelMs, tokensIn/Out, servedNode, cost, receipt, error}`. Quality is NOT scored, there is no ranking field, and the binding doctrine string rides in the payload verbatim. Server output is `ArenaRunResponse.parse(...)` — fail loud, never a silently off-contract payload.\n- **UI** — `ProvingGround.tsx` (cockpit left column, under FleetTrials): lane picker offers ONLY configured providers (+ probe-evidenced sovereign served models, labelled with the evidencing node), 2-lane minimum stated (\"one lane is a run, not a comparison\"), per-lane cards render MEASURED wall/in-model ms, tokens, cost (`ZERO`/`ESTIMATED $`/`UNKNOWN`), receipt status, servedNode, and FAILED lanes red with the real error. Caption verbatim: speed and cost are MEASURED, quality is NOT scored, no automatic winner. 401 → \"enter your key in the Run Console\".\n- **`POST /trials` run-key gate (2026-07-14)** — `/trials` now carries `requireRunKey` like `/run` (a fleet trial is real spend on EVERY configured provider at once); honestly OPEN when no key is set; spec documents the 401. `FleetTrials.tsx` states the gate and renders the 401 hint.\n- **Verified live 2026-07-14 (dev)** — 2-lane openai+gemini arena: both lanes OK with SIGNED receipts, MEASURED timings (openai 1289 ms / gemini 45525 ms — a real spread, honestly reported), 2 ledger rows at `/api/arena/run`; 1-lane body → contract 400; unknown provider / cloud override / unproven sovereign pin → honest 400s; keyless arena + trials → 401.","sha256":"948ea48ebbead55d55bf0bc58835c0cdd60a2c1748fcc2721b32fdb778e4c335"}
{"id":"doc:data-surfaces:0096","source":"doc","sourceId":"data-surfaces.md","title":"Per-run MEASURED energy (`src/lib/energy.ts` + `src/lib/backbone.ts`)","text":"Every `/run` + `/run/stream` result carries an `energy` block (the `done` SSE event mirrors it). Like `cost`, energy is NOT part of the signed receipt canonical — `receipts.ts` picks explicit fields, so adding energy never changed a receipt's shape, hash, or chain.\n\n- **Source** — the SZL per-box szl-meter exporters (Prometheus text over HTTPS, keyless): `meter.a-11-oy.com` meters the tower's GPU (nodes `tower` + `tower·nemo`), `meter2.a-11-oy.com` meters the laptop's (RTX 5050 Laptop GPU). Per-node mapping lives on `SovereignNode.meterHost` in `registry.ts` (env overrides `A11OY_METER_HOST[_2/_3]`) and rides through `RunTarget.meterHost`; cloud targets carry `null`. Families read: `szl_meter_nvml` (must be `1` in BOTH samples) and `szl_gpu_energy_joules` (NVML total-energy counter, summed across GPUs; may reset on driver reload).\n- **Window** — `sampleMeter()` (2.5 s hard timeout, failure never blocks or fails the run) is called immediately BEFORE the serving call on any metered target, and immediately AFTER only on the target that actually served. The window therefore spans the whole serving call including tunnel/network overhead (and excludes the optional self-verification second pass, which runs after the window closes). A failed pre-sample on a target that then serves = honest `UNAVAILABLE` (\"no opening sample\"), never a retro-guess. Per-run negative cache: a meter host that timed out once is not re-sampled by later failover targets in the SAME run (tower + tower·nemo share one meter) — a downed tunnel costs at most one 2.5 s timeout per host per run.\n- **EnergyStatus** `MEASURED | UNAVAILABLE | UNKNOWN | ZERO`. `MEASURED` requires: both samples real + NVML present in both + counter delta ≥ 0. Negative delta (driver reload / counter reset) → `UNAVAILABLE` with that concrete reason — the delta is discarded, never clamped to 0. Cloud-served → `UNKNOWN` (no per-run energy telemetry exists; never estimated). Demo → `ZERO` (no model call was made; nothing metered).","sha256":"758dbb9f352e35c32920480d6c0220f0fcb69cc9042a024fd0ba55d052d7ed19"}
{"id":"doc:data-surfaces:0097","source":"doc","sourceId":"data-surfaces.md","title":"Per-run MEASURED energy (`src/lib/energy.ts` + `src/lib/backbone.ts`)","text":"- **WHOLE-GPU caveat (load-bearing)** — the NVML counter is per-GPU, not per-process: a MEASURED window includes ANY concurrent load on that GPU (e.g. a training job running on the laptop). The basis string states this verbatim and the number is never claimed as attributable solely to the run. `avgWatts` is DERIVED (`joules / window`), labelled as such.\n- **UI** — `RunConsole.tsx` renders an Energy block between Cost and Observer frame: `MEASURED` → `<J> J · ~<W> W avg · <s>s window` (green) with the whole-GPU/concurrent-load caveat inline; `ZERO` green, `UNAVAILABLE`/`UNKNOWN` amber with the verbatim basis (+ reason). Full basis on hover (title attr). Spec: `EnergyBlock` schema in `openapi.yaml`, required on `RunResult` and `RunDoneEvent`.\n- **Verified live 2026-07-12** — laptop-served run: MEASURED 106.935 J over 5600 ms (~19.1 W avg) from meter2; cloud (openai) run: UNKNOWN with honest basis.","sha256":"b60dbea927ab63f26beac2319d94bf32af8235568d1ea87e0fa00a9ce1cc7cff"}
{"id":"doc:data-surfaces:0098","source":"doc","sourceId":"data-surfaces.md","title":"Per-run loop tax (`src/lib/backbone.ts` `LoopTrace`, NVIDIA Vera ingest applied)","text":"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.\n\n- **`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.\n- **`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.\n- **`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.\n- **`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.","sha256":"9d88de036c5cadfca4f80d6e39bdb3f2b6d9ea02964e28171ffbf412d32e4974"}
{"id":"doc:data-surfaces:0099","source":"doc","sourceId":"data-surfaces.md","title":"Per-run loop tax (`src/lib/backbone.ts` `LoopTrace`, NVIDIA Vera ingest applied)","text":"- **`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.\n- **`timingBasis`** — the basis string verbatim (`LOOP_TIMING_BASIS`), attached to every trace so the split is never separated from what it means.\n- **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.\n- **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.\n- **NOT in the signed receipt canonical** — `receipts.ts` picks explicit fields; adding loop fields never changes receipt shape/hash/chain.\n- **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.","sha256":"4a9ff64e46736af337d8285102f6e57a41b1f0f09322d933b41b44adc35eb9ce"}
{"id":"doc:data-surfaces:0100","source":"doc","sourceId":"data-surfaces.md","title":"Self-verification rubric (`src/lib/backbone.ts` verify pass, Lumbra eval-first ingest applied)","text":"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).\n\n- **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.\n- **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).\n- **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.\n- **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).\n- **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.","sha256":"e3956b8801bcf3226929f0d9080bbca5a73e2047c544b3d1167b9fadb75b488c"}
{"id":"doc:data-surfaces:0101","source":"doc","sourceId":"data-surfaces.md","title":"Self-verification rubric (`src/lib/backbone.ts` verify pass, Lumbra eval-first ingest applied)","text":"- **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.","sha256":"140ca40804d85ac9f122b440c99355be0140cbe4ad0aecab945fa9418b462a0a"}
{"id":"doc:architecture-notes:0000","source":"doc","sourceId":"architecture-notes.md","title":"Alloy architecture notes (deep detail)","text":"> Relocated verbatim from `replit.md` on 2026-07-12 to keep the README lean. This file is the\n> full historical subsystem detail (component wiring, ingest waves 1-9, provider quirks).\n> `docs/data-surfaces.md` remains the authoritative per-block upstream reference.","sha256":"c9b5f9775371e65e07eefb4b9dfd6dd6fdc75c24a67c5d0c2ac25ba96ab10b00"}
{"id":"doc:architecture-notes:0001","source":"doc","sourceId":"architecture-notes.md","title":"Overview","text":"pnpm workspace monorepo using TypeScript. Each package manages its own dependencies.\n\n**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).\n\n**Ownership**: This project (Alloy — Agentic Orchestrator) is a product of **SZL Holdings**. Branding reflects \"Alloy by SZL Holdings\" (hero eyebrow, footer copyright, page title).\n\n**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\".","sha256":"b6a493488a775ec7c19b39b30b533457ebf45b75a13e861d2f9688f33115017e"}
{"id":"doc:architecture-notes:0002","source":"doc","sourceId":"architecture-notes.md","title":"Stack","text":"- **Monorepo tool**: pnpm workspaces · **Node.js**: 24 · **TypeScript**: 5.9\n- **API framework**: Express 5 · **Database**: PostgreSQL + Drizzle ORM\n- **Validation**: Zod (`zod/v4`), `drizzle-zod` · **API codegen**: Orval (from OpenAPI spec) · **Build**: esbuild (CJS bundle)","sha256":"d979f818cc64000a9b75f81ccf9f69b57a83a5fcc9dcf23027b71fc0dedf3146"}
{"id":"doc:architecture-notes:0003","source":"doc","sourceId":"architecture-notes.md","title":"alloy (`artifacts/alloy`, served at `/`)","text":"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:\n\n- **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 `#`).\n- **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.\n- **Run Ledger** (`Telemetry.tsx`) — MEASURED: renders key-gated `GET /api/runs/recent` via generated hook; honest empty/UNAVAILABLE/KEY-REQUIRED states.\n- **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.","sha256":"f1c48126e3d96a9c93d8d4cce0ab299d117a64624739fb298f96a57db256e863"}
{"id":"doc:architecture-notes:0004","source":"doc","sourceId":"architecture-notes.md","title":"alloy (`artifacts/alloy`, served at `/`)","text":"- **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**).","sha256":"bcfc71bb2fb3e31a99bfff7704815a18288d09b2a5fc412e70595b0f82c06046"}
{"id":"doc:architecture-notes:0005","source":"doc","sourceId":"architecture-notes.md","title":"alloy (`artifacts/alloy`, served at `/`)","text":"- **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`.\n- **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`.","sha256":"2e09d90f9270d507c25c434bd9569d2c5a08c4ad6b95fa561ecfe6f3538f70cc"}
{"id":"doc:architecture-notes:0006","source":"doc","sourceId":"architecture-notes.md","title":"api-server (`artifacts/api-server`, served at `/api`)","text":"Express API server hosting the orchestration backbone.\n\n**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`.\n\n- **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`.","sha256":"d4fd467c53b9ba1be98457a0d17c2c2cca240c676910cf9de5c9994071620d7f"}
{"id":"doc:architecture-notes:0007","source":"doc","sourceId":"architecture-notes.md","title":"api-server (`artifacts/api-server`, served at `/api`)","text":"- **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).\n- **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.\n- **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.\n- **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.\n- **`/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.","sha256":"ada19bc26621aa4a2dce2742724b30242aae78eb7a8f7e7d0c1676228ecf89c6"}
{"id":"doc:architecture-notes:0008","source":"doc","sourceId":"architecture-notes.md","title":"api-server (`artifacts/api-server`, served at `/api`)","text":"- **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).\n- **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`.\n- **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`.","sha256":"83156c9ba17c1073d664066dd4d72455591a92ced9547b55912db439d8fce61d"}
{"id":"doc:architecture-notes:0009","source":"doc","sourceId":"architecture-notes.md","title":"api-server (`artifacts/api-server`, served at `/api`)","text":"- **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`.\n- **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`.\n- **Sovereign flywheel** (`src/routes/flywheel.ts`): MEASURED count of training samples from own-metal-served, non-demo, successful runs only; honest zero. `FlywheelPanel.tsx`.","sha256":"c8f43d99dfae3371a26deb2c633b573a8738f56348bece87459e161ac3ddaa45"}
{"id":"doc:architecture-notes:0010","source":"doc","sourceId":"architecture-notes.md","title":"api-server (`artifacts/api-server`, served at `/api`)","text":"- **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).\n- **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).\n- **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`.","sha256":"510891cc33302f262b44f5733153231b3be60303c5acfe0c378fe9bb175d11c6"}
{"id":"doc:architecture-notes:0011","source":"doc","sourceId":"architecture-notes.md","title":"api-server (`artifacts/api-server`, served at `/api`)","text":"- **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`.\n- **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`.","sha256":"91e940885e16676af8da980279133cdb740bfe5b54bb639e56677b470bfdb6fd"}
{"id":"doc:architecture-notes:0012","source":"doc","sourceId":"architecture-notes.md","title":"api-server (`artifacts/api-server`, served at `/api`)","text":"- **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).","sha256":"d762d025cd0f56d89fb4f9e02206fd0b4a5630522b08d12da1361d0b1457be1f"}
{"id":"doc:architecture-notes:0013","source":"doc","sourceId":"architecture-notes.md","title":"mockup-sandbox (`artifacts/mockup-sandbox`, served at `/__mockup`)","text":"Design canvas sandbox.","sha256":"b04a286eeef4ebcd3cd1fe4f353115b4262bd4e35325b364251985943dc00b88"}
{"id":"doc:architecture-notes:0014","source":"doc","sourceId":"architecture-notes.md","title":"Key Commands","text":"- `pnpm run typecheck` — full typecheck across all packages\n- `pnpm run build` — typecheck + build all packages\n- `pnpm --filter @workspace/api-spec run codegen` — regenerate API hooks and Zod schemas from OpenAPI spec\n- `pnpm --filter @workspace/db run push` — push DB schema changes (dev only)\n\nSee the `pnpm-workspace` skill for workspace structure, TypeScript setup, and package details.","sha256":"24ca4ebce2641d0daaff57edbbb156d30f3d6d6cebfe9b6d904d314fb9b5a62c"}
{"id":"doc:architecture-notes:0015","source":"doc","sourceId":"architecture-notes.md","title":"References","text":"- `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.\n- `docs/OWNER-SETUP.md` — owner-side setup (GPU nodes, CF Access).","sha256":"cf1ed596df2413f3c835e13111f7ca60c41965f6128960d352ad9795b007e6bc"}
{"id":"doc:sovereign-forge-honesty-audit:0000","source":"doc","sourceId":"sovereign-forge-honesty-audit.md","title":"Sovereign fleet + Forge — honesty-doctrine audit","text":"**Scope (T004).** A read-through of every sovereign-node, hosted-provider, and\nSZL-Forge/SZL-1 surface in this repo to confirm each one carries an honest label\n(MEASURED / REPORTED / DECLARED / DERIVED / UNKNOWN / UNAVAILABLE) and never\nfabricates a number, an \"online\", or a benchmark. For every slot this doc states\nthe **honest label today** and the **one owner action that would flip it to\nMEASURED**.\n\n**Ground truth read (not re-measured here):**\n`artifacts/api-server/src/lib/registry.ts` (`providers`, `sovereignNodes()`),\n`artifacts/api-server/src/routes/forge.ts`, `.../routes/sovereign.ts`,\n`.../routes/mesh.ts`, `docs/data-surfaces.md`, `docs/OWNER-SETUP.md`, and the\n`docs/forge/` kit (`README.md`, `szl_forge.py`, `szl_dataset.jsonl`, `Modelfile`).\n\n**Doctrine anchors honored throughout:** offline nodes show\n`(offline)` / `UNAVAILABLE`, never a faked reading; `szl-nemo` stays\n\"prepared · not serving\" until a live probe; **no MEASURED benchmark exists for\nany fine-tune — quality is UNKNOWN until measured**; Λ stays Conjecture‑1; the\n8 locked-proven families and the 749/14/163 Lean numbers are untouched by this\npass; `#3af4c8` unchanged.","sha256":"9fdcf09790e47b92b34e1a96058f24d8f51049b1c14c44b079b8aecb113d1ae9"}
{"id":"doc:sovereign-forge-honesty-audit:0001","source":"doc","sourceId":"sovereign-forge-honesty-audit.md","title":"Sovereign fleet + Forge — honesty-doctrine audit","text":"> **How to read the labels.** *MEASURED* = the serving process observed it on a\n> live probe this request-cycle. *REPORTED* = a value the owner or an upstream\n> stated that Alloy passes through but cannot itself verify. *DECLARED* = a\n> static owner-stated fact (env / repo). *DERIVED* = computed from measured\n> evidence. *UNKNOWN* = honestly unobservable. *UNAVAILABLE* = a fetch that was\n> attempted and failed — shown as silence, never a placeholder.\n\n---","sha256":"f92c95981d4e00015bda4a914b84e548d6b14ac13aac4d465614ad10b6e8b17c"}
{"id":"doc:sovereign-forge-honesty-audit:0002","source":"doc","sourceId":"sovereign-forge-honesty-audit.md","title":"1. The three sovereign own-metal nodes","text":"Nodes are produced by `sovereignNodes()` in `registry.ts`. A node exists in the\nfailover list **only when its base-URL env is set** — an unset node is silently\nabsent, never a fabricated endpoint. Node models are never defaulted to each\nother (the laptop may serve a smaller model than the tower; claiming otherwise\nwould be a fabrication).\n\n| 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 |\n|------|--------------|---------------|--------------------------------------------------------------------------------|------------------------|--------------------------|\n| **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). |\n| **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. |\n| **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. |","sha256":"d585216c56a9ad0266d4f38d45f3aaaf0e19149bbe99bb1f3c2da22c10aea0fe"}
{"id":"doc:sovereign-forge-honesty-audit:0003","source":"doc","sourceId":"sovereign-forge-honesty-audit.md","title":"1. The three sovereign own-metal nodes","text":"**Energy meters (context for the substrate label).** Per OWNER-SETUP.md\n(2026‑07‑12): `meter2.a-11-oy.com` (laptop) is **LIVE** — MEASURED NVML watts +\njoules on the RTX 5050; `meter.a-11-oy.com` (tower) is **TUNNEL DOWN**. Node VRAM\nis **never MEASURED** — the szl-meter exporters expose no NVML memory gauge\n(live-verified 2026‑07‑12), so `A11OY_NODE_VRAM_GB[_2/_3]` is a **DECLARED**\nowner value or `null`, and is never guessed from GPU marketing specs.\n\n**Verdict — nodes:** honest. Offline/absent nodes surface as\n`OFFLINE`/`UNREACHABLE`/`UNAVAILABLE` with a real reason and never a fabricated\nmodel list. `szl-nemo` correctly stays \"prepared · not serving\" until a live\nprobe lists it. No change required.\n\n---","sha256":"f98c72fa6cc08a507f2a44d9c58d07fa9b8e7f0355e434d27fa309d0cfed6700"}
{"id":"doc:sovereign-forge-honesty-audit:0004","source":"doc","sourceId":"sovereign-forge-honesty-audit.md","title":"2. The sovereign compute-substrate class","text":"`registry.ts` assigns the sovereign provider `substrate: \"GPU\"` with label\n**DERIVED** and an explicit basis: it is derived from MEASURED evidence (the\nszl-meter exporters sample NVML energy counters, and NVML exists only on NVIDIA\nGPUs) — a **class** claim, never a die/SKU claim. Every cloud provider is\n`substrate: \"UNKNOWN\"` / label `UNKNOWN` — serving silicon is unobservable\nthrough an OpenAI-compatible API and is never guessed; Google's TPU story stays\nvendor-REPORTED, never restated as SZL fact. No LPU or NPU serves in this fleet\nand none is claimed.\n\n**Verdict — substrate:** honest and correctly scoped (class, not SKU). No change\nrequired. *Nuance worth the owner's awareness:* the DERIVED-GPU basis rests on\nNVML meter samples; with the tower meter currently TUNNEL DOWN, the live NVML\nevidence is coming from the **laptop** meter. The claim remains true as a class\nstatement, but the \"tower/laptop\" phrasing in the basis is broader than what is\nlive-metered right now — kept as written because it describes the evidence class,\nnot a real-time reading.\n\n---","sha256":"3f5d6df57605d1abbff6cf7de2904d3b120cdbd184f9e666872bb58eefead3b7"}
{"id":"doc:sovereign-forge-honesty-audit:0005","source":"doc","sourceId":"sovereign-forge-honesty-audit.md","title":"3. Hosted providers (free/paid API fleet)","text":"Eight provider slots in `registry.ts`. The **only** availability signal Alloy can\nhonestly assert per provider is `configured` — whether the required key/base-URL\nenv is present. Pricing tier (free vs paid) is a **vendor-DECLARED** attribute\nAlloy does not verify and does not restate as fact.\n\n| Provider | `configured` gate | Substrate | Model default (with note) |\n|----------|-------------------|-----------|----------------------------|\n| 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 |\n| 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) |\n| Moonshot Kimi | `MOONSHOT_API_KEY` | UNKNOWN | `kimi-k2.6` |\n| DeepSeek | `DEEPSEEK_API_KEY` | UNKNOWN | `deepseek-chat` |\n| Qwen | `QWEN_API_KEY` | UNKNOWN | `qwen-plus` |\n| Hugging Face | `HUGGINGFACE_API_KEY` \\|\\| `HF_TOKEN` | UNKNOWN | `openai/gpt-oss-120b`; router fans out across third-party providers |\n| OpenRouter | `OPENROUTER_API_KEY` | UNKNOWN | `openrouter/auto`; vendor **and** silicon vary per request |\n| Google Gemini | `GEMINI_API_KEY` | UNKNOWN | `gemini-3.5-flash` — MEASURED live 2026‑07‑11 |","sha256":"06d6b8c6a6d7c1085a131465b4f3a6760f742ed2cffda91bff5afce8e74970d9"}
{"id":"doc:sovereign-forge-honesty-audit:0006","source":"doc","sourceId":"sovereign-forge-honesty-audit.md","title":"3. Hosted providers (free/paid API fleet)","text":"**UI cross-check (`ProviderFleet.tsx`).** Availability is only asserted when real\nbackend data has been fetched (`knowAvailability`): a provider is `Ready` only\nwhen `configured` is true from live/last-known status; otherwise `Demo`; and when\nthe backend has never been reached the badge is honestly `Unknown` with\n\"status unknown · backend unreachable\" — the offline static roster is **never**\npresented as \"Ready\". The sovereign first-light button shows real\n`LIVE`/`UNREACHABLE`/`OFFLINE` with a MEASURED timestamp. The substrate footnote\nrestates the DERIVED-GPU-vs-UNKNOWN-cloud rule verbatim.\n\n**Verdict — providers:** honest. `configured` is the correct, non-overclaiming\navailability signal; cloud substrate is uniformly UNKNOWN; the UI degrades to\n`Unknown` rather than faking readiness. No change required.\n\n---","sha256":"981e838e40128b28db8f83c2a348b6230951e8e5dfb2f4eca868111a678276e8"}
{"id":"doc:sovereign-forge-honesty-audit:0007","source":"doc","sourceId":"sovereign-forge-honesty-audit.md","title":"4. Forge / SZL-1 pipeline","text":"`routes/forge.ts` is a genuine MEASURED probe: it asks each configured node's own\n`/v1/models` what it actually serves (same base-URL + auth the router uses),\ncarries `label: \"MEASURED\"`, a real `checkedAt`, a ≤60s cache whose `checkedAt`\nalways reflects the real probe time, and returns `UNAVAILABLE` + the real\nHTTP/error reason on failure. Presence matching is exact-or-tag-prefixed\n(`szl1` matches `szl1:latest`, never `szl10`). A model being **present** is\nreported separately from being the **configured serving** model — the two are\nnever conflated.\n\n`ForgePanel.tsx` derives four steps, each with the correct honesty grade:\n\n| Step | State source | Honest grade |\n|------|--------------|--------------|\n| **Kit published** | hard `DONE` | **DECLARED** — the repo `github.com/szl-holdings/szl-forge` is public and linked |\n| **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 |\n| **`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 |\n| **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` |","sha256":"145500c8e74430d22f1a78c2658520025292ca700a6756192d07116a76ea26ca"}
{"id":"doc:sovereign-forge-honesty-audit:0008","source":"doc","sourceId":"sovereign-forge-honesty-audit.md","title":"4. Forge / SZL-1 pipeline","text":"The `docs/forge/` kit is consistent with this: its README states outright that\n\"quality is UNKNOWN until measured. No benchmark or speedup is claimed. This is\nnot a hand-tuned CUDA/Triton binary,\" and that a node \"stays honestly labeled\n'prepared · not serving'\" until a live probe succeeds. The panel footer keeps the\nscope honest: \"Fine-tune kit for SZL-1 — not from-scratch pretraining.\"\n\n**Fine-tune quality:** **UNKNOWN.** No MEASURED benchmark exists for SZL-1 or\n`szl-nemo` anywhere in the repo, and none is asserted. Flipping this to MEASURED\nrequires the owner to run a real evaluation and record the method + numbers; only\nthen may any quality claim be made.\n\n**One label/copy fix applied (in-shape, no schema change).** The \"Train on RTX\n5050\" step previously read `owner-reported`. Because Alloy genuinely cannot\nobserve the owner's local training run, the detail now reads\n`owner-reported, not observable by Alloy` so the perpetual `RUNNING` badge cannot\nbe misread as a live/measured signal. Purely client-side copy in\n`ForgePanel.tsx`; the local `PipelineState` enum, response schema, endpoints, and\nOpenAPI spec are untouched (codegen remains T001's lane).","sha256":"7cba809dea0c252fef09f8cc67d2ec119d821fc3a11014ae91b04f51fcbb12d9"}
{"id":"doc:sovereign-forge-honesty-audit:0009","source":"doc","sourceId":"sovereign-forge-honesty-audit.md","title":"4. Forge / SZL-1 pipeline","text":"**Verdict — Forge:** honest. `create`/`serve` flip on MEASURED evidence only;\n`kit` is DECLARED; `train` is owner-REPORTED and now explicitly marked\nunobservable; quality stays UNKNOWN.\n\n---","sha256":"5b453284eeaf1e5e788c05631fe78e5774b71c33618240a904f04e77b9bbb800"}
{"id":"doc:sovereign-forge-honesty-audit:0010","source":"doc","sourceId":"sovereign-forge-honesty-audit.md","title":"5. Owner action checklist — what flips each slot to MEASURED","text":"1. **Tower online** — run `tower-autostart.ps1` (secure the keyless Ollama port\n   first, OWNER-SETUP §1). When `gpu.a-11-oy.com/v1/models` returns 2xx, the\n   sovereign probe → `LIVE` and the Forge tower row → `OK` (both MEASURED).\n2. **Tower meter** — start the meter service so `meter.a-11-oy.com` serves NVML\n   watts/joules for the tower (laptop meter already LIVE).\n3. **szl-nemo (node 3)** — set `A11OY_MODEL_BASE_URL_3` + `SOVEREIGN_MODEL_3=szl-nemo`\n   at the Ollama serving it; presence flips to MEASURED on the next probe that\n   lists it. Until then it correctly reads \"prepared · not serving\".\n4. **SZL-1 create/serve** — `ollama create szl1` on a wired node, then set\n   `SOVEREIGN_MODEL=szl1`; the Forge steps flip to MEASURED-`DONE` automatically.\n5. **Fine-tune quality** — run a real eval and record method + numbers; only then\n   may quality move off UNKNOWN. No benchmark or speedup may be claimed before\n   that measurement exists.","sha256":"0e33774749f8d3a32f7c311a504e9e1eae09dcaf2949afdf930abbb564204b95"}
{"id":"doc:sovereign-forge-honesty-audit:0011","source":"doc","sourceId":"sovereign-forge-honesty-audit.md","title":"6. Summary","text":"The sovereign, provider, and Forge surfaces are already honesty-doctrine\ncompliant: offline/absent nodes and meters read `OFFLINE`/`UNREACHABLE`/`TUNNEL\nDOWN`/`UNAVAILABLE` with real reasons; `configured` is the only availability\nclaim for cloud providers; substrate is DERIVED-GPU (class) for own metal and\nUNKNOWN for every cloud; Forge `create`/`serve` flip only on MEASURED `/v1/models`\nevidence; and fine-tune quality is left UNKNOWN with no fabricated benchmark. The\nsingle change made in this pass is a one-line copy clarification on the Forge\n`train` step to mark it explicitly unobservable by Alloy. No schemas, endpoints,\n`openapi.yaml`, or codegen were touched.","sha256":"d525d0632c1328fa31b33a0a128827e0cd46ad23a33f8731845e3aec13d1858a"}
{"id":"doc:RELEASE:0000","source":"doc","sourceId":"RELEASE.md","title":"Alloy Release Checklist (repeatable)","text":"The honesty doctrine is a release gate, not a nicety. A build that fabricates,\nrepaints, or over-claims does not ship — even if every automated check is green.","sha256":"67e57680558cc424a2c2436d79729d43f90459b5cde0d290a16165cb10cd1b52"}
{"id":"doc:RELEASE:0001","source":"doc","sourceId":"RELEASE.md","title":"1. Automated pre-flight (dev)","text":"Run all three; each must report clean before proceeding.\n\n- **Typecheck** — `pnpm run typecheck` → every package prints `Done`.\n- **Security** — `pnpm --filter @workspace/scripts run security-check` → `ALL CHECKS PASSED`\n  (CORS allow-list holds, security headers present, no secret/DB leakage in `/healthz`).\n- **Reliability** — `pnpm --filter @workspace/scripts run reliability-check` → `ALL CHECKS PASSED`\n  (`/healthz` shape, no sensitive data, `Cache-Control: no-store` on dynamic endpoints, rate-limit headers on gated endpoints).","sha256":"c916213fb270c068dfb5250f420fa5923929275b21311b053c540aeaeaa34751"}
{"id":"doc:RELEASE:0002","source":"doc","sourceId":"RELEASE.md","title":"2. Wall data smoke (dev)","text":"Curl every wall endpoint through the shared proxy (`http://localhost:80/api/...`); each must\nreturn HTTP 200 **and** carry its correct honesty label (a wall with no live data must render\n`UNAVAILABLE`, never an invented number):\n\n```\nhealthz  backbone/status  frontier  velocity  leaders  quant  paper  decay\ningest   lean  invariants  honesty  memory  formulas/answers\n```","sha256":"e103cfcce3df93b38d93d101b23f2a345948c1a8b7678406d60831d7c28d1c85"}
{"id":"doc:RELEASE:0003","source":"doc","sourceId":"RELEASE.md","title":"3. Run-key gate (dev)","text":"- Keyless `POST /api/run` must return **401** whenever `A11OY_RUN_KEY` is set (fail-closed,\n  refused before any provider call). If the key is unset the gate is honestly OPEN.\n- With the key (`x-a11oy-key` header) a run streams a routing trail + a receipt.","sha256":"06b4ffc7d3a2c0bbbff4bd48b4ac06cafc6b4be7b9853baf79b52ef85258dbce"}
{"id":"doc:RELEASE:0004","source":"doc","sourceId":"RELEASE.md","title":"4. Render check (dev)","text":"Screenshot `/` and confirm:\n\n- Brand accent is teal `#3af4c8` (LIVE pill, primary highlights). Amber only on semantic\n  status labels — see doctrine gates below.\n- Hero + every wall render; no blank/crashed sections; no raw stack traces.\n- Provenance labels (MEASURED / REPORTED / DECLARED / SIMULATED / DERIVED / UNKNOWN / UNAVAILABLE)\n  are present on the page.","sha256":"ae709b5ced14ea5c2af823484e3bc0cbacfb53470a501da03c4592b747d86ec2"}
{"id":"doc:RELEASE:0005","source":"doc","sourceId":"RELEASE.md","title":"5. End-to-end (when the test harness is available)","text":"Run an e2e smoke across hero → Run Console → every wall. The Playwright harness is\noccasionally unavailable (`Notebook not found`); when it is, fall back to steps 2–4, which\ncover the same surface via backend + render verification.","sha256":"7c24dbaff29b2f5faee01bd5871acdd8728d9ea17adc86bacbd48349c806e396"}
{"id":"doc:RELEASE:0006","source":"doc","sourceId":"RELEASE.md","title":"Doctrine gates (binding — never ship if violated)","text":"- **No fabrication.** Every value carries a provenance label. Failed upstreams show\n  `UNAVAILABLE`; nothing is invented to fill a gap.\n- **Palette.** Brand accent stays `#3af4c8` — never repaint to another identity. Amber is a\n  **semantic status color** (UNAVAILABLE / UNMEASURABLE / TIMEOUT / PARTIAL / pending) — never\n  mass-convert amber → teal; only the decorative glow utilities in `index.css` are brand-teal.\n- **Claims.** Λ stays Conjecture-1 (never \"proven\"); locked-proven count = 8; corpus = 269.\n- **Layout invariants.** FrontierRadar full-width masonry; TerminalVelocity keeps two\n  Terminal-Bench boards separate with the sovereign row NOT_EVALUATED; FieldLeaders Hub rows\n  never contain SZL; QuantEngine carries its SIMULATED disclosure; DecayLedger's three bands\n  never blend; LivingPaper renders DIVERGES red and PARTIAL amber (never red).","sha256":"4070be483a01ea7573e7254184282359d52156f6ef3734a3f968e1ee422fa8cb"}
{"id":"doc:RELEASE:0007","source":"doc","sourceId":"RELEASE.md","title":"Prod prerequisites","text":"- Prod DB has the `runs` table **and the `cost_usd` column**.\n- Policy env vars are optional (unset = honestly OPEN).","sha256":"ed9f635fe69f33ce37aed874b9e59962e790a94efa67ec7fe35a75be193e6c76"}
{"id":"doc:RELEASE:0008","source":"doc","sourceId":"RELEASE.md","title":"Publish","text":"- Republish via the deployment flow; `A11OY_RUN_KEY` reaches prod automatically on republish.\n- Post-deploy: confirm `https://a11oy.net/api/healthz` returns 200 and spot-check one wall\n  endpoint returns its labeled payload.","sha256":"9a4d1a36dad6dd98f0742905939f0cb12a20f9ed1ba92c046eb298181c649703"}
{"id":"doc:replit:0000","source":"doc","sourceId":"replit.md","title":"Overview","text":"pnpm workspace monorepo (TypeScript). Each package manages its own dependencies.\n\n**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).\n\n**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.\n\n**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\".","sha256":"668bcce197ea8ea2e25bae7e8d76e7121f4a57cd324318609a28e571947bbf0b"}
{"id":"doc:replit:0001","source":"doc","sourceId":"replit.md","title":"Stack","text":"- pnpm workspaces · Node.js 24 · TypeScript 5.9\n- Express 5 · PostgreSQL + Drizzle ORM\n- Zod (`zod/v4`), `drizzle-zod` · Orval codegen (from OpenAPI spec) · esbuild (CJS bundle)","sha256":"3dfbb6a42216056c50baf6b09e69e59bc138f79748f58fbe86b3ac0f1fa22638"}
{"id":"doc:replit:0002","source":"doc","sourceId":"replit.md","title":"alloy (`artifacts/alloy`, served at `/`)","text":"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`).\n\n**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).","sha256":"bb79031d794b33e8d43e5f0e9d63e8142e747d2d925d2b6d1103e8d6c91ae094"}
{"id":"doc:replit:0003","source":"doc","sourceId":"replit.md","title":"alloy (`artifacts/alloy`, served at `/`)","text":"**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`.\n\n**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 Λ.","sha256":"20ddc6522d9af97f86bd725570efe6c7e9a7a3bc49273fe5d59f002499da1092"}
{"id":"doc:replit:0004","source":"doc","sourceId":"replit.md","title":"alloy (`artifacts/alloy`, served at `/`)","text":"**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.","sha256":"2bc34ac4883417dafee6fe76fdd323a91940c83ffec456869c942eb9473fd0eb"}
{"id":"doc:replit:0005","source":"doc","sourceId":"replit.md","title":"api-server (`artifacts/api-server`, served at `/api`)","text":"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).","sha256":"e1e30540edc06bceb670e8efea343654e4dfe16cefb73f54c629617bdd5f115f"}
{"id":"doc:replit:0006","source":"doc","sourceId":"replit.md","title":"api-server (`artifacts/api-server`, served at `/api`)","text":"Subsystems (one-liners; full detail `docs/architecture-notes.md`, per-block upstream truth `docs/data-surfaces.md`):\n\n- **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.\n- **Run key gate** (`lib/runKey.ts`): sha256 + timingSafeEqual on `A11OY_RUN_KEY` (Replit Secret — secrets must NEVER go in `.replit`); honestly OPEN when unset.\n- **Run ledger** (`lib/runLedger.ts`): every run success AND failure → Postgres; lazy DB import so missing DATABASE_URL never crashes boot.\n- **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.\n- **`/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.\n- **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).\n- **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`.","sha256":"3f0c5d77fc426123cd615b96d78f3ebfbc1260666865e1e55efcf24f55f13881"}
{"id":"doc:replit:0007","source":"doc","sourceId":"replit.md","title":"api-server (`artifacts/api-server`, served at `/api`)","text":"- **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.\n- **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).\n- **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.\n- **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.\n- **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.","sha256":"bf91690815e06511285bb69663c26ecdb32e28048d2cb21a1ddb0373799ba2c0"}
{"id":"doc:replit:0008","source":"doc","sourceId":"replit.md","title":"api-server (`artifacts/api-server`, served at `/api`)","text":"- **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/`.\n- **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.","sha256":"665471aa35ec203f91bdb7cd0d03fda94f36db6ba6032d37fc65484b4917d442"}
{"id":"doc:replit:0009","source":"doc","sourceId":"replit.md","title":"api-server (`artifacts/api-server`, served at `/api`)","text":"- **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).\n- **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).\n- **Sentry**: env-gated, inert without DSN (owner action pending); `@sentry/*` stays in esbuild `external`.","sha256":"9b22421c5c1fe86dfe31d027d8c1b93517bc6b2707a763a487032ef3fd04eab8"}
{"id":"doc:replit:0010","source":"doc","sourceId":"replit.md","title":"mockup-sandbox (`artifacts/mockup-sandbox`, served at `/__mockup`)","text":"Design canvas sandbox.","sha256":"b04a286eeef4ebcd3cd1fe4f353115b4262bd4e35325b364251985943dc00b88"}
{"id":"doc:replit:0011","source":"doc","sourceId":"replit.md","title":"Key Commands","text":"- `pnpm run typecheck` — full typecheck across all packages\n- `pnpm run build` — typecheck + build all packages\n- `pnpm --filter @workspace/api-spec run codegen` — regenerate API hooks and Zod schemas from OpenAPI spec\n- `pnpm --filter @workspace/db run push` — push DB schema changes (dev only)\n\nSee the `pnpm-workspace` skill for workspace structure and package details.","sha256":"e41dfb659a5ed00dcfb5593bc31a388d220cb5cd7f7386ed37641bac0b3ce81b"}
{"id":"doc:replit:0012","source":"doc","sourceId":"replit.md","title":"References","text":"- `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).\n- `docs/architecture-notes.md` — full relocated subsystem detail (component wiring, ingest waves, provider quirks, E2E verification history).\n- `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).\n- `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.\n- `docs/OWNER-SETUP.md` — owner-side setup (GPU nodes, CF Access). `docs/tower-autostart.ps1` — owner autostart.","sha256":"f0aa357159ea0367392d8928e5d845d9244cd2372947eaa4c374ffd7bb518607"}
{"id":"formula:blk-005ff9bca51b","source":"formula","sourceId":"thm:fibre-injectivity","title":"formal-blocks · thm:fibre-injectivity","text":"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","sha256":"eeb23742a9d2908e6e2001a7b09d3a64cb5c0236fdbfc0df0c44331f0eed8381"}
{"id":"formula:blk-010f120f0199","source":"formula","sourceId":"thm:thv18-07","title":"formal-blocks · thm:thv18-07","text":"\\begin{verbatim} theorem th_v18_07_chain_length_4 : feynmanCitationChain.length = 4 \\end{verbatim}","sha256":"8ea5d987ec288b5d476be77f035753c9551296249eecc9bd8c75659aa1f2734e"}
{"id":"formula:blk-019ec5e83523","source":"formula","sourceId":"2. Definition","title":"formal-blocks · 2. Definition","text":"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 =","sha256":"cfa82c28cb5efcf79a65d01314c4c2ffa6b00b77baee86aa48e252a6efe2e740"}
{"id":"formula:blk-0222abbd0ce6","source":"formula","sourceId":"thm:dpo-stability","title":"formal-blocks · thm:dpo-stability","text":"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","sha256":"9db538a40333f951cb06d40b1cb2d6488bec32bbd522f9ef7270947bb6c7652e"}
{"id":"formula:blk-022feaafafdb","source":"formula","sourceId":"thm:cross-domain-sovereign","title":"formal-blocks · thm:cross-domain-sovereign","text":"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","sha256":"d9365471566f0be235518ff114516569f3b8f9b1e9c18402f8fd4a9d3c61f856"}
{"id":"formula:blk-0473550d0f81","source":"formula","sourceId":"thm:two-witness-soundness","title":"formal-blocks · thm:two-witness-soundness","text":"\\begin{equation} \\mathrm{ExactlyOnePerContext}(f) \\;\\implies\\; \\mathrm{inconsistencies}(f) = 0 \\;\\wedge\\; \\mathrm{anomalyFlag}(f) = \\mathrm{CLASSICAL}. \\end{equation} \\textup{Lean:} \\texttt{Lutar/TwoW","sha256":"828b0dec0047b68862e280cbe333a5ca25a76550c98e8905a9fba118042bdc8f"}
{"id":"formula:blk-047fe1641268","source":"formula","sourceId":"thm:graph-automorphism","title":"formal-blocks · thm:graph-automorphism","text":"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","sha256":"5630351470a1e60550ea745f82ba596116d73a5c9a15887dcdedef670215c74e"}
{"id":"formula:blk-04dc0868db12","source":"formula","sourceId":"thm:quantum-decoherence","title":"formal-blocks · thm:quantum-decoherence","text":"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","sha256":"0b45d812dca3f5cabfaf79d9f9efc408c044c7b89d8f99db17dc12a8f163af2a"}
{"id":"formula:blk-0585798f77d9","source":"formula","sourceId":"III.3a","title":"formal-blocks · III.3a","text":"∑_{i : Fin k} (1/k : ℝ) = 1. By Finset.sum_const + Finset.card_fin + field_simp.","sha256":"bed3e4a4f791ecd82680852b42304edae98c9cc4f37d8ab0f293df78eac20af1"}
{"id":"formula:blk-067438ecc4e3","source":"formula","sourceId":"II.4a","title":"formal-blocks · II.4a","text":"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)","sha256":"6f7c91815b9641e95df7c663e67fd8bd2dedac33ee43ae2b5038fc58a47b3c7b"}
{"id":"formula:blk-072684d35683","source":"formula","sourceId":"def:thinking-acting-gap","title":"formal-blocks · def:thinking-acting-gap","text":"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","sha256":"79bc26cc96069cf12a4b4694f823c8c5822606fc0d705fb579a5d9f873ad4564"}
{"id":"formula:blk-0abdaacfff43","source":"formula","sourceId":"theorem:(Monotone Insertion).","title":"formal-blocks · theorem:(Monotone Insertion).","text":"(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, \\","sha256":"1b69ca3efc5f77066de6f8b811df1cba9811ba27f8df2c7bb3044bb74ff34559"}
{"id":"formula:blk-0bf49f3357f8","source":"formula","sourceId":"def:pac-bayes-bound","title":"formal-blocks · def:pac-bayes-bound","text":"\\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},","sha256":"63e126a51e9b61de1c55159302de0e0b88f71d27b8d9763003b9d08716697262"}
{"id":"formula:blk-103463216947","source":"formula","sourceId":"theorem:(closure).","title":"formal-blocks · theorem:(closure).","text":"(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.","sha256":"b8cfd7a44c897336beedf26446e14048f9906299c788845403bf1f3d8d0abddb"}
{"id":"formula:blk-12e304a8ae0b","source":"formula","sourceId":"cor:governance-guarantee","title":"formal-blocks · cor:governance-guarantee","text":"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","sha256":"404099ce290798073472f2bb2db008835db8b6e7ee084d0e0ae08f98247eb67a"}
{"id":"formula:blk-14ecbae7a3ba","source":"formula","sourceId":"3.1 Definition","title":"formal-blocks · 3.1 Definition","text":"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","sha256":"19a8b4d1da397a41a2d1d8dd1844e9494c22b0cea8f803e0a3ab5fd5c2184568"}
{"id":"formula:blk-14f2a3ce5e47","source":"formula","sourceId":"theorem:(Leaf Collision Resistance).","title":"formal-blocks · theorem:(Leaf Collision Resistance).","text":"(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 \\(","sha256":"2ef63d537a5d678ba76b6df08d679c5bf12075c00bef8d97a0f0ce1cb7a63fa7"}
{"id":"formula:blk-18a3b0805b01","source":"formula","sourceId":"IX.3f","title":"formal-blocks · IX.3f","text":"Extends IX.3e to negative δ (ℤ arithmetic). Requires Int.add_left_cancel and List.sum over ℤ-valued lists. v16 obligation.","sha256":"a46c743269246da3441f9f783cd5fc4e9f29549466df635ee1c3cbdaa9463290"}
{"id":"formula:blk-194741c05635","source":"formula","sourceId":"VII.2a","title":"formal-blocks · VII.2a","text":"Any NCHV function f satisfying ExactlyOnePerContext has zero inconsistencies under the soundness measure.","sha256":"ff68c02206e7ced04b68364271d7aba35dff1f250d6544c25a379009afb442e1"}
{"id":"formula:blk-19523427562d","source":"formula","sourceId":"IX.1b","title":"formal-blocks · IX.1b","text":"P_moral iff all six HarmCategory flags are false. Case-split over 6 HarmCategory constructors. Zero sorry.","sha256":"b48965ad00c4d9353f91fa1ee30a64d9248043fe6614b061e7d29a415ee0f488"}
{"id":"formula:blk-1e79165c0906","source":"formula","sourceId":"VI.1","title":"formal-blocks · VI.1","text":"No non-contextual hidden-variable function exists for the Cabello 18/9 structure.","sha256":"d3c5e23a0d5b50b35f038e4047b204b3f8606516c7571a474d317c6946e4155b"}
{"id":"formula:blk-1ecc6a454716","source":"formula","sourceId":"thm:cursorbench-pacbayes","title":"formal-blocks · thm:cursorbench-pacbayes","text":"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","sha256":"c2685bdb5149fee384adf980e6989867a9f1b9f1352163d258da008d32eeb94e"}
{"id":"formula:blk-1f0f73ab899a","source":"formula","sourceId":"2.4 Closure theorem","title":"formal-blocks · 2.4 Closure theorem","text":"2.4 Closure theorem — **Theorem (Λ₁₀ closure).** ρ(ℒ, M) = 1 ⇔ auditClosed(M).","sha256":"82611559e520f61b03456b96c58bab22adc04e3800be023dca25b74345eaba33"}
{"id":"formula:blk-213009738002","source":"formula","sourceId":"thm:thv18-12","title":"formal-blocks · thm:thv18-12","text":"\\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","sha256":"d47818c68ce925c7d4a3d6dc611b4213f4d221c10da5601211034145169973b8"}
{"id":"formula:blk-22342443d6ab","source":"formula","sourceId":"thm:wheeler-coherence","title":"formal-blocks · thm:wheeler-coherence","text":"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","sha256":"646c6551deb61137d9dd2a185120a6d45dcd4a96a4153af07499a988ab56d775"}
{"id":"formula:blk-228a474c75fd","source":"formula","sourceId":"thm:pac-bayes-main","title":"formal-blocks · thm:pac-bayes-main","text":"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","sha256":"3f7736649968270e015b35495dfb2ba0da8560c80e8e2a4219dc75dfcb8218e0"}
{"id":"formula:blk-233aafaa6de8","source":"formula","sourceId":"thm:coe-axis-map","title":"formal-blocks · thm:coe-axis-map","text":"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 \\","sha256":"6a7ba31c1c35dbf91be49966111a0197f86422e25c201fa2721ffda756e05cbd"}
{"id":"formula:blk-241f275821d0","source":"formula","sourceId":"3.3 Theorem 1 (Uniqueness)","title":"formal-blocks · 3.3 Theorem 1 (Uniqueness)","text":"3.3 Theorem 1 (Uniqueness) — > **Theorem 1.** Let `Λ, Λ' : [0,1]^k → [0,1]` both satisfy A1–A4. Then `Λ = Λ'`.","sha256":"244bb84974b61cfe9ec3263e376a38e592ea51ccf14cdb2c9b6a27bc5d8b8f12"}
{"id":"formula:blk-2472673c128d","source":"formula","sourceId":"thm:lambda-lower","title":"formal-blocks · thm:lambda-lower","text":"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","sha256":"8a66aa5dd22d4bd80f99efa30415f6c9a7b8fca094b00c11743d612ace7938be"}
{"id":"formula:blk-27f7d07977df","source":"formula","sourceId":"III.3","title":"formal-blocks · III.3","text":"For k ≥ 1 and c : ℝ≥0:","sha256":"6ee2b4f1fed9e08c5cc581f4abc6f8b221610b3736632eabfb7b39a99a9dc8e3"}
{"id":"formula:blk-2c891cf0dbb9","source":"formula","sourceId":"def:sparse-attn","title":"formal-blocks · def:sparse-attn","text":"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^","sha256":"2da27e1dd1644c9ba89ec05dfe2830f96229ac4e0d8c165695b6cdaf5167142c"}
{"id":"formula:blk-2d7fab34bdf5","source":"formula","sourceId":"VII.2d","title":"formal-blocks · VII.2d","text":"No NCHV function exists for the Cabello 18/9 structure.","sha256":"c28cedf61bf64caf3b7d53ff3011969369c35cceb5148e99783bc438b74e4d5b"}
{"id":"formula:blk-2dc613c350e0","source":"formula","sourceId":"thm:lambda-upper","title":"formal-blocks · thm:lambda-upper","text":"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","sha256":"280f94561ddae5743dd64950053c0796b42455f90d8d8a595db568ccaf17ad22"}
{"id":"formula:blk-2f4420c7ff82","source":"formula","sourceId":"thm:thv18-03","title":"formal-blocks · thm:thv18-03","text":"\\begin{verbatim} theorem th_v18_03_kraft_equality : (Finset.univ : Finset DoctrineLabel).sum (fun l => (1 : Real) / 2 ^ codewordLen l) = 1 \\end{verbatim}","sha256":"c228500d09d5a4d8b6b0e906bfa72a23d74d5cf498baf9cd40687100b3e856ef"}
{"id":"formula:blk-2f58396476ec","source":"formula","sourceId":"thm:dual-witness-soundness","title":"formal-blocks · thm:dual-witness-soundness","text":"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.","sha256":"c537bd7d40b849357a36d6a397d05d26920fff291ec38f8af8e0f7f2c1c09367"}
{"id":"formula:blk-32b7372b84bf","source":"formula","sourceId":"thm:zero-kl","title":"formal-blocks · thm:zero-kl","text":"$\\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","sha256":"6eeff9565fb04ed9528d8339b28eff07a5d6223f3b26bf548664ca943619c776"}
{"id":"formula:blk-32cf1755f013","source":"formula","sourceId":"IX.2","title":"formal-blocks · IX.2","text":"For integers a, b, c, d:","sha256":"b3b21a704bfb557e40e950e07c8dd57ee552543724add26e749cef087c107648"}
{"id":"formula:blk-32d151a66538","source":"formula","sourceId":"thm:openmdw-provenance","title":"formal-blocks · thm:openmdw-provenance","text":"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","sha256":"a19742652b1c57166d4c99854045b09da586e9654aeac6026e76d91a042cd98c"}
{"id":"formula:blk-3352835f38ec","source":"formula","sourceId":"thm:thv18-08","title":"formal-blocks · thm:thv18-08","text":"\\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","sha256":"dbf8f6ef8e234a68dcb33830956b12ba422e3c1e51bdb0c8d2031a6e5f8657b0"}
{"id":"formula:blk-36162bf5bd54","source":"formula","sourceId":"thm:sparse-attn-bound","title":"formal-blocks · thm:sparse-attn-bound","text":"\\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","sha256":"c11abb19a489b106418f7c6feeaf66e23a40a05f94f996523a21e9a8004ae77e"}
{"id":"formula:blk-390c45ade8d2","source":"formula","sourceId":"III.4c","title":"formal-blocks · III.4c","text":"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","sha256":"64554acb9b622183efd7a1109b6be09ec8a65af9c5ec78492c6b1340032527ff"}
{"id":"formula:blk-3b2bf6fd7a71","source":"formula","sourceId":"R3, receipt-chain associativity","title":"formal-blocks · R3, receipt-chain associativity","text":"$\\Lambda$-invariance is closed under composition of rewrites.","sha256":"d2107b9f7e5c7931eb3276174db8a4f5557ce90ff4ddb682e21d24c776a3b567"}
{"id":"formula:blk-3b8a71c4ddd6","source":"formula","sourceId":"cor:hoeffding","title":"formal-blocks · cor:hoeffding","text":"\\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\\","sha256":"fa55b2cd4e65d3cc4b43c8e9129dce82fd71ad3a51d44352bad50eb9683d07ed"}
{"id":"formula:blk-3bd4b98d9e66","source":"formula","sourceId":"2.2 RefVectors.lean — Runtime Parity The","title":"formal-blocks · 2.2 RefVectors.lean — Runtime Parity The","text":"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","sha256":"3e0f4cf84056661d8285137578b5a8d363fcff3bbb6fc32aea5aa2aef2eddf4d"}
{"id":"formula:blk-3bf0aae18b16","source":"formula","sourceId":"IX.1","title":"formal-blocks · IX.1","text":"The sum of the six Horus-Eye fractions equals 63/64:","sha256":"f2794a830732e291eb60eb03d1311fcbfabc561ca4b1ef0e0f04de5a8903ce74"}
{"id":"formula:blk-3d84ea18bfc4","source":"formula","sourceId":"def:governance-drift","title":"formal-blocks · def:governance-drift","text":"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","sha256":"b5df7e2f9f35e54bc8e015a76bd55ca6e5470d040aec1288c59c705d313771a5"}
{"id":"formula:blk-3e71bf2a90fb","source":"formula","sourceId":"thm:quantum-lambda","title":"formal-blocks · thm:quantum-lambda","text":"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","sha256":"8a36f7cd31cd728dd62f252845ca8caaea1913ac4aee16f34d9f29cab468c174"}
{"id":"formula:blk-40eed47a1fd4","source":"formula","sourceId":"thm:receipt-chain-cardinality","title":"formal-blocks · thm:receipt-chain-cardinality","text":"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","sha256":"8ee84583eb437df032e6b63b03eab617fdb893a7f09403057de68d2880426218"}
{"id":"formula:blk-4197fe082a27","source":"formula","sourceId":"IX.6","title":"formal-blocks · IX.6","text":"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","sha256":"f5f796f747fcf378921611e513aa028291d0e9f4892fdca14def252d55aaa0b3"}
{"id":"formula:blk-41b56aa54f6c","source":"formula","sourceId":"X.3","title":"formal-blocks · X.3","text":"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","sha256":"8bf8b6bb59ed0a1837c233b8fa2be2dcc902cfbe3a34a4d3b89f92d4d4ebaeae"}
{"id":"formula:blk-41b87668330e","source":"formula","sourceId":"thm:graph-lambda-le-one","title":"formal-blocks · thm:graph-lambda-le-one","text":"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:","sha256":"bcad3a477cd6fbd94b4a6f179fc38a32dcc925baee6e3185ce0756cd1045ecb8"}
{"id":"formula:blk-44e51e5ad25c","source":"formula","sourceId":"R1, single-axis repack","title":"formal-blocks · R1, single-axis repack","text":"For any single-axis rewrite $r$ that acts as the identity on coordinate $i$, $\\Lambda(r(x)) = \\Lambda(x)$ for all $x$.","sha256":"970319947827a6aed22bdc4eed8eed81acfccacf9ed2a1e6b3b67bde6fde1698"}
{"id":"formula:blk-4a6f1c133678","source":"formula","sourceId":"def:gateLID","title":"formal-blocks · def:gateLID","text":"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","sha256":"b720e7fd88573d3d99de4bb55c19834508f8476e19d75fd9081158a70f3294ef"}
{"id":"formula:blk-4dbf3e8bc47b","source":"formula","sourceId":"thm:lean-soundness","title":"formal-blocks · thm:lean-soundness","text":"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}","sha256":"01b1c7974b74c972288915bd7a8e5a7e37b477637b2f7106409ce950571ad886"}
{"id":"formula:blk-4f8c0be29d2e","source":"formula","sourceId":"def:nchv","title":"formal-blocks · def:nchv","text":"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}\\","sha256":"11c2ba167c571ac6015104341ce6d02665a88227637a949f20e6813fdb664cc8"}
{"id":"formula:blk-4fb8dca75797","source":"formula","sourceId":"2.1 Definition","title":"formal-blocks · 2.1 Definition","text":"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","sha256":"60f989b9f573dd12f9975cd93f04b0129d4b0ca5b6bd22480abb559a99b5c6ad"}
{"id":"formula:blk-50a62223948f","source":"formula","sourceId":"def:receipt-impl","title":"formal-blocks · def:receipt-impl","text":"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","sha256":"0bb7655ee38fdcdd24a549741e9be4318422e5c005591c24453b87c963c4336f"}
{"id":"formula:blk-51ece2338bd6","source":"formula","sourceId":"thm:exit0","title":"formal-blocks · thm:exit0","text":"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","sha256":"9dfe416095fee0ef45aac33e18b1c17b3521cce2722787e446e8ca7ada40b24c"}
{"id":"formula:blk-52d65f65c700","source":"formula","sourceId":"(pre-formal)","title":"formal-blocks · (pre-formal)","text":"v1 'The Loop Is the Product' — narrative paper, no formal theorem environments; introduces bounded recursion as audit primitive.","sha256":"6112a0ad76015fdf97416a15eba1be99361814ccb572e3706e669667cc66e6e7"}
{"id":"formula:blk-539052474924","source":"formula","sourceId":"def:path-integral","title":"formal-blocks · def:path-integral","text":"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","sha256":"01d33530a7c932d337c910bab7f8d9cc39d551bf6ae1164f3493a025c6072784"}
{"id":"formula:blk-53abea9a263b","source":"formula","sourceId":"thm:coe-chain-integrity","title":"formal-blocks · thm:coe-chain-integrity","text":"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","sha256":"bde3e8e518ed616cac4ac39fa2f10183621f10b57414d1eb5c56cb8908c90bbc"}
{"id":"formula:blk-54f2909e227e","source":"formula","sourceId":"VII.2c","title":"formal-blocks · VII.2c","text":"For any NCHV function f:","sha256":"3613ee4db7aad856a7631fb3073572c811b8074487740df38b5bfe6156dbe304"}
{"id":"formula:blk-5909356132c0","source":"formula","sourceId":"thm:lambda-mp-inv","title":"formal-blocks · thm:lambda-mp-inv","text":"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","sha256":"f179200e8d48f7ecf80d1aac605d4e1283b6802a7afab6eeefe3fb5d477ee96c"}
{"id":"formula:blk-591c08872039","source":"formula","sourceId":"theorem:(Window Unforgeability).","title":"formal-blocks · theorem:(Window Unforgeability).","text":"(Window Unforgeability). — ---","sha256":"2ddaed078b1d97a6f787c938cdd88ad5deee391343d692efc1d16dd5c7ebbd13"}
{"id":"formula:blk-5a768fcd606f","source":"formula","sourceId":"thm:doi-integrity","title":"formal-blocks · thm:doi-integrity","text":"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","sha256":"d0f7072ccd98461cefd3e877aca60e97150fba25862ec0160fade5c876713ab3"}
{"id":"formula:blk-5bd042196dc7","source":"formula","sourceId":"thm:thv18-06","title":"formal-blocks · thm:thv18-06","text":"\\begin{verbatim} theorem th_v18_06_brahmi_distinction : Option.some (0 : Int) <> Option.none \\end{verbatim}","sha256":"b6d23f4ea113999b022696fa69f4d2018c56acbda99f013ef28944b9c5b7238d"}
{"id":"formula:blk-5c0c3f0981f6","source":"formula","sourceId":"IX.4","title":"formal-blocks · IX.4","text":"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","sha256":"92fe22b4fc5fec36c015106b66863f2eb0b60eb294bb5ff3017e91e5609d3772"}
{"id":"formula:blk-5def10dc2eed","source":"formula","sourceId":"thm:doctrine-compositionality","title":"formal-blocks · thm:doctrine-compositionality","text":"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). \\]","sha256":"f5c53d33fc00ca7ed2f74478efd18e827e3f3e23bb5a482373be95400c89c256"}
{"id":"formula:blk-5e3bbc3625fa","source":"formula","sourceId":"XIII.2","title":"formal-blocks · XIII.2","text":"HUKLLA ∧ OVERWATCH ∧ DPI → governanceAllow.","sha256":"6f4af8c2ec85ea275b5c50c333d128649ab112aac47ea7ea8c43c6222eb96a3d"}
{"id":"formula:blk-62da46f1971b","source":"formula","sourceId":"VII.2b","title":"formal-blocks · VII.2b","text":"Every vector v ∈ Fin 18 appears in exactly 2 of the 9 Cabello contexts. Proved by decide over the explicit finite list.","sha256":"dbdfcfbd638afa06fe9789caf5a8965931f275c415d43de3ef7d4cea93646900"}
{"id":"formula:blk-66e28a905bbc","source":"formula","sourceId":"IX.3","title":"formal-blocks · IX.3","text":"The Babylonian iteration T(x) = (x + 2/x)/2 is a Banach contraction on the interval [1, 2]:","sha256":"a949a9d277bdd28cc7b7ea1e83929ce7f081b3a2b4ad1f5db23f5c4b036ebf3d"}
{"id":"formula:blk-66fad8f76ea8","source":"formula","sourceId":"II.1","title":"formal-blocks · II.1","text":"Λ k x = (Finset.univ.prod x) ^ (1/k) for k > 0. Proof: simp [Λ, hk.ne']. Operational counterpart: ouroboros/runtime/lambda-gate/src/gate.ts.","sha256":"e946bc9c1273df550918553e961d9519bbeb510a7de9ec88d06ceef5ffd0d082"}
{"id":"formula:blk-6d2ccb1f676c","source":"formula","sourceId":"thm:coe-soundness","title":"formal-blocks · thm:coe-soundness","text":"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","sha256":"0031e80c7d4cae8aaabe467307fcbd28e81cd82bab389fd1edc6dbe371ed4283"}
{"id":"formula:blk-6e2ef6e624a5","source":"formula","sourceId":"thm:pac-bayes-mono","title":"formal-blocks · thm:pac-bayes-mono","text":"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","sha256":"5785913d2106f5e17c0c32ff001ddd4233475f2ea391036c3de56b8a255f965b"}
{"id":"formula:blk-70403a802239","source":"formula","sourceId":"thm:thv18-16","title":"formal-blocks · thm:thv18-16","text":"\\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}","sha256":"31e2edf4abcf7f7ff3cc7936e6367506fb05d2b5c509fe685b319dcb8dbf498a"}
{"id":"formula:blk-70eeb9bff47d","source":"formula","sourceId":"def:green-gate","title":"formal-blocks · def:green-gate","text":"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.","sha256":"9edd890a7d8668dae1b99a62eec4bfd6654df4f0f64462b190744a25e8e4e7d2"}
{"id":"formula:blk-716e155c7ea0","source":"formula","sourceId":"R2, independent commute","title":"formal-blocks · R2, independent commute","text":"Let $r_1, r_2$ act on disjoint axis subsets. If each is $\\Lambda$-invariant, then so is $r_1 \\circ r_2$.","sha256":"d094bb4c13640b4d4cc6296a45ed3d5aadde9d00bf581a8d4b99cc48d4bf84f4"}
{"id":"formula:blk-719bca2b266e","source":"formula","sourceId":"XI.2","title":"formal-blocks · XI.2","text":"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","sha256":"0b1ba2e9108013ee6d2f53472ef262f3547ed424bd1e82141ed5d0fbfb445acc"}
{"id":"formula:blk-73d8a32ebc50","source":"formula","sourceId":"def:lambda","title":"formal-blocks · def:lambda","text":"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","sha256":"6e7352b76d29a34ba5d79a80ec42389f5de8663970bdad5be1728d94a9ac3355"}
{"id":"formula:blk-74508deb1b67","source":"formula","sourceId":"1","title":"formal-blocks · 1","text":"2^{-l_i}\\) kraft_inequality_doctrine","sha256":"74508deb1b678cd14cc8ceb090df754a58b041aff69b63dfba605a2b6f596f13"}
{"id":"formula:blk-74d36708f8f3","source":"formula","sourceId":"def:receipt","title":"formal-blocks · def:receipt","text":"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","sha256":"dc60014c28071a99c0995fd4cd0cf5a85d2e511245e87ef83540f92ee9b47489"}
{"id":"formula:blk-750ff1d2251a","source":"formula","sourceId":"A1","title":"formal-blocks · A1","text":"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 \\(","sha256":"501e3d44b4da35c89363b3a9dcdaffac0b391939c20a37226edf6f62970b7f28"}
{"id":"formula:blk-790e50bee888","source":"formula","sourceId":"III.4b","title":"formal-blocks · III.4b","text":"If k × (1/ n) = 1 then n = k. Proof: exact_mod_cast. Lean file: Lutar/Egyptian.lean, main branch.","sha256":"a16dbff9b730dccffbd463bc538a9acf5752fb7b1d4a3ac659791829ae4837a3"}
{"id":"formula:blk-7c2e819eaddd","source":"formula","sourceId":"thm:quantum-chain-bound","title":"formal-blocks · thm:quantum-chain-bound","text":"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_","sha256":"09faab0ecc5b83e4280f4bb7a785a2824d35173c92b8ef72473e055aaa330e97"}
{"id":"formula:blk-7d688554bd8a","source":"formula","sourceId":"thm:topk-isomorphism","title":"formal-blocks · thm:topk-isomorphism","text":"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","sha256":"79f4ae261e8cf22a928cbe855abf8a9bf48f63ec22d7a158d88310017bf4c29e"}
{"id":"formula:blk-7e574187d3be","source":"formula","sourceId":"IX.3d","title":"formal-blocks · IX.3d","text":"A khipu with one pendant has root value equal to that pendant. Zero sorry.","sha256":"d60ee5c8386645f620d75d2680028e19c36029ea924773e0cb7349d4662aee46"}
{"id":"formula:blk-7fe70caaaeca","source":"formula","sourceId":"thm:thv18-02","title":"formal-blocks · thm:thv18-02","text":"\\begin{verbatim} theorem th_v18_02_doctrine_alphabet_size_4 : Fintype.card DoctrineLabel = 4 \\end{verbatim}","sha256":"74fe23235ef968e6dfb73b57425723165717039fbb89f3c520e49506b4db618e"}
{"id":"formula:blk-80865c3b79f7","source":"formula","sourceId":"thm:thv18-14","title":"formal-blocks · thm:thv18-14","text":"\\begin{verbatim} axiom sha256_collision_resistant : forall (b1 b2 : ReceiptBlob), sha256 b1 = sha256 b2 -> b1 = b2 \\end{verbatim}","sha256":"6fa4a30e55e77986e46f7ceeb2401001a90f50c0acfdbd46be65a4c40d46e061"}
{"id":"formula:blk-80a59125079d","source":"formula","sourceId":"thm:precision-bound","title":"formal-blocks · thm:precision-bound","text":"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","sha256":"95d168db8a6ee3b76dcc6e43f571bf8d8451d6bc7acc8837e411af983ad2e31d"}
{"id":"formula:blk-844d9d2a27f2","source":"formula","sourceId":"X.2","title":"formal-blocks · X.2","text":"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","sha256":"3794e44282269e8301c2643976234b7735890714cc229d11735734c5fd3c17dc"}
{"id":"formula:blk-85574c7ca503","source":"formula","sourceId":"def:audit-fibre","title":"formal-blocks · def:audit-fibre","text":"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.","sha256":"de649d4f741d10da39d0fa869118791d026749c1d565dace04f08e26300425c0"}
{"id":"formula:blk-8759464163c9","source":"formula","sourceId":"IX.3e","title":"formal-blocks · IX.3e","text":"If any pendant is modified by δ > 0, the checksum changes:","sha256":"16c93e1f8d3629a9616e292348e1298bbb1d1c85209b92591de4dfcac8201649"}
{"id":"formula:blk-878c221e7c19","source":"formula","sourceId":"def:coe-claim","title":"formal-blocks · def:coe-claim","text":"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","sha256":"7bdca353d4845deea6b34d777f0ad1cafc926e1ca8cfa09deddce75529a613e3"}
{"id":"formula:blk-885c94bd436f","source":"formula","sourceId":"thm:universal-composability","title":"formal-blocks · thm:universal-composability","text":"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","sha256":"0791c41ae33cb01ad9ace4fcbed5931a27fdc9576be7fa7d915f02e16e6d42d8"}
{"id":"formula:blk-8f0899338540","source":"formula","sourceId":"thm:openmdw-grant","title":"formal-blocks · thm:openmdw-grant","text":"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","sha256":"dd37b4dd632ecbb94e18fdbc1c8ee5936f92cdb32e3a4f018584f02a8743b065"}
{"id":"formula:blk-9635f9145fff","source":"formula","sourceId":"def:soft-gate","title":"formal-blocks · def:soft-gate","text":"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.","sha256":"f0a6f3ecf5870950795bcfaa2b8026580ef64d5a87cbea6cf2673053c4f3cb87"}
{"id":"formula:blk-974919bf9e3c","source":"formula","sourceId":"thm:schur-concave","title":"formal-blocks · thm:schur-concave","text":"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","sha256":"77aaa8d4c51163b37c3a5d80272bd3b7fec0425858b24e870a910f6266b1d284"}
{"id":"formula:blk-9842a75478a1","source":"formula","sourceId":"thm:thv18-01","title":"formal-blocks · thm:thv18-01","text":"\\begin{verbatim} theorem th_v18_06_terminates (s0 : AgentState) : exists n : Nat, n <= turnBudget s0 + 1 /\\ Nat.iterate agentStep n s0 = .Done \\end{verbatim}","sha256":"a7380ca2f41122f9faa5e362429228aa9d216946f38a0b1ce59b5fa4042244b3"}
{"id":"formula:blk-99f335937cdf","source":"formula","sourceId":"thm:unique-aggregator","title":"formal-blocks · thm:unique-aggregator","text":"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","sha256":"091e76d25da9478a954f79300023efeea9ceb57f5f7e0b49fe62a314d0a83116"}
{"id":"formula:blk-9b48eee88aed","source":"formula","sourceId":"thm:path-integral","title":"formal-blocks · thm:path-integral","text":"$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{","sha256":"e75c1fe653a5e73f7c364702fd91bd696ec8d835fe7d00c4bf68735ef6f50092"}
{"id":"formula:blk-9b79fa233d77","source":"formula","sourceId":"thm:cursor-bench-bound","title":"formal-blocks · thm:cursor-bench-bound","text":"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,","sha256":"a694692178e47993c17a1f5ff94c15ed23af0b2632e36e51cb7cffce3f8afc5d"}
{"id":"formula:blk-9c684f75fc73","source":"formula","sourceId":"thm:materialx-lambda","title":"formal-blocks · thm:materialx-lambda","text":"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","sha256":"7fd2d395943fc4c54c818a62663e1d54eac9b9856b47210d77201470b1dfeea0"}
{"id":"formula:blk-9eb4a4efcc58","source":"formula","sourceId":"VII.2e","title":"formal-blocks · VII.2e","text":"No agent response can have zero inconsistencies under the Cabello structure: ∀ f : NCHV, ¬ ExactlyOnePerContext f.","sha256":"506936311d0128e415a54e43a5b7f5ffbaac585051f619dadba5e2813bea300b"}
{"id":"formula:blk-9ec3fb351a96","source":"formula","sourceId":"IX.3a","title":"formal-blocks · IX.3a","text":"pendantValue_def unfolds the pendant value formula. Lean file: Lutar/ Khipu/SummationInvariant.lean, main branch.","sha256":"8cb20fccd6277e9f9079e2ddb9cbe3760375837fe90756576310ec397dfcb79c"}
{"id":"formula:blk-9ff3e45e4855","source":"formula","sourceId":"def:epistemic-floor","title":"formal-blocks · def:epistemic-floor","text":"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","sha256":"d34dd290bb7780b47ce2b785a4340cafe164c481b94873cf806865f18324a9fc"}
{"id":"formula:blk-a5f5c32b1811","source":"formula","sourceId":"thm:wos-pi-equiv","title":"formal-blocks · thm:wos-pi-equiv","text":"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}_","sha256":"b610bfa00003e1d820b4eb8ebc6291e33b299ca88784c2f180aecb61c047d566"}
{"id":"formula:blk-a66bf7f2740a","source":"formula","sourceId":"thm:thv18-10","title":"formal-blocks · thm:thv18-10","text":"\\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","sha256":"89e1ec9e1ea699ca96c3425495a574e4f57710a19e5c8ea7c556c6cd79832329"}
{"id":"formula:blk-a82b6817ef08","source":"formula","sourceId":"thm:wos-reuse","title":"formal-blocks · thm:wos-reuse","text":"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","sha256":"4f38265988f624c97d8fa10d43d7969ef50f06d3ed4c793c6ede8cbf7c993e25"}
{"id":"formula:blk-a84633216264","source":"formula","sourceId":"II.3","title":"formal-blocks · II.3","text":"For k ≥ 1 and x ≤ y pointwise: Λ_k(x) ≤ Λ_k(y).","sha256":"393671821d8aae6888551a7233060be777544e0479c4d5d57326a5e56bf3c4c1"}
{"id":"formula:blk-a8990369f0df","source":"formula","sourceId":"II.5","title":"formal-blocks · II.5","text":"Λ_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,","sha256":"c0eab6d77158688c732e3113f218f242c7d5a9c10041d5002c3d49dd8dbaf69f"}
{"id":"formula:blk-a900997a9e84","source":"formula","sourceId":"thm:axpo-coe","title":"formal-blocks · thm:axpo-coe","text":"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","sha256":"48805da5d9ddc661a6f4e39c885106a501c6c4bc9bf751e838222435fd706808"}
{"id":"formula:blk-a9584aeb2b00","source":"formula","sourceId":"thm:graph-pac-bayes","title":"formal-blocks · thm:graph-pac-bayes","text":"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,","sha256":"defd961c52bf5de5345a4f34573e299770136adb78d2fe1d4c2305de85840f29"}
{"id":"formula:blk-a9a44996ea89","source":"formula","sourceId":"def:turbovec","title":"formal-blocks · def:turbovec","text":"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 \\|\\","sha256":"efa449886e0444ec541809dd15d5d9aaf82693b279713aa077e8728b0f74b6f0"}
{"id":"formula:blk-a9c2c47b4ce4","source":"formula","sourceId":"cor:psi2","title":"formal-blocks · cor:psi2","text":"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","sha256":"98cbcde0373cb2349aabefa85f284618fa07f5c5ceb9983aa36156af41f1c69f"}
{"id":"formula:blk-adb60cb4af33","source":"formula","sourceId":"thm:axpo-gain","title":"formal-blocks · thm:axpo-gain","text":"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","sha256":"622f3295436f89c9c043cd05b2262bfccd059495a604089888a1093357d28b62"}
{"id":"formula:blk-ae5cf8ecd248","source":"formula","sourceId":"thm:lambda-bounded","title":"formal-blocks · thm:lambda-bounded","text":"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","sha256":"79a224c4eac6ff528e155198119416d6eeeab3f515a52373e233d752cb4a2d47"}
{"id":"formula:blk-b0dc2d4ccb16","source":"formula","sourceId":"A4","title":"formal-blocks · A4","text":"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]\\),","sha256":"b1cc6cdb7773eeb7edf803d84d571e9c31bfbbb4b9144d2829405a975dbfd3f3"}
{"id":"formula:blk-b16c3ad1b5cb","source":"formula","sourceId":"def:lambda-vector","title":"formal-blocks · def:lambda-vector","text":"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","sha256":"6af8ced47d5185ad2bb9a86d818d14c8084fd25378da110917479a31f4b7cf6c"}
{"id":"formula:blk-b88875a9782f","source":"formula","sourceId":"thm:wos-convergence","title":"formal-blocks · thm:wos-convergence","text":"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","sha256":"3f2fdc0b19ec0f1bb400f5070e69222dfd8fd15f55799731f683a58241f1a8ed"}
{"id":"formula:blk-b8a2bae67146","source":"formula","sourceId":"def:receipt-category","title":"formal-blocks · def:receipt-category","text":"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","sha256":"679538a771c9047c98bc129e127b42c3a04e9d4d57a5295bbe0e648cd8741380"}
{"id":"formula:blk-c05c55de57a2","source":"formula","sourceId":"II.4","title":"formal-blocks · II.4","text":"For k ≥ 1:","sha256":"bd792788dbde1d56a3894151d7cae3b2b1f8b92f7e942f825be084f767f8838e"}
{"id":"formula:blk-c2008b718377","source":"formula","sourceId":"def:lutar-axioms","title":"formal-blocks · def:lutar-axioms","text":"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","sha256":"49af95a255eac593eefe3336dd790ffaebf96715c551b13272c5c110b028b714"}
{"id":"formula:blk-c25ff09c360a","source":"formula","sourceId":"thm:sovereign-lambda","title":"formal-blocks · thm:sovereign-lambda","text":"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","sha256":"79598eaf9c67bd5a75819be80c40fa79cc95b65da390570cb0086dc3eb5ee24c"}
{"id":"formula:blk-c2a995d3e756","source":"formula","sourceId":"thm:nist-oper-completeness","title":"formal-blocks · thm:nist-oper-completeness","text":"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","sha256":"93cf79a8834c7d96eb0b977c39b2de56bd5fe1aaae521f9523e42e2b92c9809d"}
{"id":"formula:blk-c73c7d9b0ba3","source":"formula","sourceId":"def:hard-gate","title":"formal-blocks · def:hard-gate","text":"A module action with \\(\\Lambda < \\lambda_{\\mathrm{crit}}\\) is \\emph{blocked}: the runner sets \\texttt{G(m\\_i) = 1} and the process exits~1.","sha256":"48dcc5cea58b811bc22bed2d4a9a5d9db3cc693d00de356ef1e5f4d178315650"}
{"id":"formula:blk-c73f095710fc","source":"formula","sourceId":"def:dual-witness","title":"formal-blocks · def:dual-witness","text":"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","sha256":"bdbbba783b9c1a3f84d69c7354ae701c2ac49565f981ec1914bdcc6b2fe6c5eb"}
{"id":"formula:blk-c8104024ab2f","source":"formula","sourceId":"thm:rmf-completeness","title":"formal-blocks · thm:rmf-completeness","text":"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","sha256":"09aea7cb8401016e25701ac502aee95c4e5507c55d9e8144e7939f1370054237"}
{"id":"formula:blk-d1507e347013","source":"formula","sourceId":"conj:lambda-uniqueness","title":"formal-blocks · conj:lambda-uniqueness","text":"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) \\;=\\; \\","sha256":"b94a491b86fe329a209715874f14013884c7a1d6145410659f05736039e2ee9e"}
{"id":"formula:blk-d4398c07a812","source":"formula","sourceId":"thm:schur","title":"formal-blocks · thm:schur","text":"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})","sha256":"1ee55b2a81f61b3bcda06b678b27a2243195c04a513708b86b7941547d5c6f5e"}
{"id":"formula:blk-d4e005d07324","source":"formula","sourceId":"thm:axiom-reduction","title":"formal-blocks · thm:axiom-reduction","text":"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","sha256":"6880ba9732b8f0c8b1a16888f0b557e5a81a30d85075f0f38f19c9a86b25435c"}
{"id":"formula:blk-d5003dcae067","source":"formula","sourceId":"IX.5","title":"formal-blocks · IX.5","text":"Theorem Status madhavaRemainderBound_nonneg PROVED zero-sorry madhavaRemainderBound_at_zero PROVED zero-sorry madhavaRemainderBound_anti PROVED zero-sorry (linarith) SORRY-TAGGED (~16h; Mathlib madhav","sha256":"eeaef53becf7c87dabe4aefd6913bcbe6526188b319c7a8ee00fb60608d402da"}
{"id":"formula:blk-d564052e5e41","source":"formula","sourceId":"thm:lambda-composition","title":"formal-blocks · thm:lambda-composition","text":"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","sha256":"35ae22839910f044d16029530392f4e34585b1f3618f68f825d3558ba6e071e9"}
{"id":"formula:blk-d717abaaa1ae","source":"formula","sourceId":"thm:thv18-15","title":"formal-blocks · thm:thv18-15","text":"\\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","sha256":"792061ba15f0b9b037416b61c624162a8a8f1dee6e2b6386cad991390358035b"}
{"id":"formula:blk-da2a786891ff","source":"formula","sourceId":"4.5 Underlying axiom-suite evidence","title":"formal-blocks · 4.5 Underlying axiom-suite evidence","text":"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:","sha256":"e366585d8986cb91cf1f98ecf918d9506fe7752783c407168d39676f4879ec92"}
{"id":"formula:blk-db0cc01f022b","source":"formula","sourceId":"4.2 Theorem 2 (Tamper-evidence)","title":"formal-blocks · 4.2 Theorem 2 (Tamper-evidence)","text":"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","sha256":"5ffc5874ce8e2cf85ea53e46dfe430575b170a2711318b3d57ba3e94892e324c"}
{"id":"formula:blk-db53252b6702","source":"formula","sourceId":"A2","title":"formal-blocks · A2","text":"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","sha256":"6312c23b842ef69d30d003b5551070111a75c3c4781c5c32aab127cd4e67afee"}
{"id":"formula:blk-dcf9e3149271","source":"formula","sourceId":"(no formal blocks)","title":"formal-blocks · (no formal blocks)","text":"v9: no explicit theorem/axiom blocks detected; prose/empirical paper.","sha256":"dcf9e3149271b94fb4f0a53c91f4ef86c3960b01793f7ed60ae47ecfc7ca2b2f"}
{"id":"formula:blk-ddd6da868033","source":"formula","sourceId":"thm:thv18-09","title":"formal-blocks · thm:thv18-09","text":"\\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}","sha256":"302059041760399596755b5e7219b9fa43021c0981baca990406f5649f386d73"}
{"id":"formula:blk-df8355253133","source":"formula","sourceId":"2.2 Closure theorem","title":"formal-blocks · 2.2 Closure theorem","text":"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).*","sha256":"dda7bd969c40a800d02d8b14a9cc81a6e059a7428af6e8ca893e2a1831334eef"}
{"id":"formula:blk-e0ac0e903b27","source":"formula","sourceId":"IX.3c","title":"formal-blocks · IX.3c","text":"Empty khipu has root value 0. Zero sorry.","sha256":"32844738f4ef50f16abab6ec543721caea62a1ea8e96e7eaa5fb6b4e478f22d0"}
{"id":"formula:blk-e4f6ab0cec04","source":"formula","sourceId":"thm:thv18-05","title":"formal-blocks · thm:thv18-05","text":"\\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","sha256":"e46cedf876b7c53e26c30fe0c9fbbff92cf3bdbdf9fe91b853336bdcaedaf717"}
{"id":"formula:blk-e619f7c12f1a","source":"formula","sourceId":"IX.3b","title":"formal-blocks · IX.3b","text":"The root value equals the sum of pendant values. Zero sorry.","sha256":"cbe9097192c60838697e639af687fe78eb8e46ab9679bf4224f114db17ac5576"}
{"id":"formula:blk-e7eec6ce9719","source":"formula","sourceId":"thm:lambda-bound","title":"formal-blocks · thm:lambda-bound","text":"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. \\]","sha256":"c624978c7c26e1013ebc2f7335350945bf4ade42095a37fe7384ebeae7fbb19e"}
{"id":"formula:blk-e8871f70778d","source":"formula","sourceId":"def:lambda-monotone","title":"formal-blocks · def:lambda-monotone","text":"For two agent functions $f, g$, define pointwise meet $(\\Lambda_1 \\wedge \\Lambda_2)_i := \\min(\\lambda_{1,i}, \\lambda_{2,i})$. The system satisfies \\emph{$\\Lambda$-monotone composition} when \\begin{equ","sha256":"855333eb4b65df9048ad373586e903a0b8267f66201aa83055be39667c7a34a6"}
{"id":"formula:blk-e894935630e0","source":"formula","sourceId":"theorem:(Closure Dominance, Conjecture","title":"formal-blocks · theorem:(Closure Dominance, Conjecture","text":"(Closure Dominance, Conjecture). — **The Self-Grading Loop as Revelation Mechanism:** The `evaluate-all` endpoint provides the revelation mechanism: before `submit_result`, the agent POSTs its own out","sha256":"557de467413a5ed4080cbc9befd2dfc7278e49f45079def533d7f4a3b5948bdd"}
{"id":"formula:blk-edea2e36bea8","source":"formula","sourceId":"def:verifiable-governability","title":"formal-blocks · def:verifiable-governability","text":"A system \\(S\\) is \\emph{verifiably governable} if and only if: \\begin{enumerate} \\item Every action $a$ produced by $S$ is associated with a receipt $r \\in \\mathcal{R}$ carrying a $\\Lambda$-score $\\La","sha256":"c5b2b0c7adb8fc634466d8bcdd5181dd36da8e064b06a68212b42bb60f591c4f"}
{"id":"formula:blk-f04f5aa9ba21","source":"formula","sourceId":"cor:interpretability","title":"formal-blocks · cor:interpretability","text":"For any agent output $x \\in \\mathcal{A}_9$: \\begin{equation} \\min_i x_i \\;\\le\\; \\Lambda_9(x) \\;\\le\\; \\max_i x_i. \\end{equation} This is the primary interpretability guarantee of the $\\Lambda$-gate.","sha256":"845a50c08e222247b1a186625092407172e365e73889473c7e931c842143ef06"}
{"id":"formula:blk-f0f630a03266","source":"formula","sourceId":"thm:lambda-monotone","title":"formal-blocks · thm:lambda-monotone","text":"The geometric-mean aggregator satisfies $\\Lambda$-monotone composition: if composed output scores $z_i \\ge \\min(x_i, y_i)$ componentwise, then $\\Lambda(z) \\ge \\Lambda(x) \\wedge \\Lambda(y)$. \\textup{Le","sha256":"1c8fc02c33423dd25ca158aaa31139026df2194585a8d7d3438909bf4cec47d9"}
{"id":"formula:blk-f13b9f7a7609","source":"formula","sourceId":"thm:no-nchv","title":"formal-blocks · thm:no-nchv","text":"\\begin{equation} \\forall\\, f \\colon \\mathrm{Fin}\\,18 \\to \\mathrm{Bool},\\; \\mathrm{ExactlyOnePerContext}(f) \\implies \\bot. \\end{equation} \\textup{Lean:} \\texttt{Lutar/TwoWitness.lean}, \\texttt{no\\_NCHV","sha256":"738ebe27d8bc31df6d7955796b29a8d7640ff181bec78369a0f1b7ccc8bbfb93"}
{"id":"formula:blk-f317e101a45a","source":"formula","sourceId":"thm:zero-sorry-target","title":"formal-blocks · thm:zero-sorry-target","text":"Merging PR~\\#56 (rebased) and PR~\\#66 (fifth-pass drift fix) reduces the \\texttt{sorry} count from 59 to $\\le 10$, with the remaining sorrys confined to the \\texttt{Topology/PersistentHomologyChain.le","sha256":"c4e3cfbb57de1d719ca92a774d627e29a4d39789e55bbde55003a8c18bc2de2b"}
{"id":"formula:blk-f3d822ef8fe7","source":"formula","sourceId":"def:lambda-mp","title":"formal-blocks · def:lambda-mp","text":"\\begin{equation} \\Lambda^{(v)}_{\\ell+1} \\;:=\\; \\Lambda_k\\!\\Bigl(\\bigl\\{\\Lambda^{(u)}_\\ell : u \\in \\mathcal{N}(v)\\bigr\\}\\Bigr). \\end{equation} \\textup{Source:} v18.13 PyG graft, \\texttt{LambdaMessagePa","sha256":"4cc2f15babfde9131c94a1d768170feb6fd2931a143d77fd89255fc475bf6051"}
{"id":"formula:blk-f4777ac2a59b","source":"formula","sourceId":"theorem:(Λ₁₀ closure).","title":"formal-blocks · theorem:(Λ₁₀ closure).","text":"(Λ₁₀ closure). — *Proof.* (⇐) If every M_{k,j} = 1 then ∏_j M_{k,j} = 1 for all k, so A_k = L_k and Σ A_k = Σ L_k.","sha256":"b92cca83da0345215aae21118491f86c078ed25297824d4d155fe639f8f7e288"}
{"id":"formula:blk-f6a1ac81dc37","source":"formula","sourceId":"thm:thv18-04","title":"formal-blocks · thm:thv18-04","text":"\\begin{verbatim} theorem th_v18_04_egyptian_weight_sum (k : Nat) (hk : 0 < k) : (Finset.range k).sum (fun _ => (1 : Rat) / k) = 1 \\end{verbatim}","sha256":"5585fae830fe9e7a3d9ed82253695e0cdea1c0af88e810febfe763a5963a1e87"}
{"id":"formula:blk-f6c587ec02b2","source":"formula","sourceId":"thm:nist-rmf-functor","title":"formal-blocks · thm:nist-rmf-functor","text":"Define categories $\\mathbf{RMF}$ (objects: GOVERN, MAP, MEASURE, MANAGE; morphisms: tier-inclusion maps) and $\\mathbf{\\Lambda}$ (objects: $\\mathrm{Fin}\\,9$; morphisms: monotone maps on $[0,1]^9$). The","sha256":"19456c7f9be55639064eb4754c0e01495ef53f8d3b8556dd949a325f22c1dfd3"}
{"id":"formula:blk-f9385bc61d63","source":"formula","sourceId":"thm:thv18-11","title":"formal-blocks · thm:thv18-11","text":"\\begin{verbatim} theorem th_v18_11a_const_stabilizes (c : Nat) : forall n, (fun _ => c) n = (fun _ => c) 0 \\end{verbatim}","sha256":"01269ae89b510d65fc75b9bbd1c2d71966f86d9324282a503733548839c7cf51"}
{"id":"formula:blk-f9c1b2bade53","source":"formula","sourceId":"thm:thv18-13","title":"formal-blocks · thm:thv18-13","text":"\\begin{verbatim} theorem th_v18_13a_id_monotone : IsNatMonotone id theorem th_v18_13b_const_monotone (c : Nat) : IsNatMonotone (fun _ => c) \\end{verbatim}","sha256":"ddd6075e17289140986e16a9fece53bb6ac82c53a5cecb28f93d149dd1d76885"}
{"id":"formula:blk-fbc711c1f27c","source":"formula","sourceId":"III.3b","title":"formal-blocks · III.3b","text":"The uniform weight vector (1/k, …, 1/k) is a probability vector. Governance significance: the A3 weights are the maximum- entropy prior — no axis is assumed to dominate any other. Any deviation from 1","sha256":"82d69dc54ef492bb2fee491c51dc658887196f49d6343e7c12b8e42fd9234f7f"}
{"id":"formula:blk-fc80d4189e29","source":"formula","sourceId":"A3","title":"formal-blocks · A3","text":"Egyptian inspectability — > The standard weight set is a multiset of unit fractions \\(\\{1/n_k\\}\\) with each \\(n_k\\) a positive integer, summing exactly to 1 in rational arithmetic. The aggregator \\(\\L","sha256":"ce5125981a6168e1f6f87ec713115892dc203dad3dbf7358085358bd58b80c13"}
{"id":"formula:blk-ff8cd2bccd85","source":"formula","sourceId":"thm:total-order","title":"formal-blocks · thm:total-order","text":"The set $\\mathcal{R}^*$ of all Ouroboros receipts, ordered by hash-chain precedence $r \\prec r'$, forms a \\emph{total order}. \\textup{Lean:} \\texttt{Lutar/SBOMProvenance.lean} (theorem \\texttt{sbom\\_l","sha256":"dbdf163c4ce29889dc7cd53f416360f49bf1faa1a7d329638b51bf9f9a4ab250"}
{"id":"formula:fdx-0145e737efb3","source":"formula","sourceId":"TH-V18-08-KHIPU","title":"forge-index · TH-V18-08-KHIPU","text":"Khipu receipt tree checksum invariant as v18 thesis module. Derives from TH11.","sha256":"882be060b112e075d5e17b3feb8b2812911ca26b1951155de74a665854d9bf7f"}
{"id":"formula:fdx-01ae3edadfe0","source":"formula","sourceId":"A1","title":"forge-index · A1","text":"If every axis improves, Λ does not decrease.","sha256":"7dc20f21e6fadd1ac683075df1df0e951e2a9d413945939ebbc423cff3e572c8"}
{"id":"formula:fdx-0362c1429496","source":"formula","sourceId":"TH-SBOM","title":"forge-index · TH-SBOM","text":"SBOM-component receipt total-order and dual-witness drift theorems. P1-IQT-SBOM-SUM-IS-NOT-HASH remediated (uses HMAC not arithmetic sum).","sha256":"6e6a43391ada8163a1139b8533b76fd240da92212d32429afb0d97bf090965e3"}
{"id":"formula:fdx-04327281bc8b","source":"formula","sourceId":"TH-REF-VECTORS","title":"forge-index · TH-REF-VECTORS","text":"Lean Float Λ implementation matches TypeScript runtime on curated reference vectors in reference-vectors.json.","sha256":"b123493db357c9f1b2cb5ccccf03529333c48d90670936a3adbe901f117e83ea"}
{"id":"formula:fdx-0639a511a64b","source":"formula","sourceId":"TH-TH8-LINEAR-RECEIPT","title":"forge-index · TH-TH8-LINEAR-RECEIPT","text":"Linear receipt module: receipt chain forms a free module over the Λ-semiring.","sha256":"aa0cbd28c1092110c4b743d02a3fb680dd8018cc544ea4cd31b60962221312a6"}
{"id":"formula:fdx-06765d67dedd","source":"formula","sourceId":"TH-V18-01-LOOP","title":"forge-index · TH-V18-01-LOOP","text":"Under DPI-bounded turn budget b, Λ-gated agent state machine reaches Done in finitely many steps. Pure structural termination on Nat. Zero axiom.","sha256":"c8082da6553097426fcdc243efc8899f0cdfc739e4d9e96d0c19b55fbe5101b5"}
{"id":"formula:fdx-07910f39a09f","source":"formula","sourceId":"TH-V18-14-SHA256","title":"forge-index · TH-V18-14-SHA256","text":"Documents A15 as OPEN PROBLEM (P ≠ NP assumption). Audit-integrity theorems proved conditional on A15. Honest axiom under B2 discipline.","sha256":"ff2a82fec14e5fe9d3e241cb65c50a70d02e56da7793aa8ad3138de0bbd43a7e"}
{"id":"formula:fdx-13203a702bdc","source":"formula","sourceId":"TH-LAMBDA-RING","title":"forge-index · TH-LAMBDA-RING","text":"Λ-gate composition forms a commutative semiring under pointwise product and max.","sha256":"0acb21417f370649acfc554eb03f6e9020b8770958ef864312579ee5bef5b41e"}
{"id":"formula:fdx-16ccfa022df9","source":"formula","sourceId":"TH-POSITION-AWARE","title":"forge-index · TH-POSITION-AWARE","text":"Position-aware Λ gate: axis weight reflects ordinal position in receipt sequence.","sha256":"747a6b6715b24cb395161399f70585cc48414e7a1f42d14bf2551c1eefe05bab"}
{"id":"formula:fdx-1ba48a434e01","source":"formula","sourceId":"TH-HORUS-EYE","title":"forge-index · TH-HORUS-EYE","text":"Horus Eye dyadic: ancient Egyptian fractional representation Σ 2^(-i) for i ∈ {1,2,4,8,16,32}.","sha256":"1edb58942a7367fb087f641b5a7413b09bcbe633b072b979f74da5e4ea27f2dd"}
{"id":"formula:fdx-1da653349c3a","source":"formula","sourceId":"TH-PATH-INTEGRAL","title":"forge-index · TH-PATH-INTEGRAL","text":"Audit sum over all paths equals the Feynman path integral discretization. Largest file in repo (22KB).","sha256":"95dafa51f1ed4274b38c9c0088aecb2bbebbf06627657d440ce834b484a0c60a"}
{"id":"formula:fdx-201fec2c31d5","source":"formula","sourceId":"TH-TOPOLOGY-PH","title":"forge-index · TH-TOPOLOGY-PH","text":"Persistent homology chain for receipt topology: Betti numbers track connected components in audit DAG.","sha256":"4bfe363c0b26945e99d8e3842f8113c0cd2e91893bc89749f30bc78782022dec"}
{"id":"formula:fdx-20dc38fffa89","source":"formula","sourceId":"TH-DOCTRINE-CROSS","title":"forge-index · TH-DOCTRINE-CROSS","text":"Doctrine v6 cross-component invariant: all subsystems share the same Λ gate contract.","sha256":"a5206f1f103b622938c3fb375fa9c2a5b955e48a829c2606880186139b244599"}
{"id":"formula:fdx-267a68ce9314","source":"formula","sourceId":"A4","title":"forge-index · A4","text":"min_i(x_i) ≤ Λ(x) ≤ max_i(x_i).","sha256":"8aa491552b940ccb5b2b11d4cc341ddbddb762d97401d28f343c05f7db197b79"}
{"id":"formula:fdx-30b8c962935e","source":"formula","sourceId":"TH1","title":"forge-index · TH1","text":"Λ_k(x₁,...,x_k) := (∏ x_i)^(1/k) — the weighted geometric mean with unit-fraction weights.","sha256":"92d833ed60d978fecbe6902f9ac10bc650fccb39b45f888c41c8e4e2b0310b35"}
{"id":"formula:fdx-32c0c29fac52","source":"formula","sourceId":"TH6-MERKLE","title":"forge-index · TH6-MERKLE","text":"leafCount ≤ B^height for B-ary Merkle tree; height ≤ log_B(leafCount). Structural log-height bound for receipt DAG.","sha256":"e2f347db41e171264fc255980c587f0c1669b6397fd4d8c6ab7ec73971a94ea3"}
{"id":"formula:fdx-36a45d55b842","source":"formula","sourceId":"TH-QEC-CSS","title":"forge-index · TH-QEC-CSS","text":"CSS code bridge: classical codes C₁ ⊂ C₂ → valid CSS quantum code with distance ≥ min(d₁,d₂).","sha256":"9003e60fcc7380f20ae8fd26b1d2aa655abfbb0ae0bb56227110be02380d368b"}
{"id":"formula:fdx-3a3be2ae8b57","source":"formula","sourceId":"TH-V18-10-LISTSUM","title":"forge-index · TH-V18-10-LISTSUM","text":"List.sum is preserved under the khipu encoding map. Structural induction.","sha256":"effa650cd63cd64a964e1c96a374a87d5982572feb1168d0c9de51c15f7d7f29"}
{"id":"formula:fdx-3cd70f51c756","source":"formula","sourceId":"TH-TH8-MONAD","title":"forge-index · TH-TH8-MONAD","text":"Receipt monad satisfies strong monad identity laws (unit, associativity).","sha256":"8f08e6e41eec710fdb080f0a9fa6dfa9a61422dd1b78501762a37a912fd1f26a"}
{"id":"formula:fdx-3deeb8c8873b","source":"formula","sourceId":"TH-QEC-KITAEV","title":"forge-index · TH-QEC-KITAEV","text":"Kitaev surface code toric boundary conditions: code distance scales as √n for n qubits.","sha256":"8840d2dfc1e26b522f1b3516cfd50af822d50304fea5807563f7ca358b0f2b65"}
{"id":"formula:fdx-418df71aed30","source":"formula","sourceId":"TH-GRAPH-LAMBDA","title":"forge-index · TH-GRAPH-LAMBDA","text":"GraphLambda GNN governance head: Λ-gate applied to graph-structured receipts.","sha256":"f8b309a9e90ee7b9733228b92d21659a9c01dc605c0d52ddbabedd7626571fcc"}
{"id":"formula:fdx-4227b5f452f3","source":"formula","sourceId":"TH10","title":"forge-index · TH10","text":"Any function satisfying A1–A4 equals Λ_k (the geometric mean). Proof via Cauchy 1821 functional equation + Aczel 1966.","sha256":"0c6acc57daed12a6fbe4b99fa6e831707aa19cd8a1c786bd931a02e8851f1fd1"}
{"id":"formula:fdx-447244087c74","source":"formula","sourceId":"TH-V18-02-DOCTRINE","title":"forge-index · TH-V18-02-DOCTRINE","text":"DoctrineLabel has exactly 4 elements as a Fintype. Prerequisite for TH-V18-03 Kraft inequality.","sha256":"8ecc91685d818deac8bbb9e96396d8ca9c7aea5171571c1d82f038e4315a0b82"}
{"id":"formula:fdx-480fab7aa5a2","source":"formula","sourceId":"R4-C2","title":"forge-index · R4-C2","text":"Inscribed n-gon sequence π_n is monotone increasing and bounded above by π, hence convergent. Skeleton with tagged sorry deferring to MCT.","sha256":"648c7263f4b93bdace6ca6090043b80bd096028f3fea4f444318678fc817fdf3"}
{"id":"formula:fdx-487ac5dce526","source":"formula","sourceId":"TH-PRNG-K10","title":"forge-index · TH-PRNG-K10","text":"K10v2 PRNG: deterministic replay root guarantees reproducible receipt seeding.","sha256":"9ff98e8e8acdda41481436b3831b4dac7a74e37720f5f5ebcd5a7f3dac3aca53"}
{"id":"formula:fdx-49c04fa2d49d","source":"formula","sourceId":"TH-PAC-NONVACUOUS","title":"forge-index · TH-PAC-NONVACUOUS","text":"pacBayesBound_nonvacuous_iff: bound is nonvacuous iff KL < n·(1 - risk)·log(1/δ) condition holds.","sha256":"37d69fc8eecfa2dc204b8bcfbe49c6faaab61a1787eb317db0eda3b76a26fbf2"}
{"id":"formula:fdx-4dd859019318","source":"formula","sourceId":"R3-G1","title":"forge-index · R3-G1","text":"Newton-Heron sqrt iteration is a Banach contraction on [√S,∞) with Lipschitz ≤ 1/2. Lineage hook for TH12 DPO stability.","sha256":"24761c98ca1b81be7d6e0f1edbbdae92476cb1dc0b2269aa5885ddc153afd59b"}
{"id":"formula:fdx-59a24cad61b3","source":"formula","sourceId":"R2-G6","title":"forge-index · R2-G6","text":"For round-trip (g∘f = id), contentId is preserved. Complete proof, zero sorry. Khipu transcription analogy.","sha256":"f89ea5805a6c7982665e6eb38480140d05796af9248086f2ccae49b6b7a385e9"}
{"id":"formula:fdx-5ef0282fe891","source":"formula","sourceId":"TH-MATCHED-FILTER","title":"forge-index · TH-MATCHED-FILTER","text":"Matched filter maximizes SNR for receipt correlator under AWGN.","sha256":"30a5d020d6591f7cae1701d3ce26327c868f743de31d98d999b8979d32e4ebb8"}
{"id":"formula:fdx-634c9fa45af7","source":"formula","sourceId":"TH-SEXAGESIMAL","title":"forge-index · TH-SEXAGESIMAL","text":"A positive integer n is sexagesimally regular iff n | 60^k for some k. Babylonian table of reciprocals is regular.","sha256":"7062db6f1f5a71ae819caca318b6240c8a45232e19926eb6de05f8246f577cb7"}
{"id":"formula:fdx-64579691b9ed","source":"formula","sourceId":"TH-V18-16-FEYNMAN-INT","title":"forge-index · TH-V18-16-FEYNMAN-INT","text":"Citation integrity: feynman citation chain contains no duplicates and references are non-empty.","sha256":"54b5a546db8a4752186ddb687b0be2ffcedaaa8eb2b79f1ebd0d0cb70efbf7ce"}
{"id":"formula:fdx-66b39df9e967","source":"formula","sourceId":"TH-LAMBDA-SCHUR","title":"forge-index · TH-LAMBDA-SCHUR","text":"Λ_k is Schur-concave: for majorization x ≻ y, Λ(x) ≤ Λ(y). This captures fairness under redistribution.","sha256":"4b05a7b97ae4313676107e6536dbbfc8b724154b2bb0e3b913d2808635916740"}
{"id":"formula:fdx-6736c3078261","source":"formula","sourceId":"TH-BRAHMI-AXIS","title":"forge-index · TH-BRAHMI-AXIS","text":"Brahmi axis AxisOption models the positional-zero digit enabling subtraction completion.","sha256":"0c5cb5213ab06c3f26cb7dc241a5dfc44f84e68ae4eb02e072c934b72b75c8af"}
{"id":"formula:fdx-6c0cf8959621","source":"formula","sourceId":"TH-V18-06-BRAHMI","title":"forge-index · TH-V18-06-BRAHMI","text":"Brahmi positional-zero gate: AxisOption none represents the zero-axis identity element.","sha256":"1315a9c3f486b1a1953df6129c067447b849c9df1c0f567eab2caa698871a3c8"}
{"id":"formula:fdx-6d7222fcee81","source":"formula","sourceId":"R4-I1","title":"forge-index · R4-I1","text":"Generic Madhava-Leibniz remainder: |Σ_{n=0}^{N} a_n - L| ≤ a_{N+1} for monotone-decreasing alternating series.","sha256":"2b440f95c43d35d7ba2b191c4096a6db744f70021a49d76a384c925ff6ea15ad"}
{"id":"formula:fdx-7ab8347faa29","source":"formula","sourceId":"TH-OVERWATCH","title":"forge-index · TH-OVERWATCH","text":"OVERWATCH read-only gate: observation does not mutate receipt state.","sha256":"03a40155e565156bba4f929fbcf28b4b32c7adc62aec01b031134501a91fa28a"}
{"id":"formula:fdx-7bc55c5ad707","source":"formula","sourceId":"TH-GLEASON","title":"forge-index · TH-GLEASON","text":"Doubly-even self-dual binary codes have length ≡ 0 (mod 8). SZL governance analog for 8-receipt closure invariant.","sha256":"02927390984ad5de5dc976c07500cd3d5d9cec4b1bb15965c926cf103819653c"}
{"id":"formula:fdx-7d2449f7ae9a","source":"formula","sourceId":"TH-PAC-MONO","title":"forge-index · TH-PAC-MONO","text":"PAC-Bayes bound is monotone increasing in KL divergence.","sha256":"8b7ac446c644e35b7e050e174aec19fda30a9c6283c483c1f7d7aa2af4d9e846"}
{"id":"formula:fdx-7dbee3fc184b","source":"formula","sourceId":"TH-V18-13-DPI","title":"forge-index · TH-V18-13-DPI","text":"Abstract DPI bound as v18 module, parameterized over receipt channel type.","sha256":"445dfcdf9d04648b0cf555863a4c90b2223e2d7378813ed4780e3f5bb8d3272e"}
{"id":"formula:fdx-7e6b7ffcfe11","source":"formula","sourceId":"TH-COMP","title":"forge-index · TH-COMP","text":"If S₁ is (δ,ε₁)-robust and S₂ is (ε₁,ε₂)-robust, then S₁∘S₂ is (δ,ε₂)-robust. Zero axiom, zero sorry.","sha256":"9ebc0d1b0571b3b0c81c6a94c80d532de3a2b39a77b762d6a7dabba3216992f5"}
{"id":"formula:fdx-86ca875f879e","source":"formula","sourceId":"TH-V18-09-PERM","title":"forge-index · TH-V18-09-PERM","text":"Λ is invariant under permutation of axes: Λ(σ(x)) = Λ(x) for any σ ∈ Sym(k).","sha256":"cf3248062d4b57c42325702f0801d8b152666e3924d67ca647067c88e3d07740"}
{"id":"formula:fdx-883b41f1ce9d","source":"formula","sourceId":"TH-TWO-WITNESS","title":"forge-index · TH-TWO-WITNESS","text":"TH KS-18: 18-vector Kochen-Specker proof that no non-contextual hidden-variable model exists in ℝ³.","sha256":"a38f70b9b5980d3c5ced5d06227ff47ec0c29bfd520e414083c47954b5988eb3"}
{"id":"formula:fdx-8c9dbcff9108","source":"formula","sourceId":"TH-V18-15-FAIRNESS","title":"forge-index · TH-V18-15-FAIRNESS","text":"In cooperative multi-agent system with finite fuel per agent, the system terminates. Foundational liveness for v18.x MultiAgentOrchestrator.","sha256":"b78f481c15b6119c7efc93b5dcaf1878cfbfc5b2f8507c3611858a9741a07588"}
{"id":"formula:fdx-8de365246754","source":"formula","sourceId":"TH-COMP-TH1","title":"forge-index · TH-COMP-TH1","text":"TH1 composition master theorem: sequential Λ-gate composition preserves monotonicity and boundedness.","sha256":"1d29e5f260ee7311cb779bc9a8271529fd655662ef7b2c5992125c44fe269997"}
{"id":"formula:fdx-8df6e8ec42a6","source":"formula","sourceId":"TH-QEC-HAMMING","title":"forge-index · TH-QEC-HAMMING","text":"Hamming distance triangle inequality and sphere-packing bound for quantum receipt encoding.","sha256":"0149239b2701901f0c50554f2ba8b35b578902770aedd4ec37a007c875ca64a3"}
{"id":"formula:fdx-98f99dbadf75","source":"formula","sourceId":"TH-V18-11-PARETO","title":"forge-index · TH-V18-11-PARETO","text":"Non-decreasing bounded Nat sequence stabilizes. Classically true; deferred to Nat.find with decidable predicate. TRACKED.","sha256":"018de3bea8fce3e0a3cf80dc568d421b87e1ce843fa65e767f8c08aa069601d2"}
{"id":"formula:fdx-9947560266e8","source":"formula","sourceId":"TH-TH8-GRADED-SEMIRING","title":"forge-index · TH-TH8-GRADED-SEMIRING","text":"Graded semiring of Λ-receipts indexed by trust level ∈ {0,1,2,3}.","sha256":"42d9e6c14d55148e3738f4b969d471835fae6b254e72ea9ec2fc3891f384e0bb"}
{"id":"formula:fdx-9b09e49a87ae","source":"formula","sourceId":"TH2","title":"forge-index · TH2","text":"min_i(x_i) ≤ Λ_k(x) ≤ max_i(x_i). Machine-checked via Mathlib4 geometric-mean reasoning.","sha256":"664f9d27f23d1f9628db71ba992c2fe5de464b1da95b58c48b7b9b3348fbc82f"}
{"id":"formula:fdx-9f12730b4a35","source":"formula","sourceId":"TH6-DPI-SOUND","title":"forge-index · TH6-DPI-SOUND","text":"Master DPI soundness theorem tying receipt chain to entropy monotonicity.","sha256":"dca43407be7ca6ed95089414ec1307efa77dbe639b8185da39f0b800589bcb88"}
{"id":"formula:fdx-a194ae53ba42","source":"formula","sourceId":"TH-V18-01-MONO","title":"forge-index · TH-V18-01-MONO","text":"Λ-gate monotonicity restatement as v18 module theorem.","sha256":"0d22747d2bdf8897d6239374fe77d5381a92cbb7d23f496c1f7fddc121fc49bd"}
{"id":"formula:fdx-a3b233e3fb4c","source":"formula","sourceId":"TH-RELAY-CHAIN","title":"forge-index · TH-RELAY-CHAIN","text":"Inca relay-runner (chasqui) chain: message propagates through relay stations preserving content identity.","sha256":"7a181fcf335cb4363aa89a9e37ac1878fee1ec8e9a60313f269d4c36d866efa2"}
{"id":"formula:fdx-a69959d33b56","source":"formula","sourceId":"TH6-SCITT","title":"forge-index · TH6-SCITT","text":"Entropy lower bound for SCITT receipt masks under DPI constraint.","sha256":"d77f3464f1713eaf07c2effdc8ec801e929c453cd6bc8954e225cc6ae75b2d11"}
{"id":"formula:fdx-a6d794fc4638","source":"formula","sourceId":"TH-CRT-WEIGHT","title":"forge-index · TH-CRT-WEIGHT","text":"Chinese Remainder Theorem applied to receipt weight chunking: disjoint-modulus chunks reconstruct unique weight.","sha256":"c9009bbac29c5867d992dce7bb11240423d92145d722399d72c32b7acaae90fe"}
{"id":"formula:fdx-a89e9ee625c4","source":"formula","sourceId":"A2","title":"forge-index · A2","text":"Λ(c·x) = c·Λ(x) for scalar c ≥ 0.","sha256":"e18126ce22191b7cccf8dcde7261159c9514b9d4aacc4c265f20fdcbe5927697"}
{"id":"formula:fdx-aae572187f2a","source":"formula","sourceId":"TH-PUBLIC-CLAIMS","title":"forge-index · TH-PUBLIC-CLAIMS","text":"Authoritative source of truth for all publicly-claimed Lean theorems. Each entry maps (Lean theorem, runtime counterpart, doctrine doc citation).","sha256":"730a655a17391be14d3d45e9d36858f45f03a55df8962b108f6c7bfea395e2b2"}
{"id":"formula:fdx-ad894954c649","source":"formula","sourceId":"TH2b","title":"forge-index · TH2b","text":"min_i(x_i) ≤ Λ_k(x). Companion to TH2.","sha256":"5e6a7de5200ce516f67be7424b1ad724e0de2911ae8fe8e1d6d8754e837d874a"}
{"id":"formula:fdx-b44f88576b4c","source":"formula","sourceId":"TH-V18-07-FEYNMAN","title":"forge-index · TH-V18-07-FEYNMAN","text":"Citation chain from Feynman diagrams to SZL receipt audit has length ≥ 1.","sha256":"ddb677729025248fb36e63ac9b442a1f85dc40e9b54fb7dc913d9ff148000ccd"}
{"id":"formula:fdx-b758a3695deb","source":"formula","sourceId":"TH-R1-TESTS","title":"forge-index · TH-R1-TESTS","text":"Lean-level tests for R1 composition properties against reference vectors.","sha256":"86a7355b741ab7413c06afedce00dc59c55c2db4675d0fc814c9b59880ef9be8"}
{"id":"formula:fdx-b887d6646614","source":"formula","sourceId":"TH-SHANNON","title":"forge-index · TH-SHANNON","text":"Doctrine alphabet has 4 labels; Shannon 2-bit code is optimal (H=2 bits for uniform source). Kraft equality holds.","sha256":"fdd246984d0576c1353ac631d88cbf7133b0b5c9bdb8a8c68927438cb262bc1d"}
{"id":"formula:fdx-bfd145cea203","source":"formula","sourceId":"TH-REIDEMEISTER","title":"forge-index · TH-REIDEMEISTER","text":"Three audit-Reidemeister rewrites R1 (repack), R2 (commute), R3 (associativity). CONJECTURE status; all sorry-tagged; target v16.","sha256":"33ef368d34c06383f1cc44380c396c41b9e3bab4c73690d748bb5146a83e0ce4"}
{"id":"formula:fdx-bfeda7ad8416","source":"formula","sourceId":"TH-EGYPTIAN-AKHMIM","title":"forge-index · TH-EGYPTIAN-AKHMIM","text":"Akhmim RMP 2/n table: unit-fraction decomposition of 2/n for odd n ≤ 101. Formal proof of table correctness.","sha256":"1431ea1166719e4408df61859c1c6b1dc3f4b30a202b97ad81bf4ae24bdc37d9"}
{"id":"formula:fdx-c521f9874e89","source":"formula","sourceId":"TH-V18-03-KRAFT","title":"forge-index · TH-V18-03-KRAFT","text":"4 codewords × 2^(-2) = 1. Code is Shannon-optimal for uniform 4-symbol source. Proof by norm_num.","sha256":"66a4d3357e57943e0faaa78c8663ae52c349cfe070d1daad823fbb9c95d49309"}
{"id":"formula:fdx-c5f25caa3ce9","source":"formula","sourceId":"TH13","title":"forge-index · TH13","text":"Closed-form non-vacuous PAC-Bayes bound for governance head. Arithmetic content fully formalised; probabilistic Pr ≥ 1-δ quantifier deferred.","sha256":"096387a47a13ddb32981cd4430155b82524eb6ee5afdad94cb70d1c07ea8fd23"}
{"id":"formula:fdx-caaed15ede52","source":"formula","sourceId":"TH-DOCTRINE-ENTROPY","title":"forge-index · TH-DOCTRINE-ENTROPY","text":"Measurability honesty: all doctrine labels are measurable under the sigma-algebra induced by Λ.","sha256":"7efd65cd85f130e7997bf3176a87ad28297ab18da5f8646dcec979786e758679"}
{"id":"formula:fdx-d08ad098f3eb","source":"formula","sourceId":"TH12","title":"forge-index · TH12","text":"Policy-loop rollback step is stable under DPO via Pinsker + Lipschitz composition. Three tagged sorrys: Pinsker (Mathlib), Lipschitz from Ch.9 gate boundedness.","sha256":"00d59b70fe30c2552265bbae3c20f14b06356a4402f12929500a96a7437a39cb"}
{"id":"formula:fdx-d0e797e5cbfe","source":"formula","sourceId":"TH6","title":"forge-index · TH6","text":"Elementary Cover-Thomas DPI (Theorem 2.8.1). NOT the Bekenstein physical bound (F1-4 retraction documented in CHANGELOG). Receipt chain H(X|Z) ≤ H(X|Y) for Markov chain X→Y→Z.","sha256":"7e1083bab742e3d529a67f0e8df0e5499364b59fca20cd1090195ad0d70e83ec"}
{"id":"formula:fdx-d58741af4974","source":"formula","sourceId":"TH-QEC-SHOR","title":"forge-index · TH-QEC-SHOR","text":"Shor 9-qubit code structure applied to receipt encoding: corrects any single-qubit error.","sha256":"7c9cef422aa8df1c368d9d1401fdaadd4010976815d8ab6d72abb657dfd9cb06"}
{"id":"formula:fdx-d8b7eec1770c","source":"formula","sourceId":"A3","title":"forge-index · A3","text":"Λ(c,c,...,c) = c for all c (diagonal commitment S1). Replaces vacuous tautology flagged in PhD-Math V14-C1.","sha256":"885c15b69adbe0668f349cbdd5b19a17386151551a90329f10bd3fbae84ee093"}
{"id":"formula:fdx-dd8c96027719","source":"formula","sourceId":"TH-FEYNMAN","title":"forge-index · TH-FEYNMAN","text":"feynmanToSZLChain.length = 4 (Feynman → quantum → information → SZL). chain_citations_nonempty.","sha256":"1e9745d208807d2d980ccb869b33d2d1a31c3daed744c221714788a2840d50a0"}
{"id":"formula:fdx-de72b9914137","source":"formula","sourceId":"TH-ADINKRA","title":"forge-index · TH-ADINKRA","text":"Adinkra graph supersymmetry invariant for gate receipt topology.","sha256":"c33991ff264fa609fe5922d4eeec7d3072efa67492ca397f6f4ae2b92a80f839"}
{"id":"formula:fdx-df95ea4c6f06","source":"formula","sourceId":"TH-HALT-ELIG","title":"forge-index · TH-HALT-ELIG","text":"An agent is halt-eligible iff its receipt DAG is closed under DPI and all pending receipts have been acknowledged.","sha256":"77c072194ba360061fca93d5bc6f8ad651673018780bd91e882c9c165bffdf78"}
{"id":"formula:fdx-e202ddcf0126","source":"formula","sourceId":"TH-MORAL-GROUNDING","title":"forge-index · TH-MORAL-GROUNDING","text":"Moral grounding: any doctrine-compliant agent satisfies the honesty + measurability constraints.","sha256":"f10be077ee713c8e9d65674a8d115d9420d46ab509520299a3a1f9e1fd99b252"}
{"id":"formula:fdx-e5a9f09dc8ee","source":"formula","sourceId":"TH-V18-05-TRANSDUCTION","title":"forge-index · TH-V18-05-TRANSDUCTION","text":"Transduction preserves receipt content integrity under encode-decode round-trip.","sha256":"6d39ed83e7b13d1cf470a14b2b2638a38f86fe6b0b0daa9c4d44675d3421c12a"}
{"id":"formula:fdx-eb951fbdf686","source":"formula","sourceId":"TH-V18-04-EGYPT","title":"forge-index · TH-V18-04-EGYPT","text":"Egyptian unit-fraction weights sum to 1: Σ_{i=1}^k (1/k) = 1.","sha256":"21cc842a4f24365b4e778bf6c0915b7f4c85ab91349d473a1be989d22836973e"}
{"id":"formula:fdx-ebcf9e3a76da","source":"formula","sourceId":"TH11","title":"forge-index · TH11","text":"Three-tier khipu receipt DAG: primary = Σ pendants, pendant = Σ sub-pendants. Receipt-tree coboundary integrity.","sha256":"f7e8321415d093beb4dc2af5ea3305c63b0b2bc55f2e5da8c9a88fea3cabd977"}
{"id":"formula:fdx-efbfca72f4a7","source":"formula","sourceId":"TH-COMP-OVERHEAD","title":"forge-index · TH-COMP-OVERHEAD","text":"Composition overhead: adding k layers multiplies Λ gate latency by at most k·(1+ε).","sha256":"0c2f349637e0ebd5e162624278c905a0111431ad46b625d9af335a436512a76f"}
{"id":"formula:fdx-f23d586d1d48","source":"formula","sourceId":"TH-V18-12-LAMBDA-PROD","title":"forge-index · TH-V18-12-LAMBDA-PROD","text":"Λ_k product formula: (∏ x_i)^(1/k) expressed as composition of ring operations.","sha256":"6735dfbe6de94315a3f680f5af35398cb064f1602c4b46b7b21071cbf09f25ee"}
{"id":"formula:fdx-f7658f8cecd3","source":"formula","sourceId":"TH-WHEELER","title":"forge-index · TH-WHEELER","text":"Wheeler window safety: receipts outside admission window are rejected; closeLabel is a function of admission. Idempotent.","sha256":"c2a71f6230a823a1125473c0d03924e69fbd210c791781ede4c39b6ce8294935"}
{"id":"formula:fdx-fb6352d86d3c","source":"formula","sourceId":"R1-G1","title":"forge-index · R1-G1","text":"Egyptian aha method: for affine gate f(x) = mx+c, false_position_correct recovers target exactly from two samples.","sha256":"11eae4feb69d6ce7de9262e92352c456ab39347c7750ae8b2a23f4cd9e0dde46"}
{"id":"formula:fdx-fef2053f957b","source":"formula","sourceId":"TH-TH8-GLR","title":"forge-index · TH-TH8-GLR","text":"Graded linear receipt semiring: receipts graded by trust level form a valid semiring.","sha256":"8900c8f4f7ec76904320974d1bbdd8c217712e8c9b47f35a6afef0ca477dd1ac"}
{"id":"formula:led-00cbac64de2c","source":"formula","sourceId":"TH_V18_03-kraft","title":"formula-ledger · TH_V18_03-kraft","text":"Kraft inequality: for a binary prefix code with lengths {1,2,3,3}, sum 2^{-l_i} = 1 <= 1 (complete code equality).","sha256":"63e7574fec76365185d091f33c9f36e67387a9b6285f4e2b5066d4089cb12ec9"}
{"id":"formula:led-19d29fd50b45","source":"formula","sourceId":"lambda-score-dimensionless","title":"formula-ledger · lambda-score-dimensionless","text":"Trust axes x_i in [0,1] are dimensionless; Lambda (weighted geo-mean of dimensionless axes) is dimensionless.","sha256":"86ffa794fd1df49fc3d99f673e0bf15e1f79e4e287796f1409fef2d8caca2600"}
{"id":"formula:led-1f463f03d5c8","source":"formula","sourceId":"bekenstein-dimensional","title":"formula-ledger · bekenstein-dimensional","text":"Bekenstein bound S = 2*pi*R*E/(hbar*c): the group R*E/(hbar*c) must be dimensionless.","sha256":"b3cf445086c316bdbd1602319b505434d38156a60a6d06b19e2b6bcfb55b23ad"}
{"id":"formula:led-283caee8b962","source":"formula","sourceId":"shor-913-distance","title":"formula-ledger · shor-913-distance","text":"Shor code [[9,1,3]]: distance d=3 corrects t=floor((d-1)/2)=1 error; satisfies classical Singleton n-k+1=9 >= d.","sha256":"365205726323fa05e69d7790c9b591adcc623a8d4e28b583a6bb76744166c30d"}
{"id":"formula:led-294b001766cb","source":"formula","sourceId":"k-verify-accuracy","title":"formula-ledger · k-verify-accuracy","text":"Model accuracy / khipu-verifiability / HUKLLA refusal, scored against 100 public-source Q&A items.","sha256":"0d57f93e79d11a027b753703c58603120e08633886eabc92e80b29833012fa46"}
{"id":"formula:led-42a939dc9b5a","source":"formula","sourceId":"landauer-energy","title":"formula-ledger · landauer-energy","text":"Landauer limit E = k_B * T * ln2: energy per irreversible bit erasure has units of energy (Joules).","sha256":"43ffd4f1e869c0053d640903095529d30d7148ce5495f9f0d3e2f1982ba2e4cc"}
{"id":"formula:led-4822b0715826","source":"formula","sourceId":"F0003-receipt-edge","title":"formula-ledger · F0003-receipt-edge","text":"A receipt-bound edge e in E is a tuple (a_src, r_src, r_dst, ...).","sha256":"3990e38d317850b9f80c8b8fc671b19014cbabb61e944c2d361e0952e33a5c20"}
{"id":"formula:led-4ac468ac5d77","source":"formula","sourceId":"byzantine-n3f1","title":"formula-ledger · byzantine-n3f1","text":"BFT arithmetic: with f=1 faulty, n=3f+1=4 nodes and quorum 2f+1=3 (the 3-of-4 Khipu quorum). NOTE: BFT *safety/liveness* itself is Conjecture-2/3, not proven.","sha256":"38498fc88cc4d87dff9a66a95ede1d4d71c14de5d2fe7619fbd0dfdcc69b26ae"}
{"id":"formula:led-50bce8609baf","source":"formula","sourceId":"A4-bounded-amgm","title":"formula-ledger · A4-bounded-amgm","text":"Geometric mean <= max axis (AM-GM corollary). 2-var: sqrt(a*b) <= (a+b)/2, with slack (sqrt(a)-sqrt(b))^2/2.","sha256":"edfbf311caa5ee1b20382f49be076ae8452c7e5ba911955334c8ac6dae8dbf6a"}
{"id":"formula:led-602a7e6713ff","source":"formula","sourceId":"pinsker-2pt","title":"formula-ledger · pinsker-2pt","text":"Pinsker: KL(p||q) >= 2*TV(p,q)^2. Machine-checked by numeric sampling over random 2-point distributions (NOT a symbolic proof).","sha256":"8961f0429a01e75506add4d8b02f1bdcc1d01dfdd3b75637ea2cd7931f09bdfa"}
{"id":"formula:led-66ec8c74d828","source":"formula","sourceId":"F12-kuramoto-additive","title":"formula-ledger · F12-kuramoto-additive","text":"Additive superposition fragment: total coupling over k phases = sum of per-phase couplings (linear part only; NOT nonlinear Kuramoto sync).","sha256":"8582d10563613b73e38b462ef1bdbf452cf71dcb5dac601592dde74f2507128e"}
{"id":"formula:led-6b3fbb347da4","source":"formula","sourceId":"K13-bekenstein-fire","title":"formula-ledger · K13-bekenstein-fire","text":"Bekenstein indicator fire rate = 49.5% (thesis.md 4.5).","sha256":"ba320333d24ca7a4746cff2200cec9fc54ef6553c41f88caa012e2cea3564f39"}
{"id":"formula:led-72e2647a8137","source":"formula","sourceId":"madhava-leibniz-atan","title":"formula-ledger · madhava-leibniz-atan","text":"Madhava-Leibniz series: atan(x) = sum_{m>=0} (-1)^m x^(2m+1)/(2m+1); matches sympy Taylor series of atan.","sha256":"91cae301ea81fa0042e23090c6dadc31eb948c5058ac796ab76d98136358c90c"}
{"id":"formula:led-73cb8891370d","source":"formula","sourceId":"K06-rho-closure","title":"formula-ledger · K06-rho-closure","text":"rho-closure rate = 100% (8000/8000 paired calls, ouroboros v6.3.0).","sha256":"73cb8891370d22a8a5a65d12dce28bd1701b5f9103451a544c4d7c3f5e3647dd"}
{"id":"formula:led-8356600feb18","source":"formula","sourceId":"F18-reed-solomon-singleton","title":"formula-ledger · F18-reed-solomon-singleton","text":"Singleton bound: min distance d <= n-k+1; RS(10,6) tolerates n-k=4 erasures, recoverable iff >=6 of 10 shards survive.","sha256":"4799ced408eb26401fde308e14ec3c4c86577acc5328df079bf53fc94119442a"}
{"id":"formula:led-8a47e0bade6c","source":"formula","sourceId":"F1-euler-khipu-chi","title":"formula-ledger · F1-euler-khipu-chi","text":"Euler characteristic of a convex polyhedron: V - E + F = 2 (checked on the Platonic solids).","sha256":"52be06a28b5e4a6ab3552bdad0df61d8e5324b51d2653f8c46cd7440cd77b9ce"}
{"id":"formula:led-8cc22a9e64bb","source":"formula","sourceId":"conjecture-2-khipu-safety","title":"formula-ledger · conjecture-2-khipu-safety","text":"Khipu BFT 3-of-4 safety: no two conflicting decisions both reach quorum under <=f faults.","sha256":"13de502cab7450c12aef71ec266f8fd4f7849836efce73aa9c87384266a392e5"}
{"id":"formula:led-9409be832c4f","source":"formula","sourceId":"F0001-system-tuple","title":"formula-ledger · F0001-system-tuple","text":"System defined as tuple S = <R, A, E, Lambda, rho, W> over eight regions.","sha256":"870e9be90a633c04de117218ecd6ab31cf6cbed1bffce9e3abe942511c37492f"}
{"id":"formula:led-9b9f5e8bb845","source":"formula","sourceId":"TH_L1-lambda-uniqueness","title":"formula-ledger · TH_L1-lambda-uniqueness","text":"Conjecture 1: Lambda (weighted geo-mean w/ Egyptian weights) is the UNIQUE aggregator satisfying A1-A5. Unconditional uniqueness is machine-checked FALSE (maxAgg counterexample); conditional Theorem U is proven.","sha256":"23d5821fb6f0f40a93a11149e09fe5587bbce6f64c97e3bbea846201387cb5eb"}
{"id":"formula:led-9dc65fb5d3ac","source":"formula","sourceId":"TH_V18_04-egyptian-horus","title":"formula-ledger · TH_V18_04-egyptian-horus","text":"Horus-Eye / Egyptian unit-fraction sum: 1/2+1/4+1/8+1/16+1/32+1/64 = 63/64.","sha256":"0c9109ab6db03aa010f7e780a4a4b6a385458816cd80b7e5669f736fefcb7d4b"}
{"id":"formula:led-9f6d4f3136c9","source":"formula","sourceId":"code-of-reality-lineage","title":"formula-ledger · code-of-reality-lineage","text":"'Code of reality' / ancient-text inspiration (Emerald Tablet correspondence, Dead Sea Scrolls calendrics) as substrate metaphor.","sha256":"dc02fd6cc0cb55110a2cc065180ca8e4fc084d76be19f003a79fea43d0687d92"}
{"id":"formula:led-a04259aec87c","source":"formula","sourceId":"conjecture-3-khipu-liveness","title":"formula-ledger · conjecture-3-khipu-liveness","text":"Khipu BFT liveness: every submitted action eventually reaches a quorum decision.","sha256":"9337841c819b2aa95c6d6f703437557a5fe7f1c34e733d8002d17c6cc967f76d"}
{"id":"formula:led-a9880516dcb7","source":"formula","sourceId":"F19-bekenstein-additive","title":"formula-ledger · F19-bekenstein-additive","text":"Entropy budget additive & monotone over a region partition: s1 <= s1 + s2 for s2 >= 0 (NOT the full Bekenstein bound).","sha256":"6eb3da3ab4e2ea6fd2ed4d02769295afd0d6e5a2d95c1be78286b7fd8d12f540"}
{"id":"formula:led-b1792e9633ad","source":"formula","sourceId":"axis-schema-13","title":"formula-ledger · axis-schema-13","text":"Canonical 13-axis trust vector: 2 sacred (floor 0.95) + 7 structural (0.90) + 4 introspection (0.90).","sha256":"10c1a157852901dfb0827e0260dbdae26da3b2d3dff11f0f28e5ef469ec9a652"}
{"id":"formula:led-d1146bbfee9c","source":"formula","sourceId":"A2-homogeneity","title":"formula-ledger · A2-homogeneity","text":"Weighted geometric mean is positively homogeneous degree 1: Prod (c*x_i)^{w_i} = c * Prod x_i^{w_i} when sum(w_i)=1.","sha256":"dd17f7bda7e4d3a29d6fdafb4dff0e5cbdd6adc6ca8b886fe596ca5d8e6f8bb0"}
{"id":"formula:led-e6c2d7df441b","source":"formula","sourceId":"quadratic-completion","title":"formula-ledger · quadratic-completion","text":"Completing the square: x^2 + b*x + c = (x + b/2)^2 + (c - b^2/4).","sha256":"6984bf2417f686acd6ac8782159aec53c68b11cdb503ec33cd05e711eea5d9c0"}
{"id":"formula:led-ed505404bc64","source":"formula","sourceId":"cauchy-schwarz-2d","title":"formula-ledger · cauchy-schwarz-2d","text":"Cauchy-Schwarz (n=2) via Lagrange identity: (a1*b1+a2*b2)^2 = (a1^2+a2^2)(b1^2+b2^2) - (a1*b2-a2*b1)^2, so LHS <= product.","sha256":"56d189dc5db13cd5a4fc22894d1620ee7059db2a0c44e6ec3867a81e6efbf2cb"}
{"id":"formula:led-f5e59824a7e8","source":"formula","sourceId":"dsse-envelope-struct","title":"formula-ledger · dsse-envelope-struct","text":"DSSE envelope structure with PAE binding; signature is an HONEST PLACEHOLDER (Sigstore not wired).","sha256":"1c3e0545f9ceaf06d23ddefe12409295ceaab20df82ee266eecb5a77b262ed65"}
{"id":"formula:led-f89955a1d206","source":"formula","sourceId":"fisher-rao-identity","title":"formula-ledger · fisher-rao-identity","text":"Fisher-Rao distance d(p,q) = 2*arccos(sum sqrt(p_i q_i)); self-distance d(p,p) = 2*arccos(1) = 0 when sum p_i = 1.","sha256":"60318b531fe7ce8a92d516a7f69a4648a15db7428823c6cb9622c1bc10dcc348"}
{"id":"formula:led-fa1902c5d9b7","source":"formula","sourceId":"K01-receipt-build-latency","title":"formula-ledger · K01-receipt-build-latency","text":"Receipt build p50 = 11.5 us (62764 ops/s), p99 = 50.7 us; verify p50 = 1e6/ops_per_sec.","sha256":"7112f62a939fd955122bf7ffd404caae451ce93448a06be2b336728422c55f1c"}
{"id":"ingest:ktransformers:000","source":"ingest","sourceId":"ktransformers","title":"Arithmetic-intensity-guided CPU/GPU offloading","text":"KTransformers keeps only high-arithmetic-intensity ops (MLA attention ~512, shared experts, projections, embeddings-on-CPU) on the GPU and pushes the routed-MoE experts — a batch-1 GEMV with arithmetic intensity ~0.075, and 96% of the parameters — onto the CPU/DRAM. This is precisely how they run DeepSeek-V2 (236B) in ~21GB VRAM + 136GB DRAM. For SZL this is THE thesis for making szl-nemo (a MoE) servable on the RTX 4060 Ti tower: split by intensity, not by naive layer count, so the small VRAM holds the hot dense path while cold experts live in system RAM.\n\nApplies to: szl-nemo.\n\nEvidence: doc/en/deepseek-v2-injection.md (https://raw.githubusercontent.com/kvcache-ai/ktransformers/main/doc/en/deepseek-v2-injection.md)","sha256":"ca9498a489cea4cb67596c7b3ca6ac21c64e6c9974189c49464c43b9ce4a871a"}
{"id":"ingest:ktransformers:001","source":"ingest","sourceId":"ktransformers","title":"Declarative YAML injection / op-replacement (per-node tuning as config, not code)","text":"Instead of forking model code, KTransformers matches modules by name-regex AND/OR class and swaps optimized backends via a YAML rule file (match/replace/kwargs with generate_device, prefill_op, generate_op, out_device). Device placement, quant kernel choice, and multi-GPU layer splits are all data. For SZL's heterogeneous fleet (tower vs laptop vs szl-nemo) this means one model definition + a per-node rule file — the forge recipe should emit a machine-specific placement YAML rather than bespoke code per box.\n\nApplies to: sovereign-serving.\n\nEvidence: doc/en/SFT/injection_tutorial.md (https://raw.githubusercontent.com/kvcache-ai/ktransformers/main/doc/en/SFT/injection_tutorial.md)","sha256":"ddb0217cbc70ccb092385e16e20aa30b94548a7f5bba130f1c54eeea3276fe09"}
{"id":"ingest:ktransformers:002","source":"ingest","sourceId":"ktransformers","title":"3-layer (GPU-CPU-Disk) prefix-cache reuse for failover latency","text":"balance_serve stores and reuses KVCache across a GPU→CPU→disk hierarchy (config: kvc2.gpu_only=false, cpu_memory_size_GB, disk_path). Repeated system prompts / agent scaffolds hit cached prefixes instead of re-prefilling. For SZL this is the single biggest failover-latency lever: when a request re-routes to the tower, a warm prefix cache turns a cold multi-thousand-token prefill into a near-instant continuation, and the disk tier survives process restarts.\n\nApplies to: sovereign-serving.\n\nEvidence: doc/en/prefix_cache.md (https://raw.githubusercontent.com/kvcache-ai/ktransformers/main/doc/en/prefix_cache.md)","sha256":"99263b96aaed9fc7e0f91a481ca96a2b94421b01699454aee04a538cf9f52e00"}
{"id":"ingest:ktransformers:003","source":"ingest","sourceId":"ktransformers","title":"balance_serve: C++ continuous batching + chunked prefill + variable-batch CUDA Graph","text":"A 10k+-line refactor (inspired by SGLang) split KTransformers into Server / Inference-Engine / Scheduler layers, adding FCFS continuous batching, chunked prefill, and a variable batch-size CUDA Graph (via their custom_flashinfer fork) that cuts padding/memory overhead. Reported ~130% throughput at 4-way concurrency. For SZL sovereign serving under concurrent agent load, continuous batching + chunked prefill is the pattern that stops one long prompt from head-of-line-blocking the fleet.\n\nApplies to: sovereign-serving.\n\nEvidence: doc/en/balance-serve.md (https://raw.githubusercontent.com/kvcache-ai/ktransformers/main/doc/en/balance-serve.md)","sha256":"156e41de6ece5383ce7175592414ed5e0a62be16bf87d1ae84d4eb3fb400e54c"}
{"id":"ingest:ktransformers:004","source":"ingest","sourceId":"ktransformers","title":"CPU-GPU expert scheduling with frequency-based placement","text":"kt-kernel exposes a GPU-expert mask with four placement strategies — uniform, frequency (put most-activated experts on GPU using --init-expert-location activation stats), front-loading, random — plus --kt-num-gpu-experts. This lets you spend scarce VRAM on exactly the experts that fire most. For szl-nemo on a 24GB-class card: profile activation on SZL's real workloads, then pin the hot experts to GPU and leave the long tail on CPU — a measured, data-driven use of the tower's limited VRAM.\n\nApplies to: szl-nemo.\n\nEvidence: doc/en/kt-kernel/experts-sched-Tutorial.md (https://raw.githubusercontent.com/kvcache-ai/ktransformers/main/doc/en/kt-kernel/experts-sched-Tutorial.md)","sha256":"b8f5798422ab3dc3de79aa38a53b445aa370e798af7c01ffdbd3f9b7afd63ed6"}
{"id":"ingest:ktransformers:005","source":"ingest","sourceId":"ktransformers","title":"MLA matrix-absorption to shrink the KV cache","text":"DeepSeek's Multi-head Latent Attention keeps a joint compressed KV representation; KTransformers absorbs the decompression matrices into q_proj/out_proj so attention runs on the compressed form — never materializing the decompressed KV. This both shrinks the KV cache and raises the operator's arithmetic intensity so the GPU is well-utilized. Relevant to SZL's corpus of forge recipes: if szl-nemo adopts an MLA-style attention, absorption is the trick that makes long-context serving fit small VRAM.\n\nApplies to: szl-nemo.\n\nEvidence: doc/en/deepseek-v2-injection.md (https://raw.githubusercontent.com/kvcache-ai/ktransformers/main/doc/en/deepseek-v2-injection.md)","sha256":"e42b6a999d4b08a303163dad44d024836b7739c845acf583a5f514ba492e1d30"}
{"id":"ingest:ktransformers:006","source":"ingest","sourceId":"ktransformers","title":"Runtime CPU-capability detection with honest fallback (build-once-run-anywhere)","text":"The kt-kernel PyPI wheel ships six CPU variants (AMX, AVX512+BF16/VBMI/VNNI/Base, AVX2) and auto-selects the best at import; CUDA features auto-disable when no supported GPU is present, and old CPUs fall back to AVX2. This capability-detect-then-fallback pattern (overridable via KT_KERNEL_CPU_VARIANT) is exactly what SZL's forge distribution should do: one artifact that measures the host and degrades honestly rather than shipping a box-specific binary that silently misbehaves elsewhere.\n\nApplies to: forge-training.\n\nEvidence: kt-kernel/README.md (https://raw.githubusercontent.com/kvcache-ai/ktransformers/main/kt-kernel/README.md)","sha256":"ad82fbd0e65ac4c124f01ed11e85b7401def4d5a7289ab26b59fe007a4b3ff51"}
{"id":"ingest:ktransformers:007","source":"ingest","sourceId":"ktransformers","title":"Quantized-weight kernels that operate directly on GGUF/quant data (Marlin GPU + llamafile CPU)","text":"KTransformers runs quant kernels (Marlin on GPU, llamafile/CPUInfer on CPU using AVX512-BF16 / AVX-VNNI) directly on quantized weights, avoiding the dequantize-to-BF16 round-trip that HF Transformers pays. Marlin reports ~3.87x over Torch. SZL's fleet already runs q4 GGUF (tower's llama3-szl-finetuned-q4); the lesson is to serve with kernels that consume the quant format natively so the q4 win isn't erased by on-the-fly dequant memory traffic.\n\nApplies to: sovereign-serving.\n\nEvidence: doc/en/deepseek-v2-injection.md (https://raw.githubusercontent.com/kvcache-ai/ktransformers/main/doc/en/deepseek-v2-injection.md)","sha256":"48a90017b9c2641c360d50257ff97b819ec64700a44a32e74dc67d02a0778612"}
{"id":"ingest:ktransformers:008","source":"ingest","sourceId":"ktransformers","title":"Phase-aware kernel switching + MoE fusion + work-stealing (AMX/AVX-512)","text":"On AMX-class CPUs KTransformers rearranges expert weights into 64-byte-aligned tile-friendly blocks (cache-resident in L2/L3), fuses each layer's Gate+Up projections into two unified tasks, and dynamically switches AMX (prefill, >4 tokens/expert) vs a lightweight AVX-512 kernel (decode/short prompts), with atomic task-stealing to absorb expert-activation skew — reaching 21 TFLOPS BF16 / 35 TOPS INT8 on Xeon4. Honest bound for SZL: the tower is a consumer box likely without AMX, so the direct win is the AVX-512 decode path + fusion mindset, not the AMX tiles; revisit tiling only if SZL provisions Sapphire-Rapids+ metal.\n\nApplies to: forge-training.\n\nEvidence: doc/en/AMX.md (https://raw.githubusercontent.com/kvcache-ai/ktransformers/main/doc/en/AMX.md)","sha256":"aba9769f47ddf8ec0f059f2f73650d0bdce6ae7e27d8312ec3755dc4eb5eb960"}
{"id":"ingest:ktransformers:009","source":"ingest","sourceId":"ktransformers","title":"Selective expert activation as an explicit speed/quality knob","text":"KTransformers benchmarks show running fewer routed experts (6 vs the model's default 8) raises DeepSeek-V3 prefill/decode throughput measurably (e.g. up to 286 vs 255 tokens/s prefill in V0.3-preview) at some quality cost. This is a real, honest latency lever — but it changes model behavior, so SZL must surface it as a DECLARED tuning choice with measured throughput deltas, never as a free win. Useful for the forge recipe when a node is throughput-bound.\n\nApplies to: sovereign-serving.\n\nEvidence: doc/en/DeepseekR1_V3_tutorial.md (https://raw.githubusercontent.com/kvcache-ai/ktransformers/main/doc/en/DeepseekR1_V3_tutorial.md)","sha256":"393d0576cdc29ae99d85c4c410213d6ff82c7b0541b2c35d99af1da50c070425"}
{"id":"ingest:zml:000","source":"ingest","sourceId":"zml","title":"Compiler stack, NOT a drop-in for ollama (honest applicability boundary)","text":"ZML is an ahead-of-time compile-to-hardware inference stack (Zig + MLIR/OpenXLA/PJRT, built with Bazel) that decouples models from proprietary hardware — 'Any model, many hardwares, one codebase'. It is NOT a drop-in for SZL's ollama/llama.cpp GGUF fleet: adopting it as a runtime needs a full bazel+Zig toolchain and per-model porting. Honest stance: not applicable as a runtime today; revisit when SZL needs multi-vendor peak-perf serving (e.g. mixing NVIDIA + AMD/Intel nodes) beyond what ollama offers.\n\nApplies to: sovereign-serving.\n\nEvidence: https://raw.githubusercontent.com/zml/zml/master/README.md","sha256":"2362ad05ad3414efd642ceba360fd2e5b5f96641d74a6c9060ad9f24ce60869a"}
{"id":"ingest:zml:001","source":"ingest","sourceId":"zml","title":"PJRT single-enum platform-capability abstraction","text":"One `Platform` enum {cpu, cuda, rocm, tpu, neuron, oneapi, metal} with a single `load(tag)` that dispatches to the matching per-vendor PJRT plugin, plus `isEnabled(tag)`. This is a clean portability contract SZL can mirror in its own node-capability probe: enumerate a node's real backends and dispatch, rather than assuming CUDA everywhere. Adoptable as a design pattern even without adopting ZML's runtime.\n\nApplies to: sovereign-serving.\n\nEvidence: https://raw.githubusercontent.com/zml/zml/master/platforms/platforms.zig","sha256":"7606a2039abc5d92cba16885f66d0eba766125441d00d860d3c09dddc9d2aaf4"}
{"id":"ingest:zml:002","source":"ingest","sourceId":"zml","title":"zml-smi: vendor-neutral accelerator telemetry with Prometheus exposition","text":"A standalone monitor (bin/zml-smi) probes NVML/amdsmi/oneAPI/Neuron/TPU/macOS/Linux and exposes unified `zml_device_*` Prometheus metrics (utilization, memory used/total, power_watts, temperature, fan, clocks, PCIe throughput; per-vendor extensions like Neuron core memory breakdown) via `--prometheus-listen HOST:PORT`, plus TUI/CSV/JSON. Directly transferable technique for SZL fleet observability of the tower (RTX 4060 Ti class): scrape GPU utilization/power/mem/temp into the same honest MEASURED telemetry surfaces.\n\nApplies to: sovereign-serving.\n\nEvidence: https://raw.githubusercontent.com/zml/zml/master/bin/zml-smi/prometheus/exposition.zig","sha256":"954bd6a864bb718dad2fb6a82df0436e782930bf83f554aa3fe4fe89cea4c421"}
{"id":"ingest:zml:003","source":"ingest","sourceId":"zml","title":"Compile-once Executable + weight loading parallelized for cold-start latency","text":"ZML's model lifecycle separates model compilation (struct + forward() → accelerator-specific `Executable`) from weight loading (disk → accelerator `Buffer`), and explicitly notes both are startup bottlenecks that run in parallel via Zig's std.Io. The insight matters for a szl-nemo node: cold-start latency is dominated by compile + weight-load, and overlapping them (or caching the compiled artifact) is the lever — even under ollama, pre-warming/keeping the model resident attacks the same bottleneck.\n\nApplies to: szl-nemo.\n\nEvidence: https://raw.githubusercontent.com/zml/zml/master/docs/learn/concepts.md","sha256":"e34304ab2fa61cdadea4c6473dad90dd01ec22416d96dd069780c264fc6d194b"}
{"id":"ingest:zml:004","source":"ingest","sourceId":"zml","title":"Hermetic cross-compile + distroless OCI single-binary packaging","text":"Bazel cross-compiles from the dev machine to linux_amd64/linux_arm64/macos_arm64 targets and emits either a zstd TAR (scp + run) or a distroless OCI image (rules_oci: oci_image/oci_load/oci_push over @distroless_cc_debian12, forced to linux_amd64 via platform_transition_filegroup), with weights bundled as bazel data deps and an expand_template entrypoint. The reproducible, hermetic, single-binary packaging discipline is worth adopting for SZL deployable artifacts regardless of runtime — no interpreter/venv drift on the target.\n\nApplies to: sovereign-serving.\n\nEvidence: https://raw.githubusercontent.com/zml/zml/master/docs/howtos/dockerize_models.md","sha256":"749f7428afb4dd8a85a812251c306764a51a83409bac50de74f49a358f090df2"}
{"id":"ingest:zml:005","source":"ingest","sourceId":"zml","title":"Layer-wise numerical porting/verification (torch2zml + testLayer)","text":"ZML's model-porting methodology loads safetensors into a TensorStore, builds typed layer structs (zml.nn.Linear etc), and verifies each layer numerically against reference activations dumped from the Python reference using `zml.testing.testLayer` — with an error taxonomy (compile / buffer-not-found naming mismatch / MLIR math error) and the discipline of pruning unused reference code paths first. The per-layer activation-diff verification loop is transferable to SZL's forge recipe when porting or fine-tuning a model, to catch subtle math/quantization regressions before serving.\n\nApplies to: forge-training.\n\nEvidence: https://raw.githubusercontent.com/zml/zml/master/docs/howtos/howto_torch2zml.md","sha256":"33b9fa3a72972c34af8eba43bdee53fc67b3e16de5a74b30ef115e099c16e732"}
{"id":"ingest:zml:006","source":"ingest","sourceId":"zml","title":"Two-layer profiling: host trace scopes + backend XSpace→Perfetto, with external-profiler co-existence","text":"ZML splits profiling into host tracing (`zml.tracer.scope()` emitting NVTX/ROCTx/os_signpost) and backend profiling (`Platform.profiler()` → XSpace protobuf streamed to Perfetto trace.json), and cleanly co-exists with external profilers (nsys/rocprofv3/neuron-profile) by setting SKIP_PJRT_PROFILER=true to avoid double sessions. The pattern — lightweight always-on host scopes plus opt-in deep backend capture, joined only at session end — is a good model for how SZL should instrument its serving loop without paying full-profiler overhead per request.\n\nApplies to: sovereign-serving.\n\nEvidence: https://raw.githubusercontent.com/zml/zml/master/docs/howtos/profiling.md","sha256":"3cec9adf1823f7d780e39446eab8759d080a45ba4d9302b2becc7ef2c808eb24"}
{"id":"ingest:glesmyno:000","source":"ingest","sourceId":"glesmyno","title":"Profile is a synthetic/template repo farm — study-only, adopt nothing as-is","text":"All 57 repos were pushed in a single burst (2026-06-29/30), carry grand buzzword descriptions (multi-cloud orchestration, blockchain, AI), yet the actual code is trivial scaffolding generated from a shared template. ModelRelay's 'framework' is an empty argparse+logging CLI stub whose body is literally '# Add your main logic here'; MetaStack's 'multi-cloud orchestrator' is a client-side to-do list; SignalNexus ships no code at all (LICENSE+README only). For SZL this is a negative finding: there is no substantive engineering here to distill.\n\nApplies to: frontier.\n\nEvidence: https://raw.githubusercontent.com/glesmyno/ModelRelay/HEAD/modelrelay.py","sha256":"e6e5586c7a967e0467cc2d95c581fb7580e7ea336ac816a9c009f12df3084371"}
{"id":"ingest:glesmyno:001","source":"ingest","sourceId":"glesmyno","title":"Description-vs-implementation gap is a reusable spam/synthetic-repo signal","text":"The systematic mismatch between inflated READMEs ('Innovative MetaStack orchestrates multi-cloud deployments with seamless zero-downtime updates') and trivial implementations (an add/remove item list) is exactly the pattern SZL's frontier ingestion and honesty audit should learn to down-rank. A cheap heuristic — README claim entropy vs. real LOC/imports/tests — would keep synthetic portfolios out of MEASURED/REPORTED leaderboards.\n\nApplies to: frontier.\n\nEvidence: https://raw.githubusercontent.com/glesmyno/MetaStack/HEAD/src/components/MetastackContainer.jsx","sha256":"6343076693007e966821eae5afbcbde6234d08abd8808f895af2264a41e5f98e"}
{"id":"ingest:glesmyno:002","source":"ingest","sourceId":"glesmyno","title":"Star counts here are not evidence of substance — weight by real content","text":"Top repos by stars (MetaStack 46, ModelRelay 38, SignalNexus 34) are the same empty scaffolds; SignalNexus has 34 stars and zero source files. 280 total stars across 57 repos with no forks and near-zero issues reads as inorganic. SZL's frontier/leaders ranking should never treat raw stars as a quality proxy without a content/forks/issues cross-check.\n\nApplies to: frontier.\n\nEvidence: https://api.github.com/repos/glesmyno/SignalNexus/git/trees/HEAD?recursive=1","sha256":"1bcde8212410f5bc1bbef058f458f186c129f603da5a30f58e683e7ac821f85d"}
{"id":"ingest:glesmyno:003","source":"ingest","sourceId":"glesmyno","title":"MIT license present — reuse permitted, but nothing worth reusing","text":"Every repo carries an identical 1061-byte MIT LICENSE, so reuse is legally permitted (attribution still required by SZL doctrine). The only mildly reusable artifact is ModelRelay's conventional Python CLI skeleton (argparse + configured logging + type hints), a fine boilerplate for a throwaway forge harness but neither novel nor SZL-specific. Not adopted; noted only for completeness.\n\nApplies to: forge-training.\n\nEvidence: https://raw.githubusercontent.com/glesmyno/ModelRelay/HEAD/LICENSE","sha256":"8ae6665344992798b68dfd7396d3f7ac977dcd63c865e45cbef56d8b1e0d9420"}
{"id":"ingest:yunawyner:000","source":"ingest","sourceId":"yunawyner","title":"Same synthetic template farm as glesmyno — likely the same operator","text":"All 65 repos pushed in one burst (2026-06-29/30), all MIT, all original (no forks). CipherTrace.py ('AI-driven Automated Sanctions Screening') is byte-for-byte the same empty CLI stub as glesmyno/ModelRelay.py down to the '# Add your main logic here' comment and identical logging setup. The identical LICENSE byte-size (1061), README template, and stub code across both accounts indicate a shared generator. Honest conclusion: treat glesmyno + yunawyner as one synthetic cluster, study-only, adopt nothing.\n\nApplies to: frontier.\n\nEvidence: https://raw.githubusercontent.com/yunawyner/CipherTrace/HEAD/ciphertrace.py","sha256":"2437fdc27044910646dc6328e787b09a7a07c8b77d2d916a477122d3b7d91318"}
{"id":"ingest:yunawyner:001","source":"ingest","sourceId":"yunawyner","title":"Cross-account template correlation → a dedup/cluster heuristic for SZL frontier","text":"Because both profiles emit identical stub code and README scaffolding, a content-hash / template-fingerprint check would let SZL's frontier ingestion collapse such clusters and refuse to double-count them as independent 'leaders'. This is a concrete honesty-preserving heuristic worth building into the source registry, not a technique borrowed from the repos themselves.\n\nApplies to: frontier.\n\nEvidence: https://raw.githubusercontent.com/yunawyner/CipherTrace/HEAD/LICENSE","sha256":"c9647bef462e2e7aef731675688096267344f8692bb8b844152fcf26ef99c1e6"}
{"id":"ingest:yunawyner:002","source":"ingest","sourceId":"yunawyner","title":"ProofSignal's retry-with-exponential-backoff is the only genuine (but generic) micro-pattern","text":"ProofSignal.js contains a real, correct retry helper (N attempts, throw on final failure, 1000*(i+1)ms linear backoff). It is generic and unremarkable, but it is the single piece of non-empty logic found across ~120 repos. SZL's sovereign-serving failover already needs bounded-retry-with-backoff when a node's /v1/models probe times out; this merely confirms the shape — SZL should author its own (jittered exponential) version, MIT attribution noted, not copy this one.\n\nApplies to: sovereign-serving.\n\nEvidence: https://raw.githubusercontent.com/yunawyner/ProofSignal/HEAD/src/proofsignal.js","sha256":"c21db63b05fc8bce766cde88b9ae9013395e6ca1c400e48a00a31696bbe4cdf8"}
{"id":"ingest:yunawyner:003","source":"ingest","sourceId":"yunawyner","title":"Inflated compliance/security claims with empty bodies — hard honesty-filter case","text":"CipherTrace claims 'AI-driven Automated Sanctions Screening' and FortiGuard claims an 'Intelligent Threat Defense Gateway', yet both are 1.6KB no-op stubs (FortiGuard's extra 118KB is a committed .Logs file + packed git history, not code). Security/compliance-flavoured claims with zero implementation are exactly what SZL's honesty audit must catch before any such source could touch a MEASURED/REPORTED surface.\n\nApplies to: frontier.\n\nEvidence: https://api.github.com/repos/yunawyner/FortiGuard/git/trees/HEAD?recursive=1","sha256":"c24c90dd172fe4878240d0976e60a54c1d7425c71df16d819279531c52a88406"}
{"id":"ingest:lutar-lean:000","source":"ingest","sourceId":"lutar-lean","title":"The Λ invariant's formal spine lives HERE — Alloy now surfaces it, never re-proves it","text":"lutar-lean defines the Λ aggregator (geometric-mean trust score over provenance/containment/coherence/convergence), the LutarAxioms A1–A5, and kernel-checks the theorems the runtime relies on (bounds, monotonicity, permutation-invariance, hash-chain tamper-evidence, quorum agreement). Its own machine counter reports 1323 declarations / 22 unique axioms / 254 non-comment sorries at the locked v11 baseline, with the locked-proven formula set frozen at exactly 8 {F1,F4,F7,F11,F12,F18,F19,F22} (re-locked 2026-06-10 when F4/F7 gained genuine proofs; enforced by the no-axiom theorem locked_count_eight). Alloy's GET /lean window is a REPORTED pass-through of these numbers plus a MEASURED local kernel check — it never recounts or re-badges the corpus.\n\nApplies to: lean-ledger.\n\nEvidence: https://raw.githubusercontent.com/szl-holdings/lutar-lean/HEAD/.github/data/lean_numbers.json","sha256":"aa4da26555f2ce7e806f9c64a37faa3b444ae87ba305a3ed1531db0cafe7c020"}
{"id":"ingest:lutar-lean:001","source":"ingest","sourceId":"lutar-lean","title":"Conjecture discipline: unconditional Λ uniqueness is machine-checked FALSE and stays Conjecture-1","text":"The repo machine-checks a maxAgg counterexample against UNCONDITIONAL Λ uniqueness; only the CONDITIONAL Theorem U chain ({A1–A5} + separability + slice-multiplicativity + slice-monotonicity) is kernel-clean on its stated hypotheses. A public bounty file is the only process that could ever close it. This is the exact pattern Alloy's doctrine banner enforces: no CI pass, no local kernel-check PASS, no panel can upgrade Conjecture-1.\n\nApplies to: lean-ledger.\n\nEvidence: https://github.com/szl-holdings/lutar-lean/blob/main/BOUNTY.md","sha256":"8ee0a52ef2a0288575124633cc1a2f36eb99c415b48e1e9581f9f5309acd517f"}
{"id":"ingest:lutar-lean:002","source":"ingest","sourceId":"lutar-lean","title":"EXPERIMENTAL_SCOPES: grow the corpus without silently moving locked numbers","text":"Wave branches (Putnam sampler, Wave19–23) register their file scopes under EXPERIMENTAL_SCOPES in lean_numbers.py so new experimental proofs are compiled and kernel-checked by lake build but EXCLUDED from the locked v11 baseline counts. Metrics only move by explicit re-lock, never by drift. Directly applicable to every Alloy MEASURED surface: additive experiments must not silently inflate a locked headline number.\n\nApplies to: frontier.\n\nEvidence: https://raw.githubusercontent.com/szl-holdings/lutar-lean/HEAD/.github/data/lean_numbers.json","sha256":"d02ce59c1541723e2535a82824251ad9d56f4ac46e913bd55406c92c8c51a852"}
{"id":"ingest:lutar-lean:003","source":"ingest","sourceId":"lutar-lean","title":"Split CI verdicts on the same commit are honest data, not noise","text":"At HEAD 85dee499 the repo's own Actions history shows lake-build.yml run 499 FAILED while lean.yml run 757 PASSED on the same sha. The honest rendering is both verdicts side by side, exactly as GitHub returned them — which is what Alloy's LeanLedger CI block does. Cherry-picking the green workflow (or retrying at an older sha until green) would be fabrication by omission.\n\nApplies to: lean-ledger.\n\nEvidence: https://github.com/szl-holdings/lutar-lean/actions/workflows/lake-build.yml","sha256":"db237bb34b7ac9c35a477f38cbdb436690bf6596529c0f7c8641b7dced2d1884"}
{"id":"ingest:lean-kernel:000","source":"ingest","sourceId":"lean-kernel","title":"Verify-for-yourself as a product surface — but pinned to an OLDER doctrine snapshot","text":"lean-kernel ships a Dockerized live Lean v4.13.0 kernel so outsiders can re-run the invariant proofs themselves instead of trusting SZL's word. Crucially it is pinned to Doctrine v11 at 749 declarations / 14 axioms / 163 sorries (kernel commit c7c0ba17) while lutar-lean HEAD reports 1323/22/254 — a real, visible version skew. Any Alloy panel citing corpus numbers must state WHICH snapshot it reports; mixing the two silently would fabricate a corpus that exists nowhere.\n\nApplies to: lean-ledger.\n\nEvidence: https://raw.githubusercontent.com/szl-holdings/lean-kernel/HEAD/README.md","sha256":"d6712734e483a703f5392e591e3671aaf9d05a054ee0c85a4e71e15bf3efb186"}
{"id":"ingest:lean-kernel:001","source":"ingest","sourceId":"lean-kernel","title":"Public errata notes over silent edits (the 2026-06-30 alignment fix)","text":"The README carries a dated correction block stating that a previously referenced HF Space (SZLHOLDINGS/lean-kernel) does not exist and pointing to the real artifact (the SZLHOLDINGS/szl-kernels model card). Correcting a false pointer publicly and datedly — rather than silently rewriting history — is the errata pattern SZL surfaces should follow when a claim is found wrong.\n\nApplies to: frontier.\n\nEvidence: https://raw.githubusercontent.com/szl-holdings/lean-kernel/HEAD/README.md","sha256":"e4a46dc234b026d4aca45cd5ecc0071d5d1e535f1cb297444eb9570bc8fa707e"}
{"id":"ingest:lean-kernel:002","source":"ingest","sourceId":"lean-kernel","title":"Machine-readable declaration inventory as an export contract","text":"data/lean_corpus_decls.json (~283KB) enumerates the corpus declarations as data, letting downstream tools consume the proof inventory without parsing Lean source. If Alloy ever lists individual theorems, this file — not a hand-typed list — is the honest source, fetched and labeled REPORTED with its snapshot provenance.\n\nApplies to: lean-ledger.\n\nEvidence: https://github.com/szl-holdings/lean-kernel/blob/main/data/lean_corpus_decls.json","sha256":"7d9dac6754adb6e26a72209797acb769a42c440b103211e9427efd646483cad2"}
{"id":"ingest:szl-formula-ledger:000","source":"ingest","sourceId":"szl-formula-ledger","title":"Tri-state harness verdicts with CI re-run on every push — receipts against drift","text":"The harness assigns each formula CHECKED (algebra/units machine-verified THIS pass), FAILED (identity is false), or UNCHECKABLE (no honest machine check exists: empirical, definitional, or conjecture) and CI re-runs it on every push so no claim can quietly rot. A pass is never fabricated and never carried over stale. Alloy's FormulaCodex renders this ledger as a REPORTED pass-through; the /lean window now sits beside it as the Lean-kernel counterpart.\n\nApplies to: lean-ledger.\n\nEvidence: https://raw.githubusercontent.com/szl-holdings/szl-formula-ledger/HEAD/README.md","sha256":"4f1a6e583f4b1264ce94778de8a5e2c7159ddbe344c1eae350447a765beff46a"}
{"id":"ingest:szl-formula-ledger:001","source":"ingest","sourceId":"szl-formula-ledger","title":"A pass means EXACTLY what it checked: units-check ≠ uniqueness proof","text":"lambda-score-dimensionless is CHECKED — but the README states outright that this is a UNITS check (the Λ score is dimensionless) and 'not a proof of the uniqueness conjecture'. TH_L1-lambda-uniqueness stays UNCHECKABLE [CONJECTURE] forever in this harness. Scoping every green badge to precisely what was verified is the discipline all Alloy MEASURED captions follow (e.g. a kernel-check PASS = 'these modules at this sha', nothing more).\n\nApplies to: lean-ledger.\n\nEvidence: https://raw.githubusercontent.com/szl-holdings/szl-formula-ledger/HEAD/README.md","sha256":"bda2d0008d7410f6364873586d1e88220949650e216841569bfe4d8029dd9df9"}
{"id":"ingest:szl-formula-ledger:002","source":"ingest","sourceId":"szl-formula-ledger","title":"Banned-claims enforcement at the ledger level","text":"The repo bans perpetual-motion / zero-cost-energy / 'free energy' claims outright per estate G3 doctrine — the ledger will not carry them under any label. A denylist of claim classes that no honest label can launder is a cheap, enforceable guardrail worth mirroring in any SZL surface that accepts new formula entries.\n\nApplies to: frontier.\n\nEvidence: https://raw.githubusercontent.com/szl-holdings/szl-formula-ledger/HEAD/README.md","sha256":"496a3376f37de5c691b412642c2bdfe87fa4c2ecfb63ca8c3046846d0c1f312c"}
{"id":"ingest:szl-lake:000","source":"ingest","sourceId":"szl-lake","title":"szl-lake is the DSSE receipt lake — NOT Lean's `lake` build tool (name collision resolved)","text":"Two unrelated things share the name: Lean 4's build tool `lake` (what `lake build` runs inside lutar-lean and Alloy's local lean-lab) and szl-lake, SZL's data lake of ECDSA P-256 DSSE-signed Khipu receipts on a hash-linked Merkle DAG. The GitHub repo is the front door (README + small JSON indexes + manifest pointers); the HF dataset SZLHOLDINGS/szl-lake is canonical for the NDJSON receipt streams. Anyone can pull a receipt stream and verify signatures end-to-end.\n\nApplies to: frontier.\n\nEvidence: https://raw.githubusercontent.com/szl-holdings/szl-lake/HEAD/README.md","sha256":"1ad1f61ec3371322c99dcf274bbc46f2ec244ecf7f988c0cce51ebc6929783bc"}
{"id":"ingest:szl-lake:001","source":"ingest","sourceId":"szl-lake","title":"Doctrine snapshots are PINNED to a kernel commit, never floating","text":"The lake's doctrine/ directory freezes v11 LOCKED at 749 declarations / 14 axioms / 163 sorries pinned to lutar-lean kernel commit c7c0ba17 — a diligence reviewer verifies against that exact commit, not against whatever HEAD says today. The same pin-to-sha provenance rule governs Alloy's MEASURED kernel-check artifact: it names the sha and toolchain it checked, and a fresher HEAD never silently replaces it.\n\nApplies to: lean-ledger.\n\nEvidence: https://raw.githubusercontent.com/szl-holdings/szl-lake/HEAD/README.md","sha256":"9794c80017746a6dd38e3990becd7b199103e17fd92f1ebd6e2fa331e0ef8d08"}
{"id":"ingest:szl-lake:002","source":"ingest","sourceId":"szl-lake","title":"Attestations that state what is NOT claimed","text":"The attestations/ directory records Section 889 vendor checks, an SLSA L1-honest level record, and a supply-chain self-attestation that explicitly disclaims FedRAMP / Iron Bank / CMMC. Enumerating the certifications you do NOT hold, in the same file as the ones you do, is the strongest form of the honesty doctrine — absence declared, not implied.\n\nApplies to: frontier.\n\nEvidence: https://raw.githubusercontent.com/szl-holdings/szl-lake/HEAD/README.md","sha256":"d4035a991ea153e9e3cf79bd3efb22614d44b9a3bb21625baf0905d7de9a9dfe"}
{"id":"ingest:nvidia-vera:000","source":"ingest","sourceId":"nvidia-vera","title":"The agent loop is sequential — per-step speed compounds, core count doesn't help one loop","text":"The article's central thesis: an agent advances through a chain of dependent steps (model reasons → CPU executes tool/code/data work → result feeds the next model call), so the time of EACH CPU-side step sits on the critical path and adding cores cannot shorten a single loop — only faster per-step execution can. This is directly true of Alloy's own backbone loop: routing, failover bookkeeping, meter sampling, and receipt signing all happen between model windows, serially. SZL's application is to MEASURE that orchestrator share per run (the loop tax) instead of assuming it is negligible.\n\nApplies to: backbone-loop.\n\nEvidence: https://blogs.nvidia.com/blog/nvidia-vera-max-single-threaded-cpu-at-scale/","sha256":"f6d45b6d7e95d2ce5d006ae73c77bba115084496b4a14dfa6a66406a4945626f"}
{"id":"ingest:nvidia-vera:001","source":"ingest","sourceId":"nvidia-vera","title":"Loop tax made MEASURED: Alloy now splits every run into model window vs orchestrator overhead","text":"Applied 2026-07-12: every /run result's loop block now carries modelMs (MEASURED sum of provider-attempt wall windows) and overheadMs (DERIVED: run wall − modelMs — routing, energy-meter samples, trace bookkeeping, any self-verification pass). The split reconciles exactly against the run's MEASURED latencyMs and is never claimed as pure CPU time (attempt windows include network + provider queueing). Demo runs honestly show a zero model window. This is the Vera thesis made our own: don't buy the vendor's numbers — instrument YOUR loop.\n\nApplies to: backbone-loop.\n\nEvidence: GET /api/run result → loop.modelMs / loop.overheadMs / loop.timingBasis","sha256":"f2ed43a909f69d2ee6f79d2f9a13ab8c9a27e26273c63ff013ff795f5dc9c2b0"}
{"id":"ingest:nvidia-vera:002","source":"ingest","sourceId":"nvidia-vera","title":"Idle compute waiting on the loop is the real cost — GPU-utilization economics","text":"NVIDIA frames CPU slowness as an AI-factory revenue problem: every ms the CPU spends between model calls is a ms the expensive accelerator sits idle. Scaled to SZL's two-node fleet the same logic holds — when the tower GPU waits on orchestrator work (or on a dead meter tunnel costing seconds per failover attempt), sovereign serving throughput drops. Alloy already dedupes dead meter hosts per run for exactly this reason; the loop-tax metric now makes any regression of that kind visible as a rising overheadMs instead of an invisible drag.\n\nApplies to: sovereign-serving.\n\nEvidence: https://blogs.nvidia.com/blog/nvidia-vera-max-single-threaded-cpu-at-scale/","sha256":"5c355448def555238d4f2f7bef33eeb159833c7a534c86095bf54abf364519a9"}
{"id":"ingest:nvidia-vera:003","source":"ingest","sourceId":"nvidia-vera","title":"Predictable per-step latency beats aggregate throughput for a single agent","text":"The article's design triad for agentic CPUs — strong per-core performance under load, enough memory bandwidth per core, predictable latency (its 'chiplet tax' critique) — translates for SZL into a scheduling rule, not a hardware purchase: on the consumer-grade sovereign nodes, one long request must not head-of-line-block a concurrent run's loop steps, and shared-resource effects must be labeled (Alloy's energy windows are already declared WHOLE-GPU incl. concurrent load, never attributed solely to one run).\n\nApplies to: sovereign-serving.\n\nEvidence: https://blogs.nvidia.com/blog/nvidia-vera-max-single-threaded-cpu-at-scale/","sha256":"b37ed469f7019a10afbe432123c331cededea1e7482c96c29a942f96cd390b08"}
{"id":"ingest:nvidia-vera:004","source":"ingest","sourceId":"nvidia-vera","title":"Honest boundary: every Vera number stays NVIDIA/partner-REPORTED — SZL owns no Vera silicon","text":"88 Olympus cores, 50% IPC over Grace, 1.2TB/s LPDDR5X under 40W memory power, 3.4TB/s core-to-core on a monolithic die, 1.8x sustained per-core vs x86 — all NVIDIA-REPORTED. Perplexity 1.5x/1.9x, Starburst 3x, Redpanda 6x — partner-REPORTED, methodology unpublished here. None of these are SZL measurements and Alloy never presents them as facts about its own stack; the ONLY numbers Alloy adopts are the ones it measures on its own loop and metal. Rosa/Rigel is a REPORTED roadmap, not availability.\n\nApplies to: honesty-doctrine.\n\nEvidence: https://blogs.nvidia.com/blog/nvidia-vera-max-single-threaded-cpu-at-scale/","sha256":"f507d06831a4f26bcc22123c3332d91eec542dfb197e60b39c0445eb38c33365"}
{"id":"ingest:airllm:000","source":"ingest","sourceId":"airllm","title":"Peak memory = one layer, not the sum — meta-device shell + forward hooks (code-verified)","text":"AirLLM is a memory-management wrapper, not a re-implemented transformer: it builds the model as an empty shell on the meta device (init_empty_weights), then forward pre/post hooks stream each layer's weights disk→GPU right before it runs and evict them back to meta (module.to('meta') + clean_memory) right after. The VRAM ceiling becomes the largest streamed unit instead of the whole checkpoint. For szl-nemo on SZL's small-VRAM metal this is the second wall-breaking thesis alongside KTransformers' intensity-guided offload: the 'you need a datacenter card' wall is an assumption, not a law.\n\nApplies to: szl-nemo.\n\nEvidence: https://raw.githubusercontent.com/lyogavin/airllm/main/air_llm/airllm/airllm_base.py","sha256":"cf28d525e2f3480d43d2022365ae2b404fc294c593ae2d67542a248e294678e6"}
{"id":"ingest:airllm:001","source":"ingest","sourceId":"airllm","title":"Per-layer safetensors shards with .done markers — the disk becomes the model store","text":"split_and_save_layers pre-cuts a checkpoint into one safetensors shard per layer under splitted_model/, each guarded by a .done marker so interrupted splits resume idempotently instead of trusting half-written files. The cost is honest and stated in AirLLM's own FAQ: the split needs LARGE disk headroom. Any SZL layer-streaming recipe (forge, szl-nemo) inherits both halves — cheap idempotent resume via marker files, and a disk requirement that a VRAM-only fit check must never silently ignore.\n\nApplies to: forge-training.\n\nEvidence: https://raw.githubusercontent.com/lyogavin/airllm/main/air_llm/airllm/utils.py","sha256":"6789a3ce9eb30039c8a24774ab958112fe09254a7e78a525bcc5d5933f62e721"}
{"id":"ingest:airllm:002","source":"ingest","sourceId":"airllm","title":"Prefetch overlap hides load latency — and is honestly disabled under compression","text":"A single-worker ThreadPoolExecutor overlaps the NEXT layer's disk read with the CURRENT layer's compute — the overlap is the entire latency trick, and AirLLM turns it off when the 4/8-bit compression path is active (decompression changes the timing). Alloy's loop analogue applied 2026-07-12: the failover chain is strictly sequential (code-verified, Alloy does NOT prefetch), so every run's loop block now reports deadHopMs — the MEASURED-window sum of failed hops before the served one — as the DERIVED upper bound of wall that speculative warming could in principle hide (a counterfactual, never a realized saving; warming dead providers would also bill them).\n\nApplies to: backbone-loop.\n\nEvidence: https://raw.githubusercontent.com/lyogavin/airllm/main/air_llm/airllm/airllm_base.py","sha256":"0dfca687d8df1e5fb098c075f3ffe5ec172dc04350e91dcdbbb9c63eb9e0c632"}
{"id":"ingest:airllm:003","source":"ingest","sourceId":"airllm","title":"Claims audit: 'Flash Attention' is not in the core path; 'no quantization' is default-only","text":"Two popular-retelling claims fail the source audit: (1) the viral article credits Flash Attention, but the package's core inference path contains no AirLLM-authored flash-attn — it requests transformers' attn_implementation='sdpa' (fallback eager), so any kernel efficiency is inherited from PyTorch, and (2) 'runs without quantization' is true only of the DEFAULT: an opt-in compression='4bit'/'8bit' bitsandbytes block-wise quantization path exists whose own docstring concedes a small accuracy loss. Neither invalidates the core mechanism — but an honest retelling states both, which is why SZL's ingest notes carry them.\n\nApplies to: honesty-doctrine.\n\nEvidence: https://raw.githubusercontent.com/lyogavin/airllm/main/air_llm/airllm/airllm_base.py","sha256":"a195747e11752e3073125bf8c85f70a2a62c4288b1567b6b181be4b7baf176a4"}
{"id":"ingest:airllm:004","source":"ingest","sourceId":"airllm","title":"Every VRAM headline stays README-REPORTED — and the speed tradeoff is load-bearing","text":"70B on a single 4GB card, ~1.6GB per layer, DeepSeek-V3 671B in ~12GB (which rides on the checkpoint's native FP8 weights, preserved verbatim) — all AirLLM-REPORTED figures that SZL never restates as its own measurements. The co-equal fact every retelling must carry: each generated token re-streams every layer from disk, so this is offline-batch tooling (document crunching, background analysis) — AirLLM's own framing is that it is not for live chatbots. A 'fits' verdict without the latency caveat would be a lie of omission.\n\nApplies to: honesty-doctrine.\n\nEvidence: https://raw.githubusercontent.com/lyogavin/airllm/main/README.md","sha256":"219cf6c8430bac9ca5d36d35df23960fa24a50a0e2216715538e703de30e2672"}
{"id":"ingest:airllm:005","source":"ingest","sourceId":"airllm","title":"The wall is a door — applied: the Layer-Fit Codex on the sovereign estate","text":"The transferable thesis is the reframe itself: a hardware requirement is a sum-assumption that measurement can turn into a peak-assumption. Applied 2026-07-12: /api/estate/fit computes an AirLLM-style fit estimate for any public HF model against SZL's own nodes — REPORTED safetensors param totals + config.json geometry, DERIVED average-decoder-layer bytes (embed/lm_head excluded per tie_word_embeddings, KV-cache/activations excluded and stated, lower bound not a ceiling), compared against DECLARED owner-stated node VRAM (the szl-meters expose no memory gauge — MEASURED VRAM honestly does not exist today). The verdict is never a plain 'fits': disk headroom is UNKNOWN and the offline-batch caveat rides on every response.\n\nApplies to: sovereign-serving.\n\nEvidence: GET /api/estate/fit → perLayer.estBytes / nodes[].verdict","sha256":"d0a19e1518ffec3206f6f27c79d5c9fb3c7b2c8481ea88adc1ffc5ed2aa2ff3d"}
{"id":"ingest:palantir-security-forge:000","source":"ingest","sourceId":"palantir-security-forge","title":"The thesis: the disclosure-to-exploitation window has collapsed to hours","text":"The page's opening claim (Palantir-REPORTED) is that adversaries now use frontier and open-source models to reason through exploit chains and weaponize newly disclosed CVEs within hours, not weeks, so periodic scanners are structurally too slow. SZL neither confirms nor restates this as measured fact — but the reframe is the honest, checkable part: it is exactly what the public benchmark literature is now measuring (see the field-leaders takeaway), and it motivates why an always-on orchestrator loop beats a batch scan. Adopted as motivation, not as a Palantir statistic.\n\nApplies to: frontier.\n\nEvidence: https://www.palantir.com/security-forge/ (hero — \"The Window Between Disclosure and Exploitation Has Collapsed\")","sha256":"8133495ec91b62ec19372bc73348132baff81138d875c07fe7012b0466d692b1"}
{"id":"ingest:palantir-security-forge:001","source":"ingest","sourceId":"palantir-security-forge","title":"Vulnerability operations = the whole discovery→remediation loop, humans in the lead at every critical decision","text":"Security Forge's framing (REPORTED) is a shift from vulnerability SCANNING to vulnerability OPERATIONS: one connected loop of detect → validate → remediate → deploy/recall → learn, with a human owning every critical decision point rather than fully-autonomous action. This is the same shape as Alloy's own bounded agent loop, which is deliberately gated (owner-only decisions for archiving/licenses/training) and never claims autonomous authority. SZL's application is the discipline, not the product: a security loop must name where the human sits, and Alloy's loop trace already makes each hop and its authority explicit.\n\nApplies to: backbone-loop.\n\nEvidence: https://www.palantir.com/security-forge/ (Detect / Validate / Remediate / Deploy & Recall / Learn)","sha256":"21fdb6608dc086ddebb480e0f583c451d5f6c616885f9f05f4e07525be4134a9"}
{"id":"ingest:palantir-security-forge:002","source":"ingest","sourceId":"palantir-security-forge","title":"Ontology-grounded triage — the defender's context is the asymmetric advantage the attacker lacks","text":"The page's strongest architectural idea (REPORTED): an adversarial model sees only the outside of a system, while a defensive model grounded in the org's own ontology sees pull requests, architecture decisions, ownership metadata, deployment history and service dependencies — so a finding can be triaged for REAL exploitability against full internal context, not scored in the abstract. SZL has no Palantir Ontology and claims none; the transferable principle is that context-of-ownership beats a raw severity number. Alloy's estate alignment cross-check and source registry are a much smaller instance of the same idea — internal context surfaced verbatim, never a fabricated link.\n\nApplies to: frontier.\n\nEvidence: https://www.palantir.com/security-forge/ (\"Context and Control Your Adversaries Don't Have\")","sha256":"159b42722c487488f116d847004186af9550b1c7087cdc65aeca68943097d2f5"}
{"id":"ingest:palantir-security-forge:003","source":"ingest","sourceId":"palantir-security-forge","title":"Model-family-agnostic pipelines — resilience must not be contingent on one provider's roadmap","text":"Security Forge states (REPORTED) its review pipelines are not locked to a single model family, so as adversaries grow more capable the system adapts without depending on one vendor. This is precisely — and independently — Alloy's multi-provider failover thesis: Sovereign GPU → OpenAI → Moonshot → DeepSeek → Qwen → HF → OpenRouter → Gemini, chained so no single provider outage or capability gap breaks the backbone. The convergence is worth noting, but the principle is generic and was already load-bearing in Alloy before this study; nothing is borrowed, it is corroborated.\n\nApplies to: sovereign-serving.\n\nEvidence: https://www.palantir.com/security-forge/ (\"resilience is never contingent on one provider's roadmap\")","sha256":"2a89f284a5bec933e30812889d908059219fbcc06c099ddab1d5c33e98ec814d"}
{"id":"ingest:palantir-security-forge:004","source":"ingest","sourceId":"palantir-security-forge","title":"Compounding memory + full audit trail — the honest boundary on the customer numbers","text":"Two more REPORTED ideas map onto SZL surfaces: 'compounding security memory' (every finding, false positive and fix feeds back so the next line of code is more secure) is the flywheel pattern, and 'every agent log, severity score and remediation step captured … full audit trail and complete chain of reasoning' is exactly what Alloy's ed25519-notarized, hash-chained receipt ledger already provides. The boundary held: the Accenture '700,000-person enterprise' and 'closes in a single automated loop' outcomes are Palantir/Accenture marketing claims — never SZL measurements, and SZL runs no AIP, Ontology or Apollo.\n\nApplies to: honesty-doctrine.\n\nEvidence: https://www.palantir.com/security-forge/ (\"Compounding Security Memory\"; \"In Production at Accenture\")","sha256":"08f301392cf81efab8fbaf65cae9bc1745e81de33431ab34903ac4afe737fce5"}
{"id":"ingest:lumbra:000","source":"ingest","sourceId":"lumbra","title":"The orchestration layer is the durable investment — models are interchangeable","text":"Lumbra's central conviction (REPORTED): 'Models are interchangeable. The orchestration layer is the durable investment.' The layer, not any one model, captures institutional knowledge, enforces evaluation at every junction and maintains provenance from intent to insight. This is the same bet Alloy makes: Alloy IS an orchestration backbone that treats each provider as a swappable target behind a stable routing/receipt/honesty contract. Convergent design, arrived at independently — corroboration that the durable value lives in the loop, not the weights.\n\nApplies to: backbone-loop.\n\nEvidence: https://lumbra.ai/technology (\"Models are interchangeable. The orchestration layer is the durable investment.\")","sha256":"043bc7d0205a35021b2d1a9cc96bc9b49b57ff93a374bda4f0563332cc57995b"}
{"id":"ingest:lumbra:001","source":"ingest","sourceId":"lumbra","title":"Eval-first: define what good looks like BEFORE deploy; validate in-line, not post-hoc — gap CLOSED 2026-07-12: graded rubric BUILT","text":"Lumbra's first engineering principle (REPORTED): 'Evaluation is the first thing we build, the last thing we ship, and runs continuously in between' — every model integration starts with the rubric, not the prompt, and in-line validation aims to catch hallucination, drift and confidence-collapse before a human sees the output. Alloy's honest analogue was the self-verification second pass plus the live honesty audit — evaluation at the junction, not after the fact. The gap this study originally recorded (junction-check is honesty-LABELING, not yet a graded pass/fail rubric with a defined 'good' threshold) was CLOSED 2026-07-12: the SAME single bounded self-verify pass now also grades the output against a DECLARED fixed rubric (goal-addressed / internally-consistent / no-unsupported-claims, threshold 'PASS iff every criterion is PASS'), surfaced on the run result and in the Run Console. Honesty holds: every verdict is model-REPORTED self-grading by the same model class — never external ground truth, a PASS is never proof of correctness; an unparseable grade is verdict UNPARSEABLE (never coerced to a pass — live-verified: a 3B sovereign model returned UNPARSEABLE and it was shown as exactly that); the rubric attaches only to a real SELF-CHECKED pass, never to demo output, and the verify pass still never inflates the loop iteration count.\n\nApplies to: honesty-doctrine.\n\nEvidence: https://lumbra.ai/technology (Engineering Principles — \"01 Eval-first\") ; Alloy backbone.ts runSelfVerification() rubric + VerificationRubric schema + RunConsole rubric chips (live, built 2026-07-12)","sha256":"c1f5a4a7afb539a549bed94fc5efc5035910ee29602782a902984ee337873ebb"}
{"id":"ingest:lumbra:002","source":"ingest","sourceId":"lumbra","title":"Provenance: every conclusion has receipts — full lineage through every gate","text":"Lumbra: 'Nothing in the system exists without lineage. Every output traces back through every reasoning step, every source, every evaluation gate it passed through. When the analyst asks why, the system shows its work.' (REPORTED.) This is, almost verbatim, the promise Alloy already ships: every /run carries an ed25519-signed receipt over sha256 hashes plus the full routing trail and servedNode, hash-chained in Postgres and re-verifiable in-browser via WebCrypto. SZL does not need to adopt anything here — it is the strongest external confirmation that receipt-backed provenance is the right spine. Noted as convergence, nothing copied.\n\nApplies to: honesty-doctrine.\n\nEvidence: https://lumbra.ai/technology (Engineering Principles — \"02 Provenance / Every conclusion has receipts\")","sha256":"c62bca3d26235f827da92ae21a46eba505d8bb1e682c42bf9dc285fddb6a5820"}
{"id":"ingest:lumbra:003","source":"ingest","sourceId":"lumbra","title":"Knowledge capture as durable operational rubrics — SZL's honest, narrower instance","text":"Lumbra markets capturing expert reasoning as 'living orchestration' so institutional knowledge outlives the expert — expertise encoded as operational rubrics, not tribal wisdom (REPORTED). SZL claims nothing about capturing human-expert reasoning; but the machine-checkable knowledge SZL DOES encode durably — the Lean proof ledger, the sympy formula ledger, and this very ingest codex — is a narrower, honest form of the same idea: knowledge that survives as re-runnable artifacts rather than lore. Applied as a framing for why the ledgers matter, with the scope difference stated plainly.\n\nApplies to: frontier.\n\nEvidence: https://lumbra.ai/mission (\"An operating system that captures expert reasoning as living orchestration.\")","sha256":"5d791b345ac8d67f505fb16d463f74dd46374ce846663ec41c8903249ba47de3"}
{"id":"ingest:lumbra:004","source":"ingest","sourceId":"lumbra","title":"Fashion thinking: Lumbra's visual language studied as INSPIRATION — Alloy stays itself","text":"The owner likes Lumbra's front-end, so its design language was studied (not copied): a dark high-contrast canvas, a geometric-sans + monospace pairing, hard 0px corners over rounded cards, oversized editorial headlines, and — most relevant — receipts / pass-fail / 'the machines explain themselves or they don't ship' elevated to first-class UI motifs. The honest application is to lean INTO what Alloy already is: its receipt chain, honesty labels and pass/fail verdicts are exactly the 'show its work' aesthetic Lumbra sells, so the design lesson is to make those existing truth-surfaces more prominent — NOT to repaint Alloy in Lumbra's amber (#F5C94A) or ship its fonts/logo/copy. Alloy keeps its #3af4c8 identity; zero Lumbra assets are used.\n\nApplies to: frontend.\n\nEvidence: extractBranding(lumbra.ai) → dark scheme, Space Grotesk + Geist Mono, #F5C94A accent, 0px radius (studied, not adopted)","sha256":"996dfed7c9335fa6b161f6ef1d5cd1ae69e0579bcdcf190c85b7406bab38f4a8"}
{"id":"ingest:lumbra:005","source":"ingest","sourceId":"lumbra","title":"Honest boundary + the REAL field leaders: the checkable frontier is public, not marketing","text":"Lumbra's 'production IC/DoD deployments' and the Bloomberg '$338B market' are Lumbra/press-REPORTED and unverifiable by SZL, so they are recorded as claims, never facts. The genuinely checkable frontier of agentic security — the publications and repos SZL actually tracks — is public and evidence-backed: arXiv benchmarks CVE-Bench (2503.17332, exploiting real web-app CVEs), SEC-bench (2506.11791, NeurIPS 2025), PatchEval (2511.11019) and ExploitBench (2605.14153) for autonomous detection→patch→exploit evaluation, plus open frameworks usestrix/strix, vxcontrol/pentagi and SEC-bench/SEC-bench on GitHub. These — not a marketing page — are the leaders a MEASURED/REPORTED surface may cite.\n\nApplies to: frontier.\n\nEvidence: arXiv 2503.17332 · 2506.11791 · 2511.11019 · 2605.14153 ; github.com/usestrix/strix · vxcontrol/pentagi · SEC-bench/SEC-bench","sha256":"31a1761411a3ff8cc73ccc0cbcd8ff5d31d358448ea99dd1f80b760deaaf2992"}
{"id":"ingest:seed-iq:000","source":"ingest","sourceId":"seed-iq","title":"The value is (ρᴸ, Mₜ): a state is never worth more than the record that governs it","text":"Seed IQ's premise (AIX-DECLARED, resting on the REAL no-cloning theorem) is that you cannot copy an unknown quantum state, so the useful object becomes the pair (ρᴸ, Mₜ) — the governed logical state plus the side memory recording how it is interpreted, restored and committed. SZL adopts the SHAPE of this idea, classically and by analogy only: a run's honest value is likewise a pair — its output PLUS the ed25519-signed receipt that records the routing trail, servedNode and commit position. A bare number with no governing record is, in both worlds, not a trustworthy value. This is the honesty doctrine re-stated in a quantum-information vocabulary; nothing here makes Alloy quantum.\n\nApplies to: honesty-doctrine.\n\nEvidence: Wootters & Zurek, Nature 299:802 (1982), DOI 10.1038/299802a0 ; AIX post (ρᴸ, Mₜ formulation)","sha256":"870cc69a1f53f1b47788931302e69b9fdecdcee88bed393b430af1a8e09ad27e"}
{"id":"ingest:seed-iq:001","source":"ingest","sourceId":"seed-iq","title":"Restoration, not copying — recompute the governed value, don't trust a cached copy","text":"Seed IQ replaces amplitude-copying with teleportation-assisted RESTORATION of the governed logical value onto valid execution support, with the source lane preserved (AIX-DECLARED; the teleportation primitive is Bennett et al. 1993, real). The transferable discipline — again classical and by analogy — is exactly how Alloy already treats its receipt chain: /receipts/recent RECOMPUTES the sha256 chain per request and /receipts/checkpoint re-signs per request rather than serving a stored verdict, so trust is re-derived (restored) on read, never assumed from a copy. 'Restore the governed value, don't trust a copy' is a principle Alloy can honestly sharpen without any quantum machinery.\n\nApplies to: backbone-loop.\n\nEvidence: Bennett et al., PRL 70:1895 (1993), DOI 10.1103/PhysRevLett.70.1895 ; Alloy /receipts recompute-per-request","sha256":"f9199105abe02e286aa3a60bcfa3461b88b69341f5d877423fa508021866bfc3"}
{"id":"ingest:seed-iq:002","source":"ingest","sourceId":"seed-iq","title":"Dissipation as a restoring force — failure should damp toward the truth manifold, not leak","text":"Seed IQ's most striking framing (AIX-DECLARED, on the REAL GKLS/Lindblad form ∂ρ/∂t = −i[H,ρ] + Σₖ(LₖρLₖ† − ½{Lₖ†Lₖ,ρ})) is that the Lₖ channels are not passive noise but SCHEDULED restore channels that damp leakage and redrive the register toward the committed logical value — dissipation becomes the correction, a real research line (Diehl 2008; Mirrahimi 2014). SZL keeps this strictly as a design METAPHOR, labelled as such: Alloy's honesty machinery already behaves like restore channels — a failed upstream damps to UNAVAILABLE instead of leaking a fabricated number, and the self-verification second pass pulls a run's reported shape back toward what was actually measured. The metaphor is useful; the claim that Alloy is an open quantum system is NOT made.\n\nApplies to: honesty-doctrine.\n\nEvidence: Lindblad, Commun.Math.Phys. 48:119 (1976), DOI 10.1007/BF01608499 ; Mirrahimi et al., arXiv:1312.2017 (2014)","sha256":"e507560f55ac1f9d46af11bc4a89d7809329c07e5c30e8a01550e5ec582e6655"}
{"id":"ingest:seed-iq:003","source":"ingest","sourceId":"seed-iq","title":"Side memory Mₜ = a commit history with admissibility — Alloy already keeps one, classically","text":"Seed IQ's Mₜ records syndrome, branch, frame, restore path, admissibility and commit history so the governed value can be interpreted and re-committed (AIX-DECLARED, grounded in real stabilizer/QEC theory: Gottesman 1997, Knill 2005). Alloy's hash-chained receipt ledger is a classical instance of exactly this bookkeeping: each row carries the prior hash (the chain/commit history), the routing trail (branch/restore path) and a recomputed chainStatus of VERIFIED / PARTIAL / BROKEN / EMPTY (admissibility). The lesson SZL takes is that admissibility must be a first-class, re-derivable field — which Alloy's chainStatus already is — not an afterthought; stated as convergence, nothing borrowed.\n\nApplies to: honesty-doctrine.\n\nEvidence: Gottesman 1997 (stabilizer codes); Knill 2005 ; Alloy receipt chain chainStatus VERIFIED/PARTIAL/BROKEN/EMPTY","sha256":"3bec3fe9962cb2c4c1a3a12160d10fc4b4146c501021f45c0b36a8387ae7a4e6"}
{"id":"ingest:seed-iq:004","source":"ingest","sourceId":"seed-iq","title":"Fashion thinking: take the 'governed value / restore / commit / admissibility' language as design inspiration","text":"The owner asked to take the design thinking wholesale, so Seed IQ's conceptual VISUAL LANGUAGE is studied as inspiration only: a value shown as a governed pair, an explicit restore-path, a commit history, and an admissibility verdict rendered as first-class UI — the same 'the system shows how it holds its own truth' aesthetic Alloy already earns with its receipt chain, honesty labels and pass/fail verdicts. The honest application is to make those EXISTING truth-surfaces more prominent and to borrow the vocabulary (restore / governed value / admissibility) in copy where it clarifies — NOT to imply Alloy is quantum, and NOT to re-use any AIX asset, logo, colour or trademark treatment. Alloy keeps its #3af4c8 identity and its own components.\n\nApplies to: frontend.\n\nEvidence: AIX Seed IQ post (governed value + restore path + commit history + admissibility motif) — studied as inspiration, not adopted","sha256":"8b21f0bc0963fd731db330210bb19af3f6995b42fd6bb1b58cd3b44779135dbe"}
{"id":"ingest:seed-iq:005","source":"ingest","sourceId":"seed-iq","title":"The binding boundary: real physics, DECLARED synthesis, classical Alloy — three labels never blended","text":"This entry exists BECAUSE the honesty doctrine forces the separation. The cited physics is REAL and checkable (DOIs above). The Seed IQ™ runtime that fuses it into governed teleportation-assisted memory — plus AIX's broader claims (a domain-agnostic adaptive multiagent control layer, Active Inference, the patented ΑΩ FoB HMC / Alpha-Omega Field of Belief with Hamiltonian Monte Carlo engine, quantum + data-center deployments) — is AIX-DECLARED: SZL has audited no code, reproduced no result, and measured nothing, so none of it is ever restated as SZL fact. And Alloy itself remains a classical software orchestrator with zero quantum hardware. Every takeaway above is analogy or inspiration held on the SZL side of that line — the ideas sharpen how Alloy talks about and renders its OWN provenance, and change none of its actual mechanism.\n\nApplies to: honesty-doctrine.\n\nEvidence: https://aix.us.com ; zenodo.org/records/20585365 (AIX-authored, unaudited by SZL)","sha256":"c05c766c6ea82cfc1a46bdd53b324faa1c57d902cb82794d99d6fe749ac23c05"}
{"id":"ingest:omnigent:000","source":"ingest","sourceId":"omnigent","title":"Meta-harness / provider-agnostic orchestration — CONVERGENCE with Alloy's router, not adoption","text":"Omnigent's core is a meta-harness: one orchestration layer that swaps or combines whole agent runtimes (Claude Code, Codex, Cursor, OpenCode, Hermes, Pi, custom YAML agents) without rewriting the caller. Alloy already operates the same shape one level down — a provider router (registry.ts) that puts Sovereign GPU nodes, OpenAI, Moonshot, DeepSeek, Qwen, Hugging Face, OpenRouter and Gemini behind one interface with a single failover chain (the sovereign tower→laptop failover and OpenRouter serving are MEASURED live; the key-dependent cloud providers are configured targets, not each independently re-verified here). So this corroborates a decision Alloy already made and runs; it is CONVERGENCE, not something to newly 'adopt'. The honest delta Omnigent points at is generalizing the unit from a model/provider to an entire agent harness — a DECLARED future direction for Alloy, not a claim it exists today.\n\nApplies to: backbone-loop.\n\nEvidence: Omnigent README (meta-harness over Claude Code/Codex/Cursor/OpenCode/Hermes/Pi) ; Alloy registry.ts providerToTargets() failover chain (live)","sha256":"a5dcfb96f2519876367eef30db5dfe6e73b331dbcfca11135aa425df37dfc8c9"}
{"id":"ingest:omnigent:001","source":"ingest","sourceId":"omnigent","title":"A first-class policy engine (approval gates, spend caps, tool allow-lists) — gap FULLY CLOSED 2026-07-12: spend cap + provider allow-list + per-action approval gates all BUILT","text":"Omnigent lets you write policies that pause for human approval before risky actions, cap spend, or restrict which tools an agent can reach, scoped to the whole server, one agent, or a single chat. This study originally recorded the whole cluster as a DECLARED gap. As of 2026-07-12 Alloy has BUILT all three enforceable pieces for real: (1) an enforced rolling-24h spend cap (env A11OY_SPEND_CAP_USD_DAY, enforced over the MEASURED ledger tally of per-run ESTIMATED amounts — a sum of estimates, never billing truth; ledger-down = enforcement honestly SUSPENDED, unset = honestly OPEN); (2) a provider allow-list (env A11OY_PROVIDER_ALLOWLIST, filtering the ENTIRE failover chain, not just the requested head); and (3) per-action human-approval gates (env A11OY_APPROVAL_MODE=required): every /run and /run/stream call must spend a single-use, short-TTL approval ticket minted by the run-key holder via POST /policy/approvals — one mint is one explicit human approval for one action; unset = honestly OPEN (stated, never silently waved through), required-without-a-run-key = honestly MISCONFIGURED (tickets unmintable, runs refused with that exact reason). All three gate BEFORE any provider call; denied requests are never ledger rows (nothing ran). E2E-verified live 2026-07-12: 403 without ticket, 401 on wrong mint key, mint → run → same ticket refused as spent, MISCONFIGURED refusals verbatim.\n\nApplies to: backbone-loop.\n\nEvidence: Omnigent README §'Govern your agents with policies' ; Alloy policy.ts gateRun()/evaluatePolicy() + approvals.ts single-use ticket store + POST /policy/approvals + runLedger.ts getSpendWindow() + GET /policy (live; caps/allow-list built 2026-07-12, approval gates built + E2E-verified 2026-07-12)","sha256":"dc0c9c9a9147cd711ae1f8ccfb5e62a775894c7536fc6cef1ef4b35670eedba7"}
{"id":"ingest:omnigent:002","source":"ingest","sourceId":"omnigent","title":"Governed-execution + accountability as first-class — CONVERGENCE with Alloy's receipts","text":"Omnigent treats governance and supervision of agents (watch live, pause, review one agent's work with another) as a primary product surface, not an afterthought. Alloy independently reached the adjacent conviction that a run must be ACCOUNTABLE: every run is notarized with an ed25519-signed, hash-chained receipt whose chain is recomputed and re-verified per request, with client-side WebCrypto verification. Both designs say 'the machine must be able to prove what it did'. This is recorded as convergence — Alloy's receipt chain predates and is unchanged by the study — not as an Omnigent feature imported.\n\nApplies to: honesty-doctrine.\n\nEvidence: Omnigent README (supervise/govern/collaborate) ; Alloy receipts.ts ed25519 chain + ReceiptChain.tsx client verify (live)","sha256":"8dc87dd2a1669442db65cd0950f5a2ffc5160d53b1f416f01b55d0f1e650652b"}
{"id":"ingest:omnigent:003","source":"ingest","sourceId":"omnigent","title":"OS + cloud sandboxing for agent isolation — studied, LIMITED applicability to Alloy","text":"Omnigent wraps each agent terminal in an OS sandbox (Linux bwrap, macOS seatbelt) with an L7 egress proxy, and can run sessions in disposable cloud sandboxes (Modal, Daytona, E2B, CoreWeave, Kubernetes, Databricks, etc.). This is essential for Omnigent because it executes arbitrary agent-authored code. Alloy's threat surface is narrower — it orchestrates bounded model/inference calls, not arbitrary shell — so full OS-sandboxing is only partially applicable. The honest, transferable lesson is the L7 egress-governance idea for any future tool-execution path Alloy adds; recorded as studied with its scope limit stated, not as a capability Alloy needs or has.\n\nApplies to: sovereign-serving.\n\nEvidence: Omnigent README (bwrap/seatbelt, L7 egress proxy, Modal/Daytona/E2B/CoreWeave/K8s/Databricks sandboxes)","sha256":"574d73fd428f829ae9bd40976b83733b620c031670853dfcabc9e0ff8754ad57"}
{"id":"ingest:omnigent:004","source":"ingest","sourceId":"omnigent","title":"Honest boundary: alpha status, REPORTED adoption, zero code borrowed","text":"Omnigent is Apache-2.0 and self-describes as ALPHA. Its capability and adoption claims (device-portable sessions, multi-harness supervision, managed hosts) are Omnigent-REPORTED; SZL has verified none of them by running the software. The one live figure in this row is its GitHub metadata (stars, last-push, license SPDX) fetched by the ingest route's REPORTED fan-out — GitHub's own numbers passed through and labelled REPORTED (never MEASURED, which is reserved for Alloy's own measurements), honestly UNAVAILABLE if the fetch fails, never invented. Alloy remains its own TypeScript codebase with its own #3af4c8 identity; no Omnigent code, logo, colour or asset is re-used, and every convergence above is corroboration of Alloy's existing design, not adoption of Omnigent's.\n\nApplies to: honesty-doctrine.\n\nEvidence: github.com/omnigent-ai/omnigent (Apache-2.0, status alpha) — live REPORTED meta in this row's GitHub block","sha256":"cd35fe7d43fd6f406b6311b9ced6afedf0d25e66a2b510ac81bf896ea512a5c5"}
{"id":"ingest:neuro-jepa:000","source":"ingest","sourceId":"neuro-jepa","title":"Latent-space verification, operationalized: hash/signature-space coverage on the Ouroboros invariants panel","text":"The JEPA family's defining move is to work in a compact DERIVED space rather than the raw object — Neuro-JEPA predicts the latent representations of masked regions from visible context (never voxel reconstruction). Alloy's honest ANALOGY is that it already establishes trust in a derived space too: every run is notarized with an ed25519 signature over sha256 canonical bytes — the plaintext is NEVER in the receipt. This study made that analogy OPERATIONAL: GET /invariants now emits a MEASURED latentVerification coverage ratio (verified / enumerated ledger rows verifiable purely in hash+signature space), with honest complements rotated (signed under a rotated key) and unsigned (rows predating signing) and a falsifiable tamperFailed count, rendered on the OuroborosInvariants panel. CRITICAL label boundary: Alloy's 'latent space' is a CRYPTOGRAPHIC DIGEST + SIGNATURE, NOT a learned embedding — nothing here is trained, predicted, or a model, and it does not prove or upgrade Λ (Conjecture-1). It is a coverage metric, deliberately NOT a HOLDS/VIOLATED invariant, so it does not pretend to be a falsifiable predicate it is not.\n\nApplies to: honesty-doctrine.\n\nEvidence: arXiv:2606.14957 §Methods (JEPA latent-predictive objective, EMA target encoder) ; Alloy invariants.ts latentVerification block + OuroborosInvariants.tsx (live MEASURED coverage)","sha256":"2da04ff7e67c0a9daf7c63c5ada182201d5baac2f697307efb66b50845f237a2"}
{"id":"ingest:neuro-jepa:001","source":"ingest","sourceId":"neuro-jepa","title":"Non-generative, recompute-on-read stance — CONVERGENCE with Alloy's receipts, not adoption","text":"Neuro-JEPA is deliberately NON-GENERATIVE: it learns by predicting representations, and the paper reports (paper-REPORTED) it beats reconstruction-based MAE under equivalent settings. Alloy independently reached an adjacent conviction — it does not cache or fabricate a stored verdict; the receipt chain and every invariant are RECOMPUTED per request over the enumerated tail, and chainStatus is re-derived, never served from a frozen 'proof'. Both designs prefer deriving-on-demand over storing-a-generated-artifact. Recorded as CONVERGENCE: Alloy's recompute-per-request receipt chain predates and is unchanged by this study.\n\nApplies to: backbone-loop.\n\nEvidence: arXiv:2606.14957 §Methods (latent prediction chosen over MAE reconstruction, paper-REPORTED) ; Alloy receipts.ts + invariants.ts (recomputed per request)","sha256":"21b9a5de99c00c7d927ffc4ab999defbf9285102ea24c2bf6e3961bcdadd7711"}
{"id":"ingest:neuro-jepa:002","source":"ingest","sourceId":"neuro-jepa","title":"Sparse Mixture-of-Experts routing — ANALOGY to the provider router + failover chain","text":"Neuro-JEPA's backbone routes each token through a sparse MoE (paper-REPORTED: 2 shared + 16 experts, 6 activated per pass, on alternating layers, with auxiliary-loss-free bias-update load balancing to stop collapse onto a few experts). This is thematically ANALOGOUS to Alloy's orchestrator dispatching each run to a subset of specialist providers (Sovereign GPU nodes, OpenAI, Moonshot, DeepSeek, Qwen, Hugging Face, OpenRouter, Gemini) with a failover chain that spreads load and avoids single-provider collapse. ANALOGY ONLY — Alloy shares no MoE implementation, no gating network, and no learned routing; its routing is declared-config + failover, not a trained router.\n\nApplies to: backbone-loop.\n\nEvidence: arXiv:2606.14957 §Methods (MoE 2 shared + 16 experts, 6 active, bias-update load balancing, paper-REPORTED) ; Alloy registry.ts providerToTargets() failover","sha256":"142bccc2038c72e178c83ba3470354af266b6921b582f03c2b9bcfe3057d788f"}
{"id":"ingest:neuro-jepa:003","source":"ingest","sourceId":"neuro-jepa","title":"DECLARED gaps: representation training and world-model planning — Alloy trains NO models","text":"Neuro-JEPA is a trained foundation model with an online encoder + momentum (EMA) target encoder, pretrained on 1,551,862 scans (paper-REPORTED). Alloy trains NOTHING — it orchestrates bounded calls to already-trained providers and its sovereign flywheel only COLLECTS its own verified own-metal serves as future training samples; it runs no pretraining, no EMA target, no representation-learning objective. So representation learning and JEPA-style world-model/planning are honestly-named DECLARED gaps, not capabilities Alloy has. It would be dishonest to imply Alloy learns latents; it does not, and this takeaway says so.\n\nApplies to: forge-training.\n\nEvidence: arXiv:2606.14957 §Pretraining (online + EMA target encoders, 1.55M scans, paper-REPORTED) ; Alloy has no training loop — flywheel.ts only counts verified own-metal serves","sha256":"434863d0dbceb7b2b74740aaf1fafe614b23166cf939fd4aecd7afe303eac3ea"}
{"id":"ingest:neuro-jepa:004","source":"ingest","sourceId":"neuro-jepa","title":"Honest boundary: split license, paper-REPORTED metrics, zero weights/assets borrowed","text":"The code is MIT (reusable with attribution + review of upstream V-JEPA 2 terms) but the WEIGHTS are CC-BY-NC-ND-4.0 — non-commercial, no-derivatives, non-clinical, gated (the HF README returns 401 without institutional-email approval), so they cannot be adopted, redistributed, or built upon; GitHub reports SPDX NOASSERTION precisely because of this split. Every performance figure (average AUROC/AUPRC gains, few-shot deltas, brain-age R²/MAE) is the authors' paper-REPORTED claim and is never restated as an SZL measurement. No weights were downloaded, no figures/GIFs from their assets/ folder are re-used, and Alloy keeps its own #3af4c8 identity and TypeScript codebase. The arXiv id 2606.14957 and its 2026 dates are recorded verbatim as published, not corrected.\n\nApplies to: honesty-doctrine.\n\nEvidence: github.com/NYUMedML/Neuro-JEPA LICENSE (MIT code) ; huggingface.co/NYUMedML/Neuro-JEPA (weights cc-by-nc-nd-4.0, gated:manual, card 401) ; arXiv:2606.14957 (CC BY 4.0 paper)","sha256":"f46e6248a20f7d6ef24c5f989ce7465195b727a83278f7b75957a846951d1d05"}
{"id":"ingest:compute-pillars:000","source":"ingest","sourceId":"compute-pillars","title":"The substrate taxonomy, applied only as far as honesty reaches: the fleet substrate ledger","text":"The piece's usable kernel is a vocabulary: modern serving runs on distinct silicon classes (CPU/GPU/LPU/NPU). Alloy now applies that taxonomy to its OWN fleet exactly as far as evidence exists — every provider on GET /backbone/status carries a substrate field with a verbatim basis. Own metal is the ONLY substrate Alloy can claim: 'GPU', labelled DERIVED, because the szl-meter exporters sample NVML energy counters on the serving nodes and NVML exists only on NVIDIA GPUs (class evidence from MEASURED samples — never a die/SKU claim). Every cloud provider is honestly UNKNOWN: serving silicon is unobservable through an OpenAI-compatible API, so it is never guessed — Google's TPU marketing stays Google-REPORTED, OpenRouter's per-request vendor roulette is doubly unobservable, and the ProviderFleet panel renders the ledger with the basis on hover.\n\nApplies to: backbone-loop.\n\nEvidence: Alloy registry.ts providers[] substrate/substrateLabel/substrateBasis + ProviderFleet.tsx substrate row (live) ; szl-meter NVML sampling (energy.ts, MEASURED)","sha256":"887af6f26cda40e243e5741338af5ed8a5e809779e8e4ec3a25b158a4ffa3df1"}
{"id":"ingest:compute-pillars:001","source":"ingest","sourceId":"compute-pillars","title":"The 'ecosystem of specialists' conclusion — CONVERGENCE with the router, one layer up","text":"The piece concludes the future is 'an ecosystem where specialized, AI-native processors handle what they do best' rather than one chip to rule them all. Alloy independently embodies the same shape one layer UP the stack: a multi-provider router that dispatches each run across a heterogeneous fleet (own GPU metal first, then seven cloud vendors) with a failover chain, letting each configured provider serve what it serves best. Recorded as CONVERGENCE at the orchestration layer, not adoption — Alloy's router predates this paste and orchestrates PROVIDERS, not silicon; it schedules nothing onto a CPU/GPU/LPU/NPU itself.\n\nApplies to: backbone-loop.\n\nEvidence: Alloy registry.ts providerToTargets() failover chain (live, predates this study) ; paste §'The Big Shift: Specialized Computing'","sha256":"705ccd4ccd2b21f9f37770edcac11e8a515d3ea5bfd7f4b00c577d1319f582bc"}
{"id":"ingest:compute-pillars:002","source":"ingest","sourceId":"compute-pillars","title":"LPU and NPU: honestly absent from the fleet","text":"No Groq-style LPU and no on-device NPU serves an Alloy run, and none is claimed — the ProviderFleet caption states this outright. The piece's LPU performance framing ('ChatGPT-like speeds instantly', 'drastically reducing latency and maximizing token throughput') cites no benchmark and is the author's restatement of vendor-adjacent marketing — author-REPORTED, never an SZL measurement. If a cloud vendor behind one of Alloy's providers happens to serve on an LPU or ASIC, Alloy cannot see it, so its substrate stays UNKNOWN rather than becoming a borrowed marketing claim.\n\nApplies to: sovereign-serving.\n\nEvidence: ProviderFleet.tsx caption (no LPU/NPU claimed) ; paste §3 (LPU claims, no benchmark cited)","sha256":"89f7251991a30e973c011c5712b9b98f607f7e4c766351e30af3e110e7a03afc"}
{"id":"ingest:compute-pillars:003","source":"ingest","sourceId":"compute-pillars","title":"Honest boundary: an unattributed paste is a viewpoint, not a source","text":"This entry exists partly to record HOW unattributed content is ingested under the honesty doctrine: authorship, publication, and license are UNKNOWN and stated verbatim; the checkable kernel (the four silicon classes exist as real product categories) is separated from the editorial framing (the analogies, the evolution arrow, the 'officially dead' and 'burning your budget' claims — the latter unfalsifiable as stated); no claim is upgraded by ingestion. The entry renders with no source link because none exists — a deliberate honest non-link, never a fabricated href. Nothing in this study changes any Alloy mechanism; it adds vocabulary and one new honest surface (the substrate ledger).\n\nApplies to: honesty-doctrine.","sha256":"e1c2efe1d15e34e45b8fef49f49b95f5524af986cda537c84edf625764d445d5"}
{"id":"ingest:perplexity-brain:000","source":"ingest","sourceId":"perplexity-brain","title":"The reframe: work-memory (what the AGENT did) is a distinct, more useful axis than user-profile memory","text":"Brain's central thesis (REPORTED): AI memory has two axes — what it is ABOUT and what it is FOR. Traditional memory is about the user (preferences/contacts) and for engagement; Brain remembers what the AGENT did — what worked, what failed, what corrections were made — and is FOR getting better at the job. This is the load-bearing, checkable idea. For SZL it is CONVERGENCE, not adoption: Alloy's run ledger already records every run's route, outcome, and failure — it is a work-memory store by construction, with no user-profile memory anywhere. Brain names the axis Alloy was already on.\n\nApplies to: backbone-loop.\n\nEvidence: https://www.perplexity.ai/hub/blog/self-improving-memory-for-agents (\"Brain remembers what the agent did … the most important purpose of memory\")","sha256":"aa9b0f826c6a32766c5f4690841b6a6e98706f1a64d65533a924b6fe4b6f7aa5"}
{"id":"ingest:perplexity-brain:001","source":"ingest","sourceId":"perplexity-brain","title":"Provenance on every memory entry — Alloy's receipts are the stronger form (CONVERGENCE)","text":"Brain (REPORTED) 'shows its work': every memory entry links back to the session, file, or source it came from. This is exactly Alloy's receipt spine — but Alloy's is cryptographically stronger: every /run carries an ed25519 signature over sha256 hashes, hash-chained in Postgres and re-verifiable in-browser via WebCrypto, not just a hyperlink. SZL adopts nothing here; it is the strongest external confirmation that provenance-per-entry is the right design. Noted as convergence, nothing copied.\n\nApplies to: honesty-doctrine.\n\nEvidence: https://www.perplexity.ai/hub/blog/self-improving-memory-for-agents (\"Every memory entry links back to the session, file, or source that it came from\")","sha256":"468d19231133b286bcfb17ee4c163b89c9b27e0f6f5af7afd9a59f6b8992ba15"}
{"id":"ingest:perplexity-brain:002","source":"ingest","sourceId":"perplexity-brain","title":"Overnight synthesis pass into an auto-loaded LLM wiki — this is the GENUINE GAP for SZL","text":"Brain (REPORTED) builds a context graph that takes the form of an 'LLM wiki automatically loaded onto the agent sandbox', 'incrementally updated overnight as it synthesizes the user's sessions, connector results, source changes, and corrections'. SZL already has the wiki artifact (.agents/memory/*.md, hand-maintained) — what is genuinely NEW and worth building is the SCHEDULED SYNTHESIS PASS that reads the run ledger and proposes distilled notes. The open-source field proves it is buildable (A-MEM note-evolution, Generative-Agents reflection, OpenAI 'Dreaming'); Brain is the productized packaging. SZL's version must stay honest: a synthesis pass PROPOSES, provenance-linked, never silently overwrites, and claims no % gain it did not measure.\n\nApplies to: backbone-loop.\n\nEvidence: https://www.perplexity.ai/hub/blog/self-improving-memory-for-agents (\"an LLM wiki that's automatically loaded … incrementally updated by the Brain system overnight\")","sha256":"4647aaef4e20bc2dbce2bc185b055a3010919083b42eb15c5eca9a04744c2e1b"}
{"id":"ingest:perplexity-brain:003","source":"ingest","sourceId":"perplexity-brain","title":"Learn from mistakes and corrections → fewer turns — maps to Alloy's failure ledger + self-verify","text":"Brain (REPORTED): agents 'learn from their mistakes, remembering when a user made a correction or when a source was a dead end … fewer turns, fewer model calls, better outputs.' Alloy already stores every FAILURE in the ledger (not just successes) and runs a graded self-verification pass (PASS/UNPARSEABLE, model-REPORTED self-grading, never external ground truth). The GAP: Alloy does not yet turn a failed/low-grade run into a written, retrievable 'lesson' that conditions the next similar attempt (the Reflexion pattern). Adopting this stays honest only if the lesson is labeled model-generated CONJECTURE, provenance-linked to the failing run, never a claimed fact.\n\nApplies to: backbone-loop.\n\nEvidence: https://www.perplexity.ai/hub/blog/self-improving-memory-for-agents (\"They also learn from their mistakes … fewer turns, fewer model calls\")","sha256":"93a659a92297a7f930fed1109921c4961024e372224876b1b62f1cc839639601"}
{"id":"ingest:perplexity-brain:004","source":"ingest","sourceId":"perplexity-brain","title":"Honest boundary: every Brain number stays Perplexity-REPORTED, scoped, and unaudited","text":"The three headline figures are Perplexity's own 'early measurement results', with their scoping caveats that MUST ride with them: +25% correctness applies only to 'tasks Computer has seen before', −13% cost only to 'tasks that require historical context', +16% recall unscoped. No methodology, task set, sample size, or baseline is published; Brain is a closed product SZL cannot inspect. SZL restates none of these as its own results and seeds no Alloy headline with them. The ONLY numbers Alloy ever adopts are the ones it measures on its own loop and metal. 'Recursive self-improvement' and 'proactive AI that flags problems before anyone notices' are aspirational marketing, recorded as claims, never facts.\n\nApplies to: honesty-doctrine.\n\nEvidence: https://www.perplexity.ai/hub/blog/self-improving-memory-for-agents (\"Early measurement results show … increases answer correctness by 25% on tasks Computer has seen before\")","sha256":"e39b3fe1fc4f0b0aee6ab1e6ce834b6d9fe67c7959b59962f4fff26e4e290e79"}
{"id":"ingest:zep-graphiti:000","source":"ingest","sourceId":"zep-graphiti","title":"Bi-temporal memory: never overwrite a fact — invalidate it with a valid-time window + provenance","text":"Graphiti's load-bearing idea (code + paper): every edge/fact carries BOTH event time and ingestion time, and when a fact changes it is not deleted but INVALIDATED (valid-from / valid-to set), so the graph answers 'what did we believe, and when' while keeping a provenance link to the source. This is the field's strongest provenance-preserving memory design and a structural cousin of Alloy's append-only, hash-chained receipt ledger (CONVERGENCE — Alloy never overwrites a run either). The transferable PATTERN for a future SZL memory-synthesis pass: correcting a memory adds an invalidation with valid-time, never a silent overwrite — honesty-preserving by construction.\n\nApplies to: honesty-doctrine.\n\nEvidence: https://github.com/getzep/graphiti ; https://arxiv.org/abs/2501.13956","sha256":"2263672e6a9814731121d1247569ebf314ade20033ad047941c634abfe987635"}
{"id":"ingest:zep-graphiti:001","source":"ingest","sourceId":"zep-graphiti","title":"Incremental, hybrid retrieval over a temporal graph — no batch recompute","text":"Graphiti updates the graph incrementally per episode (no full re-embedding) and retrieves via hybrid semantic + keyword (BM25) + graph traversal, purpose-built for evolving real-world data rather than a static document store. For SZL this is an ANALOGY, not an adoption: Alloy's ledger is time-ordered Postgres, and any future memory-retrieval lane should combine relevance with recency rather than pure vector similarity — but SZL would build its own honest, MEASURED implementation, not vendor a graph DB it cannot operate on its two-node fleet.\n\nApplies to: backbone-loop.\n\nEvidence: https://neo4j.com/blog/developer/graphiti-knowledge-graph-memory/","sha256":"38752c98389a589bd30084f43331ec5403a867aa143a8d2231047854c34503be"}
{"id":"ingest:mem0:000","source":"ingest","sourceId":"mem0","title":"Consolidation write-path: extract salient facts, then decide add/update/merge/delete/noop — not append-only","text":"Mem0's load-bearing mechanism: rather than appending raw turns, an LLM extracts salient facts and RECONCILES them against existing memory with an explicit add / update / delete / noop decision, so contradictions are resolved instead of accumulated. This is the exact shape a future SZL overnight synthesis pass needs over the run ledger — BUT SZL's honesty doctrine forbids the silent 'delete/overwrite' branch: SZL's reconciliation must PROPOSE changes with provenance to the runs that motivated them (Zep-style invalidation), never silently rewrite history. Adopted as a PATTERN with a doctrine guardrail, not as code.\n\nApplies to: backbone-loop.\n\nEvidence: https://github.com/mem0ai/mem0 ; https://arxiv.org/abs/2504.19413","sha256":"20dde713fc25f55707dc37978b1c699f9cff8722844d6c52e808a0ae80601ff4"}
{"id":"ingest:mem0:001","source":"ingest","sourceId":"mem0","title":"Memory as a standalone service any framework calls — plus an honesty boundary on the benchmark numbers","text":"Mem0 packages memory as a provider-agnostic layer (vector + optional graph store, Mem0ᵍ variant) callable from any agent framework — a clean separation-of-concerns worth mirroring in how SZL would expose a memory lane behind a stable contract (as Alloy already does for providers/receipts). The boundary that must ride with it: Mem0's '+26% accuracy / −91% tokens vs full-context' style figures are self-REPORTED on their own LOCOMO setup and have been publicly contested; SZL cites them as Mem0's claim, never as evidence about SZL's own stack.\n\nApplies to: honesty-doctrine.\n\nEvidence: https://mem0.ai/ (self-reported benchmarks) ; https://docs.mem0.ai/platform/overview","sha256":"d2b9a9c72c80985a93481a813fb60fd5d53fcdc132e7738e8f735c02309b7405"}
{"id":"ingest:letta-memgpt:000","source":"ingest","sourceId":"letta-memgpt","title":"LLM-as-OS: tiered context with agent-managed paging under an explicit token budget","text":"MemGPT's durable idea: treat the LLM like a process on a memory-constrained OS — a small in-prompt MAIN context plus large EXTERNAL (recall/archival) storage, with the agent issuing self-directed calls to page memory in/out and edit its own 'memory blocks'. The transferable PATTERN for SZL: context assembly is a budget-managed decision, and a distinct editable 'working-memory block' (agent-maintained) can sit alongside the immutable archival run ledger. ANALOGY only — Alloy's context is currently assembled deterministically per run; self-editing memory would be a new, opt-in, provenance-labeled lane, never silent state.\n\nApplies to: backbone-loop.\n\nEvidence: https://github.com/letta-ai/letta ; https://www.letta.com/blog/letta-v1-agent","sha256":"6d8f3227e4902c14277e07952d2d3251840f70dafb090a1b1d9147df3cf04f72"}
{"id":"ingest:letta-memgpt:001","source":"ingest","sourceId":"letta-memgpt","title":"Procedural / self-editing memory is the interesting part — and the honesty risk to manage","text":"Letta markets 'agents that learn and self-improve over time'; the honest reading is that the 'learning' is memory-EDITING (blocks the agent rewrites), not weight training — a distinction SZL must preserve so no panel implies on-the-fly model improvement. Combined with LangMem's semantic/episodic/PROCEDURAL taxonomy, the genuinely new lane for SZL is procedural memory (learned routing/recipe rules distilled from the ledger). Every such rule stays a model-generated CONJECTURE with provenance to the runs that produced it, subject to owner review before it can influence a live route.\n\nApplies to: honesty-doctrine.\n\nEvidence: https://github.com/letta-ai/letta (self-editing memory blocks / stateful agent server)","sha256":"cbb16473029a2bc98ef7e4ab549970d80fae4f40cfb174e502571bc25d13132e"}
{"id":"ingest:ferguson-decay-ledger:000","source":"ingest","sourceId":"ferguson-decay-ledger","title":"The Decay Ledger node model — a finding decays hop-by-hop, and no node is accountable","text":"Ferguson traces one fact through five nodes (paper → university press office → wire → aggregator → Vice) and shows each hop adds confabulation: the press office \"reframes a framework paper as a body of findings\" by retrieving true-but-adjacent material (\"All of it real. None of it in the source document\"), the wire \"performed a disclaimer\", the aggregator faithfully summarizes a corrupted source, and the final outlet invents \"participants who do not exist.\" His hinge (verbatim): \"There are no lonely people in that paper. There are no participants in that paper. There is no experiment in that paper.\" SZL's /api/decay antiDecayMap borrows the HOP framing as a labeled ANALOGY only — his diagnosis stays cited to him, and our map claims only what each of our own hops mechanically enforces.\n\nApplies to: honesty-doctrine.\n\nEvidence: .local/ingest-lab/wave11/ferguson-decay-ledger-article.md (saved verbatim, fetched 2026-07-12)","sha256":"0dac6f1319f2c8746346d225626b8a1629dbc9e013c6b05d80e97efed46ef10e"}
{"id":"ingest:ferguson-decay-ledger:001","source":"ingest","sourceId":"ferguson-decay-ledger","title":"The missing \"cosigner\" — a consequence-bearing component that can refuse","text":"His core diagnosis (verbatim): \"Every actor in this chain made a locally reasonable decision. The aggregate output is a fabrication… That is what a system with no consequence-bearing component does, and it will do it every single time, at whatever speed you run it.\" And: \"accountability is not a policy layer bolted onto a system. It is endogenous to the decision.\" He names the missing part the \"cosigner\" — \"the only component in the entire architecture that can refuse, and the only one who eats the consequence when he refuses wrongly.\" For SZL this seeds the Decay Ledger organ's design question: which of OUR hops can actually refuse (Zod reject, sovereign-only gate, UNSIGNED receipt state, honest UNAVAILABLE) — and each refusal path is listed with its falsifiable check, never asserted abstractly.\n\nApplies to: honesty-doctrine.\n\nEvidence: .local/ingest-lab/wave11/ferguson-decay-ledger-article.md (§1e verbatim quotes)","sha256":"319d045f73cb99daadf864fb332b9f04685ffcfe02673850bba412412540c739"}
{"id":"ingest:ferguson-decay-ledger:002","source":"ingest","sourceId":"ferguson-decay-ledger","title":"Reward-function argument: \"Every node… was rewarded for amplification. No node was penalized for decay.\"","text":"Ferguson's structural claim (verbatim): \"That is not journalism failing. That is a reward function working exactly as designed\" — and \"We did not build machines that hallucinate like institutions. We built institutions that hallucinate, wrote it all down, and then used it as training data.\" His remedy is the alignment-breaker: \"somebody stops nodding along and says wait, that is not what it says\" — the slow, expensive editor who is \"the first line item cut.\" These stay HIS claims. The transferable discipline for SZL: abstention and refusal must be first-class, non-penalized outputs (UNAVAILABLE over invented numbers, INSUFFICIENT over fabricated agreement) — which Alloy already enforces by doctrine, so the essay is convergent confirmation, not a new adoption.\n\nApplies to: honesty-doctrine.\n\nEvidence: .local/ingest-lab/wave11/ferguson-decay-ledger-article.md (§1d, §1f verbatim quotes)","sha256":"6895eec038c96373422748207722cb980409eebf12848782d2f9da118412bb94"}
{"id":"ingest:topaz-fabricated-citations:000","source":"ingest","sourceId":"topaz-fabricated-citations","title":"The primary numbers, kept primary: 4,046 fabricated citations / 2,810 papers / 97.1M references verified","text":"As the authors state them (Columbia/EurekAlert release credited \"Topaz et al., 2026, The Lancet\"): ~2.5M PMC Open Access papers (2023-01-01 → 2026-02-18) scanned, 97.1 million references verified, 4,046 fabricated citations (resolve to no record in PubMed, Crossref, OpenAlex, or Google Scholar) across 2,810 papers; rate >12-fold up since 2023 (1-in-2,828 → 1-in-458 → 1-in-277 by early 2026); one paper had \"18 out of 30\" fake references (Topaz verbatim). The separate Nature+Grounded AI estimate (>110,000 pubs from 2025 with ≥1 invalid ref) is a DIFFERENT method on a DIFFERENT corpus and is never merged with the Lancet count. The undercount caveat (PMC-OA-only, PMID-resolvable-only) is commentators' interpretive claim, labeled as such.\n\nApplies to: honesty-doctrine.\n\nEvidence: EurekAlert #1127364 (Columbia release, primary-credited) ; https://pmc.ncbi.nlm.nih.gov/articles/PMC13051339/","sha256":"616acb560de4f972373220e51da24adfd971901b1739e6cf7f9fc23191c172cd"}
{"id":"ingest:topaz-fabricated-citations:001","source":"ingest","sourceId":"topaz-fabricated-citations","title":"Decay demonstrated on the decay literature itself: Retraction Watch printed 4,406 for 4,046","text":"Retraction Watch (2026-05-07) restated the audit's rates correctly but printed the fabricated-citation count as \"4,406\" where the primary release and every other secondary source print \"4,046\" — two digits transposed in one press hop, while the paper count (2,810) and reference count (97.1M) survived intact. This is Ferguson's thesis in miniature, caught live in wave-11's own evidence base, and it is exactly why /api/decay tags every number with a sourceKind (PRIMARY/ESSAY/PRESS) and a numbersStatus: a Decay Ledger that cannot distinguish the primary figure from the press transposition would itself be a decay node. Recorded as a discrepancy, not resolved by fiat.\n\nApplies to: honesty-doctrine.\n\nEvidence: https://retractionwatch.com/2026/05/07/one-in-277-pubmed-indexed-papers-in-2026-shows-fabricated-references-says-analysis/ (prints 4,406; primary release prints 4,046)","sha256":"fb1ef0cee5b75512c90702deebff6bd7fc73bc3783a6e31f628e61313574cd2d"}
{"id":"ingest:topaz-fabricated-citations:002","source":"ingest","sourceId":"topaz-fabricated-citations","title":"Citations-as-data (Resnik & Hosseini): if citations function as data they need data-integrity provenance","text":"Resnik & Hosseini argue (their conditional, verbatim shape preserved) that hallucinated citations MAY constitute research misconduct when three conditions hold: GenAI produced the nonexistent citations, the citations FUNCTION AS DATA supporting findings, and the researcher showed indifference to fabrication risk. PLOS's counterpoint (via Retraction Watch: intent is decided institutionally) is recorded as live tension, and RW's \">98% of flagged papers saw no publisher action\" stays RW's analysis. The transferable pattern for SZL: mechanical resolution-at-ingest (Topaz et al.'s four-database check; \"publishers verify references with each paper submission\") — a citation that does not resolve is flagged or rejected, never silently carried.\n\nApplies to: honesty-doctrine.\n\nEvidence: https://pmc.ncbi.nlm.nih.gov/articles/PMC13051339/ (CC BY 4.0 full text)","sha256":"0ec0c8f75016c2a88145e929c44121a94270d05674f86d32c23827a28c510c7c"}
{"id":"ingest:semantic-uncertainty:000","source":"ingest","sourceId":"semantic-uncertainty","title":"Semantic entropy = sample k → cluster by bidirectional NLI entailment → entropy over clusters","text":"Their method detects confabulations by sampling several completions, clustering them into semantic-equivalence classes via bidirectional entailment (A entails B AND B entails A, judged by an NLI model such as DeBERTa-Large-MNLI or an LLM judge), then computing entropy over the cluster distribution — scoring MEANING, not surface form. Full SE needs white-box token probabilities; Discrete SE uses empirical cluster frequency and works black-box. Clustering costs O(M²) NLI forward passes. The structure (sample → cluster → entropy) is the intellectual parent of SZL's consistency probe.\n\nApplies to: honesty-doctrine.\n\nEvidence: https://doi.org/10.1038/s41586-024-07421-0 ; https://github.com/jlko/semantic_uncertainty","sha256":"26c71a94c792c968cb5f85b16587e6d87eebb644be854b4470bfb3e4c3f25da5"}
{"id":"ingest:semantic-uncertainty:001","source":"ingest","sourceId":"semantic-uncertainty","title":"Honest boundary: without an NLI model, SZL does NOT have semantic entropy — only a lexical ANALOGY","text":"The clustering step REQUIRES an entailment judge; a 2-vCPU CPU-only estate with no NLI model cannot run it as published. What SZL's /api/decay consistency probe actually computes is exact-match clustering over lexically NORMALIZED answers (lowercase, first-line, punctuation-stripped) plus agreement ratio (HEADLINE) and discrete entropy (secondary, coarse at small k) — the SelfCheckGPT sampling-consistency family, an ANALOGY to semantic entropy, and the caption must always say so. Claiming \"semantic entropy\" without NLI clustering would fabricate a capability — the exact violation the honesty doctrine forbids. The discrete-entropy arithmetic itself is trivially CPU-honest once clusters exist.\n\nApplies to: honesty-doctrine.\n\nEvidence: .local/ingest-lab/wave11/report-a-detection-science.md (CPU-only reproducibility verdicts, all 7 items)","sha256":"17e1a3e4a3d09502dde29f8893165eca501fedfcef98e448361c1c07d812aa57"}
{"id":"ingest:selfcheckgpt:000","source":"ingest","sourceId":"selfcheckgpt","title":"Zero-resource black-box detection: if the model knows, k samples agree; if it confabulates, they diverge","text":"SelfCheckGPT's core intuition needs no logits, no external database, no white-box access — just the ability to sample k generations and measure their consistency (variants: BERTScore, QA, n-gram, NLI, LLM-Prompt). The n-gram/exact-match end of that family is the ONLY published hallucination-detection paradigm honestly runnable on SZL's black-box CPU router, and it is precisely the shape of the /api/decay consistency probe: k sovereign-served samples, lexical exact-match clusters, agreement ratio. CONVERGENT by design and cited as the probe's method family — with the standing caveat that lexical agreement is weaker than their NLI/BERTScore variants and is labeled ANALOGY to semantic clustering.\n\nApplies to: backbone-loop.\n\nEvidence: https://arxiv.org/abs/2303.08896 ; https://github.com/potsawee/selfcheckgpt","sha256":"bb52245a2a1426d999d217b9bae8f474802ff2a5cfaada1b8a36a4daf2fb90a5"}
{"id":"ingest:selfcheckgpt:001","source":"ingest","sourceId":"selfcheckgpt","title":"Sovereign-only sampling gate: a consistency measurement over a MIXED provider pool measures nothing","text":"SelfCheckGPT assumes all k samples come from the SAME model. SZL's probe therefore counts ONLY sovereign-served samples (servedProvider=sovereign, named node, receipt-backed); cloud-served fallbacks are excluded and counted as excludedNotSovereign, and fewer than 2 sovereign samples yields status INSUFFICIENT with agreementRatio null — agreement is undefined, not zero, and never fabricated. This gate is SZL's own doctrine-driven addition, not part of the upstream method.\n\nApplies to: sovereign-serving.\n\nEvidence: scripts/src/consistency-probe-run.ts (sovereign gate + INSUFFICIENT semantics)","sha256":"cf1371fdbdf1570fe3e6b7f30b1c92648a294196bc96841eb3f268a33296a640"}
{"id":"ingest:hallucination-tooling-survey:000","source":"ingest","sourceId":"hallucination-tooling-survey","title":"The field's honest split: every production hallucination check is either a model or a deterministic string/schema check","text":"Across ten surveyed tools the mechanism is always one of: an NLI-style classifier (HHEM's FLAN-T5 consistency scorer, LettuceDetect's ModernBERT span classifier), an LLM-as-judge (RAGAS faithfulness, DeepEval G-Eval, TruLens RAG Triad, Phoenix eval templates, FacTool), a hosted proprietary scorer (Cleanlab TLM — thin MIT client, cloud-only scoring, NOT self-hostable), or deterministic checks (Guardrails schema/regex validators, RAGAS exact-match/BLEU/ROUGE). Nothing semantic runs without a model somewhere. For SZL's no-GPU TS estate the honestly portable subset is the deterministic one — sampling-consistency over lexical clusters, schema validation — which is exactly what /api/decay ships, with the limitation stated rather than hidden. A GitLab sweep found no comparable tool: recorded as none-found-in-survey, never \"none exists\".\n\nApplies to: honesty-doctrine.\n\nEvidence: .local/ingest-lab/wave11/report-b-tooling.md (summary table, all REPORTED verbatim 2026-07-12)","sha256":"652ab58875a82015697a80c33276a3195b49e2fad5e831d7d29671ec9dde6a2a"}
{"id":"ingest:hallucination-tooling-survey:001","source":"ingest","sourceId":"hallucination-tooling-survey","title":"Convergence map verdict: none of the ten ships signed receipts or in-browser verification — our sharpest gap-in-our-favor","text":"Mapped against Alloy's existing organs: Cleanlab TLM's per-response trust score is CONVERGENT in spirit with our per-run receipt but mechanically opposite (their learned confidence from a hosted model vs our cryptographic provenance anyone recomputes offline); RAGAS/DeepEval/Guardrails' falsifiable pass/fail discipline is CONVERGENT with /api/invariants (different object: content factuality vs ledger self-consistency); RAGAS/HHEM per-claim verification parallels LivingPaper's verify rubric (their NLI judge vs our named-live-endpoint recompute). The signed hash-chained receipt form and the reader's-own-browser Ed25519 verify appear in ZERO surveyed tools. Stated falsifiably — a single counterexample disproves it — and it grants SZL no accuracy advantage: it is a provenance property, not a detection score.\n\nApplies to: honesty-doctrine.\n\nEvidence: .local/ingest-lab/wave11/report-b-tooling.md (convergence map, CONVERGENT/ABSENT markers)","sha256":"0634c6ce1a564cc28ef7b4ce447e8babc66662062385932b687bfd5f8627c109"}
{"id":"ingest:provenance-frontiers:000","source":"ingest","sourceId":"provenance-frontiers","title":"Three construction-side primitives converge: span-level grounding, per-hop signed artifacts, append-only verifiable logs","text":"The frontier's leaders each harden one hop: Anthropic Citations pins generated spans to exact char-ranges in caller-supplied documents (grounds against YOUR documents only — not the world, not a signature); C2PA hard-binds media assets to signed, offline-verifiable manifests (and states itself it makes no truth judgment and detects no deepfakes); CT/Rekor make signing events publicly auditable via Merkle logs with inclusion+consistency proofs. These are the same three primitives /api/decay's antiDecayMap claims for Alloy's own hops (source-pinned blocks, Ed25519 receipts, hash-chained ledger + signed checkpoint) — each mapped as a labeled ANALOGY with its falsifiable check, never as adoption of any surveyed system.\n\nApplies to: honesty-doctrine.\n\nEvidence: .local/ingest-lab/wave11/report-d-frontiers.md (items 1-4, quotes verbatim)","sha256":"181b8f78abeabe17e88b5a6f75ee180074fc9b0c4d9fddc4693339eca47526b3"}
{"id":"ingest:provenance-frontiers:001","source":"ingest","sourceId":"provenance-frontiers","title":"Honest self-note carried into the organ: our ledger is a hash chain, NOT a Merkle transparency log","text":"Rekor/CT produce O(log n) inclusion and consistency proofs against a signed tree head; Alloy's ledger is a linear hash chain (rowHash = sha256(prevHash|contentHash), recomputed on read) with a signed checkpoint over count+head — tamper-evident, but it cannot hand a client an inclusion proof for one row without replaying the chain. The /api/decay receipts hop says exactly this instead of borrowing Merkle credibility. Also recorded verbatim from the survey's falsifiable frontier list: no public LLM API today ships per-response offline-verifiable signed receipts, a response transparency log, robust free-text provenance (SynthID is statistical, key-holder-side, paraphrase-fragile; \"no methods widely accepted as effective\" is the field's own position), real-time proof-of-model-execution, or an in-browser don't-trust-us verifier. Each stated so one counterexample disproves it; the two we DO ship (receipts, browser verify) were verified against our own source before being claimed.\n\nApplies to: honesty-doctrine.\n\nEvidence: .local/ingest-lab/wave11/report-d-frontiers.md (frontier list 1-5 + our-own baseline, verified against receipts.ts/runLedger.ts/browserVerify.ts)","sha256":"b8cd0e60aae70e71747c44b09ec01a2539e5ec04806d6ae5446fc34692e40e12"}
{"id":"ingest:radicle-heartwood:000","source":"ingest","sourceId":"radicle-heartwood","title":"Ed25519-signed refs with no central host is the sovereign-git thesis — it maps onto Alloy's receipt chain, not onto a forge SZL runs","text":"Radicle replaces the trusted central server with cryptographic identity: every repository and every ref update is signed by an Ed25519 key, and history is gossip-replicated peer-to-peer so no single host is authoritative. For SZL this is the crown-jewel ANALOGY — Alloy already establishes trust in signature space (ed25519 over sha256 canonical bytes, plaintext never in the receipt), verified per request by the `receipt-ed25519-verify` invariant. The honest boundary: SZL does NOT run Radicle and has NOT made its git storage peer-to-peer (code lives on github.com/szl-holdings + Carlota-1/Machine-Innovate). The lesson adopted is at the receipt/storage-integrity layer SZL already ships; standing up a P2P forge is a DECLARED roadmap gap, never a claimed fact. Convergence ≠ adoption.\n\nApplies to: receipt-chain.\n\nEvidence: .local/ingest-lab/wave12/report-doctrine-map.md (Ed25519-signed refs → receipt-ed25519-verify)","sha256":"3c794c694e5dc06c604a734167246632972c55f7343c1a01fcf33b5fafbb4001"}
{"id":"ingest:radicle-heartwood:001","source":"ingest","sourceId":"radicle-heartwood","title":"Append-only, tamper-evident history is the same property the Ouroboros closes on its own tail","text":"Radicle's signed, content-addressed history cannot be silently rewritten — a tamper breaks the signature chain. Alloy's run ledger is a linear hash chain (rowHash = sha256(prevHash|contentHash), recomputed on read), and the `receipt-chain-continuity` invariant recomputes that chain over its own prior hashes every request — the Ouroboros closing on its own tail. Stated with the same honesty carried from wave-11: Alloy's ledger is a hash chain, NOT a Merkle transparency log, so it cannot hand a client an O(log n) inclusion proof for one row without replaying the chain. The forge primitive is mapped as a labeled ANALOGY to that EXISTING falsifiable check — it adds zero proofs and upgrades nothing; Λ stays Conjecture-1.\n\nApplies to: ouroboros-invariants.\n\nEvidence: .local/ingest-lab/wave12/report-doctrine-map.md (append-only history → receipt-chain-continuity)","sha256":"160281da27b2902259d5953fa8fe490643c434d52ddec5b0bd32e8124f99303d"}
{"id":"ingest:gitea:000","source":"ingest","sourceId":"gitea","title":"Self-hostable single-binary sovereignty is the own-metal thesis SZL already lives at the serving layer","text":"Gitea's whole design is 'own your git host on your own hardware, one binary, no cloud dependency' — the code-storage version of SZL's sovereign-GPU default (serve from tower/laptop before any cloud). The honest mapping: SZL's sovereignty today is at the INFERENCE layer (own-metal nodes, `served-run-has-model` invariant proves a live-served run names the model that served it), not the STORAGE layer — SZL's git still lives on GitHub. A self-hosted Gitea/Forgejo mirror of Carlota-1/Machine-Innovate is a plausible DECLARED roadmap step toward storage sovereignty, recorded as a gap, never as done.\n\nApplies to: sovereign-serving.\n\nEvidence: .local/ingest-lab/wave12/report-forge-leaders.md (Gitea MIT, single Go binary)","sha256":"860955a659c6a8af26139b8f4086f17cc194933bd299ac1af52deec6466e954c"}
{"id":"ingest:gitea:001","source":"ingest","sourceId":"gitea","title":"Gitea Actions (GitHub-Actions-compatible on your own metal) is the pattern for portable, non-lock-in CI","text":"Gitea Actions runs GitHub-Actions-syntax workflows on a self-hosted runner, so the same workflow file is portable between a cloud host and own metal — no vendor lock-in on the automation layer. For SZL this is the honest CI-portability lesson: the szl-holdings CI (SLSA L1 / SBOM / DCO / CodeQL / Gitleaks) is GitHub-hosted today; keeping workflows in portable Actions syntax means they could run on a sovereign runner without a rewrite. Adopting a self-hosted runner is a roadmap item; convergence ≠ adoption.\n\nApplies to: forge-training.\n\nEvidence: .local/ingest-lab/wave12/report-forge-leaders.md (Gitea Actions, portable CI)","sha256":"74d845e75999ef8f777a8c28768b8688769868f65bcd9184a676af7cd71b57c7"}
{"id":"ingest:gitlab:000","source":"ingest","sourceId":"gitlab","title":"Merge-request approval rules → Alloy's per-action approval tickets (a human approval gates before any provider call)","text":"GitLab's approval rules require N designated reviewers to approve before a merge can land — governance enforced at the change boundary. Alloy already ships the runtime analogue: `A11OY_APPROVAL_MODE=required` makes every /run and /run/stream spend a single-use, short-TTL approval ticket minted by the run-key holder — one mint is one explicit human approval for one action, and gateRun() refuses BEFORE any provider call (denied requests are never ledger rows). The honest limit carried from the audit: those tickets are in-memory (cleared on restart), a DECLARED roadmap gap toward a durable ticket store. The forge primitive is mapped as an ANALOGY to an EXISTING enforced gate, never a new claim.\n\nApplies to: backbone-loop.\n\nEvidence: .local/ingest-lab/wave12/report-doctrine-map.md (MR approval rules → approval tickets)","sha256":"a5a8acffc7f941871df77c9dd1884d12c0b4c606a8976e6dd259f80a7c8e97fd"}
{"id":"ingest:gitlab:001","source":"ingest","sourceId":"gitlab","title":"Integrated supply-chain scanning + SBOM is the DevSecOps ceiling SZL tracks at SLSA L1, honestly below it","text":"GitLab bundles SAST/DAST/dependency scanning/container scanning/SBOM into the pipeline as first-class gates. SZL's szl-holdings CI is honestly at SLSA L1 (SBOM + DCO) with CodeQL + Gitleaks — a real but LOWER rung, stated as such (the estate's own attestations directory enumerates the certifications it does NOT hold, which is the strongest form of the honesty doctrine). The wave-12 lesson is the target shape (provenance + SBOM + scanning as enforced gates), recorded as a roadmap toward SLSA L2 on the SZL-1 model pipeline — never as a level SZL has already reached.\n\nApplies to: ouroboros-invariants.\n\nEvidence: .local/ingest-lab/wave12/report-doctrine-map.md (SLSA/SBOM → signed-columns-atomic)","sha256":"96b17ecc6b3e4f88fcd49ed5bc6788a037531f96470d75b48d121cb80dd664b8"}
{"id":"ingest:gogs:000","source":"ingest","sourceId":"gogs","title":"Radical minimalism (one small binary, cross-platform, low-resource) is the honest fit for SZL's constrained own metal","text":"Gogs's founding constraint — run a full git host on the cheapest hardware, a Raspberry Pi included — matches SZL's reality: consumer GPUs (RTX 4060 Ti-class tower) and a laptop node, not a datacenter. The lesson is the same one KTransformers taught at the inference layer (measure the host, degrade honestly) applied to storage: a mirror host, if ever stood up, should be the minimal footprint that fits the metal, not an enterprise stack the fleet cannot carry. Recorded as design guidance for a DECLARED roadmap mirror, never as deployed infrastructure.\n\nApplies to: sovereign-serving.\n\nEvidence: .local/ingest-lab/wave12/report-forge-leaders.md (Gogs MIT, minimal footprint)","sha256":"64cc84d8f7b12f8395566ebad0f2f542420bea777c18ad98b107f08a96e649f2"}
{"id":"ingest:onedev:000","source":"ingest","sourceId":"onedev","title":"Built-in CI/CD + symbol-level code search as first-class forge features → the shape of a self-contained sovereign workspace","text":"OneDev bakes the pipeline engine and semantic (symbol-level) code search directly into the forge rather than wiring external services — one self-hosted process is the whole loop: store, search, build. For SZL this is the design shape for an eventual sovereign code workspace on own metal (the Machine-Innovate mirror + a build/eval loop), where the szl-forge SZL-1 pipeline (rebirth.ps1 → eval_szl.py → calibrate.ps1) would be the 'CI' over the 269-formula calibration set. Recorded strictly as a DECLARED roadmap shape — SZL runs no OneDev instance and claims none; convergence ≠ adoption.\n\nApplies to: forge-training.\n\nEvidence: .local/ingest-lab/wave12/report-forge-leaders.md (OneDev MIT, built-in CI/CD + code search)","sha256":"a524158942159b36c7293f84d58e4cec46234b9578841ccda55309b663388ffe"}
{"id":"ingest:forgejo:000","source":"ingest","sourceId":"forgejo","title":"Copyleft-as-anti-capture governance is the licensing analogue of the honesty doctrine's 'no repaint' rule","text":"Forgejo forked Gitea and relicensed to GPL-3.0-or-later specifically so the project cannot be quietly enclosed by a single vendor — copyleft as a structural anti-capture guarantee, stewarded by a non-profit (Codeberg e.V.). This is a governance ANALOGY, not a technique SZL imports: it mirrors the honesty doctrine's binding rule that outside inspiration is pattern-study ONLY, never a repaint of SZL's own #3af4c8 identity, and that license/archival decisions stay owner-only. SZL's repos are proprietary/Apache-2.0 per repo (owner's choice) — Forgejo's copyleft is studied, explicitly NOT adopted, and the licensing decision is recorded as owner-only.\n\nApplies to: honesty-doctrine.\n\nEvidence: .local/ingest-lab/wave12/report-doctrine-map.md (Forgejo copyleft → no-repaint governance)","sha256":"534d35b9efede6852e8b45004f591602536d42163c4db0742c41201907848ed8"}
{"id":"ingest:sourcehut:000","source":"ingest","sourceId":"sourcehut","title":"Minimal-JS, fully-scriptable, don't-trust-the-UI is the same posture as Alloy's in-browser Ed25519 verifier","text":"SourceHut ships almost no client-side JavaScript and exposes everything through a plain, scriptable API — the user never has to trust an opaque web app to do the real work. Alloy's honesty organs share the posture inverted into cryptography: the ReceiptChain component runs WebCrypto Ed25519 verification in the reader's OWN browser against the source endpoint's label (a don't-trust-us verifier), and the `receipt-columns-consistent` invariant proves each receipt payload matches its indexed columns. The forge primitive is mapped as an ANALOGY to that EXISTING falsifiable surface — SZL does not run SourceHut and claims no adoption.\n\nApplies to: honesty-doctrine.\n\nEvidence: .local/ingest-lab/wave12/report-doctrine-map.md (SourceHut minimal-JS → in-browser verify)","sha256":"c2d72e4ebf29ab15c59ead7e33a9a0095e75c0e9a16d32f5fb625d968b7516b8"}
{"id":"ingest:github-supply-chain:000","source":"ingest","sourceId":"github-supply-chain","title":"Sigstore-backed artifact attestation + SLSA provenance is the exact target for the SZL-1 model pipeline's next rung","text":"GitHub's Artifact Attestations bind a built artifact to its build provenance via a Sigstore-signed, Rekor-logged attestation (SLSA lineage) — machine-verifiable 'this artifact came from this source, built this way'. The szl-forge SZL-1 pipeline currently produces a signed GGUF but has NO such provenance attestation on the model artifact itself — a DECLARED gap identified in the architecture audit. The honest wave-12 target: add a cosign attest step after rebirth.ps1 so every SZL-1 download carries offline-verifiable provenance (Rekor already ingested in wave-11). Mapped as an ANALOGY to Alloy's signed checkpoint (`signed-columns-atomic` invariant); recorded as a roadmap rung toward SLSA L2, never a level already reached.\n\nApplies to: forge-training.\n\nEvidence: .local/ingest-lab/wave12/report-doctrine-map.md (SLSA/Sigstore attestation → SZL-1 provenance gap)","sha256":"e360dddc1de00bf2397da38e424fd136b6b1a01cce6c51f0ccfb092383a270d9"}
{"id":"ingest:github-supply-chain:001","source":"ingest","sourceId":"github-supply-chain","title":"Protected branches + required reviews is the machine form of SZL's two-account PR flow on protected mains","text":"GitHub enforces 'no direct writes to main; every change lands via a reviewed PR' as a repo setting. SZL already runs exactly this by hand on protected mains — one account authors the PR, a second approves, squash-merge with a DCO trailer — because branch protection is ON. The wave-12 lesson is that this process discipline is the same governance primitive GitLab/GitHub bake in, and it composes with Alloy's runtime approval tickets: change-time review (git) plus action-time approval (run gate) are two independent gates, not a duplication. Recorded as the governance posture SZL already practices, stated as process doctrine.\n\nApplies to: ouroboros-invariants.\n\nEvidence: .local/ingest-lab/wave12/report-doctrine-map.md (protected branches → two-account PR flow)","sha256":"37d8e9877ab00fb0501abd4e8441a527d2dc0df249269d70414fa4caa64754ab"}
{"id":"ingest:rrf-cormack2009:000","source":"ingest","sourceId":"rrf-cormack2009","title":"RRF: fuse rankings by rank, not by score — RRFscore(d) = Σ 1/(k + rank_i(d))","text":"The paper's whole method is one line: given multiple rankings of the same documents, score each document by the sum of reciprocal ranks 1/(k + rank) across rankers (k=60 in the paper, chosen to damp the impact of outlier top ranks) and re-sort. Because it consumes RANKS, not raw scores, it needs no score calibration or normalization between rankers on incomparable scales. This is the one wave-13 technique SZL ADOPTED in code (2026-07-14): /brain/ask ranking is now the RRF fusion (k=60, DECLARED constant from this paper) of two deterministic lexical rankers — classic BM25 and distinct-term coverage — both MEASURED signals over the committed corpus. Adoption is disclosed as a DECLARED technique choice with fixture-pinned behavior; it is never claimed as 'better' — the paper's win claims stay the paper's.\n\nApplies to: second-brain.\n\nEvidence: https://dl.acm.org/doi/10.1145/1571941.1572114 (Section 2, the RRF equation)","sha256":"69398b394ae170731e3de574479654701fa74e55080bf391f4f2e512f1cb7739"}
{"id":"ingest:rrf-cormack2009:001","source":"ingest","sourceId":"rrf-cormack2009","title":"Rank fusion tolerates one weak ranker — robustness over tuning","text":"The authors' argument for RRF's k damping is that a document ranked #1 by one ranker and poorly by another should not dominate; the constant k=60 keeps any single ranker from owning the fused order. For SZL's adoption this is the property that matters: the term-coverage ranker is deliberately crude (count of distinct query terms matched), and RRF lets it act as a corrective vote against BM25's known long-document/rare-term-repetition bias without ever overruling BM25 outright. The retrieval floor still gates on the raw BM25 top score — fusion reorders WHICH grounding is shown first, it never manufactures grounding that BM25 did not find.\n\nApplies to: second-brain.\n\nEvidence: https://dl.acm.org/doi/10.1145/1571941.1572114","sha256":"e919cb0383b5836365e964685e09a9ceec25a2c4c3bc352cefaaba629e8595c0"}
{"id":"ingest:rrf-cormack2009:002","source":"ingest","sourceId":"rrf-cormack2009","title":"Honest boundary: the paper's effectiveness wins are ITS claims on ITS collections","text":"Cormack et al. report RRF beating Condorcet fusion and individual learning-to-rank methods on TREC collections. SZL re-implements only the equation; none of those effectiveness claims transfer to the Second Brain corpus and none are restated as SZL results. What SZL pins instead is fixture behavior: deterministic tests assert the fused ordering is exactly the RRF of the two component rankings — a correctness-of-implementation claim, never a retrieval-quality claim.\n\nApplies to: honesty-doctrine.\n\nEvidence: artifacts/api-server/src/lib/brainIndex.test.ts (fixture-pinned RRF exactness)","sha256":"39544354152d806e0d68514d2bad7b85a99d9960e5e64e8c731931be32edc02c"}
{"id":"ingest:graphrag:000","source":"ingest","sourceId":"graphrag","title":"Graph-indexed retrieval: extract an entity graph, retrieve through structure not just text","text":"GraphRAG builds an LLM-extracted entity-relationship graph over the corpus, clusters it into communities (Leiden), pre-summarizes each community, and answers 'global' questions by map-reducing over community summaries instead of top-k chunk retrieval. The structural insight — retrieval can traverse RELATIONS between chunks, not just rank chunks — is the frontier thesis of this wave. SZL's Brain Atlas already has a graph (BM25 lexical adjacency, S2), so the convergence is real but bounded: SZL's edges are shared-rare-words, GraphRAG's are LLM-extracted semantic relations. The resemblance stays labeled ANALOGY; convergence ≠ adoption.\n\nApplies to: second-brain.\n\nEvidence: https://raw.githubusercontent.com/microsoft/graphrag/main/README.md","sha256":"d679b69aa4f73b5f167ea6be83d8f47054631826a6939929e189f2fd42347857"}
{"id":"ingest:graphrag:001","source":"ingest","sourceId":"graphrag","title":"Community pre-summarization = generated prose in the index — a lane SZL will not cross today","text":"GraphRAG's community reports are LLM-GENERATED summaries baked into the index at build time. For SZL that is the honest blocker to adopting the pattern: the in-repo lane is MEASURED precisely because every chunk is committed, human-authored or deterministically derived text with a content fingerprint. Injecting model-generated summaries would make the retrieval substrate itself partially SIMULATED and every downstream citation would inherit that taint. Recorded as a DECLARED roadmap gap with the blocker named, not a rejection of the technique.\n\nApplies to: honesty-doctrine.\n\nEvidence: https://microsoft.github.io/graphrag/ (indexing pipeline docs)","sha256":"0c4bb970f168ae6e2a199b2afb5f0175e472b4cc27ab9142054b487ea7cebe51"}
{"id":"ingest:graphrag:002","source":"ingest","sourceId":"graphrag","title":"Their eval claims stay theirs","text":"Microsoft reports GraphRAG substantially outperforming naive RAG on comprehensiveness/diversity for global sensemaking questions (their arXiv:2404.16130 evaluation, their LLM-as-judge methodology). SZL restates none of it — the Second Brain has run no comparable evaluation and scores no quality. The only thing adopted from studying GraphRAG is the framing that a corpus graph is a retrieval asset, which SZL already possessed in lexical form.\n\nApplies to: honesty-doctrine.\n\nEvidence: https://raw.githubusercontent.com/microsoft/graphrag/main/README.md","sha256":"89950ce7a50b9ad31f006feb22d06dc7b8c49d71b2032c0bf22bf327fccf132d"}
{"id":"ingest:splade:000","source":"ingest","sourceId":"splade","title":"Learned sparse expansion: the model adds terms the document never contains","text":"SPLADE learns sparse lexical representations where a document's vector can activate vocabulary terms that do not literally appear in it — closing BM25's vocabulary-mismatch gap while staying an inverted-index-compatible sparse model. This names the exact ceiling of SZL's retrieval honestly: the Second Brain's BM25+coverage fusion can NEVER match a query term the chunk does not contain. That gap is now a DECLARED limitation of the in-repo lane rather than an unexamined blind spot.\n\nApplies to: second-brain.\n\nEvidence: https://raw.githubusercontent.com/naver/splade/main/README.md","sha256":"62a71bb9e353e9898ea25aa6b9660fb2ba396f5b0f8c50039a3b33a55daca039"}
{"id":"ingest:splade:001","source":"ingest","sourceId":"splade","title":"Hard honest boundary: CC BY-NC-SA + a trained model SZL does not have","text":"Two independent blockers, both recorded: (1) the repo license is NON-COMMERCIAL ShareAlike — SZL, a commercial holding, does not touch the code; (2) even the idea requires a trained expansion model, and nothing in SZL is TRAINED until real signed artifacts exist and verify in-app (forge doctrine). So learned sparse expansion is studied, named as the technique that would lift the vocabulary-mismatch ceiling, and left honestly un-adopted on both legal and evidentiary grounds.\n\nApplies to: honesty-doctrine.\n\nEvidence: https://raw.githubusercontent.com/naver/splade/main/LICENSE (verbatim: CC BY-NC-SA 4.0, NAVER Corp.)","sha256":"2ad39117f65688fe23693a739f019d72ef40359dba00033f3474a470219ce239"}
{"id":"ingest:raptor-rag:000","source":"ingest","sourceId":"raptor-rag","title":"Recursive abstraction tree: retrieve at multiple granularities at once","text":"RAPTOR clusters chunks, LLM-summarizes each cluster, then recursively clusters the summaries — producing a tree where retrieval can hit a leaf (detail) or an internal node (theme). The lesson SZL takes is the FRAMING: a flat top-k over uniform chunks structurally cannot answer 'what is the overall shape of X' questions, because no committed chunk speaks at that altitude. The Second Brain's honest equivalent of an abstraction layer is its hand-AUTHORED doc chunks (data-surfaces.md sections, doctrine prose), which are committed human abstractions rather than generated ones.\n\nApplies to: second-brain.\n\nEvidence: https://raw.githubusercontent.com/parthsarthi03/raptor/master/README.md","sha256":"b0d294dd4abd69d09cdbd5940e895c8ebcfcd68072111866dc3105729789301d"}
{"id":"ingest:raptor-rag:001","source":"ingest","sourceId":"raptor-rag","title":"Same blocker as GraphRAG, recorded once more because the failure mode differs","text":"RAPTOR's internal nodes are LLM-generated summaries that get CITED as retrieval results. In SZL's citation-gated ask flow that is the worst-case taint: a [S#] citation pointing at generated prose would launder a model's own words into 'grounding'. GraphRAG's summaries at least sit behind a map-reduce; RAPTOR's sit directly in the citable index. DECLARED roadmap gap, blocker named, not adopted.\n\nApplies to: honesty-doctrine.\n\nEvidence: https://raw.githubusercontent.com/parthsarthi03/raptor/master/README.md","sha256":"0e4d274c3ab2d2a4b0203e57229d6cb57fa6a9804eec6030c58ceebc7278e89b"}
{"id":"ingest:colbert:000","source":"ingest","sourceId":"colbert","title":"Late interaction: score at the token level, aggregate with MaxSim","text":"ColBERT encodes query and document into per-token embeddings and scores by summing, over query tokens, the maximum similarity against any document token — richer than a single-vector dot product, cheaper than full cross-attention. The transferable shape (not the neural machinery) is 'per-query-term evidence, aggregated' — which is exactly what SZL's term-coverage ranker does in degenerate lexical form: each distinct query term contributes evidence, and fusion aggregates. The family resemblance is labeled ANALOGY; SZL runs no encoder and computes no similarity — token identity, not token meaning.\n\nApplies to: second-brain.\n\nEvidence: https://raw.githubusercontent.com/stanford-futuredata/ColBERT/main/README.md","sha256":"fae58adff4443b1afc1689cbac382967ecc66123b38789224c96c611a4b8177e"}
{"id":"ingest:colbert:001","source":"ingest","sourceId":"colbert","title":"Neural retrieval is a dependency wall the in-repo lane deliberately stays behind","text":"ColBERT needs a trained checkpoint, a GPU-class encoder at query time, and a vector index — three dependencies the Second Brain's in-repo lane is DEFINED by not having (dependency-free, deterministic, pure function of committed bytes). Studying ColBERT sharpened the boundary into a positive statement: the lane trades retrieval ceiling for verifiability — anyone can recompute the exact ranking from the committed corpus with no model weights. That trade is now a DECLARED design position, not an accident of history.\n\nApplies to: second-brain.\n\nEvidence: https://raw.githubusercontent.com/stanford-futuredata/ColBERT/main/README.md","sha256":"fc1e6d088b8e02a4c59221e4a43034e096e544b7e16fc7738a791659f442ccdb"}
{"id":"ingest:bm25s:000","source":"ingest","sourceId":"bm25s","title":"Eager sparse scoring: precompute per-term score contributions at index time","text":"BM25S's core trick is computing each term's BM25 contribution for every document AT INDEX TIME into a sparse matrix, so a query is just slicing rows and summing — no per-query TF/IDF arithmetic. SZL's index computes contributions at query time; over a ~1.6k-chunk corpus that is microseconds and honesty-neutral, so nothing is adopted NOW — but this is the named, license-compatible (MIT) optimization path if the committed corpus ever grows to where query-time scoring measurably matters. Adopt-when-measured, not adopt-because-frontier.\n\nApplies to: second-brain.\n\nEvidence: https://raw.githubusercontent.com/xhluca/bm25s/main/README.md","sha256":"98a5b8b4367212991d1c0e5eb965d226c12f3ad60ee42d5b2b368ee6b165e28c"}
{"id":"ingest:bm25s:001","source":"ingest","sourceId":"bm25s","title":"External validation that dependency-free lexical retrieval is a legitimate design point","text":"BM25S exists because a plain, well-implemented BM25 on a numpy-only stack remains competitive infrastructure in 2024+ — the author positions it against both heavyweight Java (Anserini) and slow pure-Python (rank_bm25) incumbents. For SZL this is convergent evidence (their thesis, not SZL's proof) that the Second Brain's zero-dependency BM25 lane is a defensible engineering position rather than a naive placeholder. Their speed numbers stay theirs; SZL's corpus is small enough that none of it is load-bearing here.\n\nApplies to: second-brain.\n\nEvidence: https://raw.githubusercontent.com/xhluca/bm25s/main/README.md","sha256":"d337c788a8a3adf85d6ef0e734bd30dc8f0a0c8ef19dc8ea9bdd86e02f3fe1be"}
{"id":"ingest:glm-5-2:000","source":"ingest","sourceId":"glm-5-2","title":"MIT at the ~1T-parameter frontier — the permissive-license ceiling moved","text":"The checkable fact from the card is the license tag: a frontier-class MoE released mid-June 2026 under plain MIT. Third-party trackers (Artificial Analysis Intelligence Index v4.1) rank it the #1 open-weight model — THEIR ranking on THEIR methodology, recorded here as their claim. What this changes for SZL is the study landscape, not the serving reality: no estate GPU can host a ~1T MoE, and the only named path to ever touching such a model on owned metal remains the wave-1 KTransformers arithmetic-intensity offload thesis — which stays ROADMAP, unmeasured.\n\nApplies to: frontier.\n\nEvidence: https://huggingface.co/zai-org/GLM-5.2 (card license tag, release date)","sha256":"5da5bb5de09106236b49a8cc438eeef63e7075787c5823416854191339f1c0b9"}
{"id":"ingest:glm-5-2:001","source":"ingest","sourceId":"glm-5-2","title":"Open weights ≠ open source — the wave-14 boundary, stated once for the whole wave","text":"Every model in this wave publishes weights, not provenance: training data, pipeline, and RL recipes stay closed. 'MIT weights' means the artifact is permissively licensed, not that the system is reproducible. SZL records the distinction as doctrine because it mirrors the forge rule at home: SZL's own models are nothing but UNTRAINED declarations until signed receipts verify in-app — a public weight file with a benchmark table is an artifact plus ITS AUTHOR'S claims, and ingesting the card never converts those claims into SZL facts.\n\nApplies to: honesty-doctrine.\n\nEvidence: https://huggingface.co/zai-org/GLM-5.2","sha256":"226724657dba4bd01143608ac64c802331e1ae093346dec34df2a72937132b43"}
{"id":"ingest:kimi-k2-6:000","source":"ingest","sourceId":"kimi-k2-6","title":"Alloy's moonshot pin already names this exact model — offline-until-keyed, now source-verified","text":"The provider registry pins kimi-k2.6 as the moonshot lane's default, and wave-14 verification confirms that id corresponds to a real, current frontier release on the primary source (HF card, image-text-to-text pipeline tag). What 'verified' means here is precisely bounded: the model EXISTS with this identity and license — Alloy has never served it (the lane is honestly offline until MOONSHOT_API_KEY lands) and no capability claim transfers from the card to the app.\n\nApplies to: frontier.\n\nEvidence: artifacts/api-server/src/lib/registry.ts (moonshot lane, model kimi-k2.6) + https://huggingface.co/moonshotai/Kimi-K2.6","sha256":"371d593ba810fdf79692a144536ff58e07664bf5a7dc760ba04c83de3dfc07f7"}
{"id":"ingest:kimi-k2-6:001","source":"ingest","sourceId":"kimi-k2-6","title":"modified-mit is its own license, not MIT","text":"The card's machine tag is license:other with license_name modified-mit. SZL records that verbatim and treats it as a distinct set of terms that must be read before any use beyond study — collapsing 'modified MIT' into 'MIT' in a registry would be a small fabrication of exactly the kind the ingest iron rules exist to prevent. Study is unrestricted; anything more waits on the actual license text.\n\nApplies to: honesty-doctrine.\n\nEvidence: https://huggingface.co/moonshotai/Kimi-K2.6 (card metadata: license_name modified-mit)","sha256":"b0511920353b00e088fdcb7ef3f7b44289324a687f305b3833914f8ca4469c26"}
{"id":"ingest:deepseek-v4:000","source":"ingest","sourceId":"deepseek-v4","title":"Alloy's deepseek-chat alias tracks this family with zero code change — and that cuts both ways","text":"The deepseek lane pins the provider's deepseek-chat serving alias, so if the lane is ever keyed, requests route to whatever DeepSeek currently serves under that name — presumably V4-era today, but 'presumably' is exactly the word the honesty doctrine bans. The run receipt therefore reports the SERVED model verbatim from the provider response and Alloy never captions the lane as 'DeepSeek V4': an alias pin buys currency at the price of not knowing the model until the response arrives, and the UI must keep saying so.\n\nApplies to: frontier.\n\nEvidence: artifacts/api-server/src/lib/registry.ts (deepseek lane, model deepseek-chat) + https://huggingface.co/deepseek-ai/DeepSeek-V4-Flash","sha256":"7c0d15944f68029bdf05d89574f67620c64d0475606b4496bec1769253c294c2"}
{"id":"ingest:deepseek-v4:001","source":"ingest","sourceId":"deepseek-v4","title":"80.6% SWE-bench Verified stays DeepSeek's number","text":"V4-Pro's headline coding-agent score is reported by DeepSeek on their harness configuration; V4-Flash's 'most of the capability at pareto-frontier price' framing is reviewer prose. SZL restates neither as fact — Alloy has run no SWE-bench, and the Proving Ground scores no quality by design. The MIT license on both cards is the one claim SZL verified directly (card tags, 2026-07-14).\n\nApplies to: honesty-doctrine.\n\nEvidence: https://huggingface.co/deepseek-ai/DeepSeek-V4-Pro (card)","sha256":"6cb46a887866548470ced90d3cf46157be278e15edf4fed2e51766847c504e0b"}
{"id":"ingest:minimax-m3:000","source":"ingest","sourceId":"minimax-m3","title":"Native image+video understanding at open weights — a lane Alloy's backbone does not have","text":"M3's card pipeline tag is image-text-to-text and its positioning is native multimodality (screenshots, UI states, diagrams, video) at open weights. Alloy's backbone is text-only end to end — no provider lane, receipt schema, or cost table models image inputs. Wave-14 records this as a DECLARED capability gap with a named exemplar, not a roadmap promise: if agent-vision ever matters to SZL verticals, this is the open-weights lane the study points at first.\n\nApplies to: frontier.\n\nEvidence: https://huggingface.co/MiniMaxAI/MiniMax-M3 (pipeline tag image-text-to-text)","sha256":"04ccdfc68b887c628deb1eec7ba87825f7f6f5cd8108c4a64d70b27029a23290"}
{"id":"ingest:minimax-m3:001","source":"ingest","sourceId":"minimax-m3","title":"A community license is not an open-source license until the text says so","text":"license:other + license_name minimax-community + a LICENSE file link is everything the card machine-declares. SZL records exactly that and nothing more — no 'effectively Apache' paraphrase, no adoption on vibes. The SPLADE precedent from wave-13 (CC BY-NC-SA, study-only forever) is the standing example of why the license text, not the license vibe, gates every next step.\n\nApplies to: honesty-doctrine.\n\nEvidence: https://huggingface.co/MiniMaxAI/MiniMax-M3 (card metadata: license_name minimax-community, license_link LICENSE)","sha256":"6f8af40cc7735bb92a875db4e27e09e24501608919c46a9bf99c507610695de6"}
{"id":"ingest:mistral-large-3:000","source":"ingest","sourceId":"mistral-large-3","title":"Apache-2.0 at 675B — permissive frontier licensing is a pattern now, not an outlier","text":"Together with GLM-5.2's MIT, a second pole of the wave-14 landscape is a frontier-scale MoE under a standard permissive license from a European lab. The DECLARED observation SZL takes is about the FIELD: permissive licensing at frontier scale recurred within a year across two continents, which materially widens what a sovereign-minded holding can legally study, fine-tune from, or serve — someday, on hardware SZL does not have. No Alloy surface changes because of this entry.\n\nApplies to: frontier.\n\nEvidence: https://huggingface.co/mistralai/Mistral-Large-3-675B-Instruct-2512 (card license tag)","sha256":"da6dba77bdccf9ae34ab8ecde450b6b3deb0e27bb157e7336889c82d49e96eb6"}
{"id":"ingest:mistral-large-3:001","source":"ingest","sourceId":"mistral-large-3","title":"Studying a model is not wiring a provider lane","text":"Alloy has no mistral provider today, and this entry does not imply one: adding a lane is a deliberate registry + cost-table + policy decision, made when there is a reason, not because a card was ingested. The ingest iron rule 'convergence ≠ adoption' has a provider-shaped corollary recorded here: presence in the study registry NEVER leaks into ProviderFleet, which renders only what registry.ts actually declares.\n\nApplies to: honesty-doctrine.\n\nEvidence: artifacts/api-server/src/lib/registry.ts (no mistral lane declared)","sha256":"d2cba1643af40e0bbaa8b869f22dee5b2f1d2876839ae2a6a6ef0561415c004a"}
{"id":"ingest:qwen3-235b-a22b:000","source":"ingest","sourceId":"qwen3-235b-a22b","title":"Alloy's qwen-plus pin is Alibaba's HOSTED alias — a different artifact from these open weights","text":"The qwen lane pins qwen-plus, a DashScope-hosted serving alias whose underlying model Alibaba chooses and may change; this card is the OPEN-WEIGHTS Qwen3 flagship, a related but distinct artifact. Wave-14 records the split loudly because it is easy to blur: if the lane is ever keyed, Alloy serves whatever the hosted alias routes (reported verbatim per response), while the Apache-2.0 weights studied here are something SZL could in principle self-host — 22B active is the one geometry in this wave within eventual reach of the KTransformers offload thesis on owned metal. That remains ROADMAP, unmeasured, like everything unmeasured.\n\nApplies to: frontier.\n\nEvidence: artifacts/api-server/src/lib/registry.ts (qwen lane, model qwen-plus) + https://huggingface.co/Qwen/Qwen3-235B-A22B","sha256":"60d908a97aac38e8e754224c58adcf1bee30878ae998222472e8112aea4304b5"}
{"id":"ingest:qwen3-235b-a22b:001","source":"ingest","sourceId":"qwen3-235b-a22b","title":"The 269-formula corpus and every SZL surface are untouched by this wave","text":"Six frontier cards entered the study registry; zero SZL claims changed. Nothing here trains, evaluates, or upgrades anything — the forge family keeps its receipt-gated floors, the Lean locked-proven count stays 8, Λ stays Conjecture-1, and the formula corpus stays 269. Recording that explicitly is the wave's own fourth-wall discipline: an ingest wave that quietly inflated an SZL surface would be the exact failure mode the registry exists to make impossible.\n\nApplies to: honesty-doctrine.\n\nEvidence: artifacts/api-server/src/data/ingestRegistry.ts (this entry; registry is DECLARED study, never SZL fact)","sha256":"1090f4ef7b3c4fdda78809603f0b180fa751942d70f2ffecae1907c505bf61e7"}
{"id":"invariant:ouroboros-doctrine","source":"invariant","sourceId":"ouroboros-codex","title":"Ouroboros invariants — doctrine","text":"Runtime self-consistency invariants — MEASURED, recomputed per request over the enumerated ledger window. These are DISTINCT from the Lean proof corpus (see the Lean proof ledger): none of them prove or upgrade Λ, which stays Conjecture-1. The Ouroboros closes on its own tail — the receipt chain recomputes its own prior hashes, and the flywheel consumes only its own verified own-metal serves.\n\nEvery invariant shown is FALSIFIABLE: it can be VIOLATED by real ledger corruption, receipt tamper, or a write-path regression. A check that cannot fail would be verification theater and is deliberately excluded. Ledger-shape checks catch corruption or a write-path regression, not runtime correctness. Count is enumerated rows only, never a claimed total.","sha256":"b088f5ca7eb9f113def11c511eec54bbbb6f88d45b588c0c39aa78f1473ae279"}
{"id":"invariant:receipt-chain-continuity","source":"invariant","sourceId":"ouroboros-codex","title":"Receipt chain recomputes over its own tail (Ouroboros closure)","text":"The literal Ouroboros: the receipt chain closes on its own tail. Every ledger row that carries a stored hash must recompute exactly — its rowHash from its own content hash chained to the previous row's hash, and its prevHash must equal the next-older row's rowHash. The chain is recomputed per request, never trusted from a cached verdict. A row that fails to recompute means ledger corruption or tamper; rows that predate the hash chain are stated as such and are never counted as failures.\n\nFalsifiable predicate: for every ledger row with a stored hash: rowHash === sha256(prevHash | contentHash), and each row's prevHash === the next-older row's rowHash\n\nDoctrine: notarized receipt chain — tamper-evident, recomputed per request\n\nThis chunk is the DECLARED definition of a runtime invariant; its live status is MEASURED per request at /api/invariants and is never stored in this corpus.","sha256":"b2891693e74a46a99d05416592974cc95bfdbe07ab6cbda9c40885a6841113f0"}
{"id":"invariant:ledger-failure-shape","source":"invariant","sourceId":"ouroboros-codex","title":"Failed runs claim no serving provider or latency","text":"Honest failure shape: a run that failed must not claim any part of a successful serve. A failed ledger row carrying a serving provider or a latency figure would be a fabricated serve — the exact kind of invented value the honesty doctrine forbids. This check audits ledger shape: it catches corruption or a write-path regression, not runtime correctness.\n\nFalsifiable predicate: for every row where ok = false: servedProvider IS NULL and latencyMs IS NULL\n\nDoctrine: honest failure — a failed run never fabricates a serve\n\nThis chunk is the DECLARED definition of a runtime invariant; its live status is MEASURED per request at /api/invariants and is never stored in this corpus.","sha256":"90aa2d28b4b83422fb88aecb9cc44e3778194ee0f096371f650b9f98001b27f7"}
{"id":"invariant:served-run-has-model","source":"invariant","sourceId":"ouroboros-codex","title":"Live-served runs name the model that served them","text":"Provenance floor: every live (non-demo) successful run must name the model that actually served it. A live serve with no recorded model is a provenance gap — the ledger would be claiming a real serve while hiding what produced it. Demo runs are excluded because they are honestly labeled as demo, not as serves.\n\nFalsifiable predicate: for every row where ok = true and demo = false: model IS NOT NULL\n\nDoctrine: provenance — a real serve always records its model\n\nThis chunk is the DECLARED definition of a runtime invariant; its live status is MEASURED per request at /api/invariants and is never stored in this corpus.","sha256":"b57cb074dedd8ab6428c6bc6c9bf536ef9dbbb8b67761a862e7d0fd980f7926f"}
{"id":"invariant:signed-columns-atomic","source":"invariant","sourceId":"ouroboros-codex","title":"Receipt columns are all-present or all-absent","text":"Signing is atomic: a ledger row is either fully signed (receiptId, signature, keyId, and the receipt payload all present) or honestly unsigned (all absent). A partial receipt column set is unrepresentable in a correct write path, so any half-signed row indicates a write-path regression or tamper. Unsigned rows are an honest state, never a violation.\n\nFalsifiable predicate: for every row: (receiptId, signature, keyId, receiptJson) are ALL present or ALL absent\n\nDoctrine: no partial receipts — a row is signed or honestly unsigned, never half\n\nThis chunk is the DECLARED definition of a runtime invariant; its live status is MEASURED per request at /api/invariants and is never stored in this corpus.","sha256":"1a8d30cf503429bf090633805173033149e4db78197c216a2cbec66158bce3e3"}
{"id":"invariant:loop-steps-positive","source":"invariant","sourceId":"ouroboros-codex","title":"Every live-served run took at least one loop step","text":"The bounded agent loop leaves a floor: any run that really served took at least one loop step, so a live-served row recording zero steps contradicts its own serve. Only the lower bound is asserted — the per-run upper bound is targets.length, which is not persisted in the ledger, and asserting an invented ceiling would itself be a doctrine violation.\n\nFalsifiable predicate: for every row where ok = true and demo = false: loopSteps >= 1 (lower bound only — the per-run upper bound targets.length is not persisted, so it is not asserted)\n\nDoctrine: LOOP_DOCTRINE — bounded, terminating, receipt-closed\n\nThis chunk is the DECLARED definition of a runtime invariant; its live status is MEASURED per request at /api/invariants and is never stored in this corpus.","sha256":"b7086fa00f4d384ea4cb67304b9d9c2f6a5be8d55cd35d44a3d79a988a90d4f9"}
{"id":"invariant:receipt-ed25519-verify","source":"invariant","sourceId":"ouroboros-codex","title":"Each signed receipt verifies under ed25519","text":"Every signed receipt must verify under ed25519 against the exact sha256 canonical bytes it was signed over — plaintext never enters a receipt, so the signature binds hashes, not prose. A hard verification failure means tamper or canonical drift. Rows signed under a rotated key are reported as KEY_ROTATED — an honest state, never a tamper verdict — and when no signing key is configured the check reports UNAVAILABLE rather than guessing.\n\nFalsifiable predicate: for every signed row: ed25519_verify(receiptJson, signature) === true under the current key\n\nDoctrine: notarized receipts — signature checks the exact canonical bytes\n\nThis chunk is the DECLARED definition of a runtime invariant; its live status is MEASURED per request at /api/invariants and is never stored in this corpus.","sha256":"a2d7ad0d3bfaeb23f711fd6fdf78f6c21546d2b5bd8d7eca0897c699e4e62c05"}
{"id":"invariant:receipt-columns-consistent","source":"invariant","sourceId":"ouroboros-codex","title":"Receipt payload matches its indexed columns","text":"The signed canonical payload and the ledger's indexed columns are two records of the same facts, and they must agree exactly: receiptId, goalSha256, outputSha256, and keyId parsed from the stored receipt must equal the row's own columns. Any disagreement is canonical/column drift or tamper — one of the two records is lying about the run.\n\nFalsifiable predicate: for every row with a stored receipt: parse(receiptJson).{receiptId, goalSha256, outputSha256, keyId} === the row's indexed columns\n\nDoctrine: canonical/column consistency — the signed payload and the columns cannot disagree\n\nThis chunk is the DECLARED definition of a runtime invariant; its live status is MEASURED per request at /api/invariants and is never stored in this corpus.","sha256":"2802f8888780644f3b307e34507548633a30f41089a9e19b1f7b89d0f7c86e78"}
{"id":"invariant:flywheel-lineage","source":"invariant","sourceId":"ouroboros-codex","title":"Flywheel eats only its own verified tail (own-metal, never demo/cloud)","text":"Sovereign flywheel lineage: the training loop consumes ONLY its own verified own-metal tail. Every training sample that carries a receiptId must join back to a real ledger run that was not a demo and was served by a named sovereign node. A sample tracing to a demo, cloud, or missing run violates the lineage claim — the flywheel would be eating something other than its own verified serves. Samples with no receiptId to join are excluded and stated, never silently counted.\n\nFalsifiable predicate: every training sample with a receiptId joins to a runs row with demo = false and servedNode IS NOT NULL\n\nDoctrine: sovereign flywheel lineage — samples come only from real own-metal serves\n\nThis chunk is the DECLARED definition of a runtime invariant; its live status is MEASURED per request at /api/invariants and is never stored in this corpus.","sha256":"4d4c8ab3a5135aa3139555d3e5a4893c7613df7a07a9eb360afa8b3b8e6f2747"}
{"id":"invariant:factory-batch-integrity","source":"invariant","sourceId":"ouroboros-codex","title":"Conjecture Factory batch is internally consistent (counts, totals, accept provenance)","text":"Self-audit of the committed Conjecture Factory batch artifact: the transcribed kernelAccepted count must equal the enumerated KERNEL_ACCEPTED rows, the per-family and per-generator totals must each sum to batchTarget (the factory's own candidate count — NOT the 269-formula corpus), and every accepted row must carry its leanSha256 provenance. This audits ARTIFACT INTEGRITY — transcription drift or a bad hand-edit — never the mathematics: a kernel accept is pipeline evidence only, it does not expand locked-proven (stays exactly 8) and does not upgrade Conjecture-1/2.\n\nFalsifiable predicate: over the committed factory batch: counts.kernelAccepted === |{results: verdict = KERNEL_ACCEPTED}|; Σ byFamily.total === Σ byGenerator.total === batchTarget; every KERNEL_ACCEPTED result has a non-null leanSha256\n\nDoctrine: artifact integrity — audits the batch transcription, NOT the mathematics; an accept never expands locked-proven (stays 8) and never upgrades Λ\n\nThis chunk is the DECLARED definition of a runtime invariant; its live status is MEASURED per request at /api/invariants and is never stored in this corpus.","sha256":"658518ab4c7214ab475986b22007226ce157a9637f2c42eed78c72a1832d1f54"}
{"id":"invariant:latent-verification-coverage","source":"invariant","sourceId":"ouroboros-codex","title":"Latent-space verification coverage (ANALOGY, not an invariant)","text":"MEASURED coverage — fraction of the enumerated ledger window whose trust is established purely in hash/signature space (ed25519 over sha256 canonical bytes, never plaintext). ANALOGY to the JEPA latent-space objective (verify over a compact derived space, not the raw object); the mechanism is a cryptographic digest + signature, NOT a learned embedding — nothing here is trained or predictive, and this does not prove or upgrade Λ. tamperFailed lowers the ratio; rotated (signed under a rotated key) and unsigned (rows predating signing) are honest complements, never failures.","sha256":"0c4b99f3882f070afb031d33f93aa38f07cb40e6c7c70d773408cf85b6bba4a8"}