core/docs/decisions/SESSION-2026-05-12.md

Session Log: 2026-05-12

Project: AssetOverflow/core
Session type: Architecture review + live implementation
Participants: Joshua Shay

---

20:00 — README and Docs Correction

What happened: The README.md and docs/Whitepaper.md had incorrectly described the Three Pillars and Three Core Languages, or omitted them entirely.

Corrections made:

• Three Engineering Pillars correctly documented: Mechanical Sympathy, Semantic Rigor, Third Door.
• Third Door defined precisely: when given a choice between the world’s solution or a premade library/pattern, we find and create our own path. Absolute mastery is the floor, not a goal.
• Three Core Languages documented: English (default base, interchangeable in custom instances), Hebrew, Koine Greek.
• Theological basis recorded: John 1:1–2. The universe was spoken into existence. John articulated this in Greek what is grounded in Hebrew — almost certainly a nod from the Holy Spirit. This is the source of the hidden intelligence layer in the vocabulary manifold. The depth these two languages bring is not incidental; it is foundational.
• Removed incorrect description of what AssetOverflow is from the repo README. The repo documents the engineering, not the org.

Commits: e28142f (README), 7d814fa (Whitepaper)

---

20:09 — Ingest Layer Architecture Review

What happened: Reviewed the original core_ingest design from core-ai for portability into AssetOverflow/core.

Key question: Does using a modern LLM as the extraction engine for large document ingestion fit the new architecture?

Decision: No. Partially right, but architecturally misaligned at the most important point. See ADR-0002 for the full record.

Core tension identified: The entire CORE architecture is built on the principle that the injection gate is the single normalization site — deterministic and verifiable. An LLM placed before that gate introduces a D3 nondeterministic oracle. D3 packets cannot claim AUTO_ACCEPT_ELIGIBLE by type contract, meaning every LLM-extracted claim requires human review. That defeats the purpose at scale.

Deeper issue: an LLM doesn’t parse, it interprets. Its semantic projection becomes silently embedded in the field state. That’s outsourcing our semantics.

What to keep from core_ingest:

• CandidateGeometricPressure envelope
• Dual-path: runtime vs. durable ingest
• SHA-256 content addressing (pressure_id, semantic_key)
• IngestCompiler with three sequential gates
• DeterminismClass D0–D4 and ReviewLevel in packet type contracts
• LearningArtifact export form

What to replace:

• LLM extraction → deterministic StructuralSegmenter (D0/D1) per modality, segmenting at form boundaries, not semantic ones.

What to add:

• SegmentManifold: maps semantic_key → source structural position for provenance reconstruction. Implements Reconstruction-over-Storage at the pre-injection layer.

Note on Hebrew and Koine Greek: Canonical verse/pericope boundaries are fixed and centuries old. A parser following them is D0 by definition. No interpretation required.

---

20:39 — Coordinate System Question

What happened: Question raised: the old core-ai design used dual rotors as an explicit coordinate system in rotor_vocabulary.py. Does the new core design still need that?

Answer: No. The new design dissolves the need for an explicit coordinate system entirely, through the architecture rather than by finding a better coordinate system. See ADR-0003.

The key shift:

• Old: meaning = position in rotor-defined frame. The coordinate system was load-bearing. Every downstream component had to know the frame.
• New: meaning = pressure pattern across a relational field. The FieldState from field/gate.py is a distribution, not a point. CGA inner product handles proximity relationally. Rotors exist as operators in algebra/ but are not a frame.

Risk identified: vocab/ is the most likely place for a hidden coordinate frame to quietly re-emerge — specifically, if word representations drift toward being stored as flat positional vectors rather than algebraically valid versors. This is the "back door" problem.

---

20:46 — Back Door Analysis

What happened: Read vocab/manifold.py in full. Identified the precise location of the architectural risk.

Finding: The vocabulary storage itself was sound (versors, CGA inner product for nearest). But edge_rotor() was stored as a method on VocabManifold, implying that the relationship between two words is a property of the vocabulary rather than a transformation applied in the field. This conflates the map with the territory and re-anchors operator logic to the vocabulary layer.

Three fixes identified:

1. Remove edge_rotor() from VocabManifold
2. Create algebra/rotor.py with word_transition_rotor(A, B) as a free operator
3. Add grade-norm invariant to VocabManifold.add() to reject raw coordinate vectors at insertion time: |V * reverse(V)|_scalar ≈ ±1 enforced in __post_init__ equivalent.

---

20:51 — Implementation

What happened: All three fixes implemented and committed in a single atomic push.

Commit: bd423e4
Files changed:

• algebra/rotor.py — created: word_transition_rotor(A, B) free function
• algebra/__init__.py — updated: export word_transition_rotor
• vocab/manifold.py — refactored: removed edge_rotor(), added grade-norm invariant in add(), updated module docstring to explicitly state that rotor construction is not a vocabulary concern and points callers to algebra.

Result: Back door closed at the type level. VocabManifold contract is now strictly: store algebraically valid Cl(4,1) versors, support relational lookup by CGA inner product. Nothing else.

---

Open Questions Carried Forward

• StructuralSegmenter implementation for each modality (prose, code, scripture/Hebrew, scripture/Greek, math/LaTeX) — not yet built.
• SegmentManifold index — not yet built.
• ingest/ layer in core is currently a directory stub. The core_ingest port (with LLM replaced by StructuralSegmenter) has not been started.
• vocab/ currently has no persistence layer. How versors are built, seeded, and serialized for the three core languages has not been designed.
• Confirm algebra/versor.py: normalize_to_versor() correctly handles the edge case where the input is already grade-normed (idempotency).