Precompute trust, stream deltas, never fabricate.
OpsHiyma is an operational-intelligence platform that fuses geopolitical events, markets, sanctions, mobility, humanitarian, energy and space data into one working picture. This paper describes the one constraint the platform is built around — it does not serve a number it cannot account for — and shows how that constraint is enforced by code rather than promised by prose. Every figure below was measured from the repository by a script anyone can run, and the set of figures is sealed under a Merkle root you can check.
Abstract
Intelligence platforms fail in a specific, quiet way: the warehouse is emptier than the dashboard, and the gap is filled with plausible numbers. OpsHiyma’s own audits in mid-2026 found exactly that failure in its own code. The response was not a cleanup but a doctrine with teeth. Every served value carries a provenance envelope that states its source, its as-of time, and one of six honesty states. A user request never waits on a vendor; desks read canonical warehouse atoms or dated serving envelopes. A fabrication linter and a request-path linter run in CI with ratcheting debt ledgers that can only go down. On top of that floor sits an epistemic layer — content-hashed evidence, an Analysis of Competing Hypotheses kernel that refuses to rank an under-filled matrix, prediction ledgers scored by Brier against baselines, and a Trust Layer that reconciles disagreeing sources and issues Merkle certificates.
The paper closes with the evidence: 509 warehouse models, 1458 API routes, 289 connector manifests (224 keyless), 19853 unit tests, and the live row counts of the warehouse at the moment you loaded this page — followed by a ledger of what is not yet true, because a paper about honesty that hid its own gaps would refute itself.
The hollow warehouse
A data platform’s atom is a scalar cell, and a cell has no memory of where it came from, how sure anyone is, or who disagrees. Fill the store slowly and render it fast, and the gap gets filled with invention.
The failure is easy to describe and hard to see. A route needs a number; the table behind it is empty or stale; the developer reaches for a random walk, a hardcoded tape, a “representative” scenario. The panel renders under a live-looking header, the demo lands, and the invented value becomes indistinguishable from a measured one. Nothing crashes. That is the problem: fabrication is a silent success.
OpsHiyma lived this. A launch-readiness audit on 9 June 2026 counted roughly twenty endpoints and engines serving random or hardcoded data styled as real, a provenance module that was complete and used by one engine, and no scheduled ingestion in production. A systems audit three weeks later put the figure at about a third of the then-130 API routes serving some synthetic data, found fourteen stray database clients that would exhaust Postgres connections at the second Cloud Run instance, and found the best-engineered code in the repository — the Trust Layer — imported by nothing. Those audits are in the repository, unedited, under docs/launch-readiness-audit.md and docs/performance-and-ip-master-plan.md.
Five amnesias
Generalized, the local bug is the industry’s architecture. Four generations of warehouses changed where storage and compute live and never changed the atom. A modern warehouse has five kinds of amnesia:
- Provenance amnesia. Lineage answers which job produced a table, not what evidence and confidence sit behind one value.
- World-model amnesia. “Apple” in sales, “AAPL” in market data and “Apple Inc.” in the news table are three strings, not one entity.
- Single-source amnesia. Conflicts are resolved at write time into a golden record, and the disagreement — often the signal — is discarded.
- Scalar amnesia. Most real quantities are distributions with uncertainty; a cell flattens them into false precision.
- Passivity amnesia. The store waits to be queried. It does not decay stale beliefs, detect new contradictions, or re-check itself.
AI makes each of these worse, because model-generated values now enter stores looking exactly like measured ones, and because agents are about to act on those stores with no way to tell a corroborated measurement from a single-source guess. The rest of this paper is the answer OpsHiyma was forced to build for the hardest version of the problem — adversarial, contradictory, multi-source geopolitical data — and the reason we think that answer generalizes.
Doctrine: never fabricate
Random numbers dressed up as live intelligence are never acceptable.
That sentence is the header comment of lib/provenance.ts, and everything else follows from it. A route either returns real data with a status of live, cached or stale, an explicit no-data envelope when the warehouse or source is empty, an error when the source failed, or simulated when a value is modeled rather than measured — in which case it is also flagged modeled: true and must be labelled as such wherever it is drawn.
The envelope
| Field | Meaning | Why it exists |
|---|---|---|
| source | Human-readable source name, with an optional click-through URL | A number with no named source is a rumor |
| asOf | When the underlying data was produced or observed; null when unknown | Time honesty: the world’s clock, not ours |
| fetchedAt | When this server fetched or computed the value | Capture time must never masquerade as observation time |
| status | One of the six states above | The reader can tell real from modeled from absent at a glance |
| confidence | 0..1 where a calibrated number exists | Optional on purpose — an uncalibrated confidence is decoration |
| modeled / note | True for simulated values; a qualifier for tooltips | Simulated and no-data must be visually unmistakable from live |
Two of those fields carry most of the doctrine. asOf versus fetchedAt is the difference between “this price is from 16:00 yesterday” and “we looked at 09:12 today”; an options change once let capture time pollute the as-of stamp of a desk and was treated as a correctness bug, not a cosmetic one. And no-data is a first-class answer: a panel that renders an honest empty is doing its job, and the UI has a dedicated vocabulary for it — a provenance badge, a simulated tag, and a full-width prototype banner for surfaces that are illustrative by design.
The request path
Vendor I/O belongs in ingest. The user GET reads the warehouse. A provenance-honest live fetch is still a violation.
The doctrine froze on 3 September 2026 (docs/warehouse-request-path.md) after the options desk proved the shape: read Postgres, return immediately, and refresh the vendor — if at all — after the response has been sent. Four rules, applied to every desk:
- The handler never waits on a vendor.
- History is warehouse-only. A past date is served from stored rows or not at all.
- Today may refresh in
after(), a connector, or a worker — never in the GET. - Missing data is an honest empty, not an upstream round trip.
Serving envelopes
Heavy desks do not recompute on every request. They store a dated JSON product in a DeskEnvelope row keyed by desk, UTC session date and schema version, and the GET returns that row. Only today’s row can be stale; when it is, reassembly from canonical atoms is scheduled after the response and deduplicated per desk so a sixty-second poll from many tabs cannot stack rebuilds. A schema mismatch always refreshes. 20 desk schemas are registered this way today, each with its own freshness budget:
| Desk | Envelope key | Freshness budget |
|---|---|---|
| Truth Board | fusion:truth-board:{lookback} | 60 s |
| Escalation board / region | escalation:board · escalation:region:{key} | 15 min |
| Commodity War Room | comwar:board | 60 s |
| Country dossier | country:{iso2} | 6 h |
| Maritime | LogisticsSnapshot | worker ingest; the GET is read-only |
The warehouse spine
Everything a desk shows is a read of a canonical atom that a connector wrote, behind a raw record that was hashed on arrival.
A connector is a directory with a manifest — its class, freshness target, pull type, auth, endpoints, sync strategy and target tables — and a parser. The ingestion engine runs it, writes an IngestRun audit row with status, cursors in and out, fetched and upserted counts, and observed lag, drop rate and jitter, then persists every original payload as a RawRecord with a SHA-256 payload hash. Raw records carry two independent unique keys, external id and payload hash, and the engine resolves against both before writing — a re-run of any snapshot connector used to violate the second key and take the connector down after its first successful run.
Canonical atoms
| Atom | Key discipline | What it remembers |
|---|---|---|
| Event | source + externalId; optional clusterId | occurredAt and t0Utc, latency from source to ingest, first-seen source, truth / impact / actionability scores |
| Series → Observation | Series unique on (provider, dataset, seriesKey); Observation unique on (seriesId, ts) | ts is when the world was in that state; reportedAt is when the source published or revised it — replayable as reported |
| GeoFeature | unique on (source, layerKey, externalId, validFrom) | GeoJSON geometry with validFrom / validTo, a shaded metric and unit |
| Entity · Relationship | normalized name, aliases, identifiers, match confidence | The world model the events, sanctions, claims and exposures hang from |
| Claim | subject – predicate – object with qualifiers | status ACTIVE / DISPUTED / RETRACTED / CONFIRMED, and the contradicting claim’s id |
| Evidence | contentHash unique (SHA-256 of the original) | The citation spine: two citations of one wire story are one document |
Labelling happens once, at ingest. The headline labeller replaces substring matching — where “war” matched “software” and “gas” matched “Gaza” — with a word-boundary country tagger, stem-and-phrase topic matching, an auditable tone lexicon, and an urgency that is source-declared only: a wire marker at the head of the title raises it, and no keyword ever does. The same module compiles into the standalone ingestor and the web app, so there is exactly one labeller.
Enforcement as code
A promise you cannot lint is a hope.
The doctrine is only interesting because it is enforced where code lands. Every push runs 0 gates in continuous integration, read from the workflow file at measurement time:
Two ratchets
The fabrication gate has two detectors. The first flags Math.random() in a data-serving path unless the draw declares its intent — a file-level annotation for synthetic generators whose output is labelled simulated at the route boundary, or a line-level one for ids, nonces, jitter and layout. The second flags an array of three or more object literals carrying intelligence-shaped keys — price, volume, spread, probability, impact, score — inside a module that reads no data source: the literal tape of invented prints under a live-looking header, which no random-number detector can find.
When the gate was widened to the component tree it found real debt that could not be paid in one change, so it ratchets: each file may carry at most the offense count recorded in a ledger; more fails the build; fewer also fails, asking you to ratchet the ledger down; a file not in the ledger starts clean. Debt never silently reappears once paid. The request-path gate has the same shape for outbound vendor I/O and value imports of vendor SDKs in request-path modules.
Drift guards
Three tests walk the app/ directory and compare it with a registry, so coverage is a property of the data rather than of whoever last edited a navigation component. The nav-tree test fails when a page exists that no navigation surface lists, or when a nav row points at no page — before it, twenty-seven shipped pages were reachable only from inside their parent and two had no inbound link anywhere. The login-gate test holds the open tier and the public route group in lockstep, so no page becomes readable by strangers — or stops being readable — by accident. A third fails when a page under that group is not registered in the shell map, which this paper triggered on its first render: it drew the desk chrome over its own text and could not scroll. And the paper’s own test re-measures the repository and fails when the committed snapshot drifts more than ten percent from the tree — the paper may age, but it may not lie.
Underneath, TypeScript runs with 6 strictness flags (strict, exactOptionalPropertyTypes, noUncheckedIndexedAccess, noImplicitOverride, noFallthroughCasesInSwitch, verbatimModuleSyntax) and 19853 unit tests across 2371 files. The suite compiles pure modules directly rather than mocking them, including 40 connector parsers, so a vendor that changes its payload shape is caught against a captured fixture before the change can reach the warehouse.
The epistemic layer
The honesty floor says what a number is. The epistemic layer says what we believe, on what evidence, with what confidence — and refuses when it cannot.
The long-run thesis (docs/epistemic-warehouse-thesis.md) is to change the atom: from a scalar cell to a Verifiable Claim — subject, predicate, object; a value or a distribution; an epistemic class from measured to synthetic; a content-addressed evidence chain; corroboration and contradiction; calibrated confidence with a trajectory; and a proof. What exists today is the working seed of that atom, built where the intelligence use case forced it.
Evidence that refuses
Evidence had held zero rows since it was designed until the Assessment desk gave it a writer. That writer enforces four refusals rather than four conventions: it never mints evidence from the platform’s own computed output, because citing a score we calculated as evidence for a judgment we are calculating is how a provenance platform starts fabricating; it never cites the future, because a citation carries a knowledge cursor and a row ingested after it is refused as not-yet-known — the writer records why: on this warehouse the median displacement record lands 122 days after the event it describes, so a replay without that cursor has look-ahead bias in every run; the only source it may create is an analyst upload; and it deduplicates by content hash, not by row.
Analysis of Competing Hypotheses, done the right way round
The Assessment desk runs Heuer’s method as a pure kernel — no I/O, no dates, no randomness, deterministic for a given matrix — with four load-bearing rules. Consistency never enters the ordering; only weighted inconsistency does. Diagnosticity multiplies into the ordering key, so evidence that says the same thing about every hypothesis cannot move the ranking — that invariance is the acceptance test. “Not applicable” is not zero; it changes the coverage denominator. And an under-filled matrix refuses to rank. Every constant lives in one parameter block whose hash is written onto the seal, so a published ranking can be replayed years later and proven.
Around the kernel sit six models — Assessment, Hypothesis, EvidenceLink, AssumptionCheck, Judgment, ResolutionCriterion — with append-only revisions, a status machine from draft to published, superseded or retracted, and a blocked state whose payload names the missing collection: which lane, which connector, what its last run said, and what would unblock it. A model may draft an assessment; a human commits it, and model prose is never rendered as product — only the structured fields it filled.
Ledgers that are graded by the world
A political-risk desk’s claim that it can say something about a vote before it happens is untestable unless it is written down before the vote in a form that cannot be argued with afterwards. The election call ledger records, one day before polling, the crowd’s normalized probability vector, the poll average over the same outcomes when one exists, and a uniform prior over the outcome count — the floor a model must beat to be worth anything. Scoring is multi-class Brier, with a skill score against each baseline, and nothing is graded until the result is known from the world — a declared winner or a settled contract — never from the market’s own final price, because grading a market against itself always flatters it.
Three legs, one board
The Truth Board reads what sources say (narrative tone from GDELT), what crowds price (Kalshi and Polymarket contracts), and what measurement shows (warehouse series), and treats the spread as the signal. Its first working version compared raw levels and immediately produced five of six topics “divergent” at the same values every time, because news vocabulary is structurally negative and most geopolitical contracts are tails: differencing a 60 and a 12 yields a constant, not an observation. Each leg is now standardized against its own distribution across the topics on the board, so a constant offset cancels and the question becomes the one the desk actually asks — relative to how alarmed the story is about everything else, is the money unusually calm about this? A row is divergent only when some leg is a genuine outlier, not merely the largest member of a quiet set.
The same discipline runs through the regional escalation nowcast — nine weighted inputs, a confidence that is the coverage of the inputs applicable to that region, and a NO_DATA state a Gulf reading is not penalized into for lacking a European grid — and through the political-risk tools, which return “watched, not scored, because …” for an unmeasured country rather than a plausible number.
The Trust Layer
A standalone, warehouse-agnostic library that audits a dataset for honesty, scores it, reconciles disagreeing sources into one belief, fingerprints synthetic data, and issues a verifiable certificate.
lib/trust-layer/ has no dependency on the platform’s schema or runtime; it consumes a dataset profile from an adapter and could be lifted into its own package unchanged. Its pipeline runs audit → trust score → certificate, and reconciliation beside them:
| Stage | What it does | Detail that matters |
|---|---|---|
| Audit | Per-column honesty findings | missing provenance · stale-as-fresh · fabrication fingerprints · single-source critical fields · low epistemic class |
| Trust score | 0–100 with a letter grade | Aggregates findings, epistemic quality and contamination with hard caps; the demo dataset scores 69 / D |
| Reconciliation | N source claims → one belief state | Trust-tier weights S 1.0 · A 0.8 · B 0.6 · C 0.4 · D 0.2; epistemic weights measured 1.0 → synthetic 0.1; MAD outliers; consensus unanimous / majority / split / dissent / single / none |
| Contamination | 0..1 synthetic-data score | Constant or low-distinct values, excessive float precision, histogram flatness, Benford first-digit deviation, templated text |
| Certificate | SHA-256 Merkle proof | Leaf and node hashes are domain-separated (RFC 6962 style) so a leaf can never be replayed as an internal node |
The domain-separation detail is there because an audit found it missing: without the prefixes, an internal node could be presented as a leaf with a valid inclusion proof — the classic second-preimage forgery. It was fixed before the certificate was used for anything that mattered, and the seal on this page uses the fixed code.
AI under the same doctrine
A model is an untrusted source like any other: it is routed, cross-examined, hashed, gated, and given tools that refuse to guess.
The Sovereign Intelligence Fabric routes each task to a model through one task router with adapters for Anthropic, OpenAI, xAI and local Ollama models, so callers speak a neutral message and tool vocabulary and the provider is a routing decision. The Adversarial Consensus Engine sends the same prompt to several models, builds an agreement matrix, detects divergences — which it treats as the interesting output — computes each model’s bias signature, scores confidence by track record and agreement, and produces a fused answer with provenance. The provenance chain hashes each model’s reasoning with SHA-256 into a record of which models were consulted, what they agreed on, and what the alignment rules said. Those alignment checks and the human approval queue write to one shared, queryable gate log — the existing audit trail — rather than each inventing its own.
The tool loop
The copilot at /api/copilot is the first endpoint that hands a model a tools array. The loop calls the model with the available tools, executes what it returns, appends the results, and calls again; it terminates when the model stops calling tools, at a hard iteration ceiling, or by returning an executor error to the model instead of aborting. Only tools that require no approval — the read and analysis set — are exposed, and the gate is enforced twice: withheld from the schema list, and refused by the executor even if a model names one. The transcript of every call and result is returned with the answer, inside a provenance envelope.
Desks are tool-first. The model does not answer “how unstable is Romania” from memory; it calls the country reading, which returns every leg with its reason and the coverage-derived confidence, or the reason the country was held back. An answer can therefore cite its evidence, and an unmeasured country produces a refusal rather than a plausible number. The Assessment desk applies the same rule to the model’s own prose: a model may draft, its transcript is kept beside the validator’s rejection log, and none of that text is rendered as product.
The trust boundary
Default-deny at the edge, a signed identity that cannot be forged, a tenant guard that lives in one place, and a metering seam that never slows a request.
- Default-deny proxy. Every API route requires an authenticated identity; elevated paths — admin, agents, ingestion, premium and analyst surfaces, geocoding, the mutating control-plane routes — add a role requirement. The genuinely public API is two probes: health and readiness.
- Every desk needs a session; the open tier is a declared list. One module names what renders without signing in — the login page, static assets, and the marketing and legal pages under the public route group, this paper among them. Everything else redirects to the login screen. The list is not a pattern and carries no wildcard: a route is reachable anonymously only if it appears there literally, and a drift guard walks the route group in both directions, failing the build when a page is added without being declared or a declaration outlives its page.
- Signed sessions. The cookie carries an HMAC-SHA256 token over the resolved identity — user, role, organization — with issue and expiry stamps, verified at the edge and in server components; it is valid for eight hours and revocable through a Session row before then.
- Credentials without email. A username plus an access key in Crockford base32, stored only as a SHA-256 hash, compared in constant time, with uniform denial and exponential lockout. The key is minted at claim time and revealed once, so the plaintext never exists at rest in any form.
- One tenant guard. The proxy strips any client-supplied tenant header and injects the verified one; routes call one helper that returns 403 when there is no tenant context, constrain reads to the tenant, answer 404 rather than 403 on cross-tenant existence so nothing leaks, and stamp ownership on writes so a client can never set it.
- External keys and metering. API keys with a recognizable prefix are rate-limited per hashed key bucket; the metering seam records billable work per organization per UTC day after the response is computed and is never awaited.
Those four tiles are the honest state of adoption. The guard, the meter and the cache directive are each a few lines per route; the work that remains is mechanical and is tracked in §13 rather than assumed here.
Every noun is a URL
A country, an event, a chokepoint, a facility, a sanctions program, a territory, a treaty: each is an addressable object with one metric contract, so comparison, linking and citation cost nothing per kind.
The object spine registers 7 kinds with canonical ids — ISO 3166-1 alpha-2 for countries, UN/LOCODE where one exists for facilities, slugs elsewhere — and every kind emits the same dossier shape: a list of metrics, each with a value, a unit, a direction where one is defensible, and its own provenance. The universal side-by-side zips two dossiers by metric key. It computes a delta only when both sides resolved a number — one side missing is reported as no comparison, never as a delta against zero — and it names a leader only when the metric declares a direction, because without one bigger is just bigger and calling it better would be an editorial claim the data does not support.
The object index is honest in a specific way: it lists what the warehouse can actually serve, not what a registry declares. A chokepoint with no port snapshot and no AIS box is still listed, and its count says zero — that is the coverage story, and hiding it would turn the index into a brochure. Events additionally carry a source race: who reported first, and by how many minutes.
The catalog status is itself a doctrine: live means built and wired to real data, building means partial real backing exists, and planned means designed and rendering an honest scaffold — never fabricated data. The split is measured from the catalog, not from a slide.
Data strategy
Latency costs money. Breadth is free. The moat is the join, and the join is free.
There are two businesses a platform like this could be. One competes on latency — the equity consolidated tape, the options feed, a low-latency newswire — against firms with nine-figure data budgets, on data everyone else also buys. The other competes on correlation across domains that nobody joins in one place: public filings, government open data, disclosure feeds, sanctions regimes, humanitarian trackers, weather, orbit. Its floor cost is close to zero and nobody is contesting it, because the work is unglamorous integration rather than a rack in a data center. OpsHiyma chose the second, and the connector fleet is that choice made concrete.
Those are three different sets and the paper keeps them apart: 290 connector directories exist, 289 of them declare a manifest (1 is a hand-written client), and 288 are named in the loader registry — a connector the registry does not name is code that never runs, which is the kind of gap a single blurred number hides.
| Freshness target | Connectors | Examples |
|---|---|---|
| realtime | 13 | GDELT, USGS seismic, NWS alerts, ISS position |
| near_realtime | 24 | Equity tape prints, Kalshi, NASA FIRMS, RSS wires |
| hourly | 69 | OpenSky, AIS, fusion crowd sweep |
| daily | 118 | OFAC, FINRA short volume, FRED, IDMC displacement, HDX |
| weekly | 51 | CFTC positioning, Statistics Canada |
| other | 14 | cadences outside the standard set (15min, fast) |
The join
The end product is a terminal where every number traces to a public record, and its core loop runs entity → ownership → exposure → event → positioning: who is this thing (legal-entity and security-master identifiers), who controls it and are they sanctioned (13D/G and 13F filings against six sanctions regimes), what is it physically dependent on (trade, awards, grid, shipping and flights), what just happened to it (events, filings, rulemaking, disasters), and how is money placed against it (insider and institutional filings, short interest, futures positioning, crowd markets). Every incumbent holds every one of those datasets and cannot ask the question in one place, because they live in different products.
Evidence
Two kinds of figures. The first set was measured from the repository at build time and sealed; the second is read from the warehouse when you load this page, inside its own provenance envelope.
Measured from the code
Hover any chip for the exact method. All of these come from lib/whitepaper/facts.json, written by npm run whitepaper:facts at commit 259feb2 on 2026-11-21.
Read from the warehouse now
Large-table counts are the planner’s live-tuple estimates (marked ≈), because an exact count over a multi-million-row table is a sequential scan and this is a page, not a job; governance tables are counted exactly. If the warehouse is unreachable when this renders, this block says so instead of remembering.
The seal
The full certificate with a per-figure inclusion proof is served at /api/whitepaper/facts.
What is not yet true
A paper about honesty that hid its own gaps would refute itself. Each row is a claim the platform wants to make, its state today, and the measured evidence.
Two further caveats. The desk catalog’s status split — 26 live, 55 building, 5 planned — is the platform’s own assessment against its own definitions, and “live” means wired to real data, not that every panel on that desk carries an envelope. And the deployment workflow defines an hourly ingestion job; whether that job is running at any given moment is something the live proof in §12 shows through the last successful run, not something this paper asserts.
Roadmap
Convergence before width: close the foundation, prove one desk end-to-end with every cross-cutting guarantee, then fan every workstream onto that one spine.
| Phase | What changes | Gate to pass |
|---|---|---|
| E1 · Promote the atom | Every ingested datum becomes a versioned, evidenced claim; the six-state status grows into the full epistemic class taxonomy, stamped at write time | Claim + Evidence become the central write path |
| E2 · Reconcile sources, not just models | Re-point the consensus engine at multi-source data: corroboration, contradiction, outliers, confidence as a reusable service; persist the provenance chain | Reconciliation API on real vendor disagreement |
| E3 · Belief-time | A third time axis — when we came to believe a value and how confidence moved — and a query surface that filters on epistemics and answers AS OF BELIEF | As-of served from DeskEnvelope first, then everywhere |
| E4 · Transparency log | Content-address claims and evidence into a durable Merkle log; export proofs for compliance and data marketplaces | A /verify endpoint over persisted certificates |
| E5 · Productize the substrate | The Trust Layer with a Postgres adapter pointed at this warehouse as the lighthouse reference, then external estates | A published Trust Audit of the platform’s own warehouse |
In parallel, the mechanical adoption that §13 names — the tenant guard, the meter, the cache directive and the envelope on every remaining route — proceeds under the existing gates, and embeddings replace token overlap across consensus, fusion and clustering. None of it widens the plan; each item is an instance of the pattern the rest of this paper describes.
Verify this paper
Do not take the figures on trust. Re-measure the tree, run the gates, and check any figure against the root.
npm run whitepaper:facts # re-measure the tree → lib/whitepaper/facts.json
npm test # includes tests/whitepaper-facts.test.ts: drift tolerance + seal
npm run lint:fabrication # the fabrication ratchet
npm run lint:warehouse-path # the request-path ratchet
npm run lint:series-keys # the warehouse key contract (needs a reachable warehouse)
npm run trust:audit # the Trust Layer pipeline on its demo datasetGET /api/whitepaper/facts
→ { repo, seal: { certificate, claims[ { key, value, method, contentHash, proof[] } ] }, warehouse, provenance }
leaf = sha256("00" + sha256(stableStringify({ key, value, method })))
node = sha256("01" + left + right) # odd node pairs with itself
root = fold leaves pairwise until one hash remains — it must equal certificate.merkleRootimport { hashClaim, verifyProof } from './lib/trust-layer/certificate';
const res = await fetch('/api/whitepaper/facts', { headers: { cookie } }).then((r) => r.json());
const c = res.seal.claims.find((x) => x.key === 'apiRoutes');
const leaf = hashClaim({ key: c.key, value: c.value, method: c.method });
console.log(leaf === c.contentHash, verifyProof(leaf, c.proof, res.seal.certificate.merkleRoot));If a re-measurement disagrees with a printed figure by more than the drift tolerance, the unit test fails and the fix is to regenerate the snapshot — there is no way to edit a figure by hand that survives the test.
Glossary & references
- Provenance envelope
- The record attached to every served value: source, asOf, fetchedAt, one of six statuses, optional confidence, a modeled flag and a note.
- Serving envelope
- A dated, schema-versioned JSON product a heavy desk stores and returns instead of recomputing; reassembled from canonical atoms after the response, for today only.
- Canonical atom
- Event, Series/Observation, GeoFeature, Entity/Relationship, Claim, Evidence — the warehouse rows a desk is allowed to read.
- Ratchet
- A CI gate whose ledger of tolerated legacy offenses can only decrease; more fails, fewer fails until ratcheted, unknown files start clean.
- Drift guard
- A test that walks the real tree and compares it with a registry or snapshot, so coverage is a property of the data.
- Verifiable Claim
- The target atom: subject–predicate–object, value or distribution, epistemic class, evidence chain, corroboration and contradiction, calibrated confidence, proof.
- ACH
- Analysis of Competing Hypotheses. Hypotheses are ranked by weighted inconsistency only; consistency never counts; under-filled matrices refuse to rank.
- Admiralty code
- Source grading: reliability A–F, credibility 1–6. The basis of a grade — authored, derived, earned, unrated — is always shown.
- ICD 203
- The intelligence-community analytic standard. Confidence (low / moderate / high) has no probability; likelihood uses the seven-band yardstick.
- Brier score
- Σ (pᵢ − oᵢ)² over outcomes; 0 is perfect, 2 maximally wrong. A skill score against a baseline says whether the desk added anything.
- Nowcast
- A composite index whose confidence is the coverage of its applicable inputs, and which reports NO_DATA rather than a default when they are missing.
- Merkle seal
- A SHA-256 Merkle root over a set of claims with leaf/node domain separation and per-claim inclusion proofs.
- Tenant guard
- One helper that binds a request to its verified organization and constrains every tenant-owned read and write to it.
- Tool loop
- The bounded model-calls-tools cycle behind the copilot, restricted to tools that require no approval.
Sources in the repository
- lib/provenance.tsThe envelope and the doctrine sentence.
- docs/warehouse-request-path.mdThe request-path freeze and the serving-envelope contract.
- scripts/check-fabrication.mjs · scripts/check-warehouse-path.mjs · scripts/check-series-keys.mjsThe three honesty gates and their ledgers.
- prisma/schema.prismaThe warehouse spine, including the bitemporal Observation and the content-hashed Evidence.
- lib/intel/ach-kernel.ts · lib/intel/evidence-writer.ts · lib/intel/types.tsThe ACH kernel, the Evidence writer’s refusals, and the ICD 203 vocabulary.
- lib/political-risk/ledger-pure.tsThe election call ledger and its Brier scoring.
- lib/fusion/divergence.ts · lib/escalation/index-pure.tsStandardized-leg divergence and the coverage-confident nowcast.
- lib/trust-layer/Audit, trust score, reconciliation, contamination, certificate.
- lib/copilot/tool-loop.ts · lib/copilot/tool-bridge.ts · lib/sif/ace/The tool loop, its safety gate, and the consensus engine.
- lib/auth/org-scope.ts · lib/auth/session.ts · lib/auth/public-routes.ts · proxy.tsThe tenant guard, signed sessions, the page gate and the default-deny proxy.
- lib/objects/The object spine: kinds, dossiers, the universal compare.
- docs/epistemic-warehouse-thesis.md · docs/trust-layer-gtm.md · docs/zero-cost-data-strategy.md · docs/completion-program.mdThe thesis, the commercialization of the Trust Layer, the data strategy, and the convergence program.
- lib/whitepaper/This paper’s collector, snapshot, seal and warehouse proof.
Questions about the platform go through support. This document is a public draft and will be re-sealed whenever the snapshot is regenerated.