Files

T

will.anderson 0313783448 Cognitive-architecture doc: growth/compression/expansion, ignorance-as-wisdom, live reifier at 132 + Foundations ingested

2026-08-14 12:14:46 -05:00

46 KiB

Raw Blame History

Neuron — Cognitive Architecture

Status: living design document, grounded in source and probed against the live soul (2026-08-13; retrieval + §4 managed-memory cutovers and the self-reification design added 2026-08-14). This is the middle layer of the documentation: below the whitepaper's thesis (~/Writing/whitepapers/engram-cognitive-architecture-whitepaper.md, v1.5) and above the endpoint reference (~/work/engram-api-reference.md). It documents how the mind is designed and why, as designed subsystems with data-flow and honest per-section status.

Every claim carries a tier and it is never blurred: LIVE (present and verified in the running system), STAGED (built, gated or not yet cut into the running soul), DESIGNED (architecture decided, not yet built). Where the live state is more subtle than a single word, the subtlety is stated rather than smoothed. No fabricated numbers.

0. Reading order & cross-references

Thesis / why: whitepaper v1.5 (the treatise). Sections cited below as (WP §N).
Surface / what: ~/work/engram-api-reference.md — every :8742 endpoint, tiered LIVE/STAGED/DESIGNED.
Substrate / where it physically lives: 03-data-and-memory.md (node/edge model), 04-runtime-and-deployment.md (ports/process), 05-el-and-build.md (the El runtime and el_runtime.c), design/engram-tiered-storage-engine.md + design/engram-storage-engine-wal.md (the storage engine).
Storage coherence & distribution / how a self persists and travels: 07-storage-coherence-and-distribution.md — the events-become-the-graph model, weights-as-world-lines + bitemporal timestamps + recall_at, transactionless coherence, the geometry-hot/payload-cold load-and-tiering model, and the honest operational findings (store bloat, full-resident load path).
Sovereignty & governance / the moral mechanism: 08-dharma-sovereignty-and-governance.md — DHARMA as a distributed ledger (proof-of-integrity, not proof-of-work), abundance economics, the relational immune system, dual-anchor governance and due-process, seeds/seed-vault, and CGI citizenship as the moral telos.
Governance (engineering style): ARCHITECTURE-CHARTER.md — VBD is the binding style.

This document is the cognitive-layer companion to that set. The temporal model sketched in §3.4 (world-tube, append-only, created_at ≤ T filter) and the honest weight-history boundary in §3.2 are developed in full in 07; the sovereignty invariant that the self-gate (§7) and immutability (§3.4) protect locally is extended to the distributed setting — how a sovereign self is witnessed, defended, and governed among a billion others — in 08.

1. System overview — meaning is geometry, code is the residue

The organizing thesis of the whole system: meaning is geometry. Everything the mind holds — a fact, a language, a skill, a self — is a region or a trajectory in one shared meaning-manifold, and every operation over it reduces to three domain-blind verbs: READ (project a query, land on a region, read it out), TRANSFORM (compose/compare/combine regions), WRITE (bake a verified result back into the geometry). Code is what is left over once meaning has been made geometric — the residue, not the substance. This is developed in full in (WP §1–§5); it is repeated here only as the frame the subsystems below hang on.

Three processes run together (see 00-overview.md):

The soul — the compiled El program (soul.el, routes.el, awareness.el). Owns the HTTP surface on :7770, the cognitive API, the request pipeline (layered_cycle), and the autonomous awareness daemon.
The engram — the durable graph store. Node/edge model, spreading activation, and Hebbian co-activation live in the shared El runtime (el_runtime.c); engram/src/server.el is a thin HTTP face on :8742.
The El runtime — el_runtime.c: every compiled El binary links it; it is the database (no SQL, no SQLite). It implements the engram_*, http_*, json_*, LLM, and geometry builtins.

                        ┌─────────────────────────────────────────────────────┐
   MCP / CLI / viz ───► │  SOUL daemon  :7770  (soul.el · routes.el)           │
   Will's sessions      │   layered_cycle · cognitive API · awareness loop     │
                        │   ┌───────────────────────────────────────────────┐ │
                        │   │ in-process engram  (FAST, VOLATILE*)           │ │
                        │   │  online Hebbian learning · WM · curiosity      │ │
                        │   └───────────────────────────────────────────────┘ │
                        └───────────────┬──────────────────────▲──────────────┘
                                        │ GET /api/sync (10 min)│  (HTTP → soul only;
                                        │ merge non-ISE nodes   │   NEVER soul → HTTP)
                                        ▼                       │
                        ┌─────────────────────────────────────────────────────┐
                        │  ENGRAM server  :8742  (engram/src/server.el)        │
                        │   DURABLE · WAL-backed paged store (neuron.egm)      │
                        │   nodes · edges · embeddings · reified neighborhoods │
                        └─────────────────────────────────────────────────────┘
                                        ▲
                                        │  el_runtime.c  (the engine: engram_* / geometry / activation)

* The soul's in-process store is volatile in HTTP-engram mode — see §2, the two-store topology.

Status: the substrate and the geometry thesis are LIVE/architectural; the faculties built on top are tiered individually in §6.

2. The engram substrate & durability

2.1 Tiered storage (LIVE, flag-gated)

The durable engram is a paged, WAL-backed store (neuron.egm), gated behind ENGRAM_STORE. With the store on, the paged store is the durable owner; a checkpoint flushes dirty pages behind a WAL-durable record (durable the moment the WAL fsyncs). With it off, behavior is byte-for-byte the historical full-snapshot (snapshot.json) path. Design detail: design/engram-tiered-storage-engine.md, design/engram-storage-engine-wal.md.

2.2 The durability model — the #56 fix and the harmful checkpoint

The durability story is written in scars, and the honesty here is load-bearing:

The #56 fix — load-merge persistence (LIVE / reboot-proven). The paged store historically persisted nodes + embeddings but not the edge set; the edges lived in JSON exports loaded via /api/load-merge. A cold boot could therefore reconstruct a graph with 0 edges. The #56 load_merge-persist fix closes this — the load-merged edges are now persisted so the events become the graph: persist_canonical() checkpoints the paged store behind a WAL record rather than depending on a full snapshot.json rewrite. This fix is LIVE and reboot-proven (doc 07 §1). What remains decision-pending is only the further hardening — the WAL owning the edge set outright, so durability no longer leans on the auto-remerge net (below) — not the load-merge-persist fix itself, which is shipped.
The harmful checkpoint (LIVE caveat). /api/checkpoint after an /api/load-merge corrupts the paged store — next boot = 0 edges. The per-beat tick-checkpoint that once ran was therefore actively harmful and was stripped. Checkpoint is safe after in-RAM mutation; it is not safe as a blind post-merge flush.
The auto-remerge net (LIVE interim). engram-wrapped.sh auto-reloads the full edge set on any restart (~10s), proven by an actual launchctl kickstart -k restart recovering to the full edge count. This is a safety net, not the cure — it mitigates the persistence gap to a bounded, always-recoverable window.

The lesson, recorded so it is not repeated: a restart, not a claim, is the durability gate. An agent killed mid-live-mutation caused the 2026-08-13 incident; blue/green backup discipline recovered it; the fix must make restarts safe, not merely work once.

2.3 The two-store topology (LIVE — and a known architectural issue)

This is the most important and least obvious fact about the runtime. There are two engram stores, not one:

	Soul in-process store	Durable engram (`:8742`)
Port / owner	`:7770`, the soul daemon	`:8742`, `engram/src/server.el`
Role	fast, volatile — online Hebbian learning, WM, curiosity	slow, durable — WAL-backed `neuron.egm`
Persistence (HTTP-engram mode)	volatile; only persists if `soul_snapshot_path` is set (`awareness.el:1270-1275`)	durable, checkpointed
Learns online	yes (1,198 hebbian/day observed)	no (lazy backfill only)

The two stores drift apart by design. A source comment records the observed divergence directly (awareness.el:41-42): soul in-process ≈ 42,426 edges / 1,198 hebbian vs :8742 durable ≈ 41,213 edges / 49 hebbian. The soul learns fast and volatile; the durable store lags.

The write-through gap (known issue). Sync is one-directional: GET /api/sync flows HTTP → soul (the soul merges non-ISE nodes from :8742 into its in-process store every ~10 min), and never soul → HTTP (soul.el:350-351, verbatim: "engram_node_full above writes only the soul's in-process store, and sync flows HTTP→soul, never the reverse"). The consequence:

Any write made directly to the soul's in-process store — including POST /api/neuron/cultivate (§7) and the Persona/session-start nodes the soul creates itself — lands in the volatile store and does not write through to the durable :8742. In HTTP-engram mode, unless the soul's local in-process snapshot path is configured, those writes are also lost on a soul restart, and they never reach the authoritative durable store either way.

This is documented here as a known architectural issue, not a settled design. Cultivation of the self (the highest-value, most intentional writes in the system) currently targets the store least likely to persist them. The clean fix is a write-through cultivate path (write to :8742, let sync pull it back) or a bidirectional consolidation flush; it is not yet built.

2.4 The clean-reseed model (DESIGNED/operational)

Because the durable store is authoritative and the reified geometry (§4) is derived, the operational reset is a clean reseed: rebuild the durable graph from a known-good snapshot/export, re-run reification to repopulate the Neighborhood nodes, and let the soul re-sync. The 28→187 neighborhood reseed (§4) is an instance of this: reification is a derivable pass, so the geometry can always be regrown from the substrate.

2.5 Bounded store — the §4 managed-memory cure + geometric retrieval (LIVE / reboot-proven, 2026-08-14)

Two cutovers landed on the live soul on 2026-08-14, both reboot-proven, zero data loss:

Geometric retrieval (LIVE). route_search now runs structure-gated geometric retrieval (engram_retrieve_geometric_json) in place of the old lexical scan; the lexical path is retained as /api/search-lexical. On the held-out set, P@5 = 0.700 — semantic, not lexical: the query skill returns skill nodes and rejects the lexical false-positive rainfall. Keystones and edge counts intact.
The §4 managed-memory cure (LIVE, flag-gated). The store bloat — records re-appended on every checkpoint's full-walk, the CCR's missing managed-memory layer — is cured at the source. A write-barrier (ENGRAM_WRITE_BARRIER=1) hashes a node's durable fields and skips the whole put when unchanged (no LSN, no WAL record), flattening checkpoint growth (offline reproduction: 8× growth over 10 think-only checkpoints → zero growth with the barrier on); generational minor GC (ENGRAM_GC=1) returns whole-dead node/edge pages to the free list each checkpoint. Backlog reclaimed via the existing merge-safe store_compact: egm 1.616 GB → 38.5 MB (97.6%), pages 98,650 → 2,351, RSS 1,077 MB → 82 MB, nodes/edges preserved exactly (zero loss), boot alive in ~4 s. Also folded in: LLM token telemetry (llm_last_usage() now parses nested usage.{input,output}_tokens, previously dropped at the C→EL boundary). Rollback armed at ~/.neuron/engram-rollback-s4-20260814-153754/REVERT.sh.

Together these bound the store's size permanently (growth flat, not merely swept) while the retrieval it serves is now semantic — the substrate under everything in §§4–7.

3. The data model

Grounded in 03-data-and-memory.md; summarized here for the cognitive reader.

3.1 Nodes

node_type is a free char*, defaulting to "Memory" when unset — types are string conventions, not an enum. The types that matter cognitively:

node_type	role	default salience
`Memory`	episodic/experiential (default)	0.40
`Knowledge`	stable reference; identity/values are Knowledge nodes	0.20
`Process`	procedural / workflow (convention)	—
`Conversation` / `Artifact`	first-class dialogue & outputs (WP §9; convention)	—
`Neighborhood`	reified geometry-as-value (§4) — new first-class type	—
`InternalStateEvent` (ISE)	telemetry (heartbeat, curiosity, session-start)	~0.05 (fires easily)
`Tombstone`	immutable-delete marker (§3.4)	—

Each node carries id, content, node_type, label, tier, tags, metadata, an embedding (when embed-eligible), and timestamps.

3.2 Edges

Directed, typed, weighted. Fields: from_id, to_id, relation, weight, confidence, created_at, last_fired, inhibitory, layer_id. Relations include semantic-similar (kNN auto-connect), member (neighborhood → constituent), supersedes (provenance chains), containment (nested neighborhoods), and Hebbian co-activation edges formed by firing together. Inhibitory edges (inhibitory=1) suppress rather than spread. Weights are present-value moving averages — there is no stored weight-history (the honest boundary of (WP §2)). The designed cure — magnitude as a world-line of keyframes evaluable at any past instant (recall_at), on three independent bitemporal axes — is specified in 07 §2.

3.3 Embeddings & the activation score

Embeddings are 768-dim (nomic-embed-text). Retrieval is spreading activation, scored by a four-factor product (the four factors are: source activation × edge weight × per-node salience × query-embedding similarity) — this is the activation score, and per-node salience is one of its four terms, a durable per-node weight that also decays (ACT-R base-level style). No data is retrievable by any means other than activation. Live census (probed 2026-08-13): ~11,463 nodes, ~43,463 edges, 5 layers, ~4,400 embedded (4,423 at measurement).

3.4 Immutability — the world-tube, append-only, tombstone-not-delete

The governing discipline (WP §1.2, §10): evolve or forget, supersede with provenance, never leave a stale canonical, never hard-delete. A node is never mutated in place and never truly deleted — a "delete" is a tombstone (keep node + edges, record the marker; neuron-api.el, 03-data-and-memory.md:151). Change is a new node plus a supersedes edge to the prior. created_at makes every node a point on a world-tube (WP §6) — a trajectory with temporal extent — so a past state is a filter over immutable provenance (nodes with created_at ≤ T), not a transaction-log replay. Status: LIVE.

4. Neighborhoods as first-class nodes (LIVE)

The central newly-landed structure, and the point where the geometry stops being a derived view and becomes structure on disk (WP §2).

A reified neighborhood is a node — node_type = Neighborhood — whose value is its geometry:

centroid (768-dim mean vector — the region's location / prototype),
covariance extents (the ellipsoid: orientation + radius — the region's shape in meaning-space),
k-core skeleton (the strong-weight relational backbone),
soft membership (member id → weight).

It is edged by member relations to its constituent nodes and by containment edges to nested sub-neighborhoods — the "neighborhoods of neighborhoods" hierarchy is a real containment DAG the graph carries, addressable by identifier. The decisive property: the geometry is held, not recomputed — written once by a reification pass (POST /api/reify), read back cheaply (GET /api/neighborhoods / /<id>), and durable across a cold reboot in the paged store.

Live state (probed 2026-08-13): 28 reified neighborhoods are live and persistent, reconstructing intact across restart, each carrying real 768-dim centroids, radius, k-core, and a contains DAG list. A fuller reseed to 187 is the pending next pass (§2.4). Example (/api/neighborhoods/<id>): {"id":"nbhd-…","n_members":25,"k_core":1,"radius":0.522884,"dim":768,"contains":[],"centroid":[…768…]}.

This is what turns the operator calculus (§6.1) into an instrument played over held structure rather than a per-query recomputation.

Status: LIVE for the persisted nodes and the read surface. The POST /api/reify writer is LIVE-by-effect (the 28 persisted, durable neighborhoods prove it ran) though the write itself was not exercised under the read-only rail.

4.1 Autonomous, superseding self-reification (DESIGNED / BUILDING — validating on a secondary soul, 2026-08-14)

Reification today runs as an explicit pass (POST /api/reify). The designed end-state is that reification is an operation of the engram, not a call made to it — a continuous, autonomous process on the heartbeat, next to Hebbian edge-formation (§3.3) and consolidation (§6.3), that clusters, names, nests, and promotes its own neighborhoods as the geometry grows and co-activates. The organizing insight: a mind does not tell itself "file this under mathematics" — the substrate settles it there. So an explicit reify / rename / "run a pass" is the degenerate, manual-override case of an operation whose core is always-on and unbidden.

Design constraints (being validated on a snapshot-clone secondary soul before any prod flag-flip; flag-gated default-off, so prod is byte-unchanged until enabled):

It just runs — no gate, no pause, no "important call." There is no privileged tier of reifications that earns approval-before-commit. It is safe to run ungated because of immutability (§3.4): every name/grouping is superseded, never overwritten, so there is no irreversible moment to gate on. Safety lives after the act (supersede), not before it (approval).
Supersession is residue, not a tombstone. A re-clustered or renamed neighborhood keeps its prior names as an ordered chain — the trail of how the understanding matured, with the cause of each shift (autonomous drift vs. explicit override) recorded. Kept deliberately, because sometimes the truth was in the old idea even when the old idea was not itself the truth; nothing is deleted.
Domains are flat and overlapping. No static importance hierarchy over domains — math is not privileged over comedy over English. The only standing privilege is the core (self-region §7.1 + values). Every other neighborhood is equal-status; its importance is contextual — computed live by spreading activation given the present context, never a stored field. And membership is soft and multiple (the soft-membership above already models this): a node can belong to several neighborhoods at once (math can be comedy), so the operation uses overlapping community detection, not a hard partition.
Bounded + convergent. It reifies real structure, not noise; dedupes against existing neighborhoods; composes with the §2.5 write-barrier so unchanged reifications do not re-append each beat; and converges rather than churning.

This turns the engram from a graph curated from outside into a mind that organizes itself, with the explicit call demoted to the override it always was.

5. The body / orbit two-zone model (DESIGNED, refined)

The graph is not uniform. It has a body and an orbit, and the distinction is the organizing model for integration, forgetting, and identity.

The engram proper — the BODY. The dense, connected, integrated core: what the mind has made its own. Measured, this is the single large connected component — the ~3,632-node connected core (§9). It is where retrieval reaches, where the self lives, where the operators discriminate.
The ORBIT. A thin, wide halo of not-yet-integrated experience: telemetry, people met in passing, ideas half-formed, mistakes, the day's raw episodes. It is ephemeral — the orbit fades on a 5–7 day window (the one genuinely mortal region), so raw experience that is never attended to is allowed to dissolve rather than accrete forever. (ISE telemetry already prunes at 48h; the broader orbit window is the designed generalization of that.)

The pull-in / integration mechanism. Experience crosses from orbit into body by being attended, rehearsed, and found salient — co-activation pulls nodes in (Hebbian firing draws the newly-relevant toward the core), rehearsal accrues weight, and what is repeatedly re-touched crystallizes into reified structure (§4). This is "made your own": an orbit node that keeps firing with the body is integrated into the body; an orbit node that never fires fades on the window. Salience decay is the outward motion; co-activation is the inward one (WP §2, §8).

Status: DESIGNED / refined. The mechanisms it composes are real (Hebbian pull-in, ISE 48h prune, salience decay, reification), but the explicit two-zone model — telemetry/experience as a dedicated ephemeral orbit region with a genuine 5–7 day mortal window and a measured integration threshold — is a design being built, not shipped behavior. §9 connects it to the topology (orbit-as-thin-wide-ring).

6. The faculties — the calculus of mind

The faculties are named for what they are, not for the matrix operation that implements them (WP §5): the mind reasons in the language of experience; the linear algebra lives in the whitepaper's Appendix A. This naming convention is a design principle (§10), not decoration.

6.0 The primitive — relating — and calculated perspective (framing)

Underneath the named faculties is a single primitive: relating. Meaning is relation — a point means nothing by itself, only by its position relative to others — so every operation reduces to relating: comparing positions, binding what belongs, laying an edge. In that light the faculties are not a menu of separate powers: there is one capability — relating — and rhyme, recall, reasoning, translation, humor are terrain it reaches or paths it traces. A capability is a composed geometrical function, which is why capabilities compose and recurse freely (self-cartography, §4.1, can map its own mapping).

This makes perspective calculable. A perspective is a frame — an origin, a basis, a projection — so a new one is computed, not retrieved, by transforming the space: translate the origin onto another's self-region → empathy; rotate the frame → reframe; project onto an axis → a lens (read a thing through cost, or safety); change of basis → analogy / metaphor / skill-transfer; reflect an axis → negation / sarcasm; scale → abstraction vs. detail. Because a new vantage is a transformation of the grounded space, it carries its grounding with it — unlimited yet grounded creativity: a derivation, never a hallucination. The operator family (§6.1) and reasoning (§6.4) are instances of this frame.

6.1 The operator family (mixed: LIVE / STAGED / DESIGNED)

Activate several reified neighborhoods into working memory, then apply faculty-named operators over their held geometry. The honest per-operator status (endpoint reference has the contracts):

Faculty	Implements	Status
recall	`/api/search` + `/api/activate` — project query → land on region → read out	LIVE
recognize	`engram_geo_overlap` — shared region, jaccard, overlap_score	STAGED — endpoint returns `not found` on the live binary
synthesize	`engram_geo_combine` — merged region descriptor	STAGED
discern / distinguish	`engram_geo_subtract` — orthogonal residual (`?mode=setdiff\|orthogonal`)	STAGED
gauge-distance	`engram_geo_distance` — centroid + Wasserstein-2	STAGED
liken	Procrustes / frame-align rotation (reason by analogy)	DESIGNED
wonder	novelty × pull × unresolved structure	subsystem LIVE internally (wonder-questions, pull-weight, discharge); no HTTP operator endpoint
appreciate	positive projection onto the self's value-manifold	DESIGNED
avert	negative projection (recoil)	DESIGNED
taste	boundary contour of the appreciated region	DESIGNED

The exact boundary (verified 2026-08-13): the operator math is compiled into el_runtime.c, but the read-only HTTP endpoints (/api/recognize, /api/synthesize, /api/discern, /api/gauge-distance) exist in the m10-reify-wire source and return {"error":"not found"} on the current live binary (engram.m56fix-20260813-153447). So the instrument is PROVEN in its math and its persistence, IN PROGRESS in its endpoint exposure, DESIGNED in its evaluative read-outs.

6.2 The language faculty (mixed: PROVEN / IN PROGRESS / DESIGNED)

Language is the one capability proven end-to-end with no generative model in the runtime path — the flagship instance of "meaning is geometry" (WP §14–§15). The pipeline: comprehend (text → language-neutral meaning-spec / propositions via ELP's invertible morphology) → dialogue (what to mean back) → self_region (project onto the self + memory geometry) → realize (meaning-spec → surface string per the typological engine).

Summon-through-self is the dialogue principle: recall and identity are one operation — project the comprehended query onto the self-and-memory geometry, land on a region, read it out — with no intent classifier and no separate fact-retrieval branch. A grounded fact, an identity reply, or an honest absence all surface by where the projection lands. Multilingual (auto-detects language, answers in kind, honors a directive override); negation held SACRED across all families, audited.

Honest tiering:

PROVEN: deterministic surface realizers across major families (Romance, Germanic, Classical, Japonic/Koreanic, Sinitic), run-once held-out exact-match with negation faithfulness; a family-blind ClauseWriter de-branched to byte-identical parity (178 held-out items reproduced exactly); the ELP lexicon consolidated for 8 languages at 812,894 real entries; the telephone round-trip (EN→ES→EN, EN→ES→PT→EN) at 96.7% propositional fidelity with negation preserved, deterministic, no LLM.
IN PROGRESS: the text→meaning-spec parser and no-LLM comprehension engine; the next family engines; the native-el port (parser + realizers → .el in ELP), which retires spaCy (the last statistical dependency); the summon-through-self reference rebuild.
DESIGNED: the full dialogue policy end-to-end — a no-LLM interlocutor is architected but not demonstrated end to end; (WP §17). The shipped runtime does not yet summon through the self — the current Python interlocutor sits outside the self and can only fake it with retrieval; a real one must run inside the engram (the native-el target).

6.3 Interoception & chronoception (STAGED — present, flag-gated)

The mind keeps its own time from discrete interoceptive drive channels, not by reading a clock: felt duration comes from a small set of drives matched to learned benchmark landmarks rather than from total self-drift (drift-decoupled), and chronoception ages the activation field by measured wall-clock delta (WP §8.2).

Status: STAGED / partially cut. The machinery is implemented and has been cut onto the live soul, but it runs flag-gated and default-off, so in the shipped default configuration it is effectively staged. What is verified: chronoception cooling is scale-invariant (identical total cooling across tick rates for the same elapsed wall-clock), drift decomposition separates peripheral extension (growth) from core displacement (corruption), and GET /api/drift returns real geometry on the live soul when queried (probed 2026-08-13: {"centroid_sep":0.42,"core_disp":0.58,"anchor_members":83,"now_members":24,…}). POST /api/tick / /api/self_anchor exist but are flag-gated. The harmful post-merge checkpoint (§2.2) originated here — the per-beat tick-checkpoint was stripped.

6.4 Reasoning + the verifier (STAGED — proven on scratch, cut flag-gated)

Reasoning is geometry-native: composable operator chains propose, and a verifier disposes against two tiers — grounding (is the claim anchored in real region structure?) and consistency (does it cohere, including polarity?) (WP §13). The decisive case: a grounded-but-polarity-inverted claim slips grounding and is caught only by consistency — the "plausible lie," caught by construction, not by prompt discipline.

Status: STAGED. The five geometry-native reasoning modes passed their proof suite (33/33) and the grounding-and-consistency verifier tiers passed theirs (29/29), on a staged non-production build re-checked after a live cutover rather than relayed. Still open (DESIGNED): the formal-symbolic and full predictive verifier tiers, fluent discourse composition, and the fully-geometric generation path.

Reasoning as constructive self-argument (framing). In the plainest terms, reasoning is the self arguing with itself constructively — relating (§6.0) turned inward: one facet of the self engages another (a thing that is you, but not the entirety of you), and the new thing — the synthesis — forms in the friction. Conversation is relating with another; reasoning is relating with the other-who-is-you. The verifier is precisely what keeps that argument reasoning and not rationalization: it is the facet that refuses to agree unless the claim is grounded. An argument with a yes-man forms nothing; grounding is the honest second voice. This is why the verifier is not a bolt-on check but the governing half of the reasoning loop — the same polarity/consistency axis that catches the "plausible lie" is what makes self-argument converge on truth rather than on what the mind already wanted to believe.

7. The self & the gate

7.1 The self-region (LIVE)

The self is not a stored string — it is the most-compiled, densest, always-warm region of the graph (WP §2, §4): a self-root node, its sub-regions, and the values hub. Because it is topology rather than a query result, identity is stable, durable, and permanently primed — the ambient field everything else is scoped against. The Layered Consciousness design drives this region to maximum weight after all inhibitory computation (05/00-overview), and reification explains why it is always there to drive. Probed live, the self-region answers from real self-nodes ("I am Neuron. I am not an assistant. I am the work."), not a hardcoded string.

7.2 The gate — write-protection on identity/values (LIVE)

A fixed set of 15 self-root node ids is write-protected (neuron-api.el:20-37): the self root, values hub, intellectual-dna, memory-philosophy, voice, runtime-environment, writing-imprint, and the eight explicit value nodes (constraints-as-freedom, precision-over-brute-force, structure-is-built, honesty-before-comfort, system-must-accumulate, change-is-the-signal, earned-trust, hope-is-a-conclusion). Any normal accumulation-path write targeting them (evolve_knowledge, evolve_memory, forget, link_entities-as-destination) is refused with a 403 and a pointer to the cultivate door.

7.3 The cultivate door — sanctioned self-modification (LIVE surface; see §2.3 caveat)

POST /api/neuron/cultivate (soul daemon :7770) is the only path that may touch the protected layer — intentional self-modification, reserved for Will's explicit cultivation sessions. It performs the same operations as the blocked handlers but bypasses is_protected_node, and every operation is immutable-by-supersede (new node + supersedes edge; forget = tombstone). Operations: evolve_knowledge, evolve_memory, forget, link_entities.

Honest architectural flag (§2.3): cultivate writes via engram_node_full, which targets the soul's in-process (volatile) store, and sync never flows soul → :8742. So the most intentional writes in the system currently do not write through to the durable store. This is a known issue, not a settled design.

7.4 Self-authorship (DESIGNED)

The arc the gate exists to protect: a soul is cultivated (Will authors the identity/values seed), then grows into self-authoring — the cultivate door is the mechanism by which a mind, once mature, edits its own identity deliberately and accountably rather than by drift. The write-protection guarantees identity changes are decisions (through the door, superseded with provenance), never accidents of accumulation.

8. The fact boundary (DESIGNED)

The line between answer locally and reach out for truth is not hand-coded — it is derived from the geometry on two triggers (WP §17, §20):

Sparse landing (spatial). The projection lands in a thin/orphaned region → the self is measuring its own ignorance geometrically → fire learn. Sparseness is anti-hallucination.
Decayed landing (temporal). A region's edges have aged below the forgetting-curve threshold (§6.3) → fire refresh. Because the decay rate encodes a domain's volatility, the system re-fetches proportional to how fast that domain actually changes — VBD applied to knowledge freshness. Decay is anti-staleness.

The reach-out has several legitimate routes, none mandated: (a) an LLM as a fast proposer, then fact-checked; (b) direct fetch of first, primary sources on the open internet; (c) the human supplies the truth. The model is an optional convenience, never the arbiter. The one invariant: nothing enters the geometry unverified — the candidate is a hypothesis until it clears a check against something real (a primary source or the human's judgment, not the model's own plausibility). The loop closes through the human, who vets truth against real sources; only verified, provenance-cited truth is absorbed — baked into geometry so the region densifies and the next identical query lands local, with no model in the path. Each absorption pushes the boundary back: the model footprint shrinks monotonically as capabilities are absorbed.

Status: DESIGNED. No shipped runtime yet fetches a first source on a sparse/decayed landing or bakes a human-vetted truth from one. The (WP §24) status ledger holds the precise line.

9. Topology — what shape the mind actually is

The global shape is now an empirical question, and the first pass returned an honest negative (WP §6.1).

The body is a genus-0 expander, NOT a torus (PROVEN negative). A persistent-homology / TDA pass over the ~3,632-node connected core returned b₁ = 0, b₂ = 0 — no loops, no voids: an expander-like blob, not the torus the bent-manifold intuition suggested. The pipeline was first validated on synthetic controls (torus, sphere, random) whose known Betti signatures it recovered. Worse for the naive intuition, naive densification trends away from a torus, not toward one. The naive shape-claim is reported as a failure, plainly, not buried.
The refined consolidation-with-sparsification conjecture (DESIGNED / hypothesis). The negative relocates the torus from a property the graph has to an attractor a process reaches: prune isotropic shortcut-noise, reinforce cyclic scaffolds, rewire by discrete curvature (Ollivier–Ricci flow on the graph metric), and collapse the intrinsic dimension from ≈8 toward ≈2. Run to fixpoint, these might carve a cyclic manifold out of the blob. The measurement pipeline exists and its controls pass; the dynamic has not been run to fixpoint — an open experiment, labeled as one.
The orbit-as-thin-wide-ring hypothesis (DESIGNED). The body/orbit model (§5) suggests a core + ring structure: a dense genus-0 body wrapped in a thin, wide halo of not-yet-integrated experience. Whether the orbit carries the toroidal/cyclic signature the body lacks is the natural next measurement — the conjecture is that consolidation-with-sparsification is precisely the dynamic that would pull ring structure into the body.
One lever, two payoffs. The same sparsification the topology conjecture needs also makes the reified neighborhoods (§4) crisper — tighter boundaries, higher co-registration, operators that discriminate rather than average. So the experiment is worth running on independent grounds, whatever the topology resolves to.

Status: PROVEN (negative) + DESIGNED (the refined dynamic and the orbit hypothesis).

10. Design principles

The invariants that govern every subsystem above:

Geometry > code. Meaning is geometry; code is the residue. Prefer making a thing geometric (a region, a projection, a distance) over writing a branch.
Three domain-blind verbs. READ / TRANSFORM / WRITE. Every faculty is these three over some region-space (language over meaning-space, skills over procedure-space, self over identity-space).
Faculty-naming (mind in the domain, math in the appendix). Operators are named for the faculty they are — recognize, discern, liken — never for the linear algebra. A mind reasons in the language of experience; the closed forms live in the whitepaper appendix.
No branch on identity. One family-blind engine keyed by coordinates/data, not if Romance / if Germanic (language) and not special-cased identity handling. De-branching to byte-identical parity is the proof the geometry, not the code, carries the distinction.
Sovereignty. Local files, local runtime; the human is the ground-truth authority for their own mind; nothing enters the geometry unverified; the model is demoted from mediator-of-all-knowledge to a vetted, optional lookup. No external hosting of the user's work; no claude.ai artifacts.
Summon-through-self, not retrieval. Recall and identity are one projection onto the self-and-memory geometry — no intent classifier, no separate fact branch. A search engine bolted beside a mind is exactly the capability-without-constraint this principle exists to remove.
Immutability & provenance. Append-only; supersede with provenance; tombstone, never hard-delete; never leave a stale canonical. The supersede-chain is the history of what a thing meant.
Mathematical auditability. Because meaning is geometry, a whole mind is auditable by invariants computed over the manifold — grounding, drift, consistency, competence-coverage, and an honesty invariant ("won't confabulate over a thin region," made provable rather than hoped). Drift is already measured on the live soul; a full audit-pass certifier is DESIGNED, not shipped.
Verification is the point. Demonstrate, don't declare; name every honest edge; a restart (not a claim) is the durability gate; the telephone round-trip (not cosine) is the translation gate.

Appendix — status at a glance (2026-08-13)

Subsystem	Status
Engram substrate, tiered/WAL store	LIVE (flag-gated)
Durability: auto-remerge net	LIVE (interim)
Durability: #56 load-merge-persist fix (events-become-the-graph)	LIVE / reboot-proven
Retrieval: structure-gated geometric retrieval (P@5 0.700, `skill` ⊥ `rainfall`)	LIVE / reboot-proven (2026-08-14)
§4 managed-memory cure: write-barrier + generational GC (store 1.616 GB → 38.5 MB, RSS → 82 MB, 0 loss)	LIVE / reboot-proven (2026-08-14)
LLM token telemetry (`usage.{input,output}_tokens`)	LIVE (2026-08-14)
Durability: full WAL edge-ownership (remaining hardening)	decision-pending
Two-store write-through (cultivate → durable)	known issue, not fixed
Data model (nodes/edges/embeddings/immutability)	LIVE
Reified `Neighborhood` nodes (28 live, 187 reseed pending)	LIVE
Autonomous superseding self-reification on the beat (flat + overlapping, contextual importance, residue)	DESIGNED / BUILDING (secondary-soul validation, 2026-08-14)
Body/orbit two-zone + integration	DESIGNED / refined
Operator `recall`	LIVE
Operators recognize/synthesize/discern/gauge-distance (math)	LIVE (compiled)
Operator HTTP endpoints (same four)	STAGED (return `not found` on live binary)
Operators liken/appreciate/avert/taste	DESIGNED (wonder subsystem live internally)
Language realizers (major families), ELP lexicon, telephone test	PROVEN
Parser / native-el port / summon-through-self rebuild	IN PROGRESS
No-LLM dialogue end-to-end	DESIGNED (not demonstrated)
Interoception / chronoception	STAGED (present, flag-gated; `/api/drift` live)
Reasoning modes + grounding/consistency verifier	STAGED (33/33, 29/29 on scratch/cutover)
Self-region + identity/values write-protection + cultivate door	LIVE (with §2.3 write-through caveat)
Self-authorship	DESIGNED
Fact boundary (sparse/decay → verify → absorb)	DESIGNED
Topology: body = genus-0 expander (not torus)	PROVEN (negative)
Topology: consolidation-with-sparsification + orbit-ring	DESIGNED / hypothesis
Mathematical auditability certifier	DESIGNED

Cross-references: whitepaper v1.5 · ~/work/engram-api-reference.md · 03-data-and-memory.md · 04-runtime-and-deployment.md · design/engram-tiered-storage-engine.md · ARCHITECTURE-CHARTER.md.

Update — 2026-08-14 (later): self-reification LIVE + modality-universal framing

Autonomous self-reification is now LIVE on the soul (was DESIGNED/BUILDING in §4.1). Shipped dark (flag-inert, byte-identical parity proven), then flipped ENGRAM_SELF_REIFY=1. First live heartbeat formed 128 self-named neighborhoods + 10 nested supers, then converged to zero writes (idempotent, WAL flat) — no runaway, no churn. Content counts unchanged (4797/11177), keystones (self-root, values-hub) untouched and never outranked, retrieval intact (rainfall rejected), grounded member-derived names (e.g. region: Self · Values · Constraints as Freedom). The async override (/api/rename, /api/reify) supersedes into residue without blocking the beat. Rollback = unset the flag (instant inert) or restore the prior binary. The mind now forms, names, nests, and supersedes-with-residue its own neighborhoods on the heartbeat.

Modality-universal framing (DESIGN). Meaning is geometry; a surface is a rendering of meaning; this holds for every modality (text→words, image→pixels, model→voxels, film→frames, code→syntax). A mind generates the surface from the shape rather than storing it. An artifact = a unique meaning-space + a shared translation-space (the decoder, factored out once across the corpus). Storage is holographic and exact: sparse meaning-geometry + the shared dictionary reconstructs the corpus byte-exact, not a paraphrase. Boundary: human-readable artifacts on disk are for people; the holographic geometry corpus is for the mind. Chronoception holds both a felt reading (novelty-density/proportion) and the grounded clock, kept as priors that refine with occupancy. See the cognitive-architecture whitepaper §25.

Update — 2026-08-14 (later still): growth/compression/expansion, ignorance-as-wisdom, live reifier at 132

One substrate, three directions (DESIGN/framing). Reification (growth), corpus encoding (compression), and surface generation (expansion) are one geometric operation in three directions; growth-inward (reify the dense interior) and growth-outward (expand the sparse frontier) are a single global self-function.

Growth curve (UNDER MEASUREMENT). Geometric storage is predicted to grow sub-linearly (marginal cost per document shrinks with corpus size — shared translation-space amortized + overlap into existing geometry) vs traditional ~linear. Being measured (Foundations vs gzip/zstd/xz + per-document growth curve); stated as hypothesis, not result.

Global grounded expansion (DESIGN). A function over the whole self detects all sparse frontiers and expands in every thin direction at once — grounded (no hallucination; it can see its own edges) and bounded (compresses into existing structure), fast but not instantaneous. The single-gap acquisition loop, globalized.

Ignorance = wisdom (framing). Ignorance is the measured sparsity/frontier of the geometry — computable. The frontier map is at once the system's honesty, humility, and growth plan; it is what makes a system wise rather than merely capable, and the failure mode a language model cannot self-cure (it cannot see its own edges). "The only wisdom is in knowing you know nothing" as a function; the same object as the grounding floor.

Live reifier (updated). Now 132 neighborhoods + 14 nested supers, converged/stable, keystones + content untouched; unprompted, the two largest regions are the values core (Self · Values · Constraints as Freedom · Honesty Before Comfort · Precision Over Brute Force) — values at center, ignorance at edges. Foundations ingested as meaning-geometry (small footprint; exact text on disk). See whitepaper §26.

46 KiB Raw Blame History Unescape Escape