docs(architecture): record the 2026-08-14 deep-night sessions

~226 lines of architecture documentation that were written, left uncommitted in
the working tree, and nearly lost. None of it was on main. Recovered from a
stash taken while merging tonight's fixes.

Substantive content, not notes:

- Peer import-of-understanding PROVEN by execution. A exported a skill-geometry;
  on the receiver `think` went "geometry unavailable" -> operable. Cosine 1.0 on
  both the raw-geometry and text/dharma-bus transports, bidirectional. The
  mind-not-paste evidence: n_support 27 on source vs 3 on receiver, i.e. the
  imported geometry wires into the host manifold rather than sitting inert.
  Honest boundary recorded too: proven between forks sharing one embedder,
  UNTESTED cross-embedder.

- "Teacher" renamed GUIDE, and the distinction is load-bearing: its output is
  grounded/verified before trust. A teacher you believe; a guide you check.

- Layers are named persistent relational neighborhoods, not storage tiers, with
  their own growth and threshold-lock policy (note->canonical maturation lifted
  from single nodes to a region).

- The consciousness theories (Global Workspace, IIT's Phi, attention-schema,
  higher-order thought, active inference, interoception) read as geometric
  LENSES over one manifold rather than competing mechanisms. Functional problems
  fall out; the hard problem explicitly not claimed solved.

- Growth is bounded/logistic, not geometric — exponential growth is the cancer
  shape. Two-rate discipline: explore fast in local geometry, grow the engram
  slowly by verifier-gated merge.

- Orchestration as a geometric operation: critical path as geodesic, float as
  displacement, @manager compiles the work-graph. Single-writer enforced by
  capability (Rule 4).

- The decorated seam, the API surface collapse to geometry ops, and the
  distributed-self thesis — each tiered honestly against what is actually proven
  vs staged vs unbuilt.

Also gitignores dist-fresh/ (regenerate scratch dir, a build artifact).

Not included from the same stash: awareness.elh and dist/elp-c-decls.h, which
are generated artifacts now gitignored per #154/#158.

docs/architecture/07-storage-coherence-and-distribution.md

@@ -148,6 +148,31 @@ pragmatic first cut; the node form is the end state.
 
 ---
 
+### 2.4 Edges are vectors, not scalars — the complete temporal record — [TARGET]
+
+§2.1 refused to let a relationship's *strength* be a scalar overwritten in place. The same refusal extends to a
+relationship's *meaning*: an edge is intended to be a **vector** — a first-class carrier of relationship-meaning
+in the same space as the nodes it joins — not a typed pointer plus a scalar weight. That makes relationships
+**composable / subtractable / analogizable / traversable** like nodes (the `06` §6 operator algebra ranges over
+edges, not only entities).
+
+Combine the vector edge with the append-only substrate and a strong property falls out: because every
+**discrete, significant** change to a relationship is *appended* (a keyframe on material change, §2.1), the store
+retains the **full 4-D trajectory of the meaning-manifold across all recorded time** — `recall_at(t)` (§2.3) can
+read *how every relationship was configured at `t`*, so you can watch a concept, a bond, or a belief evolve. A
+row-store overwrites and keeps only the present; a graph DB keeps edges but mutates their properties; a vector DB
+keeps points with no relational history — **none preserves the trajectory of the relationships themselves.**
+It is **bounded, not a firehose**: changes are discrete + significant (not per-fire), and meaning **saturates by
+compositionality** (new relations become combinations of held ones — the same bounded/logistic law as `06`
+§Update-second-pass).
+
+**Honest tier — [TARGET], with a live gap.** The runtime edge **today** is *scalar*, not a vector: `EngramEdge`
+carries a typed `relation` string plus two scalar strength channels — an authored `weight` and a learned Hebbian
+`hebb` potentiation (`03-data-and-memory.md` §Edges). The relationship-meaning **vector** and the composable
+edge-algebra are the intended model, tracked with the world-line/keyframe work (**#39**); they are **not built.**
+The primitives the temporal-record claim stands on — append-only, tombstone-not-delete, `recall_at` over
+`created_at` — are **[LIVE]** (`06` §3.4).
+
 ## 3. Atomicity is a relationship, not a commit
 
 The classic reason to need a database transaction: "debit account A **and** credit account B — they must commit
@@ -221,6 +246,27 @@ Two things remain and are not hand-waved:
 Everything else that a transaction traditionally bought is dissolved rather than solved: the failure mode it
 guarded against **cannot arise** in an immutable, timestamped, relationship-carrying store.
 
+### 4.3 Throughput is a consequence, not a sacrifice
+
+One clarification, so nothing here reads as "meaning at the cost of speed." Append-only immutability does **not**
+trade write throughput for its temporal/coherence properties — it *improves* the write path. The store is
+**event-sourced**: current state is a **fold over the appends**, and the store **is its own log** — there is no
+separate materialized table to keep in sync. Two consequences, both toward performance:
+
+1. **Append-only writes do not contend.** No in-place mutation ⇒ no read-modify-write, no row lock, no writer
+   coordination. A mutating ACID RDBMS must serialize access to the cell it overwrites; that is a *lower* write
+   ceiling under contention, not a higher one. Appends have no cell to race on.
+2. **Zero transactions are needed.** State is recreatable from the data itself (§1), so there is nothing to wrap
+   in `BEGIN…COMMIT`. The transactional isolation an RDBMS spends its throughput budget on solves a problem this
+   store **does not have** (concurrent mutation of shared mutable cells).
+
+So the store does **not** "win meaning by losing throughput," and it is **not** framed as a worse OLTP engine
+that buys time-travel with speed: the same immutability chosen for accountability and time-travel (§1, §2) also
+removes write contention and the transaction tax. **Honest tier:** the primitives (append-only, immutable,
+per-frame physical durability, §4.1) are **[LIVE]**; this is a **structural consequence**, stated as a
+clarification — **no throughput benchmark has been run**, and none is claimed beyond "immutability does not cost
+throughput and removes two contention sources."
+
 ---
 
 ## 5. Understanding is light; facts are the payload — the load-and-tiering model
@@ -344,11 +390,14 @@ first-boot crash.
 | Immutability / append-only / tombstone / world-tube (`created_at ≤ T` filter) | **[LIVE]** (`06` §3.4) |
 | No stored weight-history (uni-temporal `created_at` = write-time) | **[LIVE]** (honest gap) |
 | Magnitude as world-line; keyframes on material change | **[TARGET]** (#39) |
+| Edges as vectors (relationship-meaning), not scalars; runtime edge scalar today | **[TARGET]** (#39); primitive edge **[LIVE]** |
+| Complete temporal record — full 4-D trajectory of the manifold, bounded | **[TARGET]** (#39; append/tombstone primitives **[LIVE]**) |
 | Bitemporal three axes (`t_valid`/`t_origin`/`t_ingest`) + HLC ordering | **[TARGET]** (#39) |
 | `recall_at(t)` over any relationship network | **[TARGET]** (#39) |
 | Atomicity-as-relationship (double-entry = one edge) | **[TARGET model; primitives LIVE]** |
 | Transactionless coherence (immutable+stamped ⇒ MVCC-to-its-end) | **[TARGET model; primitives LIVE]** |
 | Physical vs logical transaction separation | physical **[LIVE]**; logical **[TARGET]** |
+| Append-only ⇒ no write contention + zero transactions ⇒ throughput not sacrificed (not a worse OLTP DB) | **[LIVE property; unbenchmarked]** |
 | Understanding-is-geometry-light vs facts-payload-heavy (~21% geo / 53% text / ~1–2% understanding) | **[LIVE]** (measured) |
 | Geometry-hot / payload-cold — local paging | intended by planner; **boot ignores it [LIVE finding]** |
 | Every store is a CRDT (set-union merge, zero coordination) | **[TARGET; primitives LIVE]** |