chore(engine): regenerate dist/soul.c from merged main — the build input was 4 days behind the source

Merging #109, #114, #115, #127 and #130 landed the SOURCE on main. It did not
change what the build actually compiles. CI compiles the committed
dist/soul.c, and that file was last regenerated 2026-08-03 (e610a41). Measured
against origin/main before this commit:

  conv_hist_key          0     (the per-session history key — #129's fix)
  agentic_safety_screen  0     (the crisis-escalation fix itself)
  plain_chat_envelope    0     (#109)
  size                   1,147,662 bytes

So a CI or GKE build off main today would have shipped an engine with none of
the five merged fixes in it, including the P0 safety fix, while main's source
read as correct. That gap is the whole of issue #111.

After regeneration from merged main:

  conv_hist_key          9
  agentic_safety_screen  3
  plain_chat_envelope    5
  size                   1,164,103 bytes, 1226 inlined bodies (gate wants >= 1200)

Compiles clean: 903,096 bytes, 13 warnings, 0 errors. Boots on a throwaway
port with a throwaway HOME and answers /health — RUNS, not just BUILT.
Production on :7770 was never touched; no live store was read or written.

Recipe: gen-soul-amalgam.sh (elc --target=c in a scratch tree with the .elh
headers removed, which is what forces full inlining) then cc-brain.sh.

TWO THINGS THIS DOES NOT FIX, both worth their own work:

1. Nothing in the tree regenerates this file. It is only ever updated by a
   human running the recipe and committing, and history shows it lags in
   batches, never per-change. It will drift again. neuron-ui#209 tracks the
   automation and is the actual fix.

2. The shipped round-9.1 brain still matches no committed source: it was built
   from fix/liveness-engine-91 with a regenerated amalgam that was deliberately
   not committed (8b06bbe). Strings present in that binary — plain_chat_envelope,
   __working__, max_tokens":16384 — were absent from every committed state.
   This commit makes main reproducible going forward; it does not make the
   already-shipped artifact reproducible retroactively.

Refs #111

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,11 +422,11 @@ 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}"
 }
 
@@ -507,7 +498,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 +513,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 +535,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 +562,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 +647,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 +694,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 +727,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 +789,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 +809,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 +833,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 +868,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,