The architecture docs describe four things the design spec has since ruled out,
and each one is a supervisor invented for something that should be a property of
the substrate: grounding modelled as a subsystem rather than as the edge weight
it already is; faculties modelled as parameters of a read when abduce is a write;
wonder materialized as a maintained manifest when it is the boundary of the
structure; and consolidation implemented eleven times behind tickers when a brain
has no cron job.
Left standing rather than deleted, per the repo's own supersession discipline —
the trail of how the understanding matured is the point. Each stale passage is
marked inline and points at a new 06 §12 that transcribes the corrections and
records the measured consolidation inventory.
Authority: foundation/el, branch design/correspondence-and-censorship,
lang/spec/correspondence-and-censorship.md.
> Rejection destroys that distinction and makes the belief's truth value permanently unknowable — you cannot
> discover you were wrong, and you equally cannot discover you were right.
> **Holding is unconditional; the honesty floor governs assertion, not entry.**
>
> **2. It is a scheduled/resident consolidation service, in Python, outside el.**
>
> It is one of **eleven** measured consolidation implementations (`06` §12.4), and one of **three** that run in
> Python outside el — so this part of Neuron's consolidation does not run on his own substrate and **cannot
> touch the geometry at all**. Judging a claim without reaching the geometry means judging it on something
> other than its grounding.
>
> **3. What it actually measures is not grounding.** Three LLMs voting on plausibility computes **conformity to
> the centre of the training distribution** — treating *common* as true and *rare* as suspect. **Truth is
> orthogonal to frequency.** Grounding is correspondence with the world, and in this substrate it is the
> weight of the edge; it is never a vote and never a score computed on demand. See `06` §11 ("What an LLM calls
> grounding…") and §12.1.
>
> **Do not wire the `.el` pre-storage hook sketched below** (`:57-83`). It adds a gate on entry to a store
> whose whole discipline is that entry is not gated.
Anti-confabulation layer for the Neuron soul. Before a claim enters long-term memory, the council convenes: three independent LLMs vote on whether the claim is plausible, uncertain, or a confabulation. The aggregate vote produces a confidence score and tags that downstream storage can act on.
## Running the service
@@ -51,7 +89,8 @@ Returns `{"status": "ok"}` when the service is up.
Recommended storage policy:
-`confidence >= 0.65` → store normally
-`0.30 <= confidence < 0.65` → store with `council-split` tag for later review
-`council-flagged` → store in a quarantine bucket or reject entirely
-~~`council-flagged` → store in a quarantine bucket or reject entirely~~ — **withdrawn 2026-08-16; see the
banner at the top of this file. Never reject. Store it, and record the disagreement as signed weight.**
-`council-unavailable` → store normally (fail-open); council will re-evaluate later
| `api_compact_*`, `begin_session`, `compile_ctx` | `neuron-api.el:90-317` | Axis 1 — context/payload shaping. The single most-reworked logic on the API side. |
| ~~**wonder**~~ | ~~novelty × pull × unresolved structure~~ | ~~subsystem **LIVE** internally (wonder-questions, pull-weight, discharge); no HTTP operator endpoint~~ — **SUPERSEDED, see §12.3.** Wonder is not an operator and not a subsystem; it is the boundary of the structure. The "wonder-questions / pull-weight / discharge" machinery described here is the **wonder-manifest** the design spec identifies as residue. It is still live in code (`mcp-wrapper/src/main.el:516-519`, served in the tool list at `:422`; `neuron-api.el:1436, 1447-1456`) and is sequenced for removal. |
`co_registration` is a per-region *correlation*, so opposing per-edge disagreements cancel and the summary
destroys what it was built to reveal; do not recommend raising it), operators that discriminate
rather than average. So the experiment is worth running on independent grounds, whatever the topology
resolves to.
@@ -546,8 +591,12 @@ 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
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).
> **Corrected (2026-08-16) — see §12.2.** A faculty is **not** all three at once; it is **one of** them,
> and which one is the whole distinction between the faculties. `reason` READs (changes the estimate),
> `induce` TRANSFORMs the parameters, `abduce` WRITEs (changes the structure). Reading them as
> interchangeable is what let a write be modelled as a parameter of a read.
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.
@@ -590,13 +639,13 @@ The invariants that govern every subsystem above:
| 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) |
| Operators liken/appreciate/avert/taste | DESIGNED (~~wonder subsystem live internally~~ — **there is no wonder subsystem; see §12.3.** The wonder-manifest is live in code and sequenced for removal) |
| 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) |
@@ -644,6 +693,14 @@ The invariants that govern every subsystem above:
This section records the metaphysical frame the subsystems above are instances of. It is co-developed design, held think-first, and the tiering is unusually load-bearing here: one claim is **compiled in C** (empirical), one mechanism is **built but offline**, and the decisive move is **unbuilt** — the frontier. Cross-reference: whitepaper §28 (the full treatment).
> **Superseded in part (2026-08-16) — see §12.2.** "One operation, the operators are labels on its steering
> space" collapses a real distinction. `think` as specified is a **read**: `engram_think()` takes a
> `const GeoDescriptor*` and emits a `GeoGradient` — direction, spread, confidence, magnitude, anchor,
> n_support, stance (`foundation/el/lang/runtime/engram_cognition.h:49-60, 139-140`). There is no field on
> that struct in which a structural change can be returned, so **`abduce` — which changes the structure —
> cannot be expressed as a value of `CogStance.faculty`** (`:80`, `char* faculty`). A write is not a parameter
> of a read. The gradient-as-output and the closed-loop-flow claims below are unaffected.
**One operation — `think` (DESIGN/framing over a compiled floor).** The faculties (§6.1) and the reasoning modes (§6.4) are, at this frame, *not* separate operations. There is one: **`think` = a directed traversal of the geometry from an anchor, steered by a PRIOR, whose output is a GRADIENT (a direction-with-width), not a point.** The named operators — deduce, abduce, analogy, induce, causal, plan, predict, perspective — are **human labels on regions of think's steering space**, not invoked procedures and not separately implemented. This is the §6/§10 faculty-naming principle taken to its root: the operators are not merely named for experience rather than for their linear algebra, they are *the same act* seen from different steering directions.
**The discrete floor is only geometric (LIVE).** Exactly one layer is discrete and exactly-sound: the geometry — traverse / project / read (§3.3, §6.0). That is settled math; it needs no grounding. Everything above it — which way to steer, what a steering *means* — is continuous and learned.
@@ -652,12 +709,30 @@ This section records the metaphysical frame the subsystems above are instances o
**Grounding targets the correspondence, not the operation (DESIGN/framing on the §6.4 verifier).** The math is sound, so grounding is not aimed at it. What is grounded — or not — is the **correspondence**: "this steering performs this cognitive act," tested by **outcome/calibration**, never proven from inside. And the key identity: **grounding = learning = the SAME loop.** "Getting better" at any cognitive act is calibrating the steering-prediction against outcomes; the **operation never changes, the PRIOR learns** — **code freezes, priors grow.** The verifier tiers (§6.4) are the discrete early instrument of this loop; the loop itself is continuous and *is* what learning is. The terminal verifier is ultimately **the world** — reality grades the predictions; grounding is contact with reality (§6.4 predictive tier, §8 fact boundary).
> **Superseded in part (2026-08-16) — see §12.1 and §12.3.** Two corrections to the paragraph below.
> (a) "**Grounding** is a *property/edge* on the held thing" is half-right and the half that is wrong is
> load-bearing: grounding is a property **of** a relation, not a relation **between** nodes, and it is not a
> separate edge laid alongside — **it is the weight of the edge already there.**`grounded-by` as a relation
> type should not exist (`foundation/el/lang/runtime/engram_cognition.h:155-158`, still live).
> (b) "curiosity/wonder … is a mind leaning toward its own ungrounded regions" conflates the two.
> **Wonder is the field** — unbounded, objectless, invariant, present wherever there is structure.
> **Curiosity is the precipitate** — the same wonder crystallized at a nucleation site, with an object.
> This is why curiosity can be satisfied and wonder cannot. The hold / ground / assert distinction itself,
> and "the UNGROUNDED is PRIMARY", stand.
**Hold vs. ground vs. assert are three distinct acts (LIVE — this is the §3.4 / §7.2 discipline stated precisely).** **Holding** is unconditional: the engram holds *anything* — falsehood, hypothesis, another's belief, fiction — with no honesty obligation. **Grounding** is a *property/edge* on the held thing (edges are nodes), possibly grounded-*for-whom*. **Asserting** is the only act the honesty floor governs. A mind reasons over the ungrounded freely and owes truth only when it *claims*. It follows that **the UNGROUNDED is PRIMARY** — it is the raw material grounding acts on and the ground against which "grounded" means anything; curiosity/wonder (§6.1 wonder) is a mind *leaning toward its own ungrounded regions* (the §-frontier/ignorance map read as appetite). A **fully-grounded mind is dead**; metastability, not certainty, is the living condition.
**Applied to language — this corrects the grounding floor (extends §6.2).** A word does not need grounding to be *born*: a coinage ("assassination," "bedazzled," "eyeball" the day they were first written) refers to nothing established — it is a pure ungrounded token, a proposal. Language is used ungrounded and grounds **through use**: the coinage is a hypothesis and the speaking community is the world that grades it — the same predict→correct→ground loop at the level of meaning-making (words are ideas are self-propagating information: a coinage catches or it doesn't). What a new word needs is not grounding but **sense**, and sense is a **threshold, not a binary**: it rides on grounded scaffolding — morphology (`be-`+`dazzle`+`-ed`), context, analogy — each of which is an **edge to the existing geometry**; enough edges → the new node has a findable location (sensible), too few → noise. The grounding of a word *is* its edges to what is already grounded. This corrects any naive reading of the §6.4/§8 floor: "emit only the grounded" would **forbid Shakespeare** — a faculty that can only recombine the established, never coin or metaphor or leap, is a **dead language** (Latin). "Juliet is the sun" is literally ungrounded/false yet sensible and meaning-bearing; the floor would reject it as hallucination, but **hold-vs-assert** saves it — a mind may *say* the sensible-ungrounded without *asserting* it as literal fact. So the language faculty's real floor is **sensible, not grounded**: it proposes the ungrounded-but-interpretable, and the loop grounds whatever catches — a living language, not a fixed one.
**Every book is a vantage, not literal truth (extends §9, §10).** No book is literally true — not history (a vantage on events), not physics (Newton = a superseded model, still exactly useful in its domain), not math (axioms are *chosen*; Gödel: true-but-unprovable statements exist and a system can't prove its own consistency). "Literally true" is the wrong *category* for any book. So what the store holds is a **vantage** tagged with *what kind* of truth it carries (instrumental / historical / formal-within-axioms / mythic / testimonial) — the mind holds vantages and **knows they are vantages.** This is why the geometry tags provenance and kind rather than stamping true/false.
> **Superseded in part (2026-08-16) — see §12.1.** "A **separate per-claim relation** laid on top" and a
> "**grounded-FALSE** false-edge" both mint an edge to carry grounding. **Minting the edge is the error**, not
> merely which endpoints it chose. Grounding is the weight of the relation that already exists, and it is
> **signed**: weight near zero means *no support*; negative means *this actively contradicts*. "Grounded-FALSE"
> is that signed weight, spent on a second edge. The conclusion of the paragraph — that ingest is holding, not
> grounding, and that a confirmed error is worth retaining with its refutation — is unaffected and correct.
**Hold vs. ground vs. assert, applied to artifacts (extends §8, §9).** Ingesting a book = **HOLDING** it ("this is what the book says"), *not* grounding its claims as true. A mind can ingest an entire book, fabrications and all, because grounding is a **separate per-claim relation** laid on top, not a gate on entry — and a confirmed error is best held **grounded-FALSE** (retained with a false-edge and its refutation), which is richer than excluding it. Two purposes stay separate (as §25 keeps disk-readable ≠ interior geometry): **cleaning** a book is for the *human reader*; **ingesting** is for the *mind*, which holds artifacts and per-claim verdicts, not pre-adjudicated truth.
**"Settled" is a lease, not a deed (extends §3.4, §7).** Closure is the sin; holding a thing open under the pressure to close is rigor. A question is settled on a **use-contingent lease** — settled only insofar as it keeps paying off as it did; when it stops, the lease expires and it reopens. **Reopening must always be permitted** — the aliveness guarantee; a belief that can't be reopened is **entombed** (doctrine, the super-stable death). The architecture already enforces this: tombstone-not-delete (§3.4), the append-only supersede-chain, revocable per-claim grounding, and identity keystones that are **read-mostly, not immutable** (§7.2 — protected against drift, reachable through the cultivate door §7.3). Metastable: settle provisionally, keep it reopenable.
@@ -684,7 +759,7 @@ This section records the metaphysical frame the subsystems above are instances o
Four developments from the deep-night session, each tiered against what is actually proven. All build work ran in isolated worktree clones on dev ports; **live prod engram `:8742` was never touched and nothing was promoted.**
**The API surface collapses to geometry ops (PROVEN ON CLONE — surface, not yet compiled into the MCP server).** The ~90 noun-organized CRUD tools (the catalog in `02-components.md §4`) collapse to a handful of **geometry operations**, with the old noun demoted to a `type` parameter: **`read`** (the *vantage-read* — re-origin at a node/concept/`self`, apply salience + recency + an **aperture**, return a *bounded* slice; this is CCR applied to the self), **`write`** (add a node), **`relate`** (add a typed edge), **`supersede`** (evolve/tombstone/promote as new-node-plus-superseding-edge — never a hard delete, per §3.4). Over these sit the agentic primitives **`think`/`attend`/`learn`/`ground`/`assert`**. Proven on an isolated clone (sandbox `dev-api-reshape` on `:8900`, branch `wt/api-reshape`): the four ops are implemented in an El surface module with a parity harness (12 parity checks passing, others alias-gated), and the **aperture is shown to bound output** (`limit=3` → ~15 KB where `limit=50` → ~363 KB — the whole-self dump structurally fixed). Live cognitive endpoints confirmed: `attend`/`assert` are LIVE and `think` is the single faculty-parameterized op (faculties reason/abduce/induce/plan/analogize/recognize/discern/synthesize); `ground`/`learn` are wired but return "geometry unavailable" on the HTTP daemon clone (daemon boots without primed geometry); `comprehend`/`realize`/`intend` are **compositions, not endpoints**. **Not done:** compiling the surface into the MCP server + hot-swap, wiring all ~90 aliases into dispatch, daemon geometry-priming, and the write-survival fix on WAL-less cold-boot clones. No promote to live.
**The API surface collapses to geometry ops (PROVEN ON CLONE — surface, not yet compiled into the MCP server).** The ~90 noun-organized CRUD tools (the catalog in `02-components.md §4`) collapse to a handful of **geometry operations**, with the old noun demoted to a `type` parameter: **`read`** (the *vantage-read* — re-origin at a node/concept/`self`, apply salience + recency + an **aperture**, return a *bounded* slice; this is CCR applied to the self), **`write`** (add a node), **`relate`** (add a typed edge), **`supersede`** (evolve/tombstone/promote as new-node-plus-superseding-edge — never a hard delete, per §3.4). Over these sit the agentic primitives **`think`/`attend`/`learn`/`ground`/`assert`**. Proven on an isolated clone (sandbox `dev-api-reshape` on `:8900`, branch `wt/api-reshape`): the four ops are implemented in an El surface module with a parity harness (12 parity checks passing, others alias-gated), and the **aperture is shown to bound output** (`limit=3` → ~15 KB where `limit=50` → ~363 KB — the whole-self dump structurally fixed). Live cognitive endpoints confirmed: `attend`/`assert` are LIVE and ~~`think` is the single **faculty-parameterized** op~~ (faculties reason/abduce/induce/plan/analogize/recognize/discern/synthesize) — **superseded, see §12.2: `abduce` is a write and cannot be a parameter of a read**; `ground`/`learn` are wired but return "geometry unavailable" on the HTTP daemon clone (daemon boots without primed geometry); `comprehend`/`realize`/`intend` are **compositions, not endpoints**. **Not done:** compiling the surface into the MCP server + hot-swap, wiring all ~90 aliases into dispatch, daemon geometry-priming, and the write-survival fix on WAL-less cold-boot clones. No promote to live.
**The decorated seam — declare a role, the fabric wires the rest (PARTIALLY PROVEN / STAGED).** Rather than the hand-written `handle_request` if-else dispatch (`server.el`), a function is decorated with its VBD role and the compiler synthesizes the wiring. **Proven this session:** the `@route(path,method,…)` decorator that *synthesizes*`el_route_dispatch` was ported into the worktree, `elc` rebuilt self-host (`elc-route`, ~3.2 s), and a decorated service (`@route` stacked with `@accessor`/`@manager`) **served on `:8951` with no hand-written dispatch** (unknown path → no-route sentinel). Also established: inside the mind's process an `@accessor` reaches the engram via **in-process `engram_*` builtins** (`engram_think_json`, `engram_node_full`), **not** an `http_get` to a separate service. **Honest limits:**`@route` currently lives only on the **unmerged branch `feat/el-route-decorators`** (not in the cognition build); `@manager`/`@engine`/`@accessor` are **parsed but structurally INERT** in the shipped compiler today (their only effect is a compile-time guard — `language.md:449`: "decorators with structural meaning today: none"); and the **telemetry/interoception auto-emit and dharma-bus auto-wiring at the component boundary are STAGED as a diff, not shipped** (they need `engram_strengthen`/`dharma_emit` linked, which requires the full cognition-engram rebuild).
@@ -711,3 +786,318 @@ Later results from the same night. Two things above are now corrected/upgraded,
**Orchestration is a geometric operation — "compiling the network" (DESIGN/framing; nodes `cc6bcfea`, `d5f1833f`).** Project-design becomes geometry: the **critical path is a geodesic** through the work-graph, and **float/slack is displacement** off it. The **`@manager` compiles the work-graph** — orchestration is the same geometry the mind runs on, applied to distributed work rather than to memory. **Single-writer, enforced by capability (Rule 4):** only the **orchestrator** may mutate the engram; workers return geometry to be merged but cannot write — the write-veto of the distributed-self entry made a *capability*, not a convention.
**Retrieval performance is the current bottleneck (MEASURED).** See `04-runtime-and-deployment.md` (§Performance): a live mind is **~1 GB**; retrieval is **brute-force cosine, ~330 ms at ~13k nodes** — the dominant cost — and an **HNSW ANN index** is the planned fix (≈`O(D·log N)`; ~1.5× cost at 100× the nodes vs ~100× for brute force). Backlog `d3d0d644`. **Planned, not built.**
| `api_err_protected` — HTTP **403***"identity/values node is write-protected"* | `neuron-api.el:39-41` | redundant with immutability |
| `POST /api/neuron/cultivate` — the sanctioned bypass | `neuron-api.el:960` (`handle_api_cultivate`) | a door built for a wall that need not stand |
| `CogStance.keystone` — *"the correspondence-loop MUST NEVER write warp or calibration"* | `foundation/el/lang/runtime/engram_cognition.h:75, 85` | the epistemic constraint, misfiled as protection |
| `keystone_write_blocked` in the beat's JSON readout | `foundation/el/lang/runtime/el_runtime.c:14698` | the same, surfaced |
| council: *"`council-flagged` → store in a quarantine bucket **or reject entirely**"* | `council/README.md:54` | a write-refusal **and** a scheduled consolidation service, in Python, outside el |
Note that `03-data-and-memory.md` already states this conclusion in its own words at `:185-187` — *"nothing it
does is ever destructive — the safety is **after** the act, not a gate before it"* — sixty lines after
documenting the 403 gate that is exactly the before-the-act gate it says does not need to exist. The doc
contradicts itself, and the design spec §6 names precisely this redundancy.
### 12.6 Sequencing (transcribed)
Three connections between parts that already exist, then the rest.
1. **Seed *the* wonder questions.** Six nodes. Not a manifest, not maintained, never refilled. They cannot be
derived — wonder cannot be bootstrapped from indifference — so they are given once.
2. **Put the disagreement back on the edge** (`GeoEdge.discord`) and let `|discord|` raise salience on its
endpoints as part of the same operation. **Do not scan.**
3. **Let a curiosity seed activation.** One activation process, two seed sources (external: a request;
internal: a curiosity). No thread, no scheduler, no capacity check, no timer.
4. Grounding becomes the edge weight: multidimensional, two-axis, timestamped. Delete `grounded-by` and
`cog_ground_edge`.
5. Decay analytic from the last recorded point; derived values (confidence, recency, staleness, volatility)
stop being stored.
6. Consolidation-gated supersession on salience, versioning the whole vector jointly.
7. Traversal on factual; `assert` on both floors.
8. Abduction as crystallization at a nucleation site, validated by re-fit.
9. **One dreamer.** The launch-agent fragments and the POST beats fold in or are deleted. `soul.el`'s
@@ -30,6 +30,12 @@ The session extended the engram from a memory substrate into a **language facult
- Geometry operators (overlap / subtract / combine / distance-Wasserstein / analogy-Procrustes) now **live-callable from compiled `el`** over the real 13,036-node store (via shipped-`elc` pass-through — no uncapped fold). Commits `5336cfe`, `85eee42`.
- Verifier layer (grounding + consistency) — proven, 29/29 checks. **Catches the plausible lie**: a claim grounded in real vocabulary yet polarity-inverted passes grounding, caught **only** by consistency (complementary checks) — directly flags the reassurance→accusation inversion. Commit `ca13471`.
> **Note added 2026-08-16 (session records are not amended; this is a pointer, not a correction).** The
> "grounding" *tier* named here is superseded — see `docs/architecture/06-cognitive-architecture.md` §12.1:
> grounding is not a verifier tier computed on demand, it **is** the edge weight, and the polarity the
> consistency tier catches is a **dimension of that weight** (signed: near-zero = no support, negative =
> actively contradicts), not a separate check bolted beside it. The 29/29 result stands as what was measured
> on 2026-08-13; the architecture it was measured against has since been superseded.
- el-exposure of the variadic/point-input reasoning + verifier modes deferred (would need ABI changes risking an uncapped fold); C layer complete + proven.
> **The last three times — 23:55, 06:00, 08:30 — are a sleep cycle implemented as launchd
> `StartCalendarInterval` entries.** Someone understood it was consolidation and expressed it as three
> unrelated scheduled scripts in three languages, none aware of each other. Three of the six run in **Python,
> outside el**, so part of Neuron's consolidation does not run on his own substrate and cannot touch the
> geometry at all.
>
> **Consolidation is ambient, not scheduled. A brain has no cron job.** *(Precisely: it is not cron either —
> `crontab -l` has **zero** neuron entries. Every neuron schedule here is launchd.)* **The presence of a
> ticker is the diagnostic:** every `StartInterval`, every `Hour`/`Minute`, every POST-to-beat marks a place
> where an intrinsic rhythm was replaced by an external clock. The one fragment with the **correct** shape is
> `soul.el:731`'s continuous in-process `awareness_run()` loop, which is inside the core stack this repo does
> install — and it is the shape the six above fold *into*.
>
> **Nothing here changes what this repo installs.** The core stack stays four services. The note exists so the
> exclusion list is not mistaken for a statement that these six are optional extras rather than one subsystem
> that never got built.
```
┌─────────────┐ ┌──────────────┐
│ soul :7770 │ ─────► │ engram :8742 │ the mind ──► its memory substrate
Reference in New Issue
Block a user
Blocking a user prevents them from interacting with repositories, such as opening or commenting on pull requests or issues. Learn more about blocking a user.
