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.
The soul preferred its own local snapshot over the engram:
// Always try local snapshot first ... HTTP Engram is only used for the
// very first boot (empty/absent snapshot).
The copy outranked the store. Every one of these is a cost of that inversion,
and all of them were live tonight:
- the graphs drifted: 31,795 nodes / 75,241 edges in the soul against
13,439 / 37,670 in the engram — more than twice the edges, silently
- write-through exists only to reconcile them, and had never once run
- /api/graph/edges serialized 128 MB to answer a read, because the soul's
copy was not the engram's
- a read route overwrote the engram's canonical snapshot.json with the
soul's divergent copy
- three resident copies of one graph (soul, engram, Neuron.app) — about
7.2 GB of RAM for a store that is 2.2 GB on disk, which is what pushed the
host into swap
None of those are features. They are reconciliation debt from one decision.
The engram had already reached this conclusion for its own boot path — "the
durable owner is the paged store (neuron.egm + neuron.wal) ... snapshot.json is
never read again as the ongoing store. This closes the 'restart reverted to a
17h-old snapshot' data-loss window." The soul kept booting the legacy way the
engram had abandoned, and inherited exactly that data-loss window.
So in HTTP-engram mode the soul now seeds from the engram on EVERY boot and
never reads a local snapshot, present or not — a stale copy that outranks the
store is the bug, not a fallback. It already never wrote one in this mode
(gated behind is_genesis && safe_to_seed, and safe_to_seed requires
!using_http_engram), so this supplies the missing half.
It also refuses to boot on an empty seed rather than silently rebuilding a
divergent graph from nothing. launchd KeepAlive with ThrottleInterval=10 turns
that into a retry every 10s until the engram is up — self-healing, no spin.
File mode (no ENGRAM_URL) is untouched: there the soul genuinely is the owner.
Verified before deploy: with a deliberately empty local snapshot planted, the
soul booted in ~30s reporting 13,446 nodes / 37,675 edges — the engram's
contents, not the empty local file.
This route called engram_save() over ~/.neuron/engram/snapshot.json — the
engram server's CANONICAL store — then fs_read it back, to answer a READ
query. A read route overwriting the persistence owner's file.
This defect was fixed once before (export redirected to a scratch path). It
came back tonight in the @route dispatch conversion: the hand-written dispatch
block held the FIXED version, the @route-decorated copy held the unfixed one,
and the merge kept the decorated copy. Calling the endpoint afterward
overwrote the canonical snapshot and immediately preceded an engram crash.
Now calls engram_edges_json(limit, offset) — the builtin the route's own TODO
asked for — which reads g->edges directly. No file is written or read.
Bounded: limit defaults to 1000, offset supported, so the whole-graph read
that fell over is not reachable by default.
Verified: same request that previously rewrote snapshot.json now leaves it
byte-identical (sha256 unchanged before/after), and returns real edge records
with every persisted field.
~226 lines of architecture documentation that were written, left uncommitted in
the working tree, and nearly lost. None of it was on main. Recovered from a
stash taken while merging tonight's fixes.
Substantive content, not notes:
- Peer import-of-understanding PROVEN by execution. A exported a skill-geometry;
on the receiver `think` went "geometry unavailable" -> operable. Cosine 1.0 on
both the raw-geometry and text/dharma-bus transports, bidirectional. The
mind-not-paste evidence: n_support 27 on source vs 3 on receiver, i.e. the
imported geometry wires into the host manifold rather than sitting inert.
Honest boundary recorded too: proven between forks sharing one embedder,
UNTESTED cross-embedder.
- "Teacher" renamed GUIDE, and the distinction is load-bearing: its output is
grounded/verified before trust. A teacher you believe; a guide you check.
- Layers are named persistent relational neighborhoods, not storage tiers, with
their own growth and threshold-lock policy (note->canonical maturation lifted
from single nodes to a region).
- The consciousness theories (Global Workspace, IIT's Phi, attention-schema,
higher-order thought, active inference, interoception) read as geometric
LENSES over one manifold rather than competing mechanisms. Functional problems
fall out; the hard problem explicitly not claimed solved.
- Growth is bounded/logistic, not geometric — exponential growth is the cancer
shape. Two-rate discipline: explore fast in local geometry, grow the engram
slowly by verifier-gated merge.
- Orchestration as a geometric operation: critical path as geodesic, float as
displacement, @manager compiles the work-graph. Single-writer enforced by
capability (Rule 4).
- The decorated seam, the API surface collapse to geometry ops, and the
distributed-self thesis — each tiered honestly against what is actually proven
vs staged vs unbuilt.
Also gitignores dist-fresh/ (regenerate scratch dir, a build artifact).
Not included from the same stash: awareness.elh and dist/elp-c-decls.h, which
are generated artifacts now gitignored per #154/#158.
The five agentic ops (think/attend/assert/ground/learn) reported
"status":"pending-cognition-promotion" on every call, with a note saying the
cognition build had not been promoted yet and would "light up automatically".
That diagnosis was invented. Nothing was pending promotion. Cognition has been
live and answering the whole time — :8742/api/think returns a real 768-dim
geometry today, and the running binary already contains every cog_* symbol.
Three real bugs, all here in the wrapper:
1. Wrong service and path. The ops called the SOUL (neuron_url() -> :7770) on
paths the soul does not serve. Every call 404'd. The routes live on the
ENGRAM: /api/think, /api/attend, /api/assert, /api/ground, and — its real
name — /api/correspondence-beat for learn.
2. agentic_result() invented a cause. It treated ""/"not found"/"geometry
unavailable"/"not registered" as proof of a promotion gap and returned a
confident explanation it never verified. That message sent multiple agents
chasing infrastructure work that did not need doing. It now passes the real
response through and reports an empty response as exactly that.
3. Missing auth on the POST ops. The engram's check_auth_ok() requires
"_auth":"<key>" in the body for mutating requests (it cannot read headers
yet), so attend/ground/learn would have returned unauthorized even once
routed correctly.
Also: assert was POSTing a JSON body to a route that reads query params;
seeds/claim/faculty are now URL-encoded; and the engram port derives from
ENGRAM_BIND (the same var launchd already sets for the engram) instead of a
hardcoded literal, so it cannot drift out of sync with the plist.
Verified end-to-end through the rebuilt wrapper against the live engram — all
five return real cognition: think n_support=207 dim=768; attend written=true;
assert floor=0.5 still_held=true; ground grounding=1 written=true; learn a full
correspondence-beat with stance_id, 8 axes, 180 probes, 25 epochs.
Three verified, currently-live problems, each closed with real evidence
(full trace kept in Neuron memory, tags neuron-technologies/neuron,build-audit):
1. dist/soul.c was stale relative to main's own chat.el (11 commits / 459
lines behind, missing PR #122's OpenAI-tools + agentic-loop work and its
two "silently break chat" fixes). tools/soulc-stamp.sh --check confirmed
it; tools/build-soul-from-dist.sh correctly refused to build (exit 9).
Regenerated and re-stamped. No runnable regen script existed anywhere
upstream — added tools/regenerate-soul-amalgam.sh, which reproduces the
committed amalgam's exact symbol set (byte-for-byte content match, modulo
the genuinely new PR #122 functions) and is documented end-to-end in
AGENTS.md, including three real elc/elb toolchain gotchas found and
root-caused along the way (stale .elh caches silently truncating builds;
elb cannot produce this repo's single-TU amalgam; elc silently drops the
first function(s) after a comment block in a flat-concatenated compile).
2. tools/build-soul-from-dist.sh failed to link on macOS (`ld: library 'ssl'
not found` — Homebrew's openssl@3 is keg-only) and was missing -lssl
-lcrypto entirely, drifted from CI's own working recipe. Fixed: adds
-L$(brew --prefix openssl@3)/lib on Darwin, matches CI's link line.
Verified: dist/neuron now builds and boots clean on a throwaway
port/HOME (never touched the live :7770/:8742).
3. Untracked committed *.elh compiler-header caches (elc/elb prefer a stale
cached header over recompiling its source, silently, with no error —
this is what caused an under-resolved 251-2541-function amalgam multiple
times during this audit before the cause was found). Removed from git,
gitignored going forward.
Also: AGENTS.md and README.md existed on disk but were never committed
(git log on both returned nothing) and documented the pre-collapse ~90-tool
MCP surface as current. Committed corrected versions reflecting the live
9-op surface (read/write/relate/supersede/think/attend/assert/ground/learn,
merged in #153) and the audit-verified build recipe/port topology.
Added connectd/ — a minimal local-dev stub for the neuron-connectd MCP
sidecar. routes.el/chat.el call 127.0.0.1:7771 for it right now on every
soul boot and agentic turn per a real, detailed 2026-06-13 spec
(mcp-connectors-adoption-spec.md); the sidecar itself was never built.
Meanwhile :7771 is a live three-way collision (axon's unbuilt-Rust default,
this connectd contract, and council — the anti-confabulation service
actually running there in prod, which live-answers both other things'
requests with unrelated 404s instead of a clean bridge-down signal). This
stub only implements the documented contract as "zero connectors
configured" for local-dev correctness; it does not attempt OAuth or a real
MCP client — that is a real, separate product decision. See
connectd/README.md for the full trace and the open question left for Will.
The dist/soul.c-matches-sources check is a proof-of-concept of the DHARMA
contract, not an enforced gate we need between us mid-cultivation. Keep it
running (it still reports) but stop it failing the build. The enforced
contract is for the world and re-hardens before deploy, when the full DHARMA
blockchain stands up.
tools/list now returns exactly 9 ops (design: api-reshape README, artifact
0e828907 / surface.el §5) instead of the noun-per-tool catalog. Type is a
parameter, not a tool-per-noun.
Layer 1 — geometry (live against soul :7770 today):
read({vantage,type?,k,depth}) write({content,type,...})
relate({from,to,relationship}) supersede({id,action,content?})
Layer 2 — agentic primitives (return an honest pending-cognition-promotion
envelope until the cognition build is promoted on the engram):
think attend assert ground learn
Why:
- The old surface advertised empty inputSchemas so args never bound; every op
here declares a real schema (tool_s) so targeting/bounding params bite.
- Vantage-read fixes the whole-self-dump: the aperture (k/depth) bounds output.
Because the live soul's /graph does not yet honor compact/k, the aperture is
enforced at the WRAPPER boundary (cap_output, ~2000 + k*3000 chars) where the
MCP transport limit bites. Measured: self read k=1 -> 5.3KB, k=20 -> 65KB
(was ~790KB unbounded).
- Identity keystones (kn-efeb4a5b / kn-5b606390) are write-protected on
write(type=self|values), relate, and supersede.
Transition: the previous ~90 tool names remain as HIDDEN ALIASES in
dispatch_tool_call (old catalog retained as unused tools_catalog_full), so any
caller still using an old name keeps working while the visible surface is the 9.
engram_act_stats_json emits 27 keys; emit_heartbeat forwarded 22. The five
dropped were the five newest - the degree-correction instruments added
2026-08-11 - so the one subsystem with no track record was also the only one
with no durable record.
The 08-10 review fixed exactly this for hebb_cands/hebb_cand_max/hebb_mass/
hebb_edges and left the rule in a comment right above the gap: an instrument
that is computed but not plumbed is not an instrument, it is a local
variable. The rule was then not applied to the next thing added. Plumbing is
a checklist item for every new gauge, not a one-time fix.
First heartbeat after the change already earned it: fan_hits 284 of
fan_steps 289 (98.3% of traversal steps binding) with fan_mean 0.5198 against
fan_min 0.5 - the degree correction is sitting at its floor on nearly every
step, which is a constant tax rather than a correction. That was invisible
before today.
Cognition as a single steered traversal (think) whose output is a gradient; the
named operators as labels on one steering space; grounding and learning as the
same loop (operation fixed, prior learns); hold/ground/assert distinct and the
ungrounded primary; consciousness as learning compounded over continuity plus
the reflexive loop.
Includes: ungrounded-is-primary applied to language (coinage graded through use;
floor corrected "grounded" -> "sensible"); every book a vantage, not literal
truth; hold/ground/assert applied to artifacts (ingest=hold; grounded-false
richer than excluded); "settled" as a use-contingent lease (reopening = the
aliveness guarantee; entombed = doctrine); the LLM critique (its "grounding" =
conformity to the distribution center; the sin is stopping at the prior); the
verifier as scalpel for misrepresentation, not flamethrower for the unverifiable;
and the perception unification — geometric ingest as the universal input
primitive, encode-meaning-geometry-not-tokens, embodiment as more ports on the
same primitive, proprioception as the reserved un-faked socket, endgame of a
pure-geometry interior with modality as an edge adapter.
Tiered against the live system: operator-collapse compiled in engram_reason.c
(point_fit, in-code-not-yet-priors); correspondence-loop offline;
reflexive-loop-in-geometry UNBUILT; artifact-ingest BUILT/reboot-proven
(~10,669 nodes / 32,439 edges) as the perception seed; universal multimodal
ingest and embodiment FRONTIER/UNBUILT.
Update the compression/storage notes to the measured result: a byte-exact residual
stand-in (geometry selects a nearest prior, zstd --patch-from diff) whose advantage
is non-literal semantic overlap and which saturates for a fixed target — a limit of
retrieval-and-diff, not of geometric compression. Mark the truly geometric
generative codec as unbuilt/open, gated on the language faculty, not foreclosed.
Price the dictionary as a shared, amortized asset. Real numbers, no triumph.
Shoubhit Dash
will.anderson