How donto works, one document at a time

Ten stages. Each one is a real, running part of the substrate — extraction and anchoring are deliberately separate; typing, joining and identity resolution are all deferred to query time. Jump to any stage:

1. 01Ingest the sourceblob · document · revision
2. 02Extract free claimsgenerative abundance
3. 03Anchor the evidencealways-on citer
4. 04Hold it — paraconsistentlybitemporal · I3
5. 05Embed into the fabricbge-small · 384d
6. 06Align at query timeclosure · identity-as-hypothesis
7. 07Measure contradictionH⁰ / H¹ · cocycles
8. 08Rank by reality⟨maturity, corroboration, pressure, recency⟩
9. 09Recall + reconcileFTS + vector + RRF
10. 10Return with provenancefact → span → blob

A source document arrives. donto content-addresses it (SHA-256), stores the bytes as a GCS-backed blob, and records a document + revision. Nothing is summarised-and-discarded — the raw resource is kept so every fact can point back to it.

A guided LLM reads the source and emits an unbounded, multi-directional space of subject–predicate–object claims, inventing predicates as it goes. A gleaning loop pushes for coverage, not a count. Typing and joining are deferred — emit free now.

A separate, always-on citer attaches each claim to an evidence span in the source — or honestly flags it as an unanchorable hypothesis (never a bogus span). Extraction says WHAT; anchoring says WHERE. This is what makes donto evidence-first.

Claims are written to donto_statement: bitemporal (valid-time + transaction-time) and paraconsistent. Contradictions are legal state held forever — never overwritten (invariant I3: retract/supersede, never DELETE). A vector DB collapses; donto holds.

Claims, predicates and entities are embedded (bge-small, 384-dim, HNSW) by a distributed coordinator that hands out disjoint work, so CPU and GPU workers scale linearly and never double-embed. This powers semantic recall and alignment.

Freely-minted predicates are folded by similarity (donto_predicate_closure): occupation ↔ currentJob become comparable without a hand-kept synonym table. Entity identity is a hypothesis resolved at query time, not a destructive merge at write time.

occupation  ─┐
             ├─ closure fold (cos ≥ τ) ─▶ one fact
currentJob  ─┘     no synonym table — learned

ex:coen  ≈  ex:coen-qld     identity = hypothesis,
ex:coen  ≠  ex:mcivor       resolved at query time

A cellular sheaf reads the argument, incompatibility and identity layers and computes H⁰ (the consistent core) and H¹ (irreducible disagreement) — including loop conflicts (cocycles) that pairwise edges literally cannot see. Pressure flows to standing.

ex:tommy ──hasRemovalOrderTo──▶ ex:yarrabah
    │                                  ▲
    └──────────── removedTo ───────────┘
loop residual ‖δx‖ = 2√2 ≈ 2.828  (cocycle)

Every claim carries a standing vector. donto re-ranks by reality over time instead of deleting on conflict — corroborated, low-pressure, recent claims rise; contested ones are surfaced, not silently dropped.

A question triggers hybrid recall (lexical FTS + semantic vector, fused with RRF), closure-folded and reconciled by a query-time sheaf pass that tags contested claims. Token-efficient, abstention-aware, scoped to the asker.

The answer comes back WITH its trail: each fact links to its evidence span, the span to its revision, the revision to the original blob — plus contradiction tags. Fully auditable: you can always get back to the source sentence.