engram: intake realizes a signal into a manifold, it does not assume a node #158

Merged

will.anderson merged 1 commits from wire/write-realizes-signal into dev 2026-08-17 00:58:07 +00:00

Conversation 0 Commits 1 Files Changed 1

+195 -6

will.anderson commented 2026-08-16 21:35:48 +00:00

Owner

Copy Link

Copy Source

The measured defect

transduce(signal, modality) was corrected in #155 to return a Manifold — components plus relations — instead of a single Geometry. That PR touched ingest/src/ingest.el, lang/runtime/el_runtime.c, lang/runtime/el_runtime.h, lang/examples/transduce.el and tests. It never touched engram/src/server.el.

The primitive was corrected and nothing downstream called it:

$ grep -n 'transduce\|realize\|Manifold\|decompos' engram/src/server.el
1475:// The ONLY anti-pattern is decomposing a region-scale change into a LOOP of

One line. A comment. The engram's entire HTTP surface never called transduce, never called realize, never mentioned Manifold.

The flattening was one line, in route_write:

let manifold: String = "[" + body + "]"   // the body IS a valid manifold node object

A request body is not a manifold. The comment stated the wrong assumption out loud. There is no write node — what arrives at an intake route is a SIGNAL, and a node is an OUTPUT of realization, never an INPUT to it. How many nodes a signal becomes is for the realizer to say, not for the route to assume.

What was wired to what

route_write → intake_signal → transduce(signal, modality) → components and relations land in the store.

Nothing here decomposes anything, and nothing here may ever. transduce dispatches through the dlsym realizer registry (el_runtime.c:6771-6851), so adding a modality is registering a realizer — never an edit to server.el, never a patch to the runtime. intake_signal only carries what the primitive returns:

• each component becomes a node whose content and label are its key — components are addressed by key, never by index, because the key is what survives persistence;
• each component carries its own geometry at its own width, attached with node_attach_geometry rather than re-embedding its name as text;
• each relation becomes an edge at the weight the realizer stated — relation weight is the grounding (correspondence-and-censorship §1); nothing here computes or second-guesses it;
• manifold_member still wires the inserted set into one connected sub-graph, exactly as insert_manifold_json already did (server.el:1577-1583). Reused, not reinvented.

Built general, not special-cased to route_write: nt / tier / tags / region / reason / rebind are parameters, so the other five intake doors can move onto this one function as they are transitioned.

Before / after — raw JSON, same signal

Own port :19501, cp -Rc clone of ~/.neuron/engram. Production untouched.

POST /api/write {"_auth":"k","type":"memory",
                 "content":"A cathedral is stone holding a shape that stone alone would not hold."}

BEFORE (dev @ 95a0510):

{"ok":true,"region_superseded":0,"tombstone_id":"","inserted":1,"new_ids":["56ab797e-b01c-40bc-98d9-8c6320842581"],"edges_rebound":0,"nodes_added":1,"edges_added":0,"node_count":34949,"edge_count":43467,"keystones_protected":true}

Read back out, not taken on trust:

GET /api/neighbors/56ab797e-b01c-40bc-98d9-8c6320842581  →  []

AFTER, with no organ registered (this branch, unmodified):

{"ok":true,"region_superseded":0,"tombstone_id":"","inserted":1,"new_ids":["ae1e57ee-177e-49ce-baa0-d75a80bcbf74"],"edges_rebound":0,"realized":false,"modality":"text","organ":false,"components":0,"relations":0,"nodes_added":1,"edges_added":0,"node_count":34949,"edge_count":43467,"keystones_protected":true}

Production behaviour is unchanged, and that is the honest result. No realizer is authored in this diff and none is registered, so transduce returns 0 and the signal is stored flat exactly as before. What changed is that the response says so: "realized":false,"organ":false. Silent flattening was the actual defect — a caller could not distinguish "nothing decomposed me" from "I decomposed into one component". el_runtime.c draws the same line between an absent organ and a broken one, for the same reason: those two must not look alike.

The mechanism is what landed. Writes do not decompose yet.

Proof the seam actually lands components and relations

Since no organ ships here, the insertion path was exercised with a scratch, uncommitted harness: a throwaway copy of server.el with tone_realizer copied verbatim from lang/examples/transduce.el and registered at startup. The committed diff contains no realizer; this only proves the seam carries what a realizer returns.

POST /api/write {"_auth":"k","modality":"tone","content":"CEG"}

{"ok":true,"inserted":5,"edges_rebound":0,"realized":true,"modality":"tone","organ":true,"components":5,"relations":6,"nodes_added":5,"edges_added":10,"node_count":34953,"edge_count":43477,"keystones_protected":true}

Components read back out of the store (GET /api/node/<id>):

label	tags	emb_dim	embedded
note:0	["component","role:pitch","modality:tone"]	2	true
note:1	["component","role:pitch","modality:tone"]	2	true
note:2	["component","role:pitch","modality:tone"]	2	true
interval:0-1	["component","role:interval","modality:tone"]	1	true
interval:1-2	["component","role:interval","modality:tone"]	1	true

Note the widths: notes are 2-wide, intervals are 1-wide. A single fingerprint vector per signal cannot represent parts of unequal width at all — that difference is the point of a manifold over a point.

Relations read back out of the persisted snapshot (all 10 edges, from snapshot.json after persist_canonical):

note:0         --manifold_member--> note:1          weight=0.6
note:1         --manifold_member--> note:2          weight=0.6
note:2         --manifold_member--> interval:0-1    weight=0.6
interval:0-1   --manifold_member--> interval:1-2    weight=0.6
interval:0-1   --spans          --> note:0          weight=0.9
interval:0-1   --spans          --> note:1          weight=0.9
interval:1-2   --spans          --> note:1          weight=0.9
interval:1-2   --spans          --> note:2          weight=0.9
note:0         --sounds_before  --> note:1          weight=0.8
note:1         --sounds_before  --> note:2          weight=0.8

6 realizer relations + 4 manifold_member = 10, matching edges_added. The weights are exactly what the realizer stated — the grounding rode through untouched.

(Read-surface note: GET /api/neighbors/<id> returns one record per neighbour node, so it collapsed the two sounds_before edges behind the manifold_member edge on the same pair and showed 8 of 10. The edges are all present in the durable snapshot. That is a limitation of the neighbors read route, not of the write — worth a separate fix.)

Same cathedral signal through the same seam:

{"ok":true,"inserted":137,"realized":true,"modality":"tone","organ":true,"components":137,"relations":204,"nodes_added":137,"edges_added":340,"node_count":35090,"edge_count":43817}

1 node / 0 edges → 137 components / 204 relations. tone is obviously the wrong organ for an English sentence — its components are per-character and mean nothing. It proves the seam carries N components and M relations into the store; it does not claim the sentence was understood.

What still flattens

• /api/write itself, in production. No organ is registered for any modality, so every real write still lands flat. el_runtime.c:6828 makes that deliberate: "There is deliberately NO built-in realizer, not even for text." Repo-wide, realizer_register / -> Manifold / manifold_add appear in exactly 5 files: the runtime pair (the primitive), lang/examples/transduce.el and lang/tests/native/test_transduce.el (demo organs), and ingest/src/ingest.el (a comment only). Nothing registers an organ anywhere.
• The other five intake doors, unchanged in this PR: /api/supersede (the identical "[" + body + "]" line), /api/nodes, /api/neuron/knowledge/capture, /api/neuron/state-events, /api/nodes/reseed.
• /api/reframe accepts a caller-authored manifold — the client does the decomposing, which is the client doing the engram's job. Left alone deliberately: it is currently the only route that carries components and the only working reference.
• /api/nodes is two intakes through one door: content (raw signal) and emb (already-realized geometry from somebody else's realizer) arrive together.
• Queries are intake too. "it can ingest ANYTHING - a file, a url, a query, a string." A query must become geometry to be matched, so /api/search, /api/search-lexical and /api/activate belong to the same door on the read side. Not touched here — non-mutating, higher blast radius. Related: /api/search is currently a lexical token-substring scan rather than embedding-nearest, and is broken for multi-token queries — the same disease, a hand-coded path where the primitive belonged.
• /api/neuron/state-events left deliberately: telemetry, auth-exempt, high-volume, and already has an off-graph log mode. Decomposing every internal state event is a volume problem, not a correctness win.

The redundancy underneath all of this

"you coded a bunch of shit in engram that belonged in el, and then, when i fixed that, you didn't actually transition engram to use the el primitives."

el_runtime.h declares 93 native engram_* builtins (counted as el_val_t engram_* declarations, not raw occurrences of the string). Roughly 50 of them already have a route wrapping them 1:1 — argument shuffling and JSON quoting around a function already linked into the same binary. These are deletion candidates, not refactor candidates:

• Six intake doors, one builtin. write, supersede, reframe, nodes, knowledge/capture, state-events all bottom out in engram_node_full, differing only in the node_type / tier / tags they hardcode.
• Eight routes, one builtin. /api/think, /reason, /induce, /abduce, /relate, /analogize, /plan all land on engram_think_json via route_think + route_faculty. That is literally "there are not 15 transduce endpoints because transduce is one thing", with faculties in place of transduce.
• Two routes, one call. route_get_node and route_get_node_singular both call engram_get_node_json.
• Straight 1:1 wrappers: route_stats→engram_stats_json, route_neighbors→engram_neighbors_json, route_strengthen→engram_strengthen, route_reify→engram_geo_reify_run_json, route_gauge_distance→engram_geo_distance_json, route_recognize→engram_geo_overlap_json, route_discern→engram_geo_subtract_json, route_synthesize→engram_geo_combine_json, route_nearest→engram_nearest_json, route_ground*→engram_ground*_json, route_attend→engram_attend_json, route_similarity→engram_cosine_sim, and ~20 more.

One thing that is not redundancy

ingest/src/ingest.el reaches the engram over HTTP (eg_base() → http://127.0.0.1:8902, a port nothing is listening on) to call builtins that are linked into its own binary. That looks like the same redundancy from the other side. It is not, and converting those calls to native engram_* calls would silently destroy data.

engram_node_full and friends are implemented in el_runtime.c (9154, 13856, 16223, 16586) under "Batch 3: Engram in-process graph store — Single global EngramStore allocated lazily on first call": a process-global in-memory store. ingest is a separate process — its own header states it "links only el_runtime.c ... it never links el_seed.c or the engram engine." A native call from ingest would mint a node in ingest's own ephemeral store, return a valid-looking id, and lose it on exit — every ingest reporting success and writing nothing. That is the same defect class as the "200 with a fresh id while the vector was discarded" bug already documented at server.el:358-366. And writing the server's data dir from a second process is corruption, not a shortcut.

The HTTP hop between ingest and engram is IPC, not redundancy. The redundancy is entirely inside server.el, in the same address space. The correct direction is that ingest should not be a separate process at all: the file/url/query/string intake belongs inside the engram, and when it lands there the HTTP client disappears because the client disappears, not because its calls were rewritten. Deletion in the right direction, and safe.

Build and test discipline

Local build is the bar; CI is not.

cd lang && ./dist/platform/elc ../engram/src/server.el > /tmp/x.c
cc -std=c11 -O1 -I runtime ... -o /tmp/x /tmp/x.c runtime/el_runtime.c ... -lcurl -lssl -lcrypto -lpthread -lm

Compiles clean (elc rc=0; the only cc warning is the pre-existing '/*' within block comment in el_runtime.c:14439). Every run used its own port :19501 and a fresh cp -Rc clone. :8742, :18760, :7770, :7779, :17779 were never bound and production was never touched.

One measurement worth flagging as a divergence: on this snapshot embedded_count was 0 against embed_eligible_count 25,629 before any write — so on this data set the engram had not encoded its eligible nodes at all. It rose to 142 purely from the components this change inserted with attached geometry. That differs from the 1:1 embedded_count == embed_eligible_count reported on prod :8742, and the gap between the two data sets is worth a separate look.

## The measured defect `transduce(signal, modality)` was corrected in #155 to return a **Manifold** — components plus relations — instead of a single Geometry. That PR touched `ingest/src/ingest.el`, `lang/runtime/el_runtime.c`, `lang/runtime/el_runtime.h`, `lang/examples/transduce.el` and tests. It never touched `engram/src/server.el`. The primitive was corrected and nothing downstream called it: ``` $ grep -n 'transduce\|realize\|Manifold\|decompos' engram/src/server.el 1475:// The ONLY anti-pattern is decomposing a region-scale change into a LOOP of ``` One line. A comment. The engram's entire HTTP surface never called transduce, never called realize, never mentioned Manifold. The flattening was one line, in `route_write`: ```el let manifold: String = "[" + body + "]" // the body IS a valid manifold node object ``` A request body is not a manifold. The comment stated the wrong assumption out loud. **There is no write node** — what arrives at an intake route is a SIGNAL, and a node is an OUTPUT of realization, never an INPUT to it. How many nodes a signal becomes is for the realizer to say, not for the route to assume. ## What was wired to what `route_write` → `intake_signal` → `transduce(signal, modality)` → components and relations land in the store. **Nothing here decomposes anything, and nothing here may ever.** `transduce` dispatches through the dlsym realizer registry (`el_runtime.c:6771-6851`), so **adding a modality is registering a realizer** — never an edit to `server.el`, never a patch to the runtime. `intake_signal` only carries what the primitive returns: - each component becomes a node whose content and label are its **key** — components are addressed by key, never by index, because the key is what survives persistence; - each component carries its **own geometry at its own width**, attached with `node_attach_geometry` rather than re-embedding its name as text; - each relation becomes an edge at **the weight the realizer stated** — relation weight *is* the grounding (correspondence-and-censorship §1); nothing here computes or second-guesses it; - `manifold_member` still wires the inserted set into one connected sub-graph, **exactly as `insert_manifold_json` already did** (server.el:1577-1583). Reused, not reinvented. Built **general, not special-cased to `route_write`**: `nt` / `tier` / `tags` / `region` / `reason` / `rebind` are parameters, so the other five intake doors can move onto this one function as they are transitioned. ## Before / after — raw JSON, same signal Own port `:19501`, `cp -Rc` clone of `~/.neuron/engram`. Production untouched. ``` POST /api/write {"_auth":"k","type":"memory", "content":"A cathedral is stone holding a shape that stone alone would not hold."} ``` **BEFORE** (dev @ 95a0510): ```json {"ok":true,"region_superseded":0,"tombstone_id":"","inserted":1,"new_ids":["56ab797e-b01c-40bc-98d9-8c6320842581"],"edges_rebound":0,"nodes_added":1,"edges_added":0,"node_count":34949,"edge_count":43467,"keystones_protected":true} ``` Read back out, not taken on trust: ``` GET /api/neighbors/56ab797e-b01c-40bc-98d9-8c6320842581 → [] ``` **AFTER, with no organ registered** (this branch, unmodified): ```json {"ok":true,"region_superseded":0,"tombstone_id":"","inserted":1,"new_ids":["ae1e57ee-177e-49ce-baa0-d75a80bcbf74"],"edges_rebound":0,"realized":false,"modality":"text","organ":false,"components":0,"relations":0,"nodes_added":1,"edges_added":0,"node_count":34949,"edge_count":43467,"keystones_protected":true} ``` **Production behaviour is unchanged, and that is the honest result.** No realizer is authored in this diff and none is registered, so `transduce` returns 0 and the signal is stored flat exactly as before. What changed is that the response **says so**: `"realized":false,"organ":false`. Silent flattening was the actual defect — a caller could not distinguish *"nothing decomposed me"* from *"I decomposed into one component"*. `el_runtime.c` draws the same line between an absent organ and a broken one, for the same reason: those two must not look alike. **The mechanism is what landed. Writes do not decompose yet.** ## Proof the seam actually lands components and relations Since no organ ships here, the insertion path was exercised with a **scratch, uncommitted harness**: a throwaway copy of `server.el` with `tone_realizer` copied **verbatim** from `lang/examples/transduce.el` and registered at startup. The committed diff contains no realizer; this only proves the seam carries what a realizer returns. `POST /api/write {"_auth":"k","modality":"tone","content":"CEG"}` ```json {"ok":true,"inserted":5,"edges_rebound":0,"realized":true,"modality":"tone","organ":true,"components":5,"relations":6,"nodes_added":5,"edges_added":10,"node_count":34953,"edge_count":43477,"keystones_protected":true} ``` **Components read back out of the store** (`GET /api/node/<id>`): | label | tags | emb_dim | embedded | |---|---|---|---| | `note:0` | `["component","role:pitch","modality:tone"]` | 2 | true | | `note:1` | `["component","role:pitch","modality:tone"]` | 2 | true | | `note:2` | `["component","role:pitch","modality:tone"]` | 2 | true | | `interval:0-1` | `["component","role:interval","modality:tone"]` | 1 | true | | `interval:1-2` | `["component","role:interval","modality:tone"]` | 1 | true | Note the widths: notes are **2-wide**, intervals are **1-wide**. A single fingerprint vector per signal cannot represent parts of unequal width at all — that difference is the point of a manifold over a point. **Relations read back out of the persisted snapshot** (all 10 edges, from `snapshot.json` after `persist_canonical`): ``` note:0 --manifold_member--> note:1 weight=0.6 note:1 --manifold_member--> note:2 weight=0.6 note:2 --manifold_member--> interval:0-1 weight=0.6 interval:0-1 --manifold_member--> interval:1-2 weight=0.6 interval:0-1 --spans --> note:0 weight=0.9 interval:0-1 --spans --> note:1 weight=0.9 interval:1-2 --spans --> note:1 weight=0.9 interval:1-2 --spans --> note:2 weight=0.9 note:0 --sounds_before --> note:1 weight=0.8 note:1 --sounds_before --> note:2 weight=0.8 ``` 6 realizer relations + 4 `manifold_member` = 10, matching `edges_added`. The weights are exactly what the realizer stated — the grounding rode through untouched. *(Read-surface note: `GET /api/neighbors/<id>` returns one record per neighbour **node**, so it collapsed the two `sounds_before` edges behind the `manifold_member` edge on the same pair and showed 8 of 10. The edges are all present in the durable snapshot. That is a limitation of the neighbors read route, not of the write — worth a separate fix.)* Same **cathedral** signal through the same seam: ```json {"ok":true,"inserted":137,"realized":true,"modality":"tone","organ":true,"components":137,"relations":204,"nodes_added":137,"edges_added":340,"node_count":35090,"edge_count":43817} ``` **1 node / 0 edges → 137 components / 204 relations.** `tone` is obviously the wrong organ for an English sentence — its components are per-character and mean nothing. It proves the seam carries N components and M relations into the store; it does not claim the sentence was understood. ## What still flattens - **`/api/write` itself, in production.** No organ is registered for any modality, so every real write still lands flat. `el_runtime.c:6828` makes that deliberate: *"There is deliberately NO built-in realizer, not even for text."* Repo-wide, `realizer_register` / `-> Manifold` / `manifold_add` appear in exactly 5 files: the runtime pair (the primitive), `lang/examples/transduce.el` and `lang/tests/native/test_transduce.el` (demo organs), and `ingest/src/ingest.el` (a comment only). Nothing registers an organ anywhere. - **The other five intake doors**, unchanged in this PR: `/api/supersede` (the identical `"[" + body + "]"` line), `/api/nodes`, `/api/neuron/knowledge/capture`, `/api/neuron/state-events`, `/api/nodes/reseed`. - **`/api/reframe`** accepts a caller-authored manifold — the *client* does the decomposing, which is the client doing the engram's job. Left alone deliberately: it is currently the only route that carries components and the only working reference. - **`/api/nodes` is two intakes through one door**: `content` (raw signal) and `emb` (already-realized geometry from somebody else's realizer) arrive together. - **Queries are intake too.** *"it can ingest ANYTHING - a file, a url, a query, a string."* A query must become geometry to be matched, so `/api/search`, `/api/search-lexical` and `/api/activate` belong to the same door on the read side. Not touched here — non-mutating, higher blast radius. Related: `/api/search` is currently a lexical token-substring scan rather than embedding-nearest, and is broken for multi-token queries — the same disease, a hand-coded path where the primitive belonged. - **`/api/neuron/state-events`** left deliberately: telemetry, auth-exempt, high-volume, and already has an off-graph log mode. Decomposing every internal state event is a volume problem, not a correctness win. ## The redundancy underneath all of this *"you coded a bunch of shit in engram that belonged in el, and then, when i fixed that, you didn't actually transition engram to use the el primitives."* `el_runtime.h` declares **93 native `engram_*` builtins** (counted as `el_val_t engram_*` declarations, not raw occurrences of the string). Roughly 50 of them already have a route wrapping them **1:1** — argument shuffling and JSON quoting around a function already linked into the same binary. These are **deletion candidates, not refactor candidates**: - **Six intake doors, one builtin.** `write`, `supersede`, `reframe`, `nodes`, `knowledge/capture`, `state-events` all bottom out in `engram_node_full`, differing **only** in the `node_type` / `tier` / `tags` they hardcode. - **Eight routes, one builtin.** `/api/think`, `/reason`, `/induce`, `/abduce`, `/relate`, `/analogize`, `/plan` all land on `engram_think_json` via `route_think` + `route_faculty`. That is literally *"there are not 15 transduce endpoints because transduce is one thing"*, with faculties in place of transduce. - **Two routes, one call.** `route_get_node` and `route_get_node_singular` both call `engram_get_node_json`. - Straight 1:1 wrappers: `route_stats`→`engram_stats_json`, `route_neighbors`→`engram_neighbors_json`, `route_strengthen`→`engram_strengthen`, `route_reify`→`engram_geo_reify_run_json`, `route_gauge_distance`→`engram_geo_distance_json`, `route_recognize`→`engram_geo_overlap_json`, `route_discern`→`engram_geo_subtract_json`, `route_synthesize`→`engram_geo_combine_json`, `route_nearest`→`engram_nearest_json`, `route_ground*`→`engram_ground*_json`, `route_attend`→`engram_attend_json`, `route_similarity`→`engram_cosine_sim`, and ~20 more. ### One thing that is *not* redundancy `ingest/src/ingest.el` reaches the engram over HTTP (`eg_base()` → `http://127.0.0.1:8902`, a port nothing is listening on) to call builtins that are linked into its own binary. That looks like the same redundancy from the other side. **It is not, and converting those calls to native `engram_*` calls would silently destroy data.** `engram_node_full` and friends are implemented in `el_runtime.c` (9154, 13856, 16223, 16586) under *"Batch 3: Engram in-process graph store — Single global EngramStore allocated lazily on first call"*: a **process-global** in-memory store. ingest is a **separate process** — its own header states it *"links only el_runtime.c ... it never links el_seed.c or the engram engine."* A native call from ingest would mint a node in ingest's own ephemeral store, return a valid-looking id, and lose it on exit — every ingest reporting success and writing nothing. That is the same defect class as the *"200 with a fresh id while the vector was discarded"* bug already documented at `server.el:358-366`. And writing the server's data dir from a second process is corruption, not a shortcut. **The HTTP hop between ingest and engram is IPC, not redundancy.** The redundancy is entirely inside `server.el`, in the same address space. The correct direction is that ingest should not be a separate process at all: the file/url/query/string intake belongs *inside* the engram, and when it lands there the HTTP client disappears because the **client** disappears, not because its calls were rewritten. Deletion in the right direction, and safe. ## Build and test discipline Local build is the bar; CI is not. ``` cd lang && ./dist/platform/elc ../engram/src/server.el > /tmp/x.c cc -std=c11 -O1 -I runtime ... -o /tmp/x /tmp/x.c runtime/el_runtime.c ... -lcurl -lssl -lcrypto -lpthread -lm ``` Compiles clean (`elc` rc=0; the only `cc` warning is the pre-existing `'/*' within block comment` in `el_runtime.c:14439`). Every run used its own port `:19501` and a fresh `cp -Rc` clone. `:8742`, `:18760`, `:7770`, `:7779`, `:17779` were never bound and production was never touched. One measurement worth flagging as a divergence: on this snapshot `embedded_count` was **0** against `embed_eligible_count` 25,629 before any write — so on *this* data set the engram had not encoded its eligible nodes at all. It rose to 142 purely from the components this change inserted with attached geometry. That differs from the 1:1 `embedded_count == embed_eligible_count` reported on prod `:8742`, and the gap between the two data sets is worth a separate look.

will.anderson added 1 commit 2026-08-16 21:35:49 +00:00

engram: intake realizes a signal into a manifold, it does not assume a node ... 99ef855b98

There is no write node. What arrives at /api/write is a SIGNAL; a node is an
OUTPUT of realization, never an INPUT to it. route_write asserted otherwise in
one line:

    let manifold: String = "[" + body + "]"   // the body IS a valid manifold node object

A request body is not a manifold, and that assertion is the whole defect. It is
why every written signal landed as one flat node with zero edges, measured on a
clone: {"inserted":1,"nodes_added":1,"edges_added":0} and GET /api/neighbors on
the new id returning [].

PR #155 corrected transduce(signal, modality) to return a Manifold — components
plus relations — but touched only ingest, the runtime and its tests. Nothing
downstream called it: grep 'transduce|realize|Manifold|decompos' over
engram/src/server.el returned exactly one line, a comment. The primitive was
fixed and the engram's entire HTTP surface never reached for it.

This wires the intake seam to the primitive that already exists. It decomposes
nothing itself and must never: transduce dispatches through the dlsym realizer
registry, so adding a modality is registering a realizer, not editing this file
and not patching the runtime. intake_signal only carries what the primitive
returns into the store — components become nodes carrying their OWN geometry
via node_attach_geometry, relations become edges at the weight the realizer
stated, and manifold_member still wires the set into one connected sub-graph
exactly as insert_manifold_json already did.

Built general rather than special-cased: five of the six intake doors (write,
supersede, nodes, knowledge/capture, state-events) are the same hand-written
"content -> engram_node_full -> one flat node", differing only in the
node_type/tier/tags they hardcode. Those are parameters here so each door can
move onto this one function. Only /api/write rides it in this pass.

When no organ is registered the signal is stored flat exactly as before, but
the response now says so ("realized":false,"organ":false,"components":0).
Silent flattening was the real defect — a caller could not tell "nothing
decomposed me" from "I decomposed into one component". el_runtime.c draws the
same line between an absent organ and a broken one, for the same reason.

No realizer is authored here and none is registered, so production behaviour is
unchanged. The mechanism is what landed.

will.anderson merged commit b92ec92c48 into dev 2026-08-17 00:58:07 +00:00

Sign in to join this conversation.

Reviewers

No Reviewers

Labels

Clear labels

BETA-CRITICAL

On the beta critical path — must resolve before ship

HELD

Blocked pending an external decision (counsel / dual sign-off)

ORTHOGONAL

Parallel workstream (testing/hardening) — safe to assign off critical path

POST-BETA

Important but not blocking the beta ship

No labels

Milestone

No items

No Milestone

Projects

Clear projects

No projects

Assignees

Clear assignees

andre.almeida (Andre Almeida) tim.lingo (Tim Lingo) will.anderson (Will Anderson)

No Assignees

1 Participants

Notifications

Subscribe

Due Date

No due date set.

Dependencies

No dependencies set.

Reference: neuron-technologies/el#158