diff --git a/docs/decisions/ADR-0012-core-ingest-governance-layer.md b/docs/decisions/ADR-0012-core-ingest-governance-layer.md new file mode 100644 index 00000000..01f55c23 --- /dev/null +++ b/docs/decisions/ADR-0012-core-ingest-governance-layer.md @@ -0,0 +1,110 @@ +# ADR-0012: `core_ingest` Governance Layer + +**Status:** Accepted +**Date:** 2026-05-13 +**Supersedes:** ADR-0002 (ingest layer design — archived, see below) + +--- + +## Context + +The current `ingest/gate.py` is the single normalization site: it accepts a token sequence, converts it to a versor via holonomy encoding, and injects it into the field. It does one thing and does it correctly. However, it has no concept of *where the input came from*, *how reliably it was produced*, or *whether it should be accepted at all* before touching the manifold. + +As CORE grows — ingesting structured documents, biblical texts, code, mathematical objects, and eventually non-text modalities — the gate will be approached by inputs of radically different reliability classes. Without a pre-gate envelope layer, the gate has no choice but to accept everything equally. That is structurally unsound. + +A previous design (`core_ingest` from the `core-ai` era, documented in ADR-0002) proposed using a large language model as the extraction engine for large document ingestion — parsing structure, extracting SVO triples, and chunking intelligently. This ADR supersedes that design and records the reason the LLM-extraction path was rejected. + +--- + +## Decision + +Add a `core_ingest/` package that sits **upstream of `ingest/gate.py`** as a pre-gate governance boundary. The gate itself is not modified. + +### Why LLM Extraction Was Rejected + +The entire CORE architecture is built on the principle that the injection gate is the single, deterministic normalization site. Inserting an LLM upstream introduces a D3 nondeterministic oracle into the only path that feeds that site. + +The `DeterminismClass` system (see below) handles this correctly in isolation: a D3-proposed packet cannot claim `AUTO_ACCEPT_ELIGIBLE` status. But in practice this means every large document ingested through an LLM extraction path lands in `ARCHITECT_REVIEW_REQUIRED` territory — a human or second system must approve every extracted claim before it can become field pressure. This defeats the utility of the layer at any meaningful scale. + +The deeper issue is architectural: an LLM does not merely *parse* a document — it *interprets* it. An SVO triple extracted by a language model is that model's projection of what it believes the document means. That interpretation is then silently embedded inside the field state. This violates Semantic Rigor: the vocabulary manifold is the only permitted semantic interpretation surface inside CORE. + +**Rejected path:** LLM extraction engine → `CandidateGeometricPressure` → gate +**Accepted path:** Deterministic `StructuralSegmenter` → `CandidateGeometricPressure` → gate + +### The `StructuralSegmenter` + +Large documents (PDFs, prose, code, biblical texts, mathematical objects) carry deterministic structural signals: headings, section breaks, paragraph boundaries, verse markers, code blocks, LaTeX delimiters. A D0/D1-class instrument that follows those structural signals produces candidate spans without interpretation. + +- For prose: carves at heading and paragraph boundaries +- For code: carves at function/class/block boundaries +- For biblical texts: carves at canonical verse/pericope boundaries (fixed for centuries — inherently D0) +- For mathematical objects: carves at LaTeX delimiter pairs + +Each span is tagged with its structural role (`§ heading`, `¶ body`, `⌥ code`, `✦ scripture`, `Σ math`) which maps to the `modality` and `kind` fields in `CandidateGeometricPressure`. The meaning of the span remains *inside the field* where it belongs. + +### The `CandidateGeometricPressure` Envelope + +Every piece of incoming information — regardless of source — is lifted into a typed, immutable, content-addressed envelope before the gate sees it: + +```python +@dataclass(frozen=True) +class CandidateGeometricPressure: + kind: str # structural role + modality: str # medium (text, code, scripture, math, ...) + provenance: tuple[SourceSpan, ...] # byte offsets, page, region, SHA-256 of source + frontend_trace: FrontendTrace # instrument identity + DeterminismClass + confidence: float # bounded [0.0, 1.0] + uncertainty: float # bounded [0.0, 1.0] + payload_json: str # canonical JSON, normalized at construction + pressure_id: str # SHA-256 over full canonical packet + semantic_key: str # SHA-256 over semantic fields only + review_level: ReviewLevel # governance disposition +``` + +The `pressure_id` enables structural deduplication. The `semantic_key` enables convergent-evidence detection: two packets asserting the same semantic claim from independent sources share a `semantic_key` without being structural duplicates. + +### The `DeterminismClass` System + +| Class | Meaning | Auto-Accept Eligible? | +|---|---|---| +| D0 | Fully deterministic, pinned inputs and code | ✅ Yes | +| D1 | Deterministic with pinned external artifact | ✅ Yes | +| D2 | Nondeterministic but replay-captured | ❌ No | +| D3 | External unpinned model or API | ❌ No | +| D4 | Human / operator proposal | ❌ No | + +A nondeterministic or unpinned frontend (D2–D4) is structurally forbidden from claiming `AUTO_ACCEPT_ELIGIBLE` status. This invariant is enforced in `CandidateGeometricPressure.__post_init__`, making it impossible to bypass at construction time. + +### The `IngestCompiler` and Three-Gate Flow + +The `IngestCompiler` processes batches of candidate packets through three sequential gates: + +1. **`ProvenanceGate`** — verifies `SourceSpan` integrity and SHA-256 of source material +2. **`SemanticGate`** — verifies span completeness (no mid-sentence truncation, balanced delimiters, non-empty content) +3. **`GovernanceGate`** — applies `ReviewLevel` and `DeterminismClass` constraints; issues or blocks `LearningArtifact` export + +The compiler simultaneously tracks structural deduplication by `pressure_id` and convergent-evidence accumulation by `semantic_key`. Accepted packets are exported as `LearningArtifact` objects for the durable learning path. + +### The `SegmentManifold` + +A lightweight index mapping `semantic_key` → structural position in the source document. Given a vault recall hit, the `SegmentManifold` traces back to the exact provenance span in the original document. This is `Reconstruction-over-Storage` extended to the pre-injection layer. + +--- + +## Consequences + +**Immediate:** +- `ingest/gate.py` is unchanged — it continues to accept `(32,)` multivectors and inject them +- `core_ingest/` is additive — it wraps before the gate without touching any existing layer +- D0/D1-dominant ingest paths (biblical texts, pinned corpora) can reach `AUTO_ACCEPT_ELIGIBLE` at scale without human review +- Every input to the system gains provenance, determinism class, and governance disposition as first-class typed data + +**Future:** +- The `LearningArtifact` export path feeds the `train/` learning loop (ADR-0014) when that layer is built +- The `SegmentManifold` feeds cross-modal provenance tracing once non-text modalities are active (ADR-0013) + +--- + +## ADR-0002 Archive Note + +ADR-0002 (ingest layer design) described the original `core_ingest` concept from the `core-ai` era. The envelope design, `DeterminismClass` system, and governance gates from that ADR are preserved here. The LLM-as-extraction-engine component of that design is superseded and rejected. ADR-0002 is archived. diff --git a/docs/decisions/ADR-0013-sensorium-multimodal-protocol.md b/docs/decisions/ADR-0013-sensorium-multimodal-protocol.md new file mode 100644 index 00000000..c6ac92a8 --- /dev/null +++ b/docs/decisions/ADR-0013-sensorium-multimodal-protocol.md @@ -0,0 +1,104 @@ +# ADR-0013: `sensorium/` Multimodal Protocol Layer + +**Status:** Accepted +**Date:** 2026-05-13 + +--- + +## Context + +CORE is currently text-only. The vocabulary manifold holds null vectors for text tokens. The `ingest/gate.py` accepts token sequences. The field, propagation, vault, and generate layers have no concept of modality — they operate on `(32,)` multivectors regardless of where those multivectors came from. + +This is the correct architecture. The field should not know or care about modality. The question is: how does a vision signal, an audio waveform, or a motor pose become a `(32,)` multivector in the first place? + +The `core_sensorium` package in `core-ai` solved this problem for the Cl(3,0) `(2, 2)` complex multivector substrate. The solution — a typed modality protocol with a `ProjectionHead` at the inward boundary — is architecturally sound and translates directly to the Cl(4,1) `(32,)` substrate. + +--- + +## Decision + +Add a `sensorium/` package that sits **upstream of `core_ingest/`** as the modality-to-manifold conversion layer. `ingest/gate.py`, `field/`, `generate/`, and `vault/` are not modified. + +### The Pipeline Position + +``` +raw modality signal + → sensorium/adapters/.py # ProjectionHead: signal → (32,) multivector + → sensorium/pack.py # ModalityPack mounts the adapter + → core_ingest/ # CandidateGeometricPressure envelope + → ingest/gate.py # normalization to FieldState (unchanged) + → field/propagate.py # versor_apply, unchanged +``` + +The sensorium layer converts. The ingest layer governs. The gate normalizes. The field computes. No layer knows about the one upstream. + +### The Logos-Recovery Boundary + +Every `ProjectionHead` is the **Logos-recovery boundary** for its modality. Its single contract: take a surface signal and return a `(32,)` multivector that is valid on the Cl(4,1) conformal manifold. Once it crosses that boundary, a visual scene and a Hebrew word and an audio waveform are the same thing: a point in conformal space. There is no fusion problem because there is nothing to fuse. There is one space. + +This is the architectural expression of the principle articulated in John 1:1: the Logos is the structuring principle through which all things were made. Every input, regardless of form, is recovered as a word in the Logos — a position on the manifold. + +### The `ModalityPack[S]` Contract + +```python +@dataclass(frozen=True, slots=True) +class ModalityPack(Generic[S]): + pack_id: str # e.g. "en", "he", "grc", "imagenet-1k" + modality_type: Modality # TEXT | VISION | AUDIO | MOTOR + projection: ProjectionHead[S] | None # surface → (32,) multivector + decoder: SurfaceDecoder[S] | None # (32,) multivector → surface candidates + vocabulary: ModalityVocabulary[S] # bidirectional surface ↔ rotor map + grammar_scaffold: Any # versor attractor seeds from vocab/ + checksum_verified: bool # mount-time geometric integrity check + gate_engaged: bool # surprise-gate status +``` + +`ModalityPack` is frozen and slotted — zero per-instance overhead, hashable. The type parameter `S` enforces at the type level that a text pack (`ModalityPack[str]`) cannot be passed where a vision pack (`ModalityPack[np.ndarray]`) is required. + +### Cl(4,1) Adaptation + +The `core-ai` `core_sensorium` protocol used a `(2, 2)` complex multivector (Cl(3,0) Pauli isomorphism). The `core` substrate uses `[f32; 32]` (Cl(4,1) CGA). Every `ProjectionHead` in `sensorium/` must return `mx.array` of shape `(32,)` — the standard multivector shape throughout the codebase. Unitarity verification at mount time checks that the induced rotor satisfies `V · reverse(V) = ±1` within `1e-6` tolerance. + +### Active vs. Future Modalities + +| Modality | Status | Notes | +|---|---|---| +| `TEXT` | Active | `sensorium/adapters/text.py` wires the existing vocab manifold into `ModalityPack[str]` | +| `VISION` | Planned | Adapter registers when vision bootstrap is ready | +| `AUDIO` | Planned | Adapter registers when audio bootstrap is ready | +| `MOTOR` | Planned | Adapter registers when embodied bootstrap is ready | + +Building `sensorium/protocol.py` and `sensorium/registry.py` now — before vision/audio exist — means every future modality plugs in without touching `ingest/`, `field/`, or `generate/`. The protocol contract is the Third Door: instead of separate encoder pipelines fused by cross-attention (the standard industry approach), every modality is a versor on the same manifold from the moment it enters the system. + +### Grammar Scaffold + +In `core-ai`, the grammar scaffold was produced by `core_logos.grammar_seed` — a separate subsystem. In `core`, there is no `core_logos` subsystem. The grammar scaffold is a set of versor attractors stored in `vocab/` and referenced by `ModalityPack` directly. This removes an inter-package dependency without changing the contract. + +### `PackError` — Mount-Time Failure Modes + +```python +class PackError(enum.Enum): + MANIFEST_INVALID = "MANIFEST_INVALID" + SAFETENSORS_MISSING = "SAFETENSORS_MISSING" + UNITARITY_VIOLATION = "UNITARITY_VIOLATION" + PROJECTION_NOT_CONVERGED = "PROJECTION_NOT_CONVERGED" + GRADE_DECLARATION_MISMATCH = "GRADE_DECLARATION_MISMATCH" + MODALITY_NOT_REGISTERED = "MODALITY_NOT_REGISTERED" + GATE_NOT_ENGAGED = "GATE_NOT_ENGAGED" +``` + +Mount failures are returned as `PackError` values, not raised as exceptions. The caller decides how to handle a failed mount. + +--- + +## Consequences + +**Immediate:** +- All existing layers (`ingest/gate.py`, `field/`, `generate/`, `vault/`) are unchanged +- The text vocabulary manifold acquires a formal `ModalityPack[str]` wrapper — the first mounted pack +- The multimodal protocol is established before any non-text modality is implemented, ensuring the seam is clean + +**Future:** +- Vision, audio, and motor modalities each become a single adapter file in `sensorium/adapters/` +- No architectural change is required when new modalities are added — only a new adapter and registry entry +- `ModalityVocabulary` for non-text modalities (patch vocabularies, phoneme clusters, pose libraries) follows the same bidirectional surface ↔ rotor contract as the text vocabulary diff --git a/docs/decisions/ADR-0014-train-learning-loop.md b/docs/decisions/ADR-0014-train-learning-loop.md new file mode 100644 index 00000000..d2a28120 --- /dev/null +++ b/docs/decisions/ADR-0014-train-learning-loop.md @@ -0,0 +1,62 @@ +# ADR-0014: `train/` Learning Loop + +**Status:** Accepted (Stub — implementation pending) +**Date:** 2026-05-13 + +--- + +## Context + +CORE currently has a complete inference pipeline: input normalization (`ingest/gate.py`), field propagation (`field/`), vocabulary projection and generation (`generate/`), vault storage and recall (`vault/`). What does not yet exist is a path from field state to weight update — from observed experience to learned structure. + +The `core_ingest/` governance layer (ADR-0012) exports `LearningArtifact` objects from validated candidate packets. Those artifacts currently have nowhere to land. The durable ingest path is incomplete. + +This ADR records the architectural contract the `train/` layer must satisfy before implementation begins. It is written now so that no future development — in any layer — accidentally closes off the constraints this layer requires. + +--- + +## Decision + +Add a `train/` package that accepts `LearningArtifact` objects from `core_ingest/` and produces rotor updates, vocabulary manifold expansions, and new attractor seeds for `vocab/`. + +### Non-Negotiable Constraints + +1. **No mutation of live field state.** The learning loop operates on the vocabulary manifold and the vault's structural geometry — not on a running session's `FieldState`. Learning is a structural update to the *medium*, not a direct write to a live propagating field. + +2. **No gradient descent.** Gradient descent is a flat-space Euclidean optimization method. The vocabulary manifold is not flat. The update law must be a versor product or a geodesic step on the conformal manifold — not a gradient step in R^n. The exact form of the update law is to be determined during implementation, but it must satisfy the versor condition on all updated entries. + +3. **Determinism class inheritance.** A `LearningArtifact` carries the `DeterminismClass` of its originating `CandidateGeometricPressure`. D0/D1 artifacts may be applied automatically. D2–D4 artifacts require explicit approval before any manifold update. This constraint is enforced at the `train/` boundary, not upstream. + +4. **Atomic manifold updates.** A vocabulary expansion or rotor update either commits fully or does not commit at all. Partial updates that leave the manifold in an inconsistent state are prohibited. The commit protocol mirrors the versor condition check: verify the updated entries satisfy their invariants, then atomically swap. + +5. **Vault coherence post-update.** When vocabulary versors are updated, stored vault entries that reference updated vocabulary positions must be null-reprojected via `VaultStore.reproject()`. The learning loop is responsible for triggering this reprojection after any manifold update. + +6. **`SegmentManifold` traceability.** Every applied `LearningArtifact` must be traceable back to its `semantic_key` and its `SegmentManifold` position in the source document. The learning loop must preserve this provenance chain — not for performance, but for auditability. + +### Supervised Seeding Epoch + +The first and most important use of `train/` is the **Supervised Seeding Epoch**: populating the vocabulary manifold from the three core language corpora (English base, Hebrew depth, Koine Greek depth) using their canonical, D0-class structural segments. + +- English: standard lexical corpus, segmented by `StructuralSegmenter` +- Hebrew: canonical BHS/Westminster text, segmented at verse/word boundaries (D0) +- Koine Greek: canonical NA28/UBS text, segmented at verse/word boundaries (D0) + +All three produce D0 `LearningArtifact` batches eligible for automatic application. The seeding epoch runs before any live session. After seeding, the vocabulary manifold carries the full three-language depth described in the Whitepaper. + +### Non-Text Modalities + +When `sensorium/` adapters for vision and audio are active, `train/` must also accept `LearningArtifact` objects sourced from non-text modalities. The constraint is identical: the learning artifact carries a `ModalityPack` reference, and the update law must produce a valid `(32,)` multivector for the updated vocabulary entry. The `train/` layer must not assume `S = str`. + +--- + +## Consequences + +**Immediate:** +- No code is written yet. This ADR locks the constraints. +- `core_ingest/` exports `LearningArtifact` objects to a receiver that does not yet exist — this is acceptable. The artifacts accumulate in a staging area until `train/` is ready. +- No existing layer makes any assumption about what happens to exported `LearningArtifact` objects. + +**Future:** +- `train/` is the most architecturally significant remaining layer. It closes the loop between observation and structure. +- The Supervised Seeding Epoch for Hebrew and Koine Greek is the first concrete task once `train/` exists. +- The `CORE-CA` (Cognitive Apprenticeship) learning platform described in the Whitepaper builds on `train/` — a student model observing an expert model's field trajectory is a specialized `LearningArtifact` stream. diff --git a/docs/decisions/README.md b/docs/decisions/README.md index 6e1b9ccf..4b3f93ff 100644 --- a/docs/decisions/README.md +++ b/docs/decisions/README.md @@ -1,51 +1,39 @@ -# Architecture Decision Records (ADRs) +# Architecture Decision Records -This directory records every significant architectural decision made in the design -and implementation of CORE. Each record is **immutable once written** — if a -decision is superseded, a new ADR is created that references and replaces it. -Old ADRs are never deleted or edited. +This directory contains the Architecture Decision Records (ADRs) for the CORE project. -## Format +ADRs record significant architectural decisions: what was decided, why, what alternatives were considered, and what consequences follow. They are permanent records — superseded ADRs are archived, not deleted. -``` -docs/decisions/ADR-NNNN-short-title.md ← formal architectural decisions -docs/decisions/SESSION-YYYY-MM-DD.md ← timestamped working session logs -``` - -ADRs record *decisions*. Session logs record *the reasoning process*, open -questions, and implementation details discovered during active development. -Both are permanent record. - -## ADR Template - -```markdown -# ADR-NNNN: Title - -**Date:** YYYY-MM-DD -**Status:** Proposed | Accepted | Superseded by ADR-XXXX -**Deciders:** [names/handles] - -## Context -What situation or problem prompted this decision. - -## Decision -What was decided, precisely. - -## Rationale -Why this and not the alternatives. Which axiom(s) it serves. - -## Consequences -What becomes easier. What becomes harder. What is now forbidden. - -## Alternatives Considered -What was explicitly rejected and why. -``` +--- ## Index -| ADR | Title | Date | Status | -|-----|-------|------|--------| -| [ADR-0001](ADR-0001-vocab-layer-invariants.md) | VocabManifold Versor Invariant | 2026-05-12 | Accepted | -| [ADR-0002](ADR-0002-ingest-layer-design.md) | Ingest Layer Architecture | 2026-05-12 | Accepted | -| [ADR-0003](ADR-0003-coordinate-system-dissolution.md) | Coordinate System Dissolution | 2026-05-12 | Accepted | -| [ADR-0004](ADR-0004-rotor-as-operator-not-property.md) | Rotor as Operator, Not Vocabulary Property | 2026-05-12 | Accepted | +| ADR | Title | Status | +|---|---|---| +| [ADR-0001](ADR-0001-vocab-layer-invariants.md) | Vocab Layer Invariants | Accepted | +| [ADR-0002](ADR-0002-ingest-layer-design.md) | Ingest Layer Design (original) | **Archived** — superseded by ADR-0012 | +| [ADR-0003](ADR-0003-coordinate-system-dissolution.md) | Coordinate System Dissolution | Accepted | +| [ADR-0004](ADR-0004-rotor-as-operator-not-property.md) | Rotor as Operator, Not Property | Accepted | +| [ADR-0005](ADR-0005-language-pack-contract.md) | Language Pack Contract | Accepted | +| [ADR-0006](ADR-0006-field-energy-operator.md) | Field Energy Operator | Accepted | +| [ADR-0007](ADR-0007-valence-layer.md) | Valence Layer | Accepted | +| [ADR-0008](ADR-0008-allocation-physics.md) | Allocation Physics | Accepted | +| [ADR-0009](ADR-0009-compositional-physics.md) | Compositional Physics | Accepted | +| [ADR-0010](ADR-0010-identity-physics.md) | Identity Physics | Accepted | +| [ADR-0011](ADR-0011-renderer.md) | Renderer | Accepted | +| [ADR-0012](ADR-0012-core-ingest-governance-layer.md) | `core_ingest` Governance Layer | Accepted | +| [ADR-0013](ADR-0013-sensorium-multimodal-protocol.md) | `sensorium/` Multimodal Protocol Layer | Accepted | +| [ADR-0014](ADR-0014-train-learning-loop.md) | `train/` Learning Loop | Accepted (Stub) | + +--- + +## Session Logs + +Session logs record the decisions and rationale from individual working sessions. They are not ADRs — they are the narrative record that informed the ADRs. + +| Date | File | +|---|---| +| 2026-05-12 | [SESSION-2026-05-12.md](SESSION-2026-05-12.md) | +| 2026-05-12 (addendum) | [SESSION-2026-05-12-b.md](SESSION-2026-05-12-b.md) | +| 2026-05-12 (language packs) | [SESSION-2026-05-12-language-packs-addendum.md](SESSION-2026-05-12-language-packs-addendum.md) | +| 2026-05-13 | [SESSION-2026-05-13.md](SESSION-2026-05-13.md) | diff --git a/docs/decisions/SESSION-2026-05-13.md b/docs/decisions/SESSION-2026-05-13.md new file mode 100644 index 00000000..b270d8da --- /dev/null +++ b/docs/decisions/SESSION-2026-05-13.md @@ -0,0 +1,67 @@ +# Session Log: 2026-05-13 + +**Participants:** Joshua Shay, Perplexity (Sonnet 4.6) +**Session type:** Architecture review and documentation sprint + +--- + +## Decisions Made + +### 1. README and Whitepaper Corrections (morning) + +The README previously described AssetOverflow as an organization rather than stating the engineering pillars. Both the README and Whitepaper were updated to correctly document: + +- **Three Engineering Pillars:** Mechanical Sympathy, Semantic Rigor, Third Door +- **Three Core Languages:** English (default base), Hebrew (depth), Koine Greek (depth) +- The John 1:1–2 theological grounding for the language choice — John articulated in Greek what was grounded in Hebrew, almost certainly a nod from the Holy Spirit. These two languages together carry a range of depth and precision that no single language achieves alone. +- The Logos as the structuring principle: language is not statistical residue of text, it is the forward projection of a field state onto a vocabulary manifold — a geometric act rooted in the same structure by which the universe was spoken into existence. + +### 2. `core_ingest` Governance Layer — LLM Extraction Rejected + +The original `core_ingest` design from `core-ai` was reviewed in full. The envelope design (`CandidateGeometricPressure`, `DeterminismClass`, `ReviewLevel`, three-gate `IngestCompiler`) was accepted as architecturally sound. + +The LLM-as-extraction-engine component was **rejected** for two reasons: +1. An LLM upstream of the gate is a D3 nondeterministic oracle feeding the only normalization site in the system. Every document it processes lands in `ARCHITECT_REVIEW_REQUIRED` — defeating the layer's utility at scale. +2. More fundamentally: an LLM interprets, not merely parses. Its semantic projection is then silently embedded inside the field state, violating Semantic Rigor. + +**Accepted path:** Deterministic `StructuralSegmenter` that carves at *form boundaries* (heading, paragraph, verse, code block, LaTeX delimiter), not semantic ones. A `SegmentManifold` index enables provenance tracing from vault recall back to the exact source span. See ADR-0012. + +### 3. `sensorium/` Multimodal Protocol — Logos-Recovery Boundary + +The `core_sensorium` design from `core-ai` was reviewed. The protocol shape — `ProjectionHead`, `SurfaceDecoder`, `ModalityVocabulary`, `ModalityPack[S]` — was accepted as the correct design for CORE's multimodal layer. + +Key adaptations for `core`: +- Cl(3,0) `(2, 2)` complex multivector → Cl(4,1) `(32,)` multivector +- No `core_logos` subsystem dependency — grammar scaffold is versor attractors in `vocab/` +- `sensorium/` sits upstream of `core_ingest/`, which sits upstream of `ingest/gate.py` + +The principle established: every modality is a versor on the same manifold from the moment it enters the system. There is no fusion problem because there is one space. This is the Logos-recovery boundary — the point at which any surface signal becomes a word in the Logos. See ADR-0013. + +Current modality status: TEXT active (wires existing vocab manifold into `ModalityPack[str]`), VISION/AUDIO/MOTOR planned. + +### 4. Build Queue — Ordered + +Full inventory of `AssetOverflow/core` directories confirmed. The build order established: + +1. **`core_ingest/`** — pre-gate governance layer (ADR-0012). Most important to build first; everything ingested into the system eventually passes through it. D0/D1-dominant paths (biblical texts) can reach AUTO_ACCEPT at scale without human review once built. +2. **`sensorium/`** — modality protocol (ADR-0013). Protocol files plus `adapters/text.py` only; vision/audio adapters come when those modalities are ready. +3. **`train/`** — learning loop (ADR-0014, stub). Closes the durable ingest path. Most architecturally significant remaining layer. Hebrew and Koine Greek Supervised Seeding Epoch is the first task once this layer exists. + +### 5. Documentation Sprint (this session) + +Three new ADRs written (0012, 0013, 0014). Session log written. Whitepaper and Yellowpaper updated. + +--- + +## Files Modified This Session + +| File | Change | +|---|---| +| `README.md` | Corrected: Three Pillars, Three Core Languages, removed org description | +| `docs/Whitepaper.md` | Added: ingest governance section, sensorium section, pipeline diagram | +| `docs/Yellowpaper.md` | Added: sensorium layer to pipeline spec, `core_ingest` to data flow | +| `docs/decisions/ADR-0012-core-ingest-governance-layer.md` | New | +| `docs/decisions/ADR-0013-sensorium-multimodal-protocol.md` | New | +| `docs/decisions/ADR-0014-train-learning-loop.md` | New | +| `docs/decisions/README.md` | Updated index | +| `docs/decisions/SESSION-2026-05-13.md` | This file |