# 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).
