docs: add cognitive-architecture treatise (06)

The middle layer between the whitepaper (thesis) and the engram API reference (surface): how the mind is designed and why, as tiered subsystems (LIVE/STAGED/DESIGNED). Covers the geometry thesis, engram durability and the two-store topology (with the cultivate write-through gap flagged as a known issue), reified Neighborhood nodes, the body/orbit model, the operator/language/interoception/reasoning faculties, the self and the cultivate gate, the fact boundary, the topology findings (genus-0 expander, not a torus), and the design principles.
fix(mcp-wrapper): declare real input schemas so tool args actually bite
2026-08-13 17:05:27 -05:00 · 2026-08-10 16:27:03 -05:00
2 changed files with 851 additions and 96 deletions
@@ -0,0 +1,501 @@
+# Neuron — Cognitive Architecture
+
+> **Status: living design document, grounded in source and probed against the live soul (2026-08-13).**
+> 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).
+- **Governance:** `ARCHITECTURE-CHARTER.md` — VBD is the binding style.
+
+This document is the cognitive-layer companion to that set.
+
+---
+
+## 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:
+
+- **WAL edge-persistence (the #56 fix — STAGED/decision-pending).** 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 real fix is snapshot-authoritative
+  boot / WAL-durable edge records; `persist_canonical()` now checkpoints the paged store behind a WAL record
+  rather than depending on a full `snapshot.json` rewrite. The *complete* cure (WAL-owned edge set) is still
+  tracked as **decision-pending** work, not 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→~128 neighborhood reseed (§4) is an
+instance of this: reification is a derivable pass, so the geometry can always be regrown from the substrate.
+
+---
+
+## 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)*).
+
+### 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 ~128** 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.
+
+---
+
+## 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.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.
+
+---
+
+## 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:
+
+1. **Geometry > code.** Meaning is geometry; code is the residue. Prefer making a thing geometric (a region, a
+   projection, a distance) over writing a branch.
+2. **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).
+3. **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.
+4. **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.
+5. **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.
+6. **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.
+7. **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.
+8. **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.**
+9. **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: full WAL edge-persistence (#56) | STAGED / decision-pending |
+| Two-store write-through (cultivate → durable) | **known issue, not fixed** |
+| Data model (nodes/edges/embeddings/immutability) | LIVE |
+| Reified `Neighborhood` nodes (28 live, ~128 reseed pending) | LIVE |
+| 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`.
@@ -77,111 +77,327 @@ fn tool(name: String, desc: String) -> String {
    return "{\"name\":\"" + name + "\",\"description\":\"" + desc + "\",\"inputSchema\":{\"type\":\"object\",\"properties\":{}}}"
 }

+// tool_s — tool entry with an EXPLICIT JSON-Schema for its inputs. Used for tools
+// whose arguments must actually bite: unless the bounding/targeting params are
+// advertised, the MCP client sends nothing and the soul returns the FULL
+// neighborhood (480-775KB, over transport limits). Declaring the schema is what
+// makes a targeted call (entity_id/depth/compact/query/limit) reach the soul.
+fn tool_s(name: String, desc: String, schema: String) -> String {
+    return "{\"name\":\"" + name + "\",\"description\":\"" + desc + "\",\"inputSchema\":" + schema + "}"
+}
+
+// prop — a single JSON-Schema property fragment. Descriptions are plain text
+// (no quotes/newlines) so no escaping is needed here.
+fn prop(name: String, ty: String, desc: String) -> String {
+    return "\"" + name + "\":{\"type\":\"" + ty + "\",\"description\":\"" + desc + "\"}"
+}
+
+// obj_schema — wrap a comma-joined list of prop() fragments as an object schema.
+fn obj_schema(props: String) -> String {
+    return "{\"type\":\"object\",\"properties\":{" + props + "}}"
+}
+
+// ── Per-tool input schemas ──────────────────────────────────────────────────
+// Each mirrors the params the soul's /api/neuron/* handler actually honors so
+// declared == forwarded == honored (no accepted-but-ignored args).
+
+fn schema_inspect_graph() -> String {
+    return obj_schema(
+        prop("entity_id", "string", "UUID of the node to inspect (e.g. kn-... / mem-... / gn-...). Optional if name is given.") +
+        "," + prop("name", "string", "Named traversal root instead of entity_id: self, neuron, values, values_hub.") +
+        "," + prop("entity_type", "string", "Optional node-type hint (knowledge, memory, ...) for disambiguation.") +
+        "," + prop("depth", "integer", "Neighborhood hop radius. Default 1.") +
+        "," + prop("compact", "integer", "1 (default) returns a relevance-ranked bounded projection (top-K neighbors with content snippets, the rest as lightweight pointers). Set 0 to get the full, unbounded neighborhood.") +
+        "," + prop("snip", "integer", "Max content chars per node in compact mode. Default 600.") +
+        "," + prop("k", "integer", "How many top neighbors carry full content in compact mode. Default 12.")
+    )
+}
+
+fn schema_traverse_graph() -> String {
+    return obj_schema(
+        prop("entity_id", "string", "UUID of the node to start the walk from (alias: start_id). Required.") +
+        "," + prop("depth", "integer", "How many hops to walk. Default 2.") +
+        "," + prop("compact", "integer", "1 (default) returns a bounded, relevance-ranked projection; 0 returns the full neighborhood.") +
+        "," + prop("snip", "integer", "Max content chars per node in compact mode. Default 600.") +
+        "," + prop("k", "integer", "How many top neighbors carry full content in compact mode. Default 12.")
+    )
+}
+
+fn schema_retrieve_knowledge() -> String {
+    return obj_schema(
+        prop("id", "string", "UUID of the knowledge node to fetch (alias: entity_id / node_id).") +
+        "," + prop("key", "string", "Stable knowledge key/path to fetch instead of id.") +
+        "," + prop("depth", "integer", "Hop radius around the node. Default 0 (the node plus its immediate 1-hop context).") +
+        "," + prop("snip", "integer", "Max content chars per node in the bounded projection. Default 600.") +
+        "," + prop("k", "integer", "How many top neighbors carry full content. Default 12.")
+    )
+}
+
+fn schema_search_query(limit_desc: String) -> String {
+    return obj_schema(
+        prop("query", "string", "Search text. Spread-activates the engram and returns the most relevant nodes.") +
+        "," + prop("limit", "integer", limit_desc)
+    )
+}
+
+fn schema_recall() -> String {
+    return obj_schema(
+        prop("query", "string", "Search text to recall by relevance.") +
+        "," + prop("chain_name", "string", "Named memory chain to walk instead of a free-text query.") +
+        "," + prop("limit", "integer", "Max results. Default 10.")
+    )
+}
+
+// ── Reusable write/lookup schemas ───────────────────────────────────────────
+// Each declares exactly the params the corresponding wrapper handler reads and
+// forwards to the soul, so declared == forwarded == honored (no accepted-but-
+// ignored args, and no arg the handler silently drops).
+
+fn sc_id(desc: String) -> String {
+    return obj_schema(prop("id", "string", desc))
+}
+
+fn sc_id_content() -> String {
+    return obj_schema(
+        prop("id", "string", "UUID of the prior node being superseded/updated.") +
+        "," + prop("content", "string", "New content for the updated node.")
+    )
+}
+
+fn sc_edge(rel_desc: String) -> String {
+    return obj_schema(
+        prop("from_id", "string", "UUID of the source node (edge tail). Required.") +
+        "," + prop("to_id", "string", "UUID of the target node (edge head). Required.") +
+        "," + prop("relation", "string", rel_desc)
+    )
+}
+
+fn sc_limit(desc: String) -> String {
+    return obj_schema(prop("limit", "integer", desc))
+}
+
+fn sc_memory() -> String {
+    return obj_schema(
+        prop("content", "string", "The memory text. Required.") +
+        "," + prop("importance", "string", "low | normal | high | critical. Drives salience.") +
+        "," + prop("tags", "string", "Comma-separated or JSON-array tags.") +
+        "," + prop("project", "string", "Project this memory belongs to.") +
+        "," + prop("supersedes_id", "string", "UUID of a prior memory this one replaces (wires a supersedes edge).")
+    )
+}
+
+fn sc_content_title(content_desc: String) -> String {
+    return obj_schema(
+        prop("content", "string", content_desc) +
+        "," + prop("title", "string", "Short title/label for the node.")
+    )
+}
+
+fn sc_content(content_desc: String) -> String {
+    return obj_schema(
+        prop("content", "string", content_desc) +
+        "," + prop("title", "string", "Optional short title/label.") +
+        "," + prop("description", "string", "Optional longer description (used as content if content is empty).")
+    )
+}
+
+fn sc_backlog() -> String {
+    return obj_schema(
+        prop("title", "string", "Work-item title. Required.") +
+        "," + prop("content", "string", "Body/details of the item (alias: description).") +
+        "," + prop("description", "string", "Body/details of the item.") +
+        "," + prop("project", "string", "Project tag.") +
+        "," + prop("priority", "string", "P0 | P1 | P2 | P3.")
+    )
+}
+
+fn sc_track_work() -> String {
+    return obj_schema(
+        prop("item_id", "string", "UUID of the backlog item to update.") +
+        "," + prop("summary", "string", "What changed / outcome (stored as the update content).") +
+        "," + prop("action", "string", "start | complete | block.")
+    )
+}
+
+fn sc_capture_knowledge() -> String {
+    return obj_schema(
+        prop("content", "string", "Knowledge body. Required.") +
+        "," + prop("title", "string", "Knowledge title/key.")
+    )
+}
+
+fn sc_promote_knowledge() -> String {
+    return obj_schema(
+        prop("id", "string", "UUID of the prior knowledge node to promote. Required.") +
+        "," + prop("content", "string", "Updated canonical content. Required.") +
+        "," + prop("tags", "string", "Tags for the promoted node.")
+    )
+}
+
+fn sc_config_key() -> String {
+    return obj_schema(prop("key", "string", "Config key to read (e.g. neuron.self.traversal_root)."))
+}
+
+fn sc_config_tune() -> String {
+    return obj_schema(
+        prop("key", "string", "Config key to set. Required.") +
+        "," + prop("value", "string", "Value to set. Required.")
+    )
+}
+
+fn sc_consolidate() -> String {
+    return obj_schema(
+        prop("action", "string", "Consolidation action (e.g. session, reload).") +
+        "," + prop("summary", "string", "Session/work summary to persist.")
+    )
+}
+
+fn sc_browse_processes() -> String {
+    return obj_schema(prop("name", "string", "Process name to fetch; omit to list all."))
+}
+
+fn sc_notification() -> String {
+    return obj_schema(prop("content", "string", "Notification text. Required."))
+}
+
+fn sc_pin() -> String {
+    return obj_schema(prop("id", "string", "UUID of the node to strengthen/pin (alias: node_id)."))
+}
+
+fn sc_state_event() -> String {
+    return obj_schema(
+        prop("content", "string", "Description of the internal-state event.") +
+        "," + prop("kind", "string", "Event kind (frustration, uncertainty, insight, ...).") +
+        "," + prop("intensity", "string", "Optional intensity 0..1.")
+    )
+}
+
+fn sc_forget() -> String {
+    return obj_schema(
+        prop("node_id", "string", "UUID of the node to tombstone. Required. The node and its edges are kept and recoverable; blocked for protected identity nodes.")
+    )
+}
+
+fn sc_process() -> String {
+    return obj_schema(
+        prop("name", "string", "Process name. Required.") +
+        "," + prop("description", "string", "What the process does.") +
+        "," + prop("steps", "string", "Ordered steps (JSON array or text).")
+    )
+}
+
+fn sc_list_state_events() -> String {
+    return obj_schema(
+        prop("limit", "integer", "Max events. Default 20.") +
+        "," + prop("query", "string", "Optional filter text.")
+    )
+}
+
 fn tools_catalog() -> String {
    return "[" +
 // ── Session + orchestration ─────────────────────────────────────────────────
 tool("beginSession", "Initialize session: surface recent high-importance memories, project list, and preferences.") +
 "," + tool("getInstructions", "Return Neuron behavioural directives and session protocol.") +
 "," + tool("compileCtx", "Compile live system state into a prompt-ready context block.") +
-"," + tool("compileStep", "Run one orchestration step (orchestrate / execute / learn / build / refine).") +
-"," + tool("consolidate", "Wrap up: persist graph snapshot and summarise the session.") +
-"," + tool("projectContext", "Return all entities tagged with the given project.") +
+"," + tool_s("compileStep", "Run one orchestration step (orchestrate / execute / learn / build / refine).", sc_memory()) +
+"," + tool_s("consolidate", "Wrap up: persist graph snapshot and summarise the session.", sc_consolidate()) +
+"," + tool_s("projectContext", "Return all entities tagged with the given project.", schema_search_query("Max results. Default 50.")) +
 // ── Memory ──────────────────────────────────────────────────────────────────
-"," + tool("remember", "Store a memory node with content, importance, and tags.") +
-"," + tool("recall", "Retrieve memories by chain or query.") +
-"," + tool("inspectMemories", "List recent memory nodes.") +
-"," + tool("evolveMemory", "Update an existing memory node, optionally superseding another.") +
-"," + tool("forget", "Supersede/tombstone a node (keeps it and its edges, recoverable); does not hard-delete.") +
-"," + tool("pinNode", "Strengthen a node so it stays salient.") +
+"," + tool_s("remember", "Store a memory node with content, importance, and tags.", sc_memory()) +
+"," + tool_s("recall", "Retrieve memories by chain or query.", schema_recall()) +
+"," + tool_s("inspectMemories", "List recent memory nodes.", sc_limit("Max memories. Default 50.")) +
+"," + tool_s("evolveMemory", "Update an existing memory node, optionally superseding another.", sc_id_content()) +
+"," + tool_s("forget", "Tombstone a specific node by id (keeps it and its edges, recoverable); does not hard-delete.", sc_forget()) +
+"," + tool_s("pinNode", "Strengthen a node so it stays salient.", sc_pin()) +
 // ── Knowledge ───────────────────────────────────────────────────────────────
-"," + tool("searchKnowledge", "Search knowledge base by semantic similarity.") +
-"," + tool("retrieveKnowledge", "Fetch a knowledge node by id or key.") +
-"," + tool("browseKnowledge", "List knowledge nodes by category.") +
-"," + tool("captureKnowledge", "Persist a durable knowledge node.") +
-"," + tool("evolveKnowledge", "Update a knowledge node.") +
-"," + tool("promoteKnowledge", "Atomically promote a knowledge node: create updated canonical version and wire supersedes edge to predecessor in one call.") +
-"," + tool("removeKnowledge", "Delete a knowledge node.") +
+"," + tool_s("searchKnowledge", "Search knowledge base by semantic similarity.", schema_search_query("Max results. Default 10.")) +
+"," + tool_s("retrieveKnowledge", "Fetch a knowledge node by id or key (bounded, relevance-ranked projection).", schema_retrieve_knowledge()) +
+"," + tool_s("browseKnowledge", "List knowledge nodes by category.", sc_limit("Max knowledge nodes. Default 100.")) +
+"," + tool_s("captureKnowledge", "Persist a durable knowledge node.", sc_capture_knowledge()) +
+"," + tool_s("evolveKnowledge", "Update a knowledge node.", sc_id_content()) +
+"," + tool_s("promoteKnowledge", "Atomically promote a knowledge node: create updated canonical version and wire supersedes edge to predecessor in one call.", sc_promote_knowledge()) +
+"," + tool_s("removeKnowledge", "Delete a knowledge node.", sc_id("UUID of the knowledge node to delete.")) +
 // ── Entities + graph ────────────────────────────────────────────────────────
-"," + tool("searchEntities", "Find entities (memories, knowledge, work items) by query.") +
-"," + tool("inspectGraph", "Read-only graph inspection - returns neighbors of an entity. Accepts entity_id (UUID) or name (self, neuron, values).") +
-"," + tool("traverseGraph", "Walk the graph from a starting node.") +
-"," + tool("searchGraph", "Search graph nodes by content + relation filter.") +
-"," + tool("linkEntities", "Create an edge between two entities.") +
-"," + tool("linkCausal", "Create a causal edge (cause -> effect).") +
-"," + tool("restructureCausalGraph", "Re-balance the causal subgraph after new evidence.") +
+"," + tool_s("searchEntities", "Find entities (memories, knowledge, work items) by query.", schema_search_query("Max results. Default 20.")) +
+"," + tool_s("inspectGraph", "Read-only graph inspection - returns a bounded, relevance-ranked neighborhood of an entity. Accepts entity_id (UUID) or name (self, neuron, values). Use depth/compact/snip/k to bound the result.", schema_inspect_graph()) +
+"," + tool_s("traverseGraph", "Walk the graph from a starting node (bounded by default).", schema_traverse_graph()) +
+"," + tool_s("searchGraph", "Search graph nodes by content.", schema_search_query("Max results. Default 30.")) +
+"," + tool_s("linkEntities", "Create an edge between two entities.", sc_edge("Edge relation. Default associates.")) +
+"," + tool_s("linkCausal", "Create a causal edge (cause -> effect).", sc_edge("Edge relation. Default causes.")) +
+"," + tool_s("restructureCausalGraph", "Re-balance the causal subgraph after new evidence.", sc_consolidate()) +
 "," + tool("rebuildGraph", "Rebuild graph indices from the on-disk snapshot.") +
 "," + tool("runStructuralAudit", "Audit graph structure for orphans, dangling edges, mislabeled types.") +
 // ── Backlog + work ──────────────────────────────────────────────────────────
-"," + tool("planWork", "Create a backlog item.") +
-"," + tool("reviewBacklog", "Browse work items.") +
-"," + tool("trackWork", "Update status of a backlog item.") +
-"," + tool("listWork", "List active execution contexts.") +
-"," + tool("beginWork", "Open an execution context for a multi-step task.") +
-"," + tool("progressWork", "Record progress on an execution context.") +
-"," + tool("checkWork", "Verify outcomes / blockers on an execution context.") +
+"," + tool_s("planWork", "Create a backlog item.", sc_backlog()) +
+"," + tool_s("reviewBacklog", "Browse work items.", sc_limit("Max items. Default 50.")) +
+"," + tool_s("trackWork", "Update status of a backlog item.", sc_track_work()) +
+"," + tool_s("listWork", "List active execution contexts.", sc_limit("Max contexts. Default 50.")) +
+"," + tool_s("beginWork", "Open an execution context for a multi-step task.", sc_content("What you're doing (description of the work).")) +
+"," + tool_s("progressWork", "Record progress on an execution context.", sc_content("Step name / progress note.")) +
+"," + tool_s("checkWork", "Verify outcomes / blockers on an execution context.", sc_id("UUID of the execution context (alias: context_id).")) +
 // ── Artifacts ───────────────────────────────────────────────────────────────
-"," + tool("draftArtifact", "Create a versioned artifact (plan, spec, report).") +
-"," + tool("findArtifacts", "Find artifacts by project or query.") +
-"," + tool("retrieveArtifact", "Fetch a specific artifact by id.") +
-"," + tool("reviseArtifact", "Update an artifact's content.") +
-"," + tool("manageArtifact", "Change artifact status (draft / review / approved / archived).") +
+"," + tool_s("draftArtifact", "Create a versioned artifact (plan, spec, report).", sc_content_title("Artifact body / markdown. Required.")) +
+"," + tool_s("findArtifacts", "Find artifacts by project or query.", schema_search_query("Max results. Default 20.")) +
+"," + tool_s("retrieveArtifact", "Fetch a specific artifact by id.", sc_id("UUID of the artifact.")) +
+"," + tool_s("reviseArtifact", "Update an artifact's content.", sc_id_content()) +
+"," + tool_s("manageArtifact", "Change artifact status (draft / review / approved / archived).", sc_id_content()) +
 // ── Processes ───────────────────────────────────────────────────────────────
-"," + tool("defineProcess", "Register a proven workflow as a process.") +
-"," + tool("listProcesses", "List registered processes.") +
-"," + tool("browseProcesses", "Browse processes by name or step.") +
-"," + tool("retrieveProcess", "Fetch a specific process by name.") +
-"," + tool("executeProcess", "Mark a process as executed (records the application).") +
-"," + tool("exportProcess", "Export a process definition.") +
-"," + tool("deleteProcess", "Remove a process.") +
+"," + tool_s("defineProcess", "Register a proven workflow as a process.", sc_process()) +
+"," + tool_s("listProcesses", "List registered processes.", sc_limit("Max processes. Default 50.")) +
+"," + tool_s("browseProcesses", "Browse processes by name or step.", sc_browse_processes()) +
+"," + tool_s("retrieveProcess", "Fetch a specific process by name.", sc_id("Process id or name.")) +
+"," + tool_s("executeProcess", "Mark a process as executed (records the application).", sc_content("Process execution note.")) +
+"," + tool_s("exportProcess", "Export a process definition.", sc_id("Process id or name.")) +
+"," + tool_s("deleteProcess", "Remove a process.", sc_id("Process id or name.")) +
 // ── Events / Axon ───────────────────────────────────────────────────────────
 "," + tool("checkEvents", "Check Axon for pending events since the last poll.") +
-"," + tool("inspectEvent", "Fetch full detail for a single event.") +
-"," + tool("acknowledgeEvent", "Mark an event as handled.") +
+"," + tool_s("inspectEvent", "Fetch full detail for a single event.", sc_id("Event id.")) +
+"," + tool_s("acknowledgeEvent", "Mark an event as handled.", sc_id("Event id.")) +
 "," + tool("processEvents", "Drain and act on the event queue.") +
-"," + tool("sendNotification", "Emit a notification to Axon / external sinks.") +
+"," + tool_s("sendNotification", "Emit a notification to Axon / external sinks.", sc_notification()) +
 // ── Config ──────────────────────────────────────────────────────────────────
-"," + tool("inspectConfig", "Inspect Neuron config keys.") +
-"," + tool("tuneConfig", "Set a Neuron config key.") +
+"," + tool_s("inspectConfig", "Inspect Neuron config keys.", sc_config_key()) +
+"," + tool_s("tuneConfig", "Set a Neuron config key.", sc_config_tune()) +
 // ── Imprints ────────────────────────────────────────────────────────────────
-"," + tool("createImprint", "Cultivate a new imprint.") +
-"," + tool("listImprints", "List imprints.") +
-"," + tool("retrieveImprint", "Fetch an imprint by id.") +
-"," + tool("evolveImprint", "Update an imprint.") +
-"," + tool("deleteImprint", "Remove an imprint.") +
+"," + tool_s("createImprint", "Cultivate a new imprint.", sc_content_title("Imprint seed / description.")) +
+"," + tool_s("listImprints", "List imprints.", sc_limit("Max imprints. Default 50.")) +
+"," + tool_s("retrieveImprint", "Fetch an imprint by id.", sc_id("UUID of the imprint.")) +
+"," + tool_s("evolveImprint", "Update an imprint.", sc_id_content()) +
+"," + tool_s("deleteImprint", "Remove an imprint.", sc_id("UUID of the imprint.")) +
 // ── Self / cultivation ──────────────────────────────────────────────────────
 "," + tool("getSelfModel", "Return the current self-model.") +
-"," + tool("updateSelfModel", "Update the self-model.") +
+"," + tool_s("updateSelfModel", "Update the self-model.", sc_content("Self-model update text.")) +
 "," + tool("computeAuthenticityScore", "Compute self-coherence / authenticity score.") +
 "," + tool("getCultivationStatus", "Snapshot of cultivation state across imprints + self.") +
 // ── Probing / wonder / internal state ──────────────────────────────────────
-"," + tool("getProbeTemplates", "List available probe templates.") +
-"," + tool("recordProbeResponse", "Record an answer to a probe.") +
-"," + tool("completeProbingStage", "Mark a probing stage complete.") +
-"," + tool("addWonderQuestion", "Push a question onto the wonder queue.") +
-"," + tool("getWonderManifest", "List active wonder questions.") +
-"," + tool("updateWonderPullWeight", "Re-weight a wonder question.") +
-"," + tool("dischargeWonder", "Resolve / discharge a wonder question.") +
-"," + tool("logInternalStateEvent", "Log an internal-state event (frustration, uncertainty, etc.).") +
-"," + tool("listInternalStateEvents", "List internal-state events.") +
-"," + tool("getInternalStateEvent", "Fetch one internal-state event.") +
+"," + tool_s("getProbeTemplates", "List available probe templates.", schema_search_query("Max templates. Default 50.")) +
+"," + tool_s("recordProbeResponse", "Record an answer to a probe.", sc_content("Probe response text.")) +
+"," + tool_s("completeProbingStage", "Mark a probing stage complete.", sc_content("Stage completion note.")) +
+"," + tool_s("addWonderQuestion", "Push a question onto the wonder queue.", sc_content("The wonder question.")) +
+"," + tool_s("getWonderManifest", "List active wonder questions.", sc_limit("Max questions. Default 50.")) +
+"," + tool_s("updateWonderPullWeight", "Re-weight a wonder question.", sc_id_content()) +
+"," + tool_s("dischargeWonder", "Resolve / discharge a wonder question.", sc_id("UUID of the wonder question.")) +
+"," + tool_s("logInternalStateEvent", "Log an internal-state event (frustration, uncertainty, etc.).", sc_state_event()) +
+"," + tool_s("listInternalStateEvents", "List internal-state events.", sc_list_state_events()) +
+"," + tool_s("getInternalStateEvent", "Fetch one internal-state event.", sc_id("Internal-state event id.")) +
 // ── Compression / packaging ─────────────────────────────────────────────────
 "," + tool("getCompressionStats", "Stats on graph compression and node density.") +
-"," + tool("decompilePackage", "Decompile a knowledge package.") +
-"," + tool("renderPackage", "Render a knowledge package to text.") +
-"," + tool("catalogRoutes", "List registered routes.") +
-"," + tool("registerRoute", "Register a new route.") +
+"," + tool_s("decompilePackage", "Decompile a knowledge package.", sc_id("Package id.")) +
+"," + tool_s("renderPackage", "Render a knowledge package to text.", sc_id("Package id.")) +
+"," + tool_s("catalogRoutes", "List registered routes.", sc_limit("Max routes. Default 50.")) +
+"," + tool_s("registerRoute", "Register a new route.", sc_content("Route definition / description.")) +
 // ── Evaluation ──────────────────────────────────────────────────────────────
-"," + tool("beginEvaluation", "Start an evaluation run.") +
-"," + tool("getEvaluation", "Fetch an evaluation by id.") +
-"," + tool("listEvaluations", "List evaluations.") +
+"," + tool_s("beginEvaluation", "Start an evaluation run.", sc_content_title("Evaluation description.")) +
+"," + tool_s("getEvaluation", "Fetch an evaluation by id.", sc_id("Evaluation id.")) +
+"," + tool_s("listEvaluations", "List evaluations.", sc_limit("Max evaluations. Default 50.")) +
 // ── Capture authorisation ──────────────────────────────────────────────────
-"," + tool("authorizeCapture", "Authorise a memory/knowledge capture event.") +
-"," + tool("getCaptureAuthorization", "Fetch a capture authorisation.") +
-"," + tool("recordObservation", "Record an observation.") +
-"," + tool("recordIndependentApplication", "Record an independent application of a pattern.") +
-"," + tool("commitPrediction", "Commit a falsifiable prediction.") +
+"," + tool_s("authorizeCapture", "Authorise a memory/knowledge capture event.", sc_content("Capture authorisation details.")) +
+"," + tool_s("getCaptureAuthorization", "Fetch a capture authorisation.", sc_id("Capture authorisation id.")) +
+"," + tool_s("recordObservation", "Record an observation.", sc_content("Observation text.")) +
+"," + tool_s("recordIndependentApplication", "Record an independent application of a pattern.", sc_content("What was independently applied.")) +
+"," + tool_s("commitPrediction", "Commit a falsifiable prediction.", sc_content("The prediction (falsifiable).")) +
 // ── Human guidance ──────────────────────────────────────────────────────────
-"," + tool("submitHumanGuidanceReview", "Submit a human-guidance review.") +
+"," + tool_s("submitHumanGuidanceReview", "Submit a human-guidance review.", sc_content("Review content.")) +
 "]"
 }

@@ -297,6 +513,28 @@ fn search_with_query(args: String, default_limit: Int) -> String {
    return mcp_json_result(resp)
 }

+// compact_flag — resolve the compact bounding flag. Defaults to "1" (ON) so
+// neighborhoods stay bounded. Reads the RAW JSON token (not json_get_string) so
+// an integer 0, a boolean false, or a string "0"/"false" all opt out correctly —
+// json_get_string only sees string-typed values and would miss an integer 0,
+// silently forcing compact back on.
+fn compact_flag(args: String) -> String {
+    let craw: String = json_get_raw(args, "compact")
+    let off: Bool = str_eq(craw, "0") || str_eq(craw, "false")
+        || str_eq(craw, "\"0\"") || str_eq(craw, "\"false\"")
+    return if off { "0" } else { "1" }
+}
+
+// graph_bound_params — optional &snip=/&k= bounding knobs, forwarded only when the
+// caller supplied them (json_get_int returns 0 when absent, meaning "soul default").
+fn graph_bound_params(args: String) -> String {
+    let snip: Int = json_get_int(args, "snip")
+    let k: Int = json_get_int(args, "k")
+    let snip_p: String = if snip > 0 { "&snip=" + int_to_str(snip) } else { "" }
+    let k_p: String = if k > 0 { "&k=" + int_to_str(k) } else { "" }
+    return snip_p + k_p
+}
+
 fn fetch_by_id(args: String) -> String {
    let id: String = pick_id(args)
    if str_eq(id, "") {
@@ -306,7 +544,11 @@ fn fetch_by_id(args: String) -> String {
    // "single node fetch" actually pulls the full 1-hop neighborhood. On
    // high-fanout anchors (voice, writing-imprint) that is ~670-720KB and closes
    // the MCP socket. compact=1 bounds it identically to inspectGraph.
-    let resp: String = http_get(neuron_url() + "/graph?id=" + id + "&depth=0&compact=1")
+    // Honor an optional depth override plus the snip/k bounding knobs; default
+    // depth 0 (soul coerces to 1-hop) keeps the pre-existing single-node behavior.
+    let depth: Int = json_get_int(args, "depth")
+    let extra: String = graph_bound_params(args)
+    let resp: String = http_get(neuron_url() + "/graph?id=" + id + "&depth=" + int_to_str(depth) + "&compact=1" + extra)
    return mcp_json_result(resp)
 }

@@ -502,39 +744,51 @@ fn tool_inspect_memories(args: String) -> String {
 fn tool_inspect_graph(args: String) -> String {
    let entity_id: String = json_get_string(args, "entity_id")
    let name: String = json_get_string(args, "name")
-    let depth: Int = json_get_int(args, "max_depth")
-    if depth == 0 { let depth = 1 }
+    // Accept `depth` (documented/canonical) and fall back to legacy `max_depth`.
+    // Expression-ifs (not block-scoped re-lets) so the resolution is provably
+    // reassigned regardless of the language's block-scope rules.
+    let depth_raw: Int = json_get_int(args, "depth")
+    let depth_alt: Int = if depth_raw == 0 { json_get_int(args, "max_depth") } else { depth_raw }
+    let depth: Int = if depth_alt == 0 { 1 } else { depth_alt }

-    let resolved_id: String = entity_id
-
-    // Resolve named traversal roots — stable hardcoded anchors
-    if str_eq(resolved_id, "") {
+    // Resolve named traversal roots — stable hardcoded anchors.
+    let resolved_id: String = if !str_eq(entity_id, "") { entity_id } else {
        if str_eq(name, "self") || str_eq(name, "neuron") {
-            let resolved_id = "kn-efeb4a5b-5aff-4759-8a97-7233099be6ee"
-        }
+            "kn-efeb4a5b-5aff-4759-8a97-7233099be6ee"
+        } else {
            if str_eq(name, "values") || str_eq(name, "values_hub") {
-            let resolved_id = "kn-5b606390-a52d-4ca2-8e0e-eba141d13440"
+                "kn-5b606390-a52d-4ca2-8e0e-eba141d13440"
+            } else { "" }
        }
    }

    if str_eq(resolved_id, "") {
        return mcp_text_result("error: entity_id or name is required. Known names: self, neuron, values, values_hub")
    }
-    // compact=1: soul returns a bounded, relevance-ranked neighborhood (top-K
-    // with content, the rest as pointers) so high-fanout nodes (voice,
-    // writing-imprint) no longer overflow the MCP transport and close the socket.
-    let resp: String = http_get(neuron_url() + "/graph?id=" + resolved_id + "&depth=" + int_to_str(depth) + "&compact=1")
+    // compact defaults ON: the soul returns a bounded, relevance-ranked
+    // neighborhood (top-K with content, the rest as pointers) so high-fanout
+    // nodes (voice, writing-imprint) no longer overflow the MCP transport. Pass
+    // compact=0/false to opt into the full neighborhood. snip/k bound it further.
+    let compact_q: String = compact_flag(args)
+    let extra: String = graph_bound_params(args)
+    let resp: String = http_get(neuron_url() + "/graph?id=" + resolved_id + "&depth=" + int_to_str(depth) + "&compact=" + compact_q + extra)
    return mcp_json_result(resp)
 }

 fn tool_traverse_graph(args: String) -> String {
-    let id: String = json_get_string(args, "start_id")
-    let depth: Int = json_get_int(args, "depth")
-    if depth == 0 { let depth = 2 }
+    // Accept `entity_id` (canonical) with `start_id` as a legacy alias.
+    let eid: String = json_get_string(args, "entity_id")
+    let id: String = if !str_eq(eid, "") { eid } else { json_get_string(args, "start_id") }
+    let depth_raw: Int = json_get_int(args, "depth")
+    let depth: Int = if depth_raw == 0 { 2 } else { depth_raw }
    if str_eq(id, "") {
-        return mcp_text_result("error: start_id is required")
+        return mcp_text_result("error: entity_id (or start_id) is required")
    }
-    let resp: String = http_get(neuron_url() + "/graph?id=" + id + "&depth=" + int_to_str(depth))
+    // compact defaults ON so a depth-2 walk from a high-fanout node stays within
+    // the transport limit. Pass compact=0/false for the full neighborhood.
+    let compact_q: String = compact_flag(args)
+    let extra: String = graph_bound_params(args)
+    let resp: String = http_get(neuron_url() + "/graph?id=" + id + "&depth=" + int_to_str(depth) + "&compact=" + compact_q + extra)
    return mcp_json_result(resp)
 }