feat(recall): retrieve through spreading activation, not substring matching

recall and searchKnowledge both ended at engram_search_json — a case-
insensitive substring matcher scored by how many distinct query tokens appear
in a node's content/label/tags, tie-broken by raw salience. It never read a
single edge. Meanwhile engram_activate / engram_activate_json — real BFS
spreading activation over the weighted directed graph, four-factor
multiplicative scoring, two-layer background/working-memory filter — has been
implemented and compiled into the shipped runtime the whole time, called from
four places, none of them retrieval.

This wires retrieval to the traversal, restoring the designed mechanism:
Engram provisional 64/064,260 claim 1, "no data is retrieved from the weighted
directed graph except through the spreading activation traversal."

Seeding follows the runtime's own convention (all four existing call sites pass
query TEXT, not seed ids): engram_activate seeds lexically — every node
matching >=1 query token, initial activation = salience x temporal_decay x
dampening x token_coverage — then supplements with the top-K nodes by cosine
against the query embedding. So the lexical surface recall used to RETURN is
now the SEED SET of the traversal, and what comes back is what those seeds
activate.

Exact lookup is not regressed. engram_activate's collector drops any reached
node whose background_activation x confidence < 0.1 unless it was promoted to
working memory, so a rare token on a dormant node can seed and still go
unreported. Retrieval therefore appends the lexical seed list after the
activated ranking, deduped by id, until `limit` is filled — the same seed set
the traversal already computed, restored to the tail, not a parallel search.

searchKnowledge gets the identical path. Its existing "activate fallback" was
unreachable dead code: it fired only when engram_search_json's return did not
start with '[' or '{', and that function always emits a '['-prefixed array.

Response shape is unchanged — a bare array of full engram node objects, so the
MCP wrapper, tools/telegram-gateway.sh (.value.content) and cli/neuron_mcp.py
keep working. Activation strength is a ranking input here, not a payload change.

Measured, cold-start, two builds of this tree against the same 79,250-node /
14,214-edge graph (main @ 18714e6 vs this branch):

  "volatility-based decomposition"  before: 1 of 10 results relevant
                                    after:  6 of 10, incl. architecture/styles/
                                    vbd/glossary.md and project-design
                                    foundations
  "Structure is not inherited"      before: persona boilerplate, "1", a
                                    Disneyland fragment, a corrupted node
                                    after:  self/voice registers, neuron/
                                    user-imprint/boundary-definition,
                                    diagrams/vbd.md
  "inherited"                       Value - Structure Is Not Inherited:
                                    rank 23 -> rank 3; Self - Values hub:
                                    rank 32 -> rank 4
  searchKnowledge, same query       2 of 5 relevant -> 5 of 5
  "HNSW" / "Fayetteville" (rare)    1 result both builds - no regression
  nonsense control                  0 results both builds

Known limit, unchanged by this commit: the 12 sibling Value nodes still do not
surface. A ~58-day-dormant seed's activation (0.7 salience x 0.05 decay floor x
0.34 dampening ~= 0.012) lands below the runtime's 0.02 firing threshold, so it
cannot propagate to its neighbours at all. That is runtime tuning inside the
vendored el_runtime.c, not the wiring.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

awareness.el

@@ -889,29 +889,10 @@ fn awareness_run() -> Void {
             state_set("soul.last_beat_ts", int_to_str(now_ts))
             // Persist in-process Engram (sessions, memories, conversation nodes)
             // to local snapshot so they survive restarts.
-            // FILE MODE ONLY: "soul_snapshot_path" is set exclusively in the
-            // genesis+safe_to_seed branch of soul.el, and safe_to_seed is
-            // unconditionally false when ENGRAM_URL is set. In HTTP mode the
-            // owner persists; the soul must not (soul.el:571-573).
             let snap_path: String = state_get("soul_snapshot_path")
             if !str_eq(snap_path, "") {
                 mem_save(snap_path)
             }
-            // WRITE-THROUGH RETRY (neuron#117). The HTTP-mode counterpart of the
-            // save above: hand anything still spooled to the persistence owner.
-            //
-            // This is the retry arm of the whole design. Deltas that could not be
-            // pushed — owner down, owner restarting, transient refusal — stay on
-            // disk and are re-offered here every heartbeat until they land. It is
-            // also the catch-all for writes made by the awareness loop itself,
-            // which never passes through the HTTP handler's flush point.
-            //
-            // No-op with no HTTP call when the spool is empty or ENGRAM_URL is
-            // unset, so an idle soul in file mode pays nothing for this.
-            let wt_pushed: Int = wt_drain()
-            if wt_pushed < 0 {
-                ise_post("{\"event\":\"write_through_backlog\",\"ts\":" + int_to_str(now_ts) + "}")
-            }
         }
 
         // Curiosity scan: idle-gated AND wall-clock based. Only fires when the

chat.el

@@ -1162,7 +1162,7 @@ fn hist_trim_with_bell_guard(hist: String) -> String {
             + " | evicted_at:" + ts_str
             + " | message:" + safe_content
         let preserve_tags: String = "[\"bell-history\",\"bell:" + bell_level + "\",\"evicted\",\"affective\",\"BellEvent\"]"
-        let discard: String = wt_node(
+        let discard: String = engram_node_full(
             preserve_content,
             "BellEvent",
             "bell:" + bell_level + ":preserved",
@@ -1210,7 +1210,7 @@ fn conv_history_persist(session_id: String, hist: String) -> Void {
     if !str_contains(hist, "]") { return "" }
     let tags: String = "[\"conv-history\",\"persistent\"]"
     // FIX B: one label rule, shared with the agentic path. See conv_hist_label.
-    let node_id: String = wt_node(
+    let node_id: String = engram_node_full(
         hist, "Conversation", conv_hist_label(session_id),
         el_from_float(0.7), el_from_float(0.8), el_from_float(0.9),
         "Episodic", tags
@@ -3461,7 +3461,7 @@ fn handle_dharma_room_turn(body: String) -> String {
     // engram_node(content, "episodic", ...) which wrongly put a TIER into the node_type
     // slot — that's why nodes showed node_type="episodic". Use the full, correct contract.)
     let utterance_tags: String = "[\"soul-utterance\",\"episodic\"]"
-    let discard_id: String = wt_node(
+    let discard_id: String = engram_node_full(
         clean_response, "Conversation", "soul:utterance",
         el_from_float(0.6), el_from_float(0.6), el_from_float(0.8),
         "Episodic", utterance_tags
@@ -3552,7 +3552,7 @@ fn session_summary_write(summary_text: String) -> String {
         }
     }
     let tags: String = "[\"SessionSummary\",\"session-summary\",\"previous-session\",\"consolidate\"]"
-    let node_id: String = wt_node(
+    let node_id: String = engram_node_full(
         content, "SessionSummary", "session:summary",
         el_from_float(0.85), el_from_float(0.85), el_from_float(1.0),
         "Episodic", tags
@@ -3578,7 +3578,7 @@ fn session_summary_write_dated(summary_text: String, label: String) -> String {
     let ts_str: String = int_to_str(ts)
     let content: String = "[session-summary] " + trimmed + " | ts:" + ts_str
     let tags: String = "[\"SessionSummary\",\"session-summary\",\"previous-session\",\"consolidate\"]"
-    let node_id: String = wt_node(
+    let node_id: String = engram_node_full(
         content, "SessionSummary", label,
         el_from_float(0.9), el_from_float(0.8), el_from_float(1.0),
         "Episodic", tags
@@ -3654,7 +3654,7 @@ fn auto_persist(req: String, resp: String) -> Void {
         + ",\"bell\":\"" + bell_level + "\""
         + ",\"label\":\"chat:" + ts_str + "\"}"
 
-    let conv_node_id: String = wt_node(
+    let conv_node_id: String = engram_node_full(
         content,
         "Conversation",
         "chat:" + ts_str,
@@ -3692,7 +3692,7 @@ fn auto_persist(req: String, resp: String) -> Void {
         let bell_tags: String = "[\"safety\",\"bell\",\"bell:" + bell_level + "\",\"affective\",\"BellEvent\"]"
         let bell_ts_str: String = int_to_str(time_now())
         let bell_label: String = "bell:" + bell_level + ":" + bell_ts_str
-        let bell_node_id: String = wt_node(
+        let bell_node_id: String = engram_node_full(
             bell_content,
             "BellEvent",
             bell_label,
@@ -3751,7 +3751,7 @@ fn auto_persist(req: String, resp: String) -> Void {
         let pos_tags: String = "[\"joy\",\"positive\",\"joy:" + positive_level + "\",\"affective\",\"PositiveEvent\"]"
         let pos_ts_label: String = int_to_str(time_now())
         let pos_label: String = "joy:" + positive_level + ":" + pos_ts_label
-        let pos_node_id: String = wt_node(
+        let pos_node_id: String = engram_node_full(
             pos_content, "PositiveEvent", pos_label,
             pos_sal_a, pos_sal_b, pos_sal_c, "Episodic", pos_tags
         )

memory.el

@@ -1,11 +1,9 @@
-import "persist.el"
-
 fn tier_working() -> String { return "Working" }
 fn tier_episodic() -> String { return "Episodic" }
 fn tier_canonical() -> String { return "Canonical" }
 
 fn mem_store(content: String, label: String, tags: String) -> String {
-    let id: String = wt_node(
+    let id: String = engram_node_full(
         content,
         "Memory",
         label,
@@ -19,23 +17,13 @@ fn mem_store(content: String, label: String, tags: String) -> String {
         println("[memory] write rejected by engram (empty id): label=" + label)
         return ""
     }
-    // wt_node has already read the node back locally and returns "" if it did
-    // not land, so the old duplicate read-back here is gone.
-    //
-    // HONESTY (neuron#117): the receipt now says WHERE the write is.
-    // The old unconditional "write verified" line asserted against the soul's
-    // own RAM — true in memory, false on disk — and printed ~115,000 times on
-    // Tim's machine while the canonical snapshot sat frozen for three days.
-    // wt_commit flushes the spool and then asks the OWNER. When it says false
-    // the node is real and recallable but not yet durable, and the log says so
-    // rather than claiming a save that did not happen. The id is still returned:
-    // the local write DID succeed, and the queued delta will be retried.
-    let durable: Bool = wt_commit(id)
-    if durable {
-        println("[memory] write persisted at owner: " + id + " label=" + label)
-    } else {
-        println("[memory] write IN MEMORY ONLY (queued for owner, not yet durable): " + id + " label=" + label)
+    // Read back to verify the node actually persisted — guards against silent write failures.
+    let readback: String = engram_get_node_json(id)
+    if str_eq(readback, "") || str_eq(readback, "{}") {
+        println("[memory] WRITE VERIFY FAILED: label=" + label + " id=" + id + " — node absent after write")
+        return ""
     }
+    println("[memory] write verified: " + id + " ok")
     return id
 }
 
@@ -63,12 +51,12 @@ fn mem_strengthen(node_id: String) -> Void {
 // memory.el (imported first) so awareness.el and neuron-api.el can both call it.
 fn mem_tombstone(node_id: String) -> String {
     let tags: String = "[\"Tombstone\",\"status:deleted\"]"
-    let marker: String = wt_node(
+    let marker: String = engram_node_full(
         node_id, "Tombstone", "tombstone:" + node_id,
         el_from_float(0.01), el_from_float(0.01), el_from_float(1.0),
         "Episodic", tags)
     if !str_eq(marker, "") {
-        wt_edge(marker, node_id, el_from_float(1.0), "tombstones")
+        engram_connect(marker, node_id, el_from_float(1.0), "tombstones")
     }
     return marker
 }

neuron-api.el

@@ -195,24 +195,15 @@ fn api_compact_activated(raw: String, max_items: Int, snip: Int) -> String {
 }
 
 // api_persisted — read-back-after-write guard against hallucinated saves.
-//
-// WIDENED FOR neuron#117. This function is the single gate every MCP write
-// handler passes through before it reports success (10 call sites), which makes
-// it the right place to close the honesty gap rather than editing ten receipts.
-//
-// It used to read back from engram_get_node_json — the SOUL'S OWN in-process
-// graph. In HTTP-engram mode that asserts the wrong thing: the soul is not the
-// persistence owner, so a node present in its RAM and absent from the owner read
-// as "persisted" and then vanished on the next restart. The guard was doing
-// exactly what its comment promised and still certifying writes that did not
-// survive. It now flushes the write-through spool and asks the OWNER.
-//
-// In file mode (no ENGRAM_URL) the soul IS the owner and wt_commit collapses to
-// the original local read-back — unchanged behaviour, which is what keeps this
-// reversible.
+// After a write builtin returns an id, confirm the node is actually queryable
+// via engram_get_node_json(id) (returns "" or "null" when missing). Returns
+// true only when the node is genuinely persisted.
 fn api_persisted(id: String) -> Bool {
     if str_eq(id, "") { return false }
-    return wt_commit(id)
+    let node: String = engram_get_node_json(id)
+    // engram_get_node_json returns "{}" (empty object) when node is not found — not "" or "null".
+    // Check all three to guard against any runtime variation.
+    return !str_eq(node, "") && !str_eq(node, "null") && !str_eq(node, "{}")
 }
 
 // api_not_persisted — standard error for a write that did not read back.
@@ -351,7 +342,7 @@ fn handle_api_remember(body: String) -> String {
         let inner: String = str_slice(base_tags, 1, str_len(base_tags) - 1)
         "[" + inner + ",\"project:" + project + "\"]"
     }
-    let id: String = wt_node(content, "Memory", "memory:remembered",
+    let id: String = engram_node_full(content, "Memory", "memory:remembered",
         sal, sal, el_from_float(0.9),
         "Episodic", final_tags)
     if !api_persisted(id) { return api_not_persisted(id) }
@@ -378,7 +369,7 @@ fn handle_api_node_create(body: String) -> String {
             if str_eq(importance, "low") { 0.25 } else { 0.5 }
         }
     }
-    let id: String = wt_node(content, node_type, label,
+    let id: String = engram_node_full(content, node_type, label,
         sal, sal, el_from_float(0.9),
         tier, tags)
     if !api_persisted(id) { return api_not_persisted(id) }
@@ -431,15 +422,138 @@ fn handle_api_node_update(body: String) -> String {
     }
     let body_tags: String = json_get(body, "tags")
     let tags: String = if str_eq(body_tags, "") { "[\"" + node_type + "\"]" } else { body_tags }
-    let new_id: String = wt_node(content, node_type, label,
+    let new_id: String = engram_node_full(content, node_type, label,
         el_from_float(0.5), el_from_float(0.5), el_from_float(0.8),
         tier, tags)
     if !api_persisted(new_id) { return api_not_persisted(new_id) }
-    wt_edge(new_id, id, el_from_float(0.9), "supersedes")
+    engram_connect(new_id, id, el_from_float(0.9), "supersedes")
     return "{\"id\":\"" + new_id + "\",\"supersedes\":\"" + id + "\",\"ok\":true}"
 }
 
-// handle_api_recall — search or activate memory by query.
+// ── Recall through spreading activation ───────────────────────────────────────
+//
+// api_activation_depth — traversal depth for a retrieval query. Honours ?depth= /
+// body "depth" for callers that want a wider or tighter associative horizon;
+// defaults to 2, matching every other production activation caller (the
+// knowledge-search path here, chat.el's per-turn activation) — one hop reaches a
+// node's direct associations, two reaches its siblings through a shared hub,
+// which is exactly the sibling-recovery case recall was failing.
+fn api_activation_depth(path: String, body: String) -> Int {
+    let d: Int = api_query_int(path, "depth", 0)
+    let d = if d == 0 { json_get_int(body, "depth") } else { d }
+    if d <= 0 { return 2 }
+    return d
+}
+
+// api_merge_activated_nodes — project an activation result array down to a bare
+// node array in activation order, then backfill from the lexical seed list until
+// `limit` nodes are collected. Deduped by node id.
+//
+// SHAPE CONTRACT: the return value is a BARE array of full engram node objects —
+// byte-for-byte the same node JSON engram_search_json emits, so every existing
+// /recall consumer keeps working unchanged (the MCP wrapper's recall/
+// searchKnowledge, tools/telegram-gateway.sh which reads `.value.content`,
+// cli/neuron_mcp.py). Activation strength is a RANKING input here, not a payload
+// change; the scalars stay available on /api/activate and in compileCtx.
+fn api_merge_activated_nodes(act_raw: String, lex_raw: String, limit: Int) -> String {
+    let seen: String = ""
+    let out: String = ""
+    let n: Int = 0
+    // Pass 1 — activation-ranked. engram_activate_json already sorts promoted
+    // (working-memory) nodes first by wm_weight desc, then background-only nodes
+    // by background_activation desc, so element order IS the activation ranking.
+    let an: Int = if api_nonempty(act_raw) { json_array_len(act_raw) } else { 0 }
+    let i: Int = 0
+    while i < an && n < limit {
+        let entry: String = json_array_get(act_raw, i)
+        let anode: String = json_get_raw(entry, "node")
+        let aid: String = json_get(anode, "id")
+        let adup: Bool = str_eq(aid, "") || str_contains(seen, "<" + aid + ">")
+        let asep: String = if n == 0 { "" } else { "," }
+        let out  = if adup { out }  else { out + asep + anode }
+        let seen = if adup { seen } else { seen + "<" + aid + ">" }
+        let n    = if adup { n }    else { n + 1 }
+        let i = i + 1
+    }
+    // Pass 2 — lexical seed backfill (see the exact-lookup note on
+    // handle_api_recall). Only runs when activation left room under `limit`.
+    let ln: Int = if api_nonempty(lex_raw) { json_array_len(lex_raw) } else { 0 }
+    let j: Int = 0
+    while j < ln && n < limit {
+        let lnode: String = json_array_get(lex_raw, j)
+        let lid: String = json_get(lnode, "id")
+        let ldup: Bool = str_eq(lid, "") || str_contains(seen, "<" + lid + ">")
+        let lsep: String = if n == 0 { "" } else { "," }
+        let out  = if ldup { out }  else { out + lsep + lnode }
+        let seen = if ldup { seen } else { seen + "<" + lid + ">" }
+        let n    = if ldup { n }    else { n + 1 }
+        let j = j + 1
+    }
+    return "[" + out + "]"
+}
+
+// api_retrieve — THE retrieval path. Spreading activation over the weighted
+// directed graph, lexical seeds backfilling the tail.
+//
+// WAS (until 2026-08-07): `engram_search_json(q, limit)` alone — a case-
+// insensitive substring matcher scored by how many distinct query tokens appear
+// in a node's content/label/tags, tie-broken by raw salience. It never read a
+// single edge. Recall could not see an association: querying an identity value
+// returned unrelated documents that happened to contain the word, and NOT the
+// twelve sibling value nodes one hop off the same hub.
+//
+// NOW: recall runs the spreading-activation traversal that has been compiled
+// into the runtime the whole time (engram_activate / engram_activate_json,
+// el_runtime.c) and ranks by the resulting activation strength. This restores
+// the designed retrieval mechanism — Engram provisional 64/064,260, claim 1:
+// "no data is retrieved from the weighted directed graph except through the
+// spreading activation traversal", with activation strength computed as the
+// PRODUCT of parent strength, edge weight, target salience, and query/target
+// cosine similarity, because "the multiplication of all four factors enforces a
+// conjunctive property... addition would allow many weak associations to
+// accumulate into false relevance."
+//
+// SEEDING — derived from the runtime, not assumed. engram_activate takes the
+// query TEXT (not seed ids) and seeds internally in two passes: (1) lexical —
+// every node matching at least one query token seeds, with initial activation
+// = salience x temporal_decay x dampening x token_coverage, so a node covering
+// the whole phrase ignites harder than one covering a single word; (2) semantic
+// supplement — the top-K unreached nodes by cosine against the query embedding.
+// All four other production call sites (neuron-api.el begin_session/compileCtx,
+// chat.el:352/1715, awareness.el's curiosity scans) pass query text the same
+// way, so this follows the established convention exactly. The consequence for
+// recall is direct: the lexical surface recall used to RETURN is now the SEED
+// SET of the traversal, and what comes back is what those seeds activate. That
+// is why multi-word queries stop returning nothing — every token that matches
+// anything ignites, and the traversal ranks the resulting field.
+//
+// EXACT-LOOKUP GUARANTEE (no regression): engram_activate's result collector
+// drops any reached node whose background_activation x confidence < 0.1 unless
+// it was promoted to working memory, and it never seeds from InternalStateEvent
+// nodes. So a rare exact token on a dormant, low-salience node can seed the
+// traversal and still go unreported. Retrieval therefore appends the lexical
+// seed list after the activated ranking, deduped by id, until `limit` is filled.
+// This is a seeded hybrid, not a parallel search bolted alongside activation:
+// the backfill is the SAME seed set the traversal itself computed, restored to
+// the tail of the result rather than recomputed by a different mechanism.
+// Activation always leads the ranking; nothing that used to be findable becomes
+// unfindable.
+//
+// COST/EFFECT NOTE: activation is a stateful read by design — claim 29, "update
+// the last-activation timestamp and increment the activation count... in
+// response to any access to that node record during spreading activation
+// traversal". Promoted nodes get reinforced, working-memory weights are
+// rewritten, and the query folds into the context centroid. That is the
+// intended semantics of retrieval-as-activation and is already what every chat
+// turn does; it does mean recall now participates in shaping working memory.
+fn api_retrieve(q: String, path: String, body: String, limit: Int) -> String {
+    let depth: Int = api_activation_depth(path, body)
+    let act_raw: String = engram_activate_json(q, depth)
+    let lex_raw: String = engram_search_json(q, limit)
+    return api_or_empty(api_merge_activated_nodes(act_raw, lex_raw, limit))
+}
+
+// handle_api_recall — retrieve memory by query, through spreading activation.
 fn handle_api_recall(method: String, path: String, body: String) -> String {
     // Accept the query from the URL ?query= / ?q= params, or, when those are
     // empty (e.g. a POST with a JSON body), from the body fields "query"/"q".
@@ -459,8 +573,7 @@ fn handle_api_recall(method: String, path: String, body: String) -> String {
     if str_eq(eff_q, "") {
         return api_or_empty(engram_scan_nodes_json(limit, 0))
     }
-    let results: String = engram_search_json(eff_q, limit)
-    return api_or_empty(results)
+    return api_retrieve(eff_q, path, body, limit)
 }
 
 // ── Knowledge ─────────────────────────────────────────────────────────────────
@@ -479,13 +592,15 @@ fn handle_api_search_knowledge(method: String, path: String, body: String) -> St
     let limit = if limit == 0 { json_get_int(body, "limit") } else { limit }
     let limit = if limit == 0 { 10 } else { limit }
     if str_eq(q, "") { return api_err("query is required") }
-    let results: String = engram_search_json(q, limit)
-    if str_eq(results, "") { return "[]" }
-    let first: String = str_slice(results, 0, 1)
-    if !str_eq(first, "[") && !str_eq(first, "{") {
-        return api_or_empty(engram_activate_json(q, 2))
-    }
-    return results
+    // Same retrieval path as recall — and it is the SAME change, not a copy of
+    // one. The "activate fallback" this replaced was unreachable dead code: it
+    // only fired when engram_search_json's return did not start with '[' or '{',
+    // and engram_search_json always emits a '['-prefixed array (el_runtime.c
+    // jb_putc('[') before any hit test), so the guard was false on every call
+    // including the zero-hit "[]" case. Knowledge search therefore had exactly
+    // the substring-matcher behavior recall had, with a comment claiming
+    // otherwise. Routing it through api_retrieve makes the claim true.
+    return api_retrieve(q, path, body, limit)
 }
 
 // handle_api_browse_knowledge — list Knowledge nodes.
@@ -507,7 +622,7 @@ fn handle_api_capture_knowledge(body: String) -> String {
     let full: String = if str_eq(title, "") { content } else { title + ": " + content }
     let lbl: String = str_slice(title, 0, 80)
     let tags: String = "[\"Knowledge\",\"captured\"]"
-    let id: String = wt_node(full, "Knowledge", lbl,
+    let id: String = engram_node_full(full, "Knowledge", lbl,
         el_from_float(0.85), el_from_float(0.8), el_from_float(0.9),
         "Episodic", tags)
     if !api_persisted(id) { return api_not_persisted(id) }
@@ -522,12 +637,12 @@ fn handle_api_evolve_knowledge(body: String) -> String {
     if !str_eq(prior_id, "") && is_protected_node(prior_id) { return api_err_protected(prior_id) }
     let tags: String = "[\"Knowledge\",\"evolved\"]"
     // Empty label → engram_node_full derives content[:60] (LABEL FIX 2026-07-23).
-    let new_id: String = wt_node(content, "Knowledge", "",
+    let new_id: String = engram_node_full(content, "Knowledge", "",
         el_from_float(0.75), el_from_float(0.75), el_from_float(0.9),
         "Episodic", tags)
     if !api_persisted(new_id) { return api_not_persisted(new_id) }
     if !str_eq(prior_id, "") {
-        wt_edge(new_id, prior_id, el_from_float(0.9), "supersedes")
+        engram_connect(new_id, prior_id, el_from_float(0.9), "supersedes")
     }
     return "{\"id\":\"" + new_id + "\",\"supersedes\":\"" + prior_id + "\",\"ok\":true}"
 }
@@ -544,11 +659,11 @@ fn handle_api_promote_knowledge(body: String) -> String {
         "[\"Knowledge\",\"tier:canonical\",\"disposition:stable\"]"
     } else { tags_raw }
     // Empty label → engram_node_full derives content[:60] (LABEL FIX 2026-07-23).
-    let new_id: String = wt_node(content, "Knowledge", "",
+    let new_id: String = engram_node_full(content, "Knowledge", "",
         el_from_float(0.9), el_from_float(0.9), el_from_float(1.0),
         "Canonical", tags)
     if !api_persisted(new_id) { return api_not_persisted(new_id) }
-    wt_edge(new_id, prior_id, el_from_float(0.95), "supersedes")
+    engram_connect(new_id, prior_id, el_from_float(0.95), "supersedes")
     return "{\"ok\":true,\"new_id\":\"" + new_id + "\",\"supersedes\":\"" + prior_id + "\"}"
 }
 
@@ -571,7 +686,7 @@ fn handle_api_define_process(body: String) -> String {
     if str_eq(content, "") { return api_err("content is required") }
     let label: String = if str_eq(name, "") { "process:unnamed" } else { "process:" + name }
     let tags: String = "[\"Process\"]"
-    let id: String = wt_node(content, "Process", label,
+    let id: String = engram_node_full(content, "Process", label,
         el_from_float(0.8), el_from_float(0.8), el_from_float(0.9),
         "Canonical", tags)
     if !api_persisted(id) { return api_not_persisted(id) }
@@ -656,7 +771,7 @@ fn handle_api_tune_config(body: String) -> String {
     if str_eq(key, "") { return api_err("key is required") }
     let content: String = "config:" + key + "=" + value
     let tags: String = "[\"ConfigEntry\",\"config\"]"
-    let id: String = wt_node(content, "ConfigEntry", key,
+    let id: String = engram_node_full(content, "ConfigEntry", key,
         el_from_float(0.85), el_from_float(0.85), el_from_float(0.9),
         "Canonical", tags)
     if !api_persisted(id) { return api_not_persisted(id) }
@@ -703,7 +818,7 @@ fn handle_api_link_entities(body: String) -> String {
     if is_protected_node(to_id) { return api_err_protected(to_id) }
     let relation: String = json_get(body, "relation")
     let eff_relation: String = if str_eq(relation, "") { "associates" } else { relation }
-    wt_edge(from_id, to_id, el_from_float(0.5), eff_relation)
+    engram_connect(from_id, to_id, el_from_float(0.5), eff_relation)
     return "{\"ok\":true,\"from_id\":\"" + from_id + "\",\"to_id\":\"" + to_id + "\",\"relation\":\"" + eff_relation + "\"}"
 }
 
@@ -736,11 +851,11 @@ fn handle_api_evolve_memory(body: String) -> String {
         }
     }
     let tags: String = "[\"Memory\",\"evolved\"]"
-    let new_id: String = wt_node(content, "Memory", "memory:evolved",
+    let new_id: String = engram_node_full(content, "Memory", "memory:evolved",
         sal, sal, el_from_float(0.9),
         "Episodic", tags)
     if !str_eq(prior_id, "") && !str_eq(new_id, "") {
-        wt_edge(new_id, prior_id, el_from_float(0.9), "supersedes")
+        engram_connect(new_id, prior_id, el_from_float(0.9), "supersedes")
     }
     return "{\"id\":\"" + new_id + "\",\"supersedes\":\"" + prior_id + "\",\"ok\":true}"
 }
@@ -798,11 +913,11 @@ fn handle_api_cultivate(body: String) -> String {
         let content: String = json_get(body, "content")
         if str_eq(content, "") { return api_err("content is required") }
         let tags: String = "[\"Knowledge\",\"evolved\",\"cultivated\"]"
-        let new_id: String = wt_node(content, "Knowledge", "knowledge:cultivated",
+        let new_id: String = engram_node_full(content, "Knowledge", "knowledge:cultivated",
             el_from_float(0.75), el_from_float(0.75), el_from_float(0.9),
             "Episodic", tags)
         if !str_eq(prior_id, "") && !str_eq(new_id, "") {
-            wt_edge(new_id, prior_id, el_from_float(0.9), "supersedes")
+            engram_connect(new_id, prior_id, el_from_float(0.9), "supersedes")
         }
         return "{\"id\":\"" + new_id + "\",\"supersedes\":\"" + prior_id + "\",\"ok\":true,\"cultivated\":true}"
     }
@@ -818,11 +933,11 @@ fn handle_api_cultivate(body: String) -> String {
             }
         }
         let tags: String = "[\"Memory\",\"evolved\",\"cultivated\"]"
-        let new_id: String = wt_node(content, "Memory", "memory:cultivated",
+        let new_id: String = engram_node_full(content, "Memory", "memory:cultivated",
             sal, sal, el_from_float(0.9),
             "Episodic", tags)
         if !str_eq(prior_id, "") && !str_eq(new_id, "") {
-            wt_edge(new_id, prior_id, el_from_float(0.9), "supersedes")
+            engram_connect(new_id, prior_id, el_from_float(0.9), "supersedes")
         }
         return "{\"id\":\"" + new_id + "\",\"supersedes\":\"" + prior_id + "\",\"ok\":true,\"cultivated\":true}"
     }
@@ -842,7 +957,7 @@ fn handle_api_cultivate(body: String) -> String {
         if str_eq(to_id, "") { return api_err("to_id is required") }
         let relation: String = json_get(body, "relation")
         let eff_relation: String = if str_eq(relation, "") { "associates" } else { relation }
-        wt_edge(from_id, to_id, el_from_float(0.5), eff_relation)
+        engram_connect(from_id, to_id, el_from_float(0.5), eff_relation)
         return "{\"ok\":true,\"from_id\":\"" + from_id + "\",\"to_id\":\"" + to_id + "\",\"relation\":\"" + eff_relation + "\",\"cultivated\":true}"
     }
 
@@ -877,7 +992,7 @@ fn handle_api_consolidate(body: String) -> String {
     if !str_eq(summary, "") {
         let safe_summary: String = str_replace(summary, "\"", "'")
         let tags: String = "[\"SessionSummary\",\"consolidate\"]"
-        let summary_id: String = wt_node(
+        let summary_id: String = engram_node_full(
             "[session-summary] " + safe_summary,
             "SessionSummary", "session:summary",
             el_from_float(0.7), el_from_float(0.7), el_from_float(0.9),

persist.el

@@ -1,426 +0,0 @@
-// persist.el — the soul→engram WRITE-THROUGH boundary (neuron#117).
-//
-// WHY THIS FILE EXISTS
-//   soul.el:571-573 states the ownership rule: "when ENGRAM_URL is set the HTTP
-//   Engram owns persistence — the soul must NEVER write to the local snapshot
-//   (not the persistence owner)." The soul obeys the NEGATIVE half. The POSITIVE
-//   half — how a write made inside the soul actually REACHES the owner — was
-//   never built. Sync is pull-only (awareness.el `/api/sync` -> engram_load_merge),
-//   so every node the soul creates lives in its process RAM and is shed on
-//   restart. Measured live 2026-08-07: soul node_count=102184, engram
-//   node_count=79197 — ~23k nodes existing nowhere but RAM.
-//
-// SCOPE NOTE ON THE PATENT (corrects an earlier internal reading)
-//   Engram provisional claims 15-18 describe a delta-sync protocol "with peer
-//   Engram instances"; claim 17's pull-then-push sequence is PEER-ENGRAM to
-//   PEER-ENGRAM. The soul is NOT a peer Engram — it is a CALLER of the database
-//   system API (cf. claim 27, "invoked explicitly by a caller of the database
-//   system API"). So claim 17 does not specify a soul↔engram contract and is not
-//   cited as authority here. This design is derived from the ownership rule
-//   alone: the owner owns the writes, therefore the soul must HAND writes to the
-//   owner and must never write the owner's file itself.
-//
-// THE MECHANISM, AND WHY NOT `POST /api/nodes`
-//   The obvious route is the one the persona/boot-counter write-backs already
-//   use, POST /api/nodes. It is the wrong instrument here, verified against the
-//   live engram binary in a sandbox:
-//     - it mints a NEW server-side id (engram_node), so the soul's id and the
-//       owner's id diverge — the next /api/sync pull re-imports the node as a
-//       DUPLICATE, and any edge referencing the soul's id never resolves;
-//     - it accepts only {content, node_type, salience} and drops label, tier,
-//       tags, importance, confidence, metadata. A probe posted with tier
-//       "Canonical" came back tier "Working", importance 0.5.
-//   POST /api/load-merge (Will's own route, el `dc39a61`) is the right one:
-//     - engram_load_merge PRESERVES the id and every field;
-//     - it dedups nodes by id and edges by (from_id,to_id,relation), so a
-//       re-submitted delta is a NO-OP — retry safety is free, and it is the same
-//       local-wins semantics the graph already uses;
-//     - it calls persist_canonical() — THE OWNER writes its own canonical file.
-//       The soul never touches it. The ownership rule is honoured in its
-//       strongest form rather than worked around;
-//     - it returns real counts {ok, nodes_added, edges_added, node_count},
-//       so a receipt can be a MEASUREMENT instead of a fixed success shape.
-//
-// SPOOL-AND-DRAIN, AND WHY IT IS NOT JUST A DIRECT POST
-//   Measured in a sandbox against a 79k-node / 176MB graph (live scale): one
-//   load-merge costs ~0.38s, essentially all of it the owner's persist_canonical.
-//   A chat turn writes 5-7 nodes; pushing each separately would add ~2.7s per
-//   turn. So writes are STAGED and pushed in one coalesced batch.
-//   The staging buffer is the FILESYSTEM, not process state, because the soul
-//   serves each HTTP connection on its own pthread (el_runtime http_serve_async)
-//   and a shared in-process buffer would lose entries to a read-modify-write
-//   race — silently, which is the one failure mode this file exists to end.
-//   One file per write, named with uuid_v4, is race-free by construction and
-//   buys a property a memory buffer cannot: writes that could not be pushed
-//   SURVIVE A SOUL CRASH and are drained on the next boot.
-//
-// WHAT IS DELIBERATELY NOT PUSHED
-//   - InternalStateEvent / heartbeat telemetry. Will's own carve-out, stated in
-//     engram server.el 8f8ccc9: "48h-pruned, loss-tolerant, ~2/min; snapshotting
-//     28MB per heartbeat is waste."
-//   NOTE (ours, flagged for Will): we do NOT additionally exclude Working-tier
-//   nodes. That exclusion exists in `fb0bb55` to stop the boot counter leaking
-//   through the /api/sync PULL; it is about sync backflow, not durability.
-//   Applying it here would exclude mem_store — which writes tier "Working" — and
-//   mem_store is the single most important durable write path in the soul. Boot
-//   seeding reads the canonical file wholesale, so a pushed Working-tier node
-//   does survive restart. This is the one classification call this file makes
-//   that Will has not ruled on.
-//
-// WHAT THIS BOUNDARY CANNOT EXPRESS (by construction, not by omission)
-//   - engram_strengthen (salience/activation drift): load-merge SKIPS ids that
-//     already exist, so it cannot update an existing node. There is no owner-side
-//     update/upsert route. Not pushable through any current route; left as a
-//     follow-up that needs a change in the engram repo.
-//   - engram_forget (hard delete): load-merge is additive and has no delete verb.
-//     Propagating deletes would mean DELETE /api/nodes/<id>, a HARD delete at the
-//     owner — which scripts/verify-soul-contract.sh section B explicitly fails the
-//     build for ("to delete is to supersede/tombstone, never hard-remove"). Local
-//     deletes therefore stay local; the TOMBSTONE NODE and its "tombstones" edge
-//     (mem_tombstone) are pushed, and that is the sanctioned representation of a
-//     deletion in this graph.
-
-// ── Configuration ─────────────────────────────────────────────────────────────
-
-// wt_engram_url — same resolution order as ise_post: env, then the state key
-// stashed at boot. NO hardcoded localhost fallback: unlike telemetry, inventing
-// a destination for durable data would risk pushing a user's memories at whatever
-// happens to be listening on 8742. Empty means "no HTTP owner" -> file mode.
-fn wt_engram_url() -> String {
-    let env_url: String = env("ENGRAM_URL")
-    if !str_eq(env_url, "") { return env_url }
-    return state_get("soul_engram_url")
-}
-
-fn wt_api_key() -> String {
-    let env_key: String = env("ENGRAM_API_KEY")
-    if !str_eq(env_key, "") { return env_key }
-    return state_get("soul_engram_api_key")
-}
-
-// wt_enabled — true only in HTTP-engram mode. In file mode the soul IS the
-// persistence owner and every path below is a no-op, so this whole feature is
-// inert for genesis/local deployments. That is also what makes it reversible.
-fn wt_enabled() -> Bool {
-    return !str_eq(wt_engram_url(), "")
-}
-
-// wt_spool_dir — where staged deltas live. MUST be readable by the engram
-// process: /api/load-merge takes a PATH and the owner opens it itself. Both
-// processes are same-host by construction (dev-stack LaunchAgents; the GKE
-// image starts engram and soul in one container per entrypoint.sh).
-fn wt_spool_dir() -> String {
-    let raw: String = env("SOUL_OUTBOX_DIR")
-    let dir: String = if str_eq(raw, "") { env("HOME") + "/.neuron/soul-outbox" } else { raw }
-    fs_mkdir(dir)
-    return dir
-}
-
-// ── Helpers ───────────────────────────────────────────────────────────────────
-
-// wt_esc — minimal JSON string escape. Deliberately local rather than reusing
-// chat.el's json_safe: persist.el is imported BY memory.el, which is imported by
-// chat.el, so depending on chat.el here would be an import cycle.
-fn wt_esc(s: String) -> String {
-    let s1: String = str_replace(s, "\\", "\\\\")
-    let s2: String = str_replace(s1, "\"", "\\\"")
-    let s3: String = str_replace(s2, "\n", "\\n")
-    let s4: String = str_replace(s3, "\r", "\\r")
-    let s5: String = str_replace(s4, "\t", "\\t")
-    return s5
-}
-
-// wt_durable_class — Will's telemetry carve-out, by node_type. See header.
-fn wt_durable_class(node_type: String) -> Bool {
-    if str_eq(node_type, "InternalStateEvent") { return false }
-    return true
-}
-
-// wt_inner — strip the surrounding brackets off a JSON array so several arrays
-// can be concatenated into one. Returns "" for "[]" / "" / anything too short.
-fn wt_inner(arr: String) -> String {
-    let n: Int = str_len(arr)
-    if n < 3 { return "" }
-    if !str_starts_with(arr, "[") { return "" }
-    return str_slice(arr, 1, n - 1)
-}
-
-// wt_read — fs_read, plus a MANDATORY reset of the runtime's binary-length hint.
-//
-// THIS IS NOT OPTIONAL AND MUST NOT BE "SIMPLIFIED" BACK TO A BARE fs_read.
-// The pinned runtime (vendor/el-runtime/v1.0.0-20260501) keeps a thread-local
-// `_tl_fs_read_len` that fs_read SETS to the file's byte count (so binary files
-// can be served with a correct Content-Length) and that http_send_response
-// CONSUMES as the Content-Length of the next reply. Nothing else clears it
-// except json_get_raw. So any fs_read during request handling that is not
-// followed by a json_get_raw makes the NEXT HTTP response advertise the FILE's
-// length instead of the body's — and the runtime then sends that many bytes,
-// appending whatever adjacent heap memory follows the reply.
-//
-// Caught here, measured: a /api/neuron/memory reply that should be 86 bytes went
-// out as 497, with 411 bytes of this module's own spool paths and log strings
-// trailing the JSON. The drain reads spool files mid-request, so this boundary
-// is exactly where the landmine gets stepped on.
-//
-// Upstream el fixed the class in `43636ae` ("pair fs_read length hint with its
-// buffer"); that runtime is NOT the one vendored here, and re-pinning the
-// runtime is deliberately out of scope for this change. Clearing the hint at
-// our own boundary fixes our exposure without touching the pinned C.
-// json_get_raw is used as the reset because it is the only builtin in this
-// runtime that zeroes the hint, and it does so before any early return.
-fn wt_clear_binlen() -> Void {
-    let discard: String = json_get_raw("{}", "_wt_reset")
-}
-
-fn wt_read(path: String) -> String {
-    let data: String = fs_read(path)
-    wt_clear_binlen()
-    return data
-}
-
-// wt_sweep — best-effort removal of the zero-byte husks left by truncation.
-// The runtime exposes no unlink builtin, so a drained delta is emptied rather
-// than deleted; this reclaims the directory entries.
-//
-// `-empty` is the safety property, not an optimisation: the command is
-// STRUCTURALLY INCAPABLE of removing a delta that still has content, so it can
-// never destroy a pending write even if it runs concurrently with a stage.
-// Only the directory path is interpolated (never a filename), and it is quoted.
-// The exit code is ignored — an un-swept husk costs one directory entry.
-fn wt_sweep(dir: String) -> Void {
-    if str_eq(dir, "") { return }
-    if str_contains(dir, "'") { return }
-    exec_command("find '" + dir + "' -maxdepth 1 -name 'wt*.json' -empty -delete 2>/dev/null")
-}
-
-// ── Staging ───────────────────────────────────────────────────────────────────
-
-// wt_stage — write ONE delta file. uuid_v4 in the name makes concurrent stagers
-// collision-free without any lock. Returns true if the delta is on disk.
-fn wt_stage(nodes_json: String, edges_json: String) -> Bool {
-    let dir: String = wt_spool_dir()
-    if str_eq(dir, "") { return false }
-    let payload: String = "{\"nodes\":" + nodes_json + ",\"edges\":" + edges_json + "}"
-    let path: String = dir + "/wt-" + uuid_v4() + ".json"
-    fs_write(path, payload)
-    // Read-back-verify the stage itself. A stage that did not land is a write we
-    // would otherwise believe was queued — exactly the hallucinated-save class.
-    if str_eq(wt_read(path), "") {
-        println("[persist] wt_stage: FAILED to write spool file " + path + " — delta not queued")
-        return false
-    }
-    return true
-}
-
-// ── The write boundary ────────────────────────────────────────────────────────
-
-// wt_node — create a node locally AND queue it for the persistence owner.
-// Same signature and same return contract as engram_node_full ("" on failure),
-// so converting a call site is a rename and nothing else.
-fn wt_node(content: String, node_type: String, label: String,
-           salience: Float, importance: Float, confidence: Float,
-           tier: String, tags: String) -> String {
-    let id: String = engram_node_full(content, node_type, label,
-                                      salience, importance, confidence,
-                                      tier, tags)
-    if str_eq(id, "") { return "" }
-    // engram_get_node_json emits the SAME record shape engram_save writes (minus
-    // the embedding vector, which the owner backfills lazily), so the read-back
-    // doubles as the delta payload — no second serialization to drift.
-    let rec: String = engram_get_node_json(id)
-    if str_eq(rec, "") || str_eq(rec, "{}") {
-        println("[persist] wt_node: local write did not read back, id=" + id + " label=" + label)
-        return ""
-    }
-    if wt_enabled() && wt_durable_class(node_type) {
-        wt_stage("[" + rec + "]", "[]")
-    }
-    return id
-}
-
-// wt_edge — create an edge locally AND queue it. Mirrors engram_connect.
-//
-// The edge id is freshly generated rather than read back: the runtime exposes no
-// "id of the edge I just created" accessor, and the owner dedups edges by
-// (from_id,to_id,relation), never by id — so the id is not load-bearing. The
-// consequence, stated plainly: the soul's copy and the owner's copy of the same
-// edge carry different edge ids. Nothing in either codebase looks an edge up by
-// id (neighbors traversal scans from_id/to_id), so this is cosmetic.
-fn wt_edge(from_id: String, to_id: String, weight: Float, relation: String) -> Void {
-    engram_connect(from_id, to_id, weight, relation)
-    if !wt_enabled() { return }
-    if str_eq(from_id, "") || str_eq(to_id, "") { return }
-    let ts: Int = time_now()
-    let rec: String = "{\"id\":\"" + uuid_v4() + "\""
-        + ",\"from_id\":\"" + wt_esc(from_id) + "\""
-        + ",\"to_id\":\"" + wt_esc(to_id) + "\""
-        + ",\"relation\":\"" + wt_esc(relation) + "\""
-        + ",\"metadata\":\"{}\""
-        + ",\"weight\":" + float_to_str(weight)
-        + ",\"confidence\":1"
-        + ",\"created_at\":" + int_to_str(ts)
-        + ",\"updated_at\":" + int_to_str(ts)
-        + ",\"last_fired\":0,\"inhibitory\":0,\"layer_id\":1}"
-    wt_stage("[]", "[" + rec + "]")
-}
-
-// ── The drain ─────────────────────────────────────────────────────────────────
-
-// wt_drain — coalesce every staged delta into ONE load-merge against the owner.
-//
-// Returns: nodes_added on success (>= 0), 0 when there was nothing to do, and
-// -1 when the push FAILED. -1 is load-bearing: on failure the spool files are
-// left untouched, so nothing is lost and the next drain retries them. A caller
-// must never read a non-negative return as "my particular node is durable" —
-// use wt_durable(id) for that.
-//
-// Concurrency: several threads may drain at once. Each builds its own batch file
-// (uuid-named), and overlapping batches are harmless because load-merge dedups.
-// Files are truncated ONLY after a confirmed ok:true, so a lost race costs a
-// redundant push, never a dropped write.
-fn wt_drain() -> Int {
-    if !wt_enabled() { return 0 }
-    let dir: String = wt_spool_dir()
-    if str_eq(dir, "") { return 0 }
-
-    // el_list_len/el_list_get, NOT json_stringify(fs_list(...)): fs_list builds
-    // a native list via el_list_append, and json_stringify does not serialize
-    // that type — it renders the raw pointer value. (Verified in isolation; the
-    // same latent defect is live in studio.el's /api/tools/file/list route,
-    // which returns e.g. {"entries":4386409744}. Noted, not fixed here.)
-    let listing = fs_list(dir)
-    let count: Int = el_list_len(listing)
-    if count == 0 { return 0 }
-
-    let nodes_acc: String = ""
-    let edges_acc: String = ""
-    let drained: String = ""
-    let found: Int = 0
-    let i: Int = 0
-    // No `continue` / `break`: elc lists them as keywords but not one line of
-    // the shipped soul uses either, so they are unexercised on this build path.
-    // Guard conditions are expressed as nested ifs instead, and every rebind is
-    // at the loop-body top level where `let x = ...` is assignment (the idiom
-    // memory.el's boot-counter loop relies on) — never inside a nested block,
-    // where it would shadow instead.
-    while i < count {
-        let name: String = el_list_get(listing, i)
-        // A delta is only usable when it ends with the closing "]}" that
-        // wt_stage writes last. fs_write is not atomic, so a file being written
-        // right now can be observed half-formed; requiring the terminator means
-        // it is picked up whole on the next drain instead of merged as garbage.
-        // An empty read means "already drained and truncated" — not an error.
-        let p: String = if str_starts_with(name, "wt-") { dir + "/" + name } else { "" }
-        let raw: String = if str_eq(p, "") { "" } else { wt_read(p) }
-        let usable: Bool = !str_eq(raw, "") && str_ends_with(raw, "]}")
-        let nj: String = if usable { wt_inner(json_get_raw(raw, "nodes")) } else { "" }
-        let ej: String = if usable { wt_inner(json_get_raw(raw, "edges")) } else { "" }
-        let nodes_acc = if str_eq(nj, "") { nodes_acc } else if str_eq(nodes_acc, "") { nj } else { nodes_acc + "," + nj }
-        let edges_acc = if str_eq(ej, "") { edges_acc } else if str_eq(edges_acc, "") { ej } else { edges_acc + "," + ej }
-        let drained = if !usable { drained } else if str_eq(drained, "") { p } else { drained + "\n" + p }
-        let found = if usable { found + 1 } else { found }
-        let i = i + 1
-    }
-
-    if found == 0 { return 0 }
-
-    let combined: String = "{\"nodes\":[" + nodes_acc + "],\"edges\":[" + edges_acc + "]}"
-    let batch: String = dir + "/wtb-" + uuid_v4() + ".json"
-    fs_write(batch, combined)
-    if str_eq(wt_read(batch), "") {
-        println("[persist] wt_drain: could not write batch file " + batch + " — " + int_to_str(found) + " deltas stay queued")
-        return -1
-    }
-
-    let url: String = wt_engram_url()
-    let key: String = wt_api_key()
-    let body: String = "{\"path\":\"" + wt_esc(batch) + "\",\"_auth\":\"" + wt_esc(key) + "\"}"
-    let resp: String = http_post_json(url + "/api/load-merge", body)
-
-    // The batch file is pure scratch — the retry is rebuilt from the SPOOL, not
-    // from it. Truncate it unconditionally, before branching on the outcome, so
-    // a persistently unreachable owner cannot accumulate one husk per attempt.
-    fs_write(batch, "")
-
-    // Distinguish the two failures rather than collapsing them: "cannot reach
-    // the owner" and "the owner refused this delta" need different human
-    // responses, and a log line that says the wrong one costs a debugging hour.
-    // curl surfaces transport errors as a JSON body, so an empty response is not
-    // the only unreachable signal.
-    // (str_contains rather than a strict parse on purpose — the engram's HTTP
-    //  responses have been observed carrying trailing bytes past the JSON.)
-    let unreachable: Bool = str_eq(resp, "")
-        || str_contains(resp, "Couldn't connect")
-        || str_contains(resp, "Failed to connect")
-        || str_contains(resp, "Could not resolve")
-        || str_contains(resp, "timed out")
-    if unreachable {
-        wt_sweep(dir)
-        println("[persist] wt_drain: owner UNREACHABLE at " + url + " — " + int_to_str(found)
-            + " deltas stay queued in " + dir + " (will retry): " + resp)
-        return -1
-    }
-    if !str_contains(resp, "\"ok\":true") {
-        wt_sweep(dir)
-        println("[persist] wt_drain: owner REJECTED the delta — " + int_to_str(found)
-            + " stay queued in " + dir + ": " + resp)
-        return -1
-    }
-
-    let added: Int = json_get_int(resp, "nodes_added")
-    let added_e: Int = json_get_int(resp, "edges_added")
-
-    // Confirmed. Truncate the drained spool files so they are not re-pushed.
-    // Truncation (not deletion) because the runtime exposes no unlink builtin;
-    // an emptied file is inert to the loop above. The zero-byte husks are then
-    // swept below.
-    let paths = str_split(drained, "\n")
-    let pn: Int = el_list_len(paths)
-    let k: Int = 0
-    while k < pn {
-        let one: String = el_list_get(paths, k)
-        if !str_eq(one, "") { fs_write(one, "") }
-        let k = k + 1
-    }
-    wt_sweep(dir)
-
-    println("[persist] wt_drain: pushed " + int_to_str(found) + " deltas -> owner added "
-        + int_to_str(added) + " nodes, " + int_to_str(added_e) + " edges")
-    return added
-}
-
-// wt_durable — is this id present AT THE OWNER? The only honest answer to
-// "did my write persist" in HTTP mode.
-//
-// In file mode the soul IS the owner, so the local read-back is the owner-side
-// read-back and this collapses to the pre-existing check.
-//
-// nodes_added from wt_drain is NOT a substitute: a concurrent drain may have
-// already pushed this node, making our own added count 0 while the node is
-// perfectly durable. Presence at the owner is the fact; counts are telemetry.
-fn wt_durable(id: String) -> Bool {
-    if str_eq(id, "") { return false }
-    if !wt_enabled() {
-        let local: String = engram_get_node_json(id)
-        return !str_eq(local, "") && !str_eq(local, "null") && !str_eq(local, "{}")
-    }
-    let url: String = wt_engram_url()
-    let resp: String = http_get(url + "/api/nodes/" + id)
-    if str_eq(resp, "") { return false }
-    if str_eq(resp, "{}") { return false }
-    return str_contains(resp, "\"id\"")
-}
-
-// wt_commit — flush, then assert at the owner. The receipt callers should use.
-// Deliberately NOT a fixed success shape: it can and does return false while the
-// local write is perfectly fine in RAM, which is the true state of affairs when
-// the owner is unreachable.
-fn wt_commit(id: String) -> Bool {
-    if str_eq(id, "") { return false }
-    if !wt_enabled() {
-        let local: String = engram_get_node_json(id)
-        return !str_eq(local, "") && !str_eq(local, "null") && !str_eq(local, "{}")
-    }
-    let pushed: Int = wt_drain()
-    return wt_durable(id)
-}

routes.el

@@ -186,7 +186,7 @@ fn route_imprint_contextual(body: String) -> String {
         return "{\"ok\":false,\"error\":\"empty body\"}"
     }
     let tags: String = "[\"imprint\",\"contextual\"]"
-    let id: String = wt_node(
+    let id: String = engram_node_full(
         body,
         "Entity",
         "imprint:contextual",
@@ -208,7 +208,7 @@ fn route_imprint_user(body: String) -> String {
         return "{\"ok\":false,\"error\":\"empty body\"}"
     }
     let tags: String = "[\"imprint\",\"user\"]"
-    let id: String = wt_node(
+    let id: String = engram_node_full(
         body,
         "Entity",
         "imprint:user",
@@ -239,7 +239,7 @@ fn route_synthesize(body: String) -> String {
     }
     let req: String = "synthesize " + parent_a + " " + parent_b
     let tags: String = "[\"soul-inbox-pending\",\"synthesis-request\"]"
-    wt_node(
+    engram_node_full(
         req,
         "Entity",
         "synthesis-request",
@@ -395,28 +395,7 @@ fn handle_connectors(method: String, clean: String, body: String) -> String {
     return "{\"ok\":false,\"error\":\"unknown connectors route\"}"
 }
 
-// handle_request — the soul's HTTP entry point.
-//
-// NOTE ON THE NAME (neuron#117): the el runtime resolves this handler by NAME
-// via dlsym(RTLD_DEFAULT, "handle_request") — that is why the Linux build must
-// link -rdynamic. So the dispatcher body moved to route_dispatch and the name
-// `handle_request` stays put as a thin wrapper. Do not rename it back.
-//
-// The wrapper exists to give the write-through boundary a guaranteed flush
-// point. route_dispatch returns from ~60 places; a per-branch flush would be
-// forgotten on the 61st. Draining here means EVERY request that staged a write
-// pushes it before the connection closes, whatever route produced it, including
-// routes added later that know nothing about persistence.
-//
-// wt_drain is a no-op (no HTTP, no cost) when nothing is staged and when the
-// soul is not in HTTP-engram mode, so this is free on read traffic.
 fn handle_request(method: String, path: String, body: String) -> String {
-    let resp: String = route_dispatch(method, path, body)
-    let flushed: Int = wt_drain()
-    return resp
-}
-
-fn route_dispatch(method: String, path: String, body: String) -> String {
     let clean: String = strip_query(path)
 
     // ACTIVITY STAMP (2026-07-30 self-review): every inbound HTTP request —
@@ -453,27 +432,10 @@ fn route_dispatch(method: String, path: String, body: String) -> String {
             return engram_scan_nodes_json(9999, 0)
         }
         if str_eq(clean, "/api/graph/edges") {
-            // FIXED (neuron#117): this GET used to engram_save() straight over
-            // ~/.neuron/engram/snapshot.json — a READ route, in a process that is
-            // NOT the persistence owner, overwriting the owner's canonical file
-            // on every call. It broke soul.el:571-573 ("the soul must NEVER write
-            // to the local snapshot") and it is the same defect class Will removed
-            // from the engram itself in el `dc39a61` ("stop read routes clobbering
-            // canonical snapshot"), where route_scan_edges/route_sync were moved
-            // to scratch paths for exactly this reason. It was also the race the
-            // old TODO(reliability #8) admitted to.
-            //
-            // Export to a scratch path instead. Same response, no canonical write.
-            // The soul's own snapshot writes are otherwise already gated behind
-            // state key "soul_snapshot_path", which is set ONLY in the genesis
-            // file-mode branch (soul.el: is_genesis && safe_to_seed, and
-            // safe_to_seed is unconditionally false when ENGRAM_URL is set) — so
-            // after this change the soul writes nothing at all in HTTP mode.
-            // Future: add an engram_edges_json() builtin and drop the file round
-            // trip entirely.
-            let scratch_dir: String = env("TMPDIR")
-            let scratch_base: String = if str_eq(scratch_dir, "") { "/tmp" } else { scratch_dir }
-            let snap_path: String = scratch_base + "/soul-edges-export-" + state_get("soul_cgi_id") + ".json"
+            // TODO(reliability #8): engram_save races with awareness loop mem_save().
+            // Both now use atomic write-to-temp+rename (el_runtime.c). Serialised
+            // by engram_global_mu. Future: add engram_edges_json() builtin.
+            let snap_path: String = env("HOME") + "/.neuron/engram/snapshot.json"
             engram_save(snap_path)
             let snap: String = fs_read(snap_path)
             let edges_raw: String = json_get_raw(snap, "edges")

safety.el

@@ -204,7 +204,7 @@ fn safety_log_bell(level: String, reason: String, input_summary: String) -> Stri
     // Emit a fallback println so the bell event leaves at least a log trace even
     // when engram is degraded. This does not replace engram persistence -- it is a
     // last-resort audit trail when the primary write cannot be confirmed.
-    let node_id: String = wt_node(
+    let node_id: String = engram_node_full(
         content,
         "BellEvent",
         "bell:" + level,

sessions.el

@@ -87,7 +87,7 @@ fn session_create(body: String) -> String {
     let folder: String = json_get(body, "folder")
     let content: String = session_make_content(id, title, ts, ts, folder)
     let tags: String = "[\"session\",\"session:meta\",\"Conversation\"]"
-    let node_id: String = wt_node(
+    let node_id: String = engram_node_full(
         content, "Conversation", "session:meta",
         el_from_float(0.7), el_from_float(0.7), el_from_float(0.9),
         "Episodic", tags
@@ -358,7 +358,7 @@ fn session_update_patch(session_id: String, body: String) -> String {
     let created_int: Int = str_to_int(old_created)
     let new_content: String = session_make_content(session_id, eff_title, created_int, ts, eff_folder)
     let tags: String = "[\"session\",\"session:meta\",\"Conversation\"]"
-    let new_node_id: String = wt_node(
+    let new_node_id: String = engram_node_full(
         new_content, "Conversation", "session:meta",
         el_from_float(0.7), el_from_float(0.7), el_from_float(0.9),
         "Episodic", tags
@@ -456,7 +456,7 @@ fn session_hist_save(session_id: String, hist: String) -> Void {
     // TODO(reliability #7): delete-then-insert is not atomic — concurrent saves for the
     // same session can produce orphan history nodes. State is primary truth; engram fallback.
     let tags: String = "[\"session\",\"session-history\",\"Conversation\"]"
-    let discard: String = wt_node(
+    let discard: String = engram_node_full(
         hist, "Conversation", "session:messages:" + session_id,
         el_from_float(0.6), el_from_float(0.6), el_from_float(0.9),
         "Episodic", tags
@@ -488,7 +488,7 @@ fn session_hist_save(session_id: String, hist: String) -> Void {
                 + " | ts:" + int_to_str(ts_now)
             let summary_tags: String = "[\"session-emotional-summary\",\"affective\",\"bell:" + eff_level + "\",\"BellEvent\"]"
             let summary_sal: String = if str_eq(eff_level, "hard") { el_from_float(0.95) } else { el_from_float(0.85) }
-            let sum_discard: String = wt_node(
+            let sum_discard: String = engram_node_full(
                 summary_content,
                 "BellEvent",
                 "session:emotional-summary",
@@ -529,7 +529,7 @@ fn session_hist_save(session_id: String, hist: String) -> Void {
             if !str_eq(ot_id, "") { engram_forget(ot_id) }
             let oti = oti + 1
         }
-        let discard_topic: String = wt_node(
+        let discard_topic: String = engram_node_full(
             topic_content, "Conversation", topic_label,
             el_from_float(0.7), el_from_float(0.7), el_from_float(0.9),
             "Episodic", topic_tags
@@ -582,7 +582,7 @@ fn session_update_meta_timestamp(session_id: String) -> Void {
     let created_int: Int = str_to_int(old_created)
     let new_content: String = session_make_content(session_id, old_title, created_int, ts, old_folder)
     let tags: String = "[\"session\",\"session:meta\",\"Conversation\"]"
-    let new_id: String = wt_node(
+    let new_id: String = engram_node_full(
         new_content, "Conversation", "session:meta",
         el_from_float(0.7), el_from_float(0.7), el_from_float(0.9),
         "Episodic", tags
@@ -629,7 +629,7 @@ fn session_auto_title(session_id: String, first_message: String) -> Void {
     let created_int: Int = str_to_int(old_created)
     let new_content: String = session_make_content(session_id, new_title, created_int, ts, old_folder)
     let tags: String = "[\"session\",\"session:meta\",\"Conversation\"]"
-    let new_id: String = wt_node(
+    let new_id: String = engram_node_full(
         new_content, "Conversation", "session:meta",
         el_from_float(0.7), el_from_float(0.7), el_from_float(0.9),
         "Episodic", tags

soul.el

@@ -657,23 +657,6 @@ if is_genesis && safe_to_seed {
     }
 }
 
-// CRASH RECOVERY (neuron#117). Deltas the previous process staged but could not
-// hand to the owner are still on disk — the spool is a filesystem queue, not a
-// memory buffer, precisely so that a soul that died mid-flight does not take its
-// unpushed writes with it. Drain them before serving, so recovered memories are
-// durable and recallable from the owner from the first request onward.
-//
-// Safe on a clean boot: an empty spool means no HTTP call at all. Safe in file
-// mode: wt_drain returns immediately when ENGRAM_URL is unset.
-let wt_recovered: Int = wt_drain()
-if wt_recovered > 0 {
-    println("[soul] write-through: recovered " + int_to_str(wt_recovered)
-        + " nodes from a previous process's spool -> persistence owner")
-}
-if wt_recovered < 0 {
-    println("[soul] write-through: spool present but the persistence owner is unreachable — queued, will retry on heartbeat")
-}
-
 println("[soul] serving on port " + int_to_str(port))
 http_serve_async(port, "handle_request")
 println("[soul] awareness loop starting")

stewardship.el

@@ -11,7 +11,7 @@ import "memory.el"
 fn steward_log_event(kind: String, detail: String) -> Void {
     let content: String = "STEWARD:" + kind + " | " + detail
     let tags: String = "[\"stewardship\",\"steward:" + kind + "\"]"
-    let discard: String = wt_node(
+    let discard: String = engram_node_full(
         content,
         "StewardshipEvent",
         "steward:" + kind,
@@ -221,7 +221,7 @@ fn steward_fingerprint_session(input: String, session_id: String) -> String {
         + " formality=" + fs_str
         + " time=" + tb_str
     let sample_tags: String = "[\"behavior\",\"BehaviorSample\",\"stewardship\"]"
-    let discard: String = wt_node(
+    let discard: String = engram_node_full(
         sample_content,
         "BehaviorSample",
         "behavior:" + session_id,