Compile sources into reviewable context.

From sources to a reviewed capsule

Six stages, one invariant: models propose, humans decide, the compiler is deterministic. Typed artifacts let a reviewer inspect each stage.

1. 01

   Source pack

   Documents are normalized into a content-addressed pack: every file hashed, every span addressable, rights recorded. Source references are retained for later inspection.

   source_pack.json · spans · sha256 per document

2. 02

   Extraction proposals

   Models read the pack and propose — claims, episodes, graph edges, ontology terms, reasoning devices, language rules. Proposals are typed records with confidence and source spans. Models propose records; acceptance belongs to the review and promotion stages.

   extraction_proposals.jsonl · proposal boundary (ADR-007)

3. 03

   Review gates

   A human expert decides: approve, approve with caveats, or reject — per record. The design records the reviewer’s role and reasoning alongside each decision, so later readers can inspect how a record was accepted.

   reviewer_decisions.json · review_queue.json

4. 04

   Promotion

   Approved records enter the canonical ledgers. Rejected proposals remain traceable so the next analyst can inspect both decisions.

   promoted_record_set · promotion_summary.json

5. 05

   Deterministic compile

   Deterministic compilation aims to produce the same bundle from the same approved inputs and toolchain. Reproducibility lets reviewers compare versions and check integrity.

   manifest · ledgers · graph.jsonld · embedded graph

6. 06

   Archive & packs

   The bundle is packaged as a portable .capsule archive. PRAXIS context packs, agent skills, and MCP resources are intended consumption paths; each adapter needs its own integration checks.

   .capsule (mimetype-first zip) · context packs

A model-generated record can look convincing and still misread its source. Keeping proposals separate from accepted records gives a reviewer a place to inspect the evidence, record a reservation, or reject an interpretation before it is reused.

Why layered graphs, not one big graph

A single undifferentiated graph collapses things that must never be confused: what a source said, what an analyst concluded, when each became known, and which method produced the judgment. The proposed architecture separates nine responsibilities; the compiled historical reference has eight layers and no separate memory layer. These counts are a dated crosswalk, not a claim of nine deployed graphs.

The payoff is precision on both sides of the human-machine boundary: an agent can cite at the right level (this claim, from this span, under this trust rule), and a human can contest at the right level (the source is fine; the inference is wrong; the method was misapplied).

Inspect the reference capsule’s embedded graph

Alongside the semantic JSON-LD, the compiler builds a read-only Ladybug projection — capsule.lbug — an embedded graph database queryable with Cypher, no server required. It is digest-pinned to the source graph: if the semantic layer changes, the projection is rebuilt and both hashes are recorded. The snippets below are from the actual reference capsule, not mockups.

CREATE NODE TABLE CapsuleNode(
  id STRING, node_type STRING, label STRING,
  review_state STRING, source_span_ids_json STRING,
  properties_json STRING, PRIMARY KEY(id));

CREATE REL TABLE CapsuleEdge(
  FROM CapsuleNode TO CapsuleNode,
  id STRING, edge_type STRING, confidence DOUBLE,
  temporal_scope_json STRING, source_span_ids_json STRING,
  review_state STRING, explanation STRING);

MATCH (n:CapsuleNode) RETURN count(n) AS node_count;

MATCH (a:CapsuleNode)-[e:CapsuleEdge]->(b:CapsuleNode)
RETURN a.id, e.edge_type, b.id LIMIT 50;

"engine": "ladybug",
"database_path": "graph/ladybug/capsule.lbug",
"source_graph_digest": "sha256:f28a32eceba22140f2e14a19508e4bd8…",
"projection_digest":   "sha256:8ee639b5cec225f95127ab60250fc611…",
"read_only": true,
"rebuildable": true

Each capsule type gets a graph profile suited to what it holds:

Two clocks, thirteen relations

Every claim carries two timestamps: when the thing happened (valid time) and when the capsule learned it (observation time). The separation is what lets analysis be honest about its own past — “what did we know on the 14th?” is a query, not an argument. Episodes relate through Allen’s thirteen interval relations, and superseded claims chain to their successors instead of disappearing.

A kernel grammar, extended per capsule

The semantic layer starts from a kernel of eight typed primitives — the grammar practitioners actually think in — and grows a capsule-specific ontology blueprint on top: domain terms proposed during extraction, mapped with confidence, and promoted through the same review gates as everything else. The kernel is stable and MIT-licensed; the extensions are local, versioned, and provenance-mandatory.

The nine capsule layers and the eight kernel primitives are orthogonal: primitives are the vocabulary, layers are the epistemics. A Commitment is a primitive; whether it sits in claims (asserted), temporal (scheduled), or governance (reviewed) depends on what kind of statement is being made about it. Full formal treatment: the grammar and Ontology-Augmented Generation.

Reproducible builds and the limits of a hash

Reproducible compilation makes changes inspectable: the inputs, toolchain, and output must be recorded together. The proposed integrity envelope (ADR-009) adds a Merkle root over the bundle, Ed25519 signatures, and a future capsule verify. The reference capsule includes a SHA-256 digest, and the Seal you see in the viewer is drawn from that hash. A matching digest helps detect changes to the artifact; it does not establish that its claims are true or that its author is trusted.

Capsule anatomy, for reference: evidence · claims · graph · temporal · ontology · reasoning · memory · governance · runtime.