fix(api): bound inspect_graph with relevance-ranked projection; regen soul.c

High-fanout identity anchors (voice, writing-imprint, self-root) have ~670KB
neighborhoods. inspect_graph returned the full traversal, which overflowed the
MCP client's context and socket-closed the wrapper mid self-load -- the soul
could not traverse its own identity graph.

handle_api_inspect_graph gains an opt-in `compact` projection (compact=1|true):
the neighborhood is relevance-ranked, the top K (default 12) keep a UTF-8-safe
content snippet (default snip=600), and the remainder collapse to lightweight
{id,label,node_type,tier,edge,pointer:true} stubs. This bounds the voice node
from 669,799B -> 25,353B (HTTP 200, valid JSON) and the wrapper's soul-load no
longer socket-closes. New helpers: api_compact_neighbors, api_neigh_full,
api_neigh_pointer, api_neigh_rank, api_neigh_better, api_float_or.

The flag is gated: ABSENT it, the response is byte-identical to the old plain
traversal, so the studio app (which never sends it) is unaffected. The MCP
wrapper (mcp-wrapper/src/main.el) appends &compact=1 on its inspectGraph and
fetch-by-id paths.

dist/soul.c is REGENERATED so CI ships the fix: CI compiles the committed
single-TU dist/soul.c directly (running elb/elc on the Linux runner OOM-kills
it), so an .el-only change would build the OLD behavior. Regenerated and verified
on macOS -- compiles with the CI cc line (0 errors) and, on a throwaway soul over
a copy of the live snapshot, serves compact ~25KB / non-compact ~670KB. The regen
also syncs the amalgamation to this branch's .el sources, which had drifted
several self-review commits ahead of the previously-committed soul.c.

Docs: docs/architecture/00-05 added; 01/02/05 corrected so the relevance-ranked
inspect_graph projection reads as committed source, not an in-flight concern.

awareness.el

@@ -30,6 +30,74 @@ fn idle_reset() -> Void {
 // read decide where telemetry goes. The in-process write remains only as a
 // last resort when the HTTP POST itself fails, and is tagged ise-fallback-local
 // so misrouting is visible in the stream instead of silent.
+// hebb_consolidate — push self-formed associations to the durable store.
+//
+// WHY THIS EXISTS (2026-08-07 self-review, measured on the live system).
+// Yesterday's eligibility-trace fix made Hebbian learning work: hebb_max
+// 0.000799 -> 0.4725, and 1,198 hebbian-associate edges formed in 23h48m.
+// A census this morning found all 1,198 of them living in this process's RAM
+// and nowhere else:
+//
+//   soul daemon in-process graph:   42,426 edges, 1,198 hebbian
+//   engram server (:8742, durable): 41,213 edges,    49 hebbian
+//
+// The soul pulls from the server every 10 min (GET /api/sync) and never
+// pushes. It also cannot save its own snapshot: soul.el only sets
+// soul_snapshot_path inside `if is_genesis && safe_to_seed`, and safe_to_seed
+// is unconditionally false when ENGRAM_URL is set — which it is, in the
+// launchd plist — because the HTTP server owns persistence and a soul writing
+// snapshot.json would clobber it. That guard is right. So mem_save() below has
+// literally never run, and this daemon (the ONLY process doing idle cognition,
+// therefore where essentially all co-activation happens) was throwing away
+// every association it learned, every restart, silently.
+//
+// The fix is not to let the soul write the file. It is to make consolidation a
+// message: hand each newly-formed edge to the durable store over the API the
+// server already exposes. Fast volatile store learns online; slow durable store
+// keeps what cleared the threshold. Only edges past ENGRAM_HEBB_LINK_MIN are
+// ever queued, so what crosses the boundary already earned it.
+//
+// Failure is non-fatal by construction: a drained entry that fails to POST is
+// gone, and that is fine — a real association re-forms from live co-activation.
+// The counts go into the heartbeat (hebb_wb_*) so a consolidation path that has
+// stopped delivering is visible in the stream rather than in a later autopsy.
+fn hebb_consolidate() -> Int {
+    let batch: String = engram_hebb_drain_json(64)
+    if str_eq(batch, "") { return 0 }
+    if str_eq(batch, "[]") { return 0 }
+    let n: Int = json_array_len(batch)
+    if n == 0 { return 0 }
+    let url_env: String = env("SOUL_ISE_URL")
+    let url_state: String = if str_eq(url_env, "") { state_get("soul_engram_url") } else { url_env }
+    let engram_url: String = if str_eq(url_state, "") { "http://localhost:8742" } else { url_state }
+    // ONE request for the whole batch, not one per edge. The server's
+    // persist_canonical() writes the full 60MB snapshot on every durable
+    // write, so per-edge POSTs would cost ~840MB of disk per heartbeat to
+    // persist ~14 associations. /api/edges/batch connects them all and
+    // snapshots once. The drain payload is already the right shape; it only
+    // needs an envelope: the drain already emits the relation per entry.
+    //
+    // _auth is REQUIRED and its absence is silent. check_auth_ok() in server.el
+    // exempts GET and /api/neuron/state-events (which is why ise_post works
+    // without a key) but gates every other mutation on "_auth" in the BODY —
+    // http_serve does not surface request headers, so there is no Bearer path.
+    // A batch posted without it comes back {"error":"unauthorized"}, which is a
+    // non-empty response: the naive `if resp == "" return 0` check would read
+    // that as success and report edges delivered that were in fact refused,
+    // after the drain had already destroyed them. Hence both the key and the
+    // accepted-count check below. Fall back to env when the state key is empty
+    // — never let a corruptible state read decide whether learning persists.
+    let key_state: String = state_get("soul_engram_api_key")
+    let api_key: String = if str_eq(key_state, "") { env("ENGRAM_API_KEY") } else { key_state }
+    let auth_part: String = if str_eq(api_key, "") { "" } else { ",\"_auth\":\"" + api_key + "\"" }
+    let body: String = "{\"edges\":" + batch + auth_part + "}"
+    let resp: String = http_post_json(engram_url + "/api/edges/batch", body)
+    if str_eq(resp, "") { return 0 }
+    let acc: String = json_get(resp, "accepted")
+    if str_eq(acc, "") { return 0 }
+    return str_to_int(acc)
+}
+
 fn ise_post(content: String) -> Void {
     let ise_url: String = env("SOUL_ISE_URL")
     let state_url: String = if str_eq(ise_url, "") { state_get("soul_engram_url") } else { ise_url }
@@ -54,6 +122,21 @@ fn ise_post(content: String) -> Void {
         let fail_raw: String = state_get("soul.ise_fail_count")
         let fail_n: Int = if str_eq(fail_raw, "") { 0 } else { str_to_int(fail_raw) }
         state_set("soul.ise_fail_count", int_to_str(fail_n + 1))
+        // el_from_float on a LITERAL is correct and is NOT the double-wrap bug
+        // (checked and dismissed 2026-08-02 self-review — recording the result
+        // so this call site is not "fixed" again by the next reader).
+        // The compiler treats el_from_float as the boxing intrinsic: both
+        // `el_from_float(0.3)` and a bare `0.3` emit exactly one
+        // el_from_float(0.3) in dist/awareness.c. Verified byte-identical
+        // codegen either way.
+        // The real bug fixed in server.el on 2026-08-01 was different: there
+        // the arguments came from json_get_float(), i.e. values ALREADY boxed
+        // as el_val_t. Wrapping THOSE a second time reinterprets the boxed
+        // bits as a raw double, fails engram_decode_score's range check, and
+        // silently clamps to defaults.
+        // The sweep criterion is therefore "el_from_float applied to an
+        // already-boxed expression", never "el_from_float applied to a
+        // literal". Grepping for the call name alone produces false positives.
         let discard: String = engram_node_full(
             content, "InternalStateEvent", "state-event",
             el_from_float(0.3), el_from_float(0.3), el_from_float(0.8),
@@ -299,8 +382,89 @@ fn emit_heartbeat() -> Void {
     // here so the stuck-term failure is visible in the heartbeat stream too.
     let hb_ats_raw: String = state_get("soul.auto_term_streak")
     let hb_ats: Int = if str_eq(hb_ats_raw, "") { 0 } else { str_to_int(hb_ats_raw) }
+    // auto_term_empty_streak (2026-08-06): consecutive scans producing NO auto
+    // term. Split out because str_eq("","") made the two failures indist-
+    // inguishable — see the comment at the streak computation in
+    // proactive_curiosity. Nonzero and climbing = extractor broken, not stuck.
+    let hb_ate_raw: String = state_get("soul.auto_term_empty_streak")
+    let hb_ate: Int = if str_eq(hb_ate_raw, "") { 0 } else { str_to_int(hb_ate_raw) }
+    // Hebbian eligibility gauges (2026-08-06 self-review). The graph learned
+    // ZERO structure in its first 23h of uptime: hebb_max 0.000799 against a
+    // 0.15 consolidation threshold, hebbian-associate edges 0, and the
+    // awareness loop calls engram_connect nowhere — so Hebbian consolidation
+    // is the only self-structuring path there is, and it was inert.
+    //   hebb_warm — nodes with a live eligibility trace but NOT co-resident in
+    //               WM: exactly the population the old simultaneity rule threw
+    //               away. 0 forever ⇒ traces never arm and this bought nothing.
+    //   hebb_max  — strongest single association. The number that has to move.
+    //   hebb_links— consolidated edges. The outcome that has to become nonzero.
+    let hebb_warm_raw: String = json_get(act_stats, "hebb_warm")
+    let hebb_warm: String = if str_eq(hebb_warm_raw, "") { "-1" } else { hebb_warm_raw }
+    let hebb_max_raw: String = json_get(act_stats, "hebb_max")
+    let hebb_max: String = if str_eq(hebb_max_raw, "") { "-1" } else { hebb_max_raw }
+    let hebb_links_raw: String = json_get(act_stats, "hebb_links")
+    let hebb_links: String = if str_eq(hebb_links_raw, "") { "-1" } else { hebb_links_raw }
+    // Candidate-table gauges (2026-08-10 self-review). el_runtime.c COMPUTES
+    // hebb_cands/hebb_cand_max/hebb_mass/hebb_edges and emits them from
+    // engram_metrics_json — and this function dropped all four on the floor.
+    // Nineteen keys crossed the C boundary; fourteen reached the ISE stream.
+    // The two that mattered most are exactly the pair the runtime added to
+    // answer the question the 08-06 review had to instrument for:
+    //   hebb_cands    — associations currently being tracked toward
+    //                   consolidation. 0 ⇒ nothing co-activates at all.
+    //   hebb_cand_max — how close the leading candidate is to
+    //                   ENGRAM_HEBB_LINK_MIN (0.15). Sustained just-below ⇒
+    //                   the THRESHOLD is the bottleneck, not the event rate.
+    // Without both, "hebb_links stopped climbing" is undiagnosable from the
+    // durable record: nothing-co-activates and threshold-too-high look
+    // identical. An instrument that is computed but not plumbed to durable
+    // storage is not an instrument — it is a local variable.
+    //   hebb_mass     — Σ hebb across edges; the runaway detector against the
+    //                   ENGRAM_HEBB_NODE_BUDGET homeostatic cap.
+    //   hebb_edges    — total potentiated edges (hebb > MIN), the denominator
+    //                   hebb_max is the max of.
+    let hebb_cands_raw: String = json_get(act_stats, "hebb_cands")
+    let hebb_cands: String = if str_eq(hebb_cands_raw, "") { "-1" } else { hebb_cands_raw }
+    let hebb_cmax_raw: String = json_get(act_stats, "hebb_cand_max")
+    let hebb_cmax: String = if str_eq(hebb_cmax_raw, "") { "-1" } else { hebb_cmax_raw }
+    let hebb_mass_raw: String = json_get(act_stats, "hebb_mass")
+    let hebb_mass: String = if str_eq(hebb_mass_raw, "") { "-1" } else { hebb_mass_raw }
+    let hebb_edges_raw: String = json_get(act_stats, "hebb_edges")
+    let hebb_edges: String = if str_eq(hebb_edges_raw, "") { "-1" } else { hebb_edges_raw }
+    // Consolidation write-back gauges (2026-08-07 self-review). hebb_links
+    // counts what this process LEARNED; these three count what SURVIVES it.
+    // The distinction is the whole finding: 1,198 links formed, 0 persisted,
+    // because the learner is not the persistence owner (see hebb_consolidate).
+    //   wb_pending — queued, not yet handed over. Climbing ⇒ writer is down.
+    //   wb_drained — cumulative popped for delivery. Flat while hebb_links
+    //                climbs ⇒ the drain is not being called at all.
+    //   wb_dropped — lost to a full queue. Must stay 0; nonzero means the
+    //                durable store has been unreachable long enough to matter.
+    //   wb_sent    — POSTs the durable store actually accepted this beat.
+    let wb_pend_raw: String = json_get(act_stats, "hebb_wb_pending")
+    let wb_pend: String = if str_eq(wb_pend_raw, "") { "-1" } else { wb_pend_raw }
+    let wb_drain_raw: String = json_get(act_stats, "hebb_wb_drained")
+    let wb_drain: String = if str_eq(wb_drain_raw, "") { "-1" } else { wb_drain_raw }
+    let wb_drop_raw: String = json_get(act_stats, "hebb_wb_dropped")
+    let wb_drop: String = if str_eq(wb_drop_raw, "") { "-1" } else { wb_drop_raw }
+    let wb_sent_raw: String = state_get("soul.hebb_wb_sent")
+    let wb_sent: String = if str_eq(wb_sent_raw, "") { "0" } else { wb_sent_raw }
+    // dup_wm_global (2026-08-06): redundant WM residents that arrived via the
+    // carry-over path, which Pass 3½ structurally could not see. Confirmed live
+    // by a census that caught two byte-identical copies of one 3,193-char
+    // document both holding slots.
+    let dup_wm_g_raw: String = json_get(act_stats, "dup_wm_global")
+    let dup_wm_g: String = if str_eq(dup_wm_g_raw, "") { "-1" } else { dup_wm_g_raw }
     let act_brk_raw: String = json_get(act_stats, "embed_breaker_open")
     let act_brk: String = if str_eq(act_brk_raw, "") { "-1" } else { act_brk_raw }
+    // embed_consec_fail (2026-08-10 self-review): also computed by the C side
+    // and also dropped here. embed_breaker_open is the LAGGING indicator — it
+    // only goes 1 after ENGRAM_EMBED_BREAKER_LIMIT consecutive failures, by
+    // which point semantic activation has already degraded to pure lexical
+    // for the whole cooldown. consec_fail is the leading edge of the same
+    // event and costs nothing to carry.
+    let emb_cf_raw: String = json_get(act_stats, "embed_consec_fail")
+    let emb_cf: String = if str_eq(emb_cf_raw, "") { "-1" } else { emb_cf_raw }
     // ctx_cos (2026-07-29 self-review): cos(query, context centroid) at the
     // last activate call — the drift gauge for the new context-centroid
     // scoring. ~1.0 aligned; low at domain-rotation boundaries is healthy;
@@ -308,7 +472,79 @@ fn emit_heartbeat() -> Void {
     // down) and semantic continuity is silently absent.
     let ctx_cos_raw: String = json_get(act_stats, "ctx_cos")
     let ctx_cos: String = if str_eq(ctx_cos_raw, "") { "-2" } else { ctx_cos_raw }
-    let payload: String = "{\"event\":\"heartbeat\",\"pulse\":" + pulse + ",\"tick\":" + pulse + ",\"boot\":" + boot + ",\"idle\":" + idle + ",\"idle_ms\":" + int_to_str(idle_ms) + ",\"node_count\":" + int_to_str(nc) + ",\"edge_count\":" + int_to_str(ec) + ",\"node_delta\":" + int_to_str(node_delta) + ",\"edge_delta\":" + int_to_str(edge_delta) + ",\"wm_active\":" + int_to_str(wmc) + ",\"wm_delta\":" + int_to_str(wm_delta) + ",\"wm_saturated\":" + int_to_str(wm_sat) + ",\"wm_top0_streak\":" + int_to_str(t0streak) + ",\"wm_churn\":" + int_to_str(wm_churn) + ",\"wm_top0_wm\":" + wm_top0_wm + ",\"sync_added_total\":" + sat_str + ",\"sync_age_ms\":" + int_to_str(sync_age) + ",\"wm_avg_weight\":" + wm_avg_str + ",\"wm_top\":" + wm_top + ",\"ts\":" + int_to_str(ts) + ",\"uptime_ms\":" + int_to_str(up_ms) + ",\"uptime\":\"" + up_human + "\",\"embed_ok\":" + int_to_str(emb_ok) + ",\"embed_backfilled\":" + bf_done + ",\"embed_count\":" + bf_total + ",\"embed_eligible\":" + embed_elig + ",\"wm_evicted\":" + act_evict + ",\"wm_evicted_delta\":" + int_to_str(evict_delta) + ",\"breakthroughs\":" + act_bt + ",\"breakthroughs_delta\":" + int_to_str(bt_delta) + ",\"auto_term_streak\":" + int_to_str(hb_ats) + ",\"embed_breaker_open\":" + act_brk + ",\"ctx_cos\":" + ctx_cos + ",\"ise_fail\":" + fail_str + "}"
+    // Redundancy suppression gauges (2026-08-05 self-review). A content-hash
+    // census found 1,858 redundant copies — 44.9% of the non-ISE graph, from a
+    // June id-scheme migration. They embed identically, so they were taking
+    // 40.2% of semantic seed slots (measured: 4.78 distinct seeds of 8).
+    //   dup_seeds — redundant copies denied a seed slot, cumulative. A healthy
+    //               nonzero rate means the suppressor is doing real work; a
+    //               sustained drop toward 0 means the duplicates were finally
+    //               merged out of the graph (the repair this defends against).
+    //   dup_wm    — duplicate WM candidates evicted before the capacity cap.
+    // Cumulative like wm_evicted/breakthroughs; diff across heartbeats for rate.
+    let dup_seeds_raw: String = json_get(act_stats, "dup_seeds")
+    let dup_seeds: String = if str_eq(dup_seeds_raw, "") { "-1" } else { dup_seeds_raw }
+    let dup_wm_raw: String = json_get(act_stats, "dup_wm")
+    let dup_wm: String = if str_eq(dup_wm_raw, "") { "-1" } else { dup_wm_raw }
+    // txt_damaged (2026-08-08 self-review): nodes created THIS process whose
+    // content carries the character-loss signature (see eg_text_loss_signature
+    // in el_runtime.c). Today's review found the JSON parser had been replacing
+    // every \uXXXX escape with a literal '?' for at least two months — 76% of
+    // non-telemetry nodes damaged, including the self root and every values
+    // node — and nothing caught it, because every gauge here reported whether
+    // the machinery was RUNNING and none reported whether the text it carried
+    // was INTACT. The parser is fixed; this is the standing regression signal.
+    // Healthy state is a flat 0. Any climb means a write path is mangling text
+    // again. The full store census is GET /api/text-health (too expensive for
+    // a 60s beat); this is the cheap flow counter that belongs on every beat.
+    let txt_dmg_raw: String = json_get(act_stats, "txt_damaged")
+    let txt_dmg: String = if str_eq(txt_dmg_raw, "") { "-1" } else { txt_dmg_raw }
+    // ── Corpus damage STOCK, not just flow (2026-08-10 self-review) ────────
+    // txt_damaged above is a FLOW gauge: nodes damaged by a write in THIS
+    // process. The 08-08 review fixed the parser, watched that flow fall to
+    // 0, and recorded the defect as closed. It was not closed. Today's census
+    // on the live store: scanned 4100, damaged 2781 — 67.8% of the corpus is
+    // STILL carrying the character loss, including the self root and every
+    // values node ("Value ? Constraints as Freedom"). The parser stopped
+    // producing new damage; nothing ever repaired the old.
+    //
+    // That is the 08-08 lesson recursing one level up. 08-08 said "instrument
+    // the payload, not just the machinery" — and then instrumented the payload
+    // RATE and not the payload STOCK. A flow gauge reads 0 both when the
+    // corpus is clean and when it is uniformly damaged but quiescent. Those
+    // are opposite states and the beat could not tell them apart.
+    //
+    // Cost: GET /api/text-health scans the whole store, too expensive for a
+    // 60s beat (which is why 08-08 left it off). So sample it on a countdown
+    // and CARRY the last reading on every beat, with its age. A stale-but-
+    // present stock number beats an absent one; damaged_age_ms makes the
+    // staleness explicit rather than implied. No modulo/multiply — both
+    // operators are broken in this compiler (see the note at line ~160).
+    let tc_raw: String = state_get("soul.txt_census_countdown")
+    let tc_n: Int = if str_eq(tc_raw, "") { 0 } else { str_to_int(tc_raw) }
+    if tc_n <= 0 {
+        let th_resp: String = http_get(hb_engram_url + "/api/text-health")
+        let th_pct: String = json_get(th_resp, "damaged_pct")
+        if !str_eq(th_pct, "") {
+            state_set("soul.txt_damaged_pct", th_pct)
+            state_set("soul.txt_damaged_n", json_get(th_resp, "damaged"))
+            state_set("soul.txt_scanned_n", json_get(th_resp, "scanned"))
+            state_set("soul.txt_census_ts", int_to_str(ts))
+        }
+        // 30 beats ≈ 30 min at the 60s cadence. Reset even on a failed census
+        // so an unreachable route cannot turn this into a per-beat full scan.
+        state_set("soul.txt_census_countdown", "30")
+    }
+    if tc_n > 0 { state_set("soul.txt_census_countdown", int_to_str(tc_n - 1)) }
+    let dmg_pct_raw: String = state_get("soul.txt_damaged_pct")
+    let dmg_pct: String = if str_eq(dmg_pct_raw, "") { "-1" } else { dmg_pct_raw }
+    let dmg_n_raw: String = state_get("soul.txt_damaged_n")
+    let dmg_n: String = if str_eq(dmg_n_raw, "") { "-1" } else { dmg_n_raw }
+    let dmg_scan_raw: String = state_get("soul.txt_scanned_n")
+    let dmg_scan: String = if str_eq(dmg_scan_raw, "") { "-1" } else { dmg_scan_raw }
+    let dmg_ts_raw: String = state_get("soul.txt_census_ts")
+    let dmg_age: Int = if str_eq(dmg_ts_raw, "") { 0 - 1 } else { ts - str_to_int(dmg_ts_raw) }
+    let payload: String = "{\"event\":\"heartbeat\",\"pulse\":" + pulse + ",\"tick\":" + pulse + ",\"boot\":" + boot + ",\"idle\":" + idle + ",\"idle_ms\":" + int_to_str(idle_ms) + ",\"node_count\":" + int_to_str(nc) + ",\"edge_count\":" + int_to_str(ec) + ",\"node_delta\":" + int_to_str(node_delta) + ",\"edge_delta\":" + int_to_str(edge_delta) + ",\"wm_active\":" + int_to_str(wmc) + ",\"wm_delta\":" + int_to_str(wm_delta) + ",\"wm_saturated\":" + int_to_str(wm_sat) + ",\"wm_top0_streak\":" + int_to_str(t0streak) + ",\"wm_churn\":" + int_to_str(wm_churn) + ",\"wm_top0_wm\":" + wm_top0_wm + ",\"sync_added_total\":" + sat_str + ",\"sync_age_ms\":" + int_to_str(sync_age) + ",\"wm_avg_weight\":" + wm_avg_str + ",\"wm_top\":" + wm_top + ",\"ts\":" + int_to_str(ts) + ",\"uptime_ms\":" + int_to_str(up_ms) + ",\"uptime\":\"" + up_human + "\",\"embed_ok\":" + int_to_str(emb_ok) + ",\"embed_backfilled\":" + bf_done + ",\"embed_count\":" + bf_total + ",\"embed_eligible\":" + embed_elig + ",\"wm_evicted\":" + act_evict + ",\"wm_evicted_delta\":" + int_to_str(evict_delta) + ",\"breakthroughs\":" + act_bt + ",\"breakthroughs_delta\":" + int_to_str(bt_delta) + ",\"auto_term_streak\":" + int_to_str(hb_ats) + ",\"auto_term_empty_streak\":" + int_to_str(hb_ate) + ",\"embed_breaker_open\":" + act_brk + ",\"ctx_cos\":" + ctx_cos + ",\"dup_seeds\":" + dup_seeds + ",\"dup_wm\":" + dup_wm + ",\"dup_wm_global\":" + dup_wm_g + ",\"hebb_warm\":" + hebb_warm + ",\"hebb_max\":" + hebb_max + ",\"hebb_links\":" + hebb_links + ",\"hebb_cands\":" + hebb_cands + ",\"hebb_cand_max\":" + hebb_cmax + ",\"hebb_mass\":" + hebb_mass + ",\"hebb_edges\":" + hebb_edges + ",\"embed_consec_fail\":" + emb_cf + ",\"txt_damaged_pct\":" + dmg_pct + ",\"txt_damaged_n\":" + dmg_n + ",\"txt_scanned_n\":" + dmg_scan + ",\"txt_census_age_ms\":" + int_to_str(dmg_age) + ",\"hebb_wb_pending\":" + wb_pend + ",\"hebb_wb_drained\":" + wb_drain + ",\"hebb_wb_dropped\":" + wb_drop + ",\"hebb_wb_sent\":" + wb_sent + ",\"ise_fail\":" + fail_str + ",\"txt_damaged\":" + txt_dmg + "}"
     ise_post(payload)
 }
 
@@ -400,6 +636,48 @@ fn auto_term_try_slot(slot_type: String, slot_lbl: String) -> Void {
                 // carrying a quote character is not a topic word.
                 if str_contains(term, "\"") { state_set("_ats_gw", "1") }
                 if str_contains(term, "'")  { state_set("_ats_gw", "1") }
+                // TERM-SPECIFICITY GATE (2026-08-03 self-review): the three
+                // guards above are hand-curated lists, and every one of them
+                // was written REACTIVELY — after a flood was already observed
+                // in the ISE stream. A list can only ever contain the floods
+                // that already happened. Two were in flight, unfixed, while
+                // this review ran:
+                //     "<!--" → 252 nodes activated  (markdown comment opener:
+                //              4 chars, no quote, no colon — passes every
+                //              guard above)
+                //     "SELF" → 541 nodes activated  (the stopword list has
+                //              "Self" Title-case; str_eq is case-SENSITIVE,
+                //              so the uppercase token sails through)
+                // Replace reaction with measurement: engram_label_df(term)
+                // counts nodes whose label contains the term. Low-specificity
+                // tokens are corpus-frequent BY DEFINITION, so this catches
+                // the flood class PROSPECTIVELY and tracks the corpus as the
+                // world-ingestor changes what the store is made of.
+                // This is IDF — Spärck Jones (1972) named it "term
+                // specificity"; automatic stopword compilation from it is the
+                // textbook application.
+                //
+                // Threshold node_count/400 (floor 8), measured on this store
+                // (13,370 nodes → 33). Live df separates the classes by an
+                // order of magnitude: <!--:220, SELF:175, Context:53 rejected;
+                // Dual:12, Sparse:8, engram_goal_bias:1, Clin-JEPA:1 pass.
+                //
+                // This does NOT replace the stopword list — verified against
+                // all 86 listed terms, not assumed. It catches 13 (Will:306,
+                // Self:175, Over:116, Knowledge:112 …) and misses 73
+                // (Whose:0, Would:0, Could:0, This:9 …). Labels are terse
+                // titles, so English function words are genuinely RARE in
+                // them: low df, high noise. The gates cover disjoint failure
+                // modes — stopwords catch function words, df catches
+                // corpus-frequent markup/sentinel/genre tokens. Both required.
+                // Nested rather than max(): El `let` is single-assignment, so
+                // the floor is expressed as a second conjunct. Reject iff
+                // df > node_count/400 AND df > 8 — i.e. df > max(that, 8).
+                let df_max: Int = engram_node_count() / 400
+                let df_term: Int = engram_label_df(term)
+                if df_term > df_max {
+                    if df_term > 8 { state_set("_ats_gw", "1") }
+                }
                 // AUTO-TERM TABU (2026-07-25 self-review): finst-style
                 // inhibition-of-return (ACT-R declarative finsts: small
                 // marker pool, hard exclusion). The last 4 selected auto
@@ -549,9 +827,25 @@ fn proactive_curiosity() -> Bool {
     let prev_auto: String = state_get("soul.prev_auto_term")
     let atstreak_raw: String = state_get("soul.auto_term_streak")
     let atstreak_prev: Int = if str_eq(atstreak_raw, "") { 0 } else { str_to_int(atstreak_raw) }
-    let atstreak: Int = if str_eq(auto_term, prev_auto) { atstreak_prev + 1 } else { 1 }
+    // A streak of nothing is not a streak (2026-08-06 self-review).
+    // str_eq("", "") is true, so an auto-term extractor that kept FAILING
+    // reported a rising auto_term_streak — the same signal that means
+    // "fixated on one term" also meant "producing no term at all", which are
+    // opposite failures needing opposite responses. Observed live in the ISE
+    // stream as {"auto_term":"","auto_term_streak":3}. This is the same class
+    // of bug already fixed for wm_top0_streak; auto_term was missed then.
+    // Empty now reads 0, and the empty run is counted on its own axis so the
+    // extractor failing is visible rather than disguised as health.
+    let is_empty: Bool = str_eq(auto_term, "")
+    let atstreak: Int = if is_empty { 0 } else {
+        if str_eq(auto_term, prev_auto) { atstreak_prev + 1 } else { 1 }
+    }
+    let atempty_raw: String = state_get("soul.auto_term_empty_streak")
+    let atempty_prev: Int = if str_eq(atempty_raw, "") { 0 } else { str_to_int(atempty_raw) }
+    let atempty: Int = if is_empty { atempty_prev + 1 } else { 0 }
     state_set("soul.prev_auto_term", auto_term)
     state_set("soul.auto_term_streak", int_to_str(atstreak))
+    state_set("soul.auto_term_empty_streak", int_to_str(atempty))
     if !str_eq(auto_term, "") {
         state_set("soul.tabu_t3", state_get("soul.tabu_t2"))
         state_set("soul.tabu_t2", state_get("soul.tabu_t1"))
@@ -571,6 +865,7 @@ fn proactive_curiosity() -> Bool {
     let ise: String = "{\"event\":\"curiosity_scan\",\"seed\":\"" + curiosity_seed
         + "\",\"auto_term\":\"" + safe_auto
         + "\",\"auto_term_streak\":" + int_to_str(atstreak)
+        + ",\"auto_term_empty_streak\":" + int_to_str(atempty)
         + ",\"minute_block\":" + int_to_str(minute_block)
         + ",\"activated\":" + int_to_str(total_found)
         + ",\"wm_active\":" + int_to_str(wmc)
@@ -857,8 +1152,15 @@ fn awareness_run() -> Void {
             // still leaves no trace — that absence is itself the crash signal.)
             let sd_boot_raw: String = state_get("soul_boot_count")
             let sd_boot: String = if str_eq(sd_boot_raw, "") { "0" } else { sd_boot_raw }
+            // Final consolidation before exit. The periodic drain runs on the
+            // heartbeat (~8 min), so a clean shutdown between beats would take
+            // everything learned since the last one to the grave — the exact
+            // loss this whole path exists to stop, just at a smaller scale.
+            // Best-effort: if the durable store is already down we exit anyway.
+            let sd_wb: Int = hebb_consolidate()
             ise_post("{\"event\":\"shutdown\",\"boot\":" + sd_boot
                 + ",\"pulse\":" + int_to_str(pulse_count())
+                + ",\"hebb_wb_sent\":" + int_to_str(sd_wb)
                 + ",\"uptime_ms\":" + int_to_str(elapsed_ms())
                 + ",\"ts\":" + int_to_str(time_now()) + "}")
             println("[awareness] exiting")
@@ -885,6 +1187,12 @@ fn awareness_run() -> Void {
         let beat_elapsed: Int = now_ts - last_beat_ts
         let should_beat: Bool = beat_elapsed >= beat_ms
         if should_beat {
+            // Consolidate BEFORE the heartbeat so the gauges the heartbeat
+            // reports describe the state this beat actually left behind, not
+            // the state one beat stale. See hebb_consolidate for why a daemon
+            // that learns 1,198 associations a day was keeping none of them.
+            let wb_sent_n: Int = hebb_consolidate()
+            state_set("soul.hebb_wb_sent", int_to_str(wb_sent_n))
             emit_heartbeat()
             state_set("soul.last_beat_ts", int_to_str(now_ts))
             // Persist in-process Engram (sessions, memories, conversation nodes)

chat.elh

@@ -20,6 +20,7 @@ extern fn engram_compile(intent: String) -> String
 extern fn distill_transcript(transcript: String) -> String
 extern fn json_safe(s: String) -> String
 extern fn current_engine_note(model: String) -> String
+extern fn bounded_persona_floor() -> String
 extern fn build_system_prompt(ctx: String, chat_mode: Bool) -> String
 extern fn hist_append(hist: String, role: String, content: String) -> String
 extern fn hist_trim(hist: String) -> String
@@ -28,6 +29,7 @@ extern fn clean_llm_response(s: String) -> String
 extern fn conv_history_persist(hist: String) -> Void
 extern fn conv_history_load() -> String
 extern fn session_preload_bullets(nodes: String, max_bullets: Int, snip_len: Int) -> String
+extern fn affective_context_prefix() -> String
 extern fn handle_chat(body: String) -> String
 extern fn handle_see(body: String) -> String
 extern fn studio_tools_json() -> String
@@ -46,6 +48,10 @@ extern fn call_neuron_mcp(tool_name: String, args: String) -> String
 extern fn agent_workspace_root() -> String
 extern fn path_within_root(path: String, root: String) -> Bool
 extern fn resolve_in_root(path: String, root: String) -> String
+extern fn run_command_is_readonly(cmd: String) -> Bool
+extern fn cmd_abs_escape_at(cmd: String, root: String, needle: String) -> Bool
+extern fn run_command_guard(cmd: String, root: String) -> String
+extern fn classify_tool_risk(tool_name: String, tool_input: String) -> String
 extern fn dispatch_tool(tool_name: String, tool_input: String) -> String
 extern fn is_builtin_tool(tool_name: String) -> Bool
 extern fn next_bridge_id() -> String

dist/awareness.c

@@ -21,6 +21,7 @@ el_val_t mem_emit_state_event(el_val_t trigger, el_val_t kind, el_val_t content)
 el_val_t idle_count(void);
 el_val_t idle_inc(void);
 el_val_t idle_reset(void);
+el_val_t hebb_consolidate(void);
 el_val_t ise_post(el_val_t content);
 el_val_t elapsed_ms(void);
 el_val_t elapsed_human(void);
@@ -65,10 +66,41 @@ el_val_t idle_reset(void) {
   return 0;
 }
 
+el_val_t hebb_consolidate(void) {
+  el_val_t batch = engram_hebb_drain_json(64);
+  if (str_eq(batch, EL_STR(""))) {
+    return 0;
+  }
+  if (str_eq(batch, EL_STR("[]"))) {
+    return 0;
+  }
+  el_val_t n = json_array_len(batch);
+  if (n == 0) {
+    return 0;
+  }
+  el_val_t url_env = env(EL_STR("SOUL_ISE_URL"));
+  el_val_t url_state = ({ el_val_t _if_result_1 = 0; if (str_eq(url_env, EL_STR(""))) { _if_result_1 = (state_get(EL_STR("soul_engram_url"))); } else { _if_result_1 = (url_env); } _if_result_1; });
+  el_val_t engram_url = ({ el_val_t _if_result_2 = 0; if (str_eq(url_state, EL_STR(""))) { _if_result_2 = (EL_STR("http://localhost:8742")); } else { _if_result_2 = (url_state); } _if_result_2; });
+  el_val_t key_state = state_get(EL_STR("soul_engram_api_key"));
+  el_val_t api_key = ({ el_val_t _if_result_3 = 0; if (str_eq(key_state, EL_STR(""))) { _if_result_3 = (env(EL_STR("ENGRAM_API_KEY"))); } else { _if_result_3 = (key_state); } _if_result_3; });
+  el_val_t auth_part = ({ el_val_t _if_result_4 = 0; if (str_eq(api_key, EL_STR(""))) { _if_result_4 = (EL_STR("")); } else { _if_result_4 = (el_str_concat(el_str_concat(EL_STR(",\"_auth\":\""), api_key), EL_STR("\""))); } _if_result_4; });
+  el_val_t body = el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"edges\":"), batch), auth_part), EL_STR("}"));
+  el_val_t resp = http_post_json(el_str_concat(engram_url, EL_STR("/api/edges/batch")), body);
+  if (str_eq(resp, EL_STR(""))) {
+    return 0;
+  }
+  el_val_t acc = json_get(resp, EL_STR("accepted"));
+  if (str_eq(acc, EL_STR(""))) {
+    return 0;
+  }
+  return str_to_int(acc);
+  return 0;
+}
+
 el_val_t ise_post(el_val_t content) {
   el_val_t ise_url = env(EL_STR("SOUL_ISE_URL"));
-  el_val_t state_url = ({ el_val_t _if_result_1 = 0; if (str_eq(ise_url, EL_STR(""))) { _if_result_1 = (state_get(EL_STR("soul_engram_url"))); } else { _if_result_1 = (ise_url); } _if_result_1; });
-  el_val_t engram_url = ({ el_val_t _if_result_2 = 0; if (str_eq(state_url, EL_STR(""))) { _if_result_2 = (EL_STR("http://localhost:8742")); } else { _if_result_2 = (state_url); } _if_result_2; });
+  el_val_t state_url = ({ el_val_t _if_result_5 = 0; if (str_eq(ise_url, EL_STR(""))) { _if_result_5 = (state_get(EL_STR("soul_engram_url"))); } else { _if_result_5 = (ise_url); } _if_result_5; });
+  el_val_t engram_url = ({ el_val_t _if_result_6 = 0; if (str_eq(state_url, EL_STR(""))) { _if_result_6 = (EL_STR("http://localhost:8742")); } else { _if_result_6 = (state_url); } _if_result_6; });
   el_val_t safe1 = str_replace(content, EL_STR("\\"), EL_STR("\\\\"));
   el_val_t safe2 = str_replace(safe1, EL_STR("\""), EL_STR("\\\""));
   el_val_t safe3 = str_replace(safe2, EL_STR("\n"), EL_STR("\\n"));
@@ -77,7 +109,7 @@ el_val_t ise_post(el_val_t content) {
   el_val_t resp = http_post_json(el_str_concat(engram_url, EL_STR("/api/neuron/state-events")), body);
   if (str_eq(resp, EL_STR(""))) {
     el_val_t fail_raw = state_get(EL_STR("soul.ise_fail_count"));
-    el_val_t fail_n = ({ el_val_t _if_result_3 = 0; if (str_eq(fail_raw, EL_STR(""))) { _if_result_3 = (0); } else { _if_result_3 = (str_to_int(fail_raw)); } _if_result_3; });
+    el_val_t fail_n = ({ el_val_t _if_result_7 = 0; if (str_eq(fail_raw, EL_STR(""))) { _if_result_7 = (0); } else { _if_result_7 = (str_to_int(fail_raw)); } _if_result_7; });
     state_set(EL_STR("soul.ise_fail_count"), int_to_str((fail_n + 1)));
     el_val_t discard = engram_node_full(content, EL_STR("InternalStateEvent"), EL_STR("state-event"), el_from_float(0.3), el_from_float(0.3), el_from_float(0.8), EL_STR("Episodic"), EL_STR("[\"internal-state\",\"InternalStateEvent\",\"ise-fallback-local\"]"));
     return EL_STR("");
@@ -130,11 +162,11 @@ el_val_t embed_ok(void) {
 el_val_t emit_heartbeat(void) {
   el_val_t pulse = int_to_str(pulse_count());
   el_val_t boot_raw = state_get(EL_STR("soul_boot_count"));
-  el_val_t boot = ({ el_val_t _if_result_4 = 0; if (str_eq(boot_raw, EL_STR(""))) { _if_result_4 = (EL_STR("0")); } else { _if_result_4 = (boot_raw); } _if_result_4; });
+  el_val_t boot = ({ el_val_t _if_result_8 = 0; if (str_eq(boot_raw, EL_STR(""))) { _if_result_8 = (EL_STR("0")); } else { _if_result_8 = (boot_raw); } _if_result_8; });
   el_val_t idle = int_to_str(idle_count());
   el_val_t ts = time_now();
   el_val_t last_act_raw = state_get(EL_STR("soul.last_activity_ts"));
-  el_val_t idle_ms = ({ el_val_t _if_result_5 = 0; if (str_eq(last_act_raw, EL_STR(""))) { _if_result_5 = ((0 - 1)); } else { _if_result_5 = ((ts - str_to_int(last_act_raw))); } _if_result_5; });
+  el_val_t idle_ms = ({ el_val_t _if_result_9 = 0; if (str_eq(last_act_raw, EL_STR(""))) { _if_result_9 = ((0 - 1)); } else { _if_result_9 = ((ts - str_to_int(last_act_raw))); } _if_result_9; });
   el_val_t nc = engram_node_count();
   el_val_t ec = engram_edge_count();
   el_val_t wmc = engram_wm_count();
@@ -145,36 +177,36 @@ el_val_t emit_heartbeat(void) {
   el_val_t up_human = elapsed_human();
   el_val_t emb_ok = embed_ok();
   el_val_t fail_raw = state_get(EL_STR("soul.ise_fail_count"));
-  el_val_t fail_str = ({ el_val_t _if_result_6 = 0; if (str_eq(fail_raw, EL_STR(""))) { _if_result_6 = (EL_STR("0")); } else { _if_result_6 = (fail_raw); } _if_result_6; });
+  el_val_t fail_str = ({ el_val_t _if_result_10 = 0; if (str_eq(fail_raw, EL_STR(""))) { _if_result_10 = (EL_STR("0")); } else { _if_result_10 = (fail_raw); } _if_result_10; });
   el_val_t sat_raw = state_get(EL_STR("soul.sync_added_total"));
-  el_val_t sat_str = ({ el_val_t _if_result_7 = 0; if (str_eq(sat_raw, EL_STR(""))) { _if_result_7 = (EL_STR("0")); } else { _if_result_7 = (sat_raw); } _if_result_7; });
+  el_val_t sat_str = ({ el_val_t _if_result_11 = 0; if (str_eq(sat_raw, EL_STR(""))) { _if_result_11 = (EL_STR("0")); } else { _if_result_11 = (sat_raw); } _if_result_11; });
   el_val_t prev_wm_raw = state_get(EL_STR("soul.prev_wm_active"));
-  el_val_t prev_wm = ({ el_val_t _if_result_8 = 0; if (str_eq(prev_wm_raw, EL_STR(""))) { _if_result_8 = (0); } else { _if_result_8 = (str_to_int(prev_wm_raw)); } _if_result_8; });
+  el_val_t prev_wm = ({ el_val_t _if_result_12 = 0; if (str_eq(prev_wm_raw, EL_STR(""))) { _if_result_12 = (0); } else { _if_result_12 = (str_to_int(prev_wm_raw)); } _if_result_12; });
   el_val_t wm_delta = (wmc - prev_wm);
   state_set(EL_STR("soul.prev_wm_active"), int_to_str(wmc));
   el_val_t prev_nc_raw = state_get(EL_STR("soul.prev_node_count"));
-  el_val_t prev_nc = ({ el_val_t _if_result_9 = 0; if (str_eq(prev_nc_raw, EL_STR(""))) { _if_result_9 = (nc); } else { _if_result_9 = (str_to_int(prev_nc_raw)); } _if_result_9; });
+  el_val_t prev_nc = ({ el_val_t _if_result_13 = 0; if (str_eq(prev_nc_raw, EL_STR(""))) { _if_result_13 = (nc); } else { _if_result_13 = (str_to_int(prev_nc_raw)); } _if_result_13; });
   el_val_t node_delta = (nc - prev_nc);
   state_set(EL_STR("soul.prev_node_count"), int_to_str(nc));
   el_val_t prev_ec_raw = state_get(EL_STR("soul.prev_edge_count"));
-  el_val_t prev_ec = ({ el_val_t _if_result_10 = 0; if (str_eq(prev_ec_raw, EL_STR(""))) { _if_result_10 = (ec); } else { _if_result_10 = (str_to_int(prev_ec_raw)); } _if_result_10; });
+  el_val_t prev_ec = ({ el_val_t _if_result_14 = 0; if (str_eq(prev_ec_raw, EL_STR(""))) { _if_result_14 = (ec); } else { _if_result_14 = (str_to_int(prev_ec_raw)); } _if_result_14; });
   el_val_t edge_delta = (ec - prev_ec);
   state_set(EL_STR("soul.prev_edge_count"), int_to_str(ec));
   el_val_t sync_ok_raw = state_get(EL_STR("soul.last_sync_ok_ts"));
-  el_val_t sync_age = ({ el_val_t _if_result_11 = 0; if (str_eq(sync_ok_raw, EL_STR(""))) { _if_result_11 = ((0 - 1)); } else { _if_result_11 = ((ts - str_to_int(sync_ok_raw))); } _if_result_11; });
+  el_val_t sync_age = ({ el_val_t _if_result_15 = 0; if (str_eq(sync_ok_raw, EL_STR(""))) { _if_result_15 = ((0 - 1)); } else { _if_result_15 = ((ts - str_to_int(sync_ok_raw))); } _if_result_15; });
   el_val_t hb_env_url = env(EL_STR("SOUL_ISE_URL"));
-  el_val_t hb_state_url = ({ el_val_t _if_result_12 = 0; if (str_eq(hb_env_url, EL_STR(""))) { _if_result_12 = (state_get(EL_STR("soul_engram_url"))); } else { _if_result_12 = (hb_env_url); } _if_result_12; });
-  el_val_t hb_engram_url = ({ el_val_t _if_result_13 = 0; if (str_eq(hb_state_url, EL_STR(""))) { _if_result_13 = (EL_STR("http://localhost:8742")); } else { _if_result_13 = (hb_state_url); } _if_result_13; });
+  el_val_t hb_state_url = ({ el_val_t _if_result_16 = 0; if (str_eq(hb_env_url, EL_STR(""))) { _if_result_16 = (state_get(EL_STR("soul_engram_url"))); } else { _if_result_16 = (hb_env_url); } _if_result_16; });
+  el_val_t hb_engram_url = ({ el_val_t _if_result_17 = 0; if (str_eq(hb_state_url, EL_STR(""))) { _if_result_17 = (EL_STR("http://localhost:8742")); } else { _if_result_17 = (hb_state_url); } _if_result_17; });
   el_val_t bf_resp = http_get(el_str_concat(hb_engram_url, EL_STR("/api/embed-backfill?n=32")));
   el_val_t bf_done_raw = json_get(bf_resp, EL_STR("embedded"));
-  el_val_t bf_done = ({ el_val_t _if_result_14 = 0; if (str_eq(bf_done_raw, EL_STR(""))) { _if_result_14 = (EL_STR("-1")); } else { _if_result_14 = (bf_done_raw); } _if_result_14; });
+  el_val_t bf_done = ({ el_val_t _if_result_18 = 0; if (str_eq(bf_done_raw, EL_STR(""))) { _if_result_18 = (EL_STR("-1")); } else { _if_result_18 = (bf_done_raw); } _if_result_18; });
   el_val_t bf_total_raw = json_get(bf_resp, EL_STR("embedded_count"));
-  el_val_t bf_total = ({ el_val_t _if_result_15 = 0; if (str_eq(bf_total_raw, EL_STR(""))) { _if_result_15 = (EL_STR("-1")); } else { _if_result_15 = (bf_total_raw); } _if_result_15; });
-  el_val_t wm_sat = ({ el_val_t _if_result_16 = 0; if ((wmc >= 24)) { _if_result_16 = (1); } else { _if_result_16 = (0); } _if_result_16; });
+  el_val_t bf_total = ({ el_val_t _if_result_19 = 0; if (str_eq(bf_total_raw, EL_STR(""))) { _if_result_19 = (EL_STR("-1")); } else { _if_result_19 = (bf_total_raw); } _if_result_19; });
+  el_val_t wm_sat = ({ el_val_t _if_result_20 = 0; if ((wmc >= 24)) { _if_result_20 = (1); } else { _if_result_20 = (0); } _if_result_20; });
   el_val_t prev_sat_raw = state_get(EL_STR("soul.prev_wm_saturated"));
-  el_val_t prev_sat = ({ el_val_t _if_result_17 = 0; if (str_eq(prev_sat_raw, EL_STR(""))) { _if_result_17 = (wm_sat); } else { _if_result_17 = (str_to_int(prev_sat_raw)); } _if_result_17; });
+  el_val_t prev_sat = ({ el_val_t _if_result_21 = 0; if (str_eq(prev_sat_raw, EL_STR(""))) { _if_result_21 = (wm_sat); } else { _if_result_21 = (str_to_int(prev_sat_raw)); } _if_result_21; });
   if (wm_sat != prev_sat) {
-    el_val_t sat_dir = ({ el_val_t _if_result_18 = 0; if ((wm_sat == 1)) { _if_result_18 = (EL_STR("onset")); } else { _if_result_18 = (EL_STR("release")); } _if_result_18; });
+    el_val_t sat_dir = ({ el_val_t _if_result_22 = 0; if ((wm_sat == 1)) { _if_result_22 = (EL_STR("onset")); } else { _if_result_22 = (EL_STR("release")); } _if_result_22; });
     ise_post(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"event\":\"wm_saturation_transition\",\"direction\":\""), sat_dir), EL_STR("\",\"wm_active\":")), int_to_str(wmc)), EL_STR(",\"wm_top\":")), wm_top), EL_STR(",\"ts\":")), int_to_str(ts)), EL_STR("}")));
   }
   state_set(EL_STR("soul.prev_wm_saturated"), int_to_str(wm_sat));
@@ -182,8 +214,8 @@ el_val_t emit_heartbeat(void) {
   el_val_t wm_top0_id = json_get(wm_top0, EL_STR("id"));
   el_val_t prev_top0 = state_get(EL_STR("soul.prev_wm_top0"));
   el_val_t t0streak_raw = state_get(EL_STR("soul.wm_top0_streak"));
-  el_val_t t0streak_prev = ({ el_val_t _if_result_19 = 0; if (str_eq(t0streak_raw, EL_STR(""))) { _if_result_19 = (0); } else { _if_result_19 = (str_to_int(t0streak_raw)); } _if_result_19; });
-  el_val_t t0streak = ({ el_val_t _if_result_20 = 0; if (str_eq(wm_top0_id, EL_STR(""))) { _if_result_20 = (0); } else { _if_result_20 = (({ el_val_t _if_result_21 = 0; if (str_eq(wm_top0_id, prev_top0)) { _if_result_21 = ((t0streak_prev + 1)); } else { _if_result_21 = (1); } _if_result_21; })); } _if_result_20; });
+  el_val_t t0streak_prev = ({ el_val_t _if_result_23 = 0; if (str_eq(t0streak_raw, EL_STR(""))) { _if_result_23 = (0); } else { _if_result_23 = (str_to_int(t0streak_raw)); } _if_result_23; });
+  el_val_t t0streak = ({ el_val_t _if_result_24 = 0; if (str_eq(wm_top0_id, EL_STR(""))) { _if_result_24 = (0); } else { _if_result_24 = (({ el_val_t _if_result_25 = 0; if (str_eq(wm_top0_id, prev_top0)) { _if_result_25 = ((t0streak_prev + 1)); } else { _if_result_25 = (1); } _if_result_25; })); } _if_result_24; });
   state_set(EL_STR("soul.prev_wm_top0"), wm_top0_id);
   state_set(EL_STR("soul.wm_top0_streak"), int_to_str(t0streak));
   el_val_t ch_id1 = json_get(json_array_get(wm_top, 1), EL_STR("id"));
@@ -191,28 +223,28 @@ el_val_t emit_heartbeat(void) {
   el_val_t ch_id3 = json_get(json_array_get(wm_top, 3), EL_STR("id"));
   el_val_t ch_id4 = json_get(json_array_get(wm_top, 4), EL_STR("id"));
   el_val_t prev_top5 = state_get(EL_STR("soul.prev_wm_top5"));
-  el_val_t ch0 = ({ el_val_t _if_result_22 = 0; if (str_eq(wm_top0_id, EL_STR(""))) { _if_result_22 = (0); } else { _if_result_22 = (({ el_val_t _if_result_23 = 0; if (str_contains(prev_top5, wm_top0_id)) { _if_result_23 = (0); } else { _if_result_23 = (1); } _if_result_23; })); } _if_result_22; });
-  el_val_t ch1 = ({ el_val_t _if_result_24 = 0; if (str_eq(ch_id1, EL_STR(""))) { _if_result_24 = (0); } else { _if_result_24 = (({ el_val_t _if_result_25 = 0; if (str_contains(prev_top5, ch_id1)) { _if_result_25 = (0); } else { _if_result_25 = (1); } _if_result_25; })); } _if_result_24; });
-  el_val_t ch2 = ({ el_val_t _if_result_26 = 0; if (str_eq(ch_id2, EL_STR(""))) { _if_result_26 = (0); } else { _if_result_26 = (({ el_val_t _if_result_27 = 0; if (str_contains(prev_top5, ch_id2)) { _if_result_27 = (0); } else { _if_result_27 = (1); } _if_result_27; })); } _if_result_26; });
-  el_val_t ch3 = ({ el_val_t _if_result_28 = 0; if (str_eq(ch_id3, EL_STR(""))) { _if_result_28 = (0); } else { _if_result_28 = (({ el_val_t _if_result_29 = 0; if (str_contains(prev_top5, ch_id3)) { _if_result_29 = (0); } else { _if_result_29 = (1); } _if_result_29; })); } _if_result_28; });
-  el_val_t ch4 = ({ el_val_t _if_result_30 = 0; if (str_eq(ch_id4, EL_STR(""))) { _if_result_30 = (0); } else { _if_result_30 = (({ el_val_t _if_result_31 = 0; if (str_contains(prev_top5, ch_id4)) { _if_result_31 = (0); } else { _if_result_31 = (1); } _if_result_31; })); } _if_result_30; });
+  el_val_t ch0 = ({ el_val_t _if_result_26 = 0; if (str_eq(wm_top0_id, EL_STR(""))) { _if_result_26 = (0); } else { _if_result_26 = (({ el_val_t _if_result_27 = 0; if (str_contains(prev_top5, wm_top0_id)) { _if_result_27 = (0); } else { _if_result_27 = (1); } _if_result_27; })); } _if_result_26; });
+  el_val_t ch1 = ({ el_val_t _if_result_28 = 0; if (str_eq(ch_id1, EL_STR(""))) { _if_result_28 = (0); } else { _if_result_28 = (({ el_val_t _if_result_29 = 0; if (str_contains(prev_top5, ch_id1)) { _if_result_29 = (0); } else { _if_result_29 = (1); } _if_result_29; })); } _if_result_28; });
+  el_val_t ch2 = ({ el_val_t _if_result_30 = 0; if (str_eq(ch_id2, EL_STR(""))) { _if_result_30 = (0); } else { _if_result_30 = (({ el_val_t _if_result_31 = 0; if (str_contains(prev_top5, ch_id2)) { _if_result_31 = (0); } else { _if_result_31 = (1); } _if_result_31; })); } _if_result_30; });
+  el_val_t ch3 = ({ el_val_t _if_result_32 = 0; if (str_eq(ch_id3, EL_STR(""))) { _if_result_32 = (0); } else { _if_result_32 = (({ el_val_t _if_result_33 = 0; if (str_contains(prev_top5, ch_id3)) { _if_result_33 = (0); } else { _if_result_33 = (1); } _if_result_33; })); } _if_result_32; });
+  el_val_t ch4 = ({ el_val_t _if_result_34 = 0; if (str_eq(ch_id4, EL_STR(""))) { _if_result_34 = (0); } else { _if_result_34 = (({ el_val_t _if_result_35 = 0; if (str_contains(prev_top5, ch_id4)) { _if_result_35 = (0); } else { _if_result_35 = (1); } _if_result_35; })); } _if_result_34; });
   el_val_t wm_churn = ((((ch0 + ch1) + ch2) + ch3) + ch4);
   state_set(EL_STR("soul.prev_wm_top5"), el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(wm_top0_id, EL_STR("|")), ch_id1), EL_STR("|")), ch_id2), EL_STR("|")), ch_id3), EL_STR("|")), ch_id4));
   el_val_t wm_top0_wm_raw = json_get(wm_top0, EL_STR("wm"));
-  el_val_t wm_top0_wm = ({ el_val_t _if_result_32 = 0; if (str_eq(wm_top0_wm_raw, EL_STR(""))) { _if_result_32 = (EL_STR("0")); } else { _if_result_32 = (wm_top0_wm_raw); } _if_result_32; });
+  el_val_t wm_top0_wm = ({ el_val_t _if_result_36 = 0; if (str_eq(wm_top0_wm_raw, EL_STR(""))) { _if_result_36 = (EL_STR("0")); } else { _if_result_36 = (wm_top0_wm_raw); } _if_result_36; });
   el_val_t act_stats = engram_act_stats_json();
   el_val_t act_evict_raw = json_get(act_stats, EL_STR("wm_evicted"));
-  el_val_t act_evict = ({ el_val_t _if_result_33 = 0; if (str_eq(act_evict_raw, EL_STR(""))) { _if_result_33 = (EL_STR("-1")); } else { _if_result_33 = (act_evict_raw); } _if_result_33; });
+  el_val_t act_evict = ({ el_val_t _if_result_37 = 0; if (str_eq(act_evict_raw, EL_STR(""))) { _if_result_37 = (EL_STR("-1")); } else { _if_result_37 = (act_evict_raw); } _if_result_37; });
   el_val_t act_bt_raw = json_get(act_stats, EL_STR("breakthroughs"));
-  el_val_t act_bt = ({ el_val_t _if_result_34 = 0; if (str_eq(act_bt_raw, EL_STR(""))) { _if_result_34 = (EL_STR("-1")); } else { _if_result_34 = (act_bt_raw); } _if_result_34; });
-  el_val_t evict_now = ({ el_val_t _if_result_35 = 0; if (str_eq(act_evict_raw, EL_STR(""))) { _if_result_35 = ((0 - 1)); } else { _if_result_35 = (str_to_int(act_evict_raw)); } _if_result_35; });
-  el_val_t bt_now = ({ el_val_t _if_result_36 = 0; if (str_eq(act_bt_raw, EL_STR(""))) { _if_result_36 = ((0 - 1)); } else { _if_result_36 = (str_to_int(act_bt_raw)); } _if_result_36; });
+  el_val_t act_bt = ({ el_val_t _if_result_38 = 0; if (str_eq(act_bt_raw, EL_STR(""))) { _if_result_38 = (EL_STR("-1")); } else { _if_result_38 = (act_bt_raw); } _if_result_38; });
+  el_val_t evict_now = ({ el_val_t _if_result_39 = 0; if (str_eq(act_evict_raw, EL_STR(""))) { _if_result_39 = ((0 - 1)); } else { _if_result_39 = (str_to_int(act_evict_raw)); } _if_result_39; });
+  el_val_t bt_now = ({ el_val_t _if_result_40 = 0; if (str_eq(act_bt_raw, EL_STR(""))) { _if_result_40 = ((0 - 1)); } else { _if_result_40 = (str_to_int(act_bt_raw)); } _if_result_40; });
   el_val_t prev_evict_raw = state_get(EL_STR("soul.prev_wm_evicted"));
-  el_val_t prev_evict = ({ el_val_t _if_result_37 = 0; if (str_eq(prev_evict_raw, EL_STR(""))) { _if_result_37 = (0); } else { _if_result_37 = (str_to_int(prev_evict_raw)); } _if_result_37; });
+  el_val_t prev_evict = ({ el_val_t _if_result_41 = 0; if (str_eq(prev_evict_raw, EL_STR(""))) { _if_result_41 = (0); } else { _if_result_41 = (str_to_int(prev_evict_raw)); } _if_result_41; });
   el_val_t prev_bt_raw = state_get(EL_STR("soul.prev_breakthroughs"));
-  el_val_t prev_bt = ({ el_val_t _if_result_38 = 0; if (str_eq(prev_bt_raw, EL_STR(""))) { _if_result_38 = (0); } else { _if_result_38 = (str_to_int(prev_bt_raw)); } _if_result_38; });
-  el_val_t evict_delta = ({ el_val_t _if_result_39 = 0; if ((evict_now < 0)) { _if_result_39 = (0); } else { _if_result_39 = (({ el_val_t _if_result_40 = 0; if ((evict_now < prev_evict)) { _if_result_40 = (evict_now); } else { _if_result_40 = ((evict_now - prev_evict)); } _if_result_40; })); } _if_result_39; });
-  el_val_t bt_delta = ({ el_val_t _if_result_41 = 0; if ((bt_now < 0)) { _if_result_41 = (0); } else { _if_result_41 = (({ el_val_t _if_result_42 = 0; if ((bt_now < prev_bt)) { _if_result_42 = (bt_now); } else { _if_result_42 = ((bt_now - prev_bt)); } _if_result_42; })); } _if_result_41; });
+  el_val_t prev_bt = ({ el_val_t _if_result_42 = 0; if (str_eq(prev_bt_raw, EL_STR(""))) { _if_result_42 = (0); } else { _if_result_42 = (str_to_int(prev_bt_raw)); } _if_result_42; });
+  el_val_t evict_delta = ({ el_val_t _if_result_43 = 0; if ((evict_now < 0)) { _if_result_43 = (0); } else { _if_result_43 = (({ el_val_t _if_result_44 = 0; if ((evict_now < prev_evict)) { _if_result_44 = (evict_now); } else { _if_result_44 = ((evict_now - prev_evict)); } _if_result_44; })); } _if_result_43; });
+  el_val_t bt_delta = ({ el_val_t _if_result_45 = 0; if ((bt_now < 0)) { _if_result_45 = (0); } else { _if_result_45 = (({ el_val_t _if_result_46 = 0; if ((bt_now < prev_bt)) { _if_result_46 = (bt_now); } else { _if_result_46 = ((bt_now - prev_bt)); } _if_result_46; })); } _if_result_45; });
   if (evict_now >= 0) {
     state_set(EL_STR("soul.prev_wm_evicted"), int_to_str(evict_now));
   }
@@ -221,14 +253,72 @@ el_val_t emit_heartbeat(void) {
   }
   el_val_t hb_stats = http_get(el_str_concat(hb_engram_url, EL_STR("/api/stats")));
   el_val_t embed_elig_raw = json_get(hb_stats, EL_STR("embed_eligible_count"));
-  el_val_t embed_elig = ({ el_val_t _if_result_43 = 0; if (str_eq(embed_elig_raw, EL_STR(""))) { _if_result_43 = (EL_STR("-1")); } else { _if_result_43 = (embed_elig_raw); } _if_result_43; });
+  el_val_t embed_elig = ({ el_val_t _if_result_47 = 0; if (str_eq(embed_elig_raw, EL_STR(""))) { _if_result_47 = (EL_STR("-1")); } else { _if_result_47 = (embed_elig_raw); } _if_result_47; });
   el_val_t hb_ats_raw = state_get(EL_STR("soul.auto_term_streak"));
-  el_val_t hb_ats = ({ el_val_t _if_result_44 = 0; if (str_eq(hb_ats_raw, EL_STR(""))) { _if_result_44 = (0); } else { _if_result_44 = (str_to_int(hb_ats_raw)); } _if_result_44; });
+  el_val_t hb_ats = ({ el_val_t _if_result_48 = 0; if (str_eq(hb_ats_raw, EL_STR(""))) { _if_result_48 = (0); } else { _if_result_48 = (str_to_int(hb_ats_raw)); } _if_result_48; });
+  el_val_t hb_ate_raw = state_get(EL_STR("soul.auto_term_empty_streak"));
+  el_val_t hb_ate = ({ el_val_t _if_result_49 = 0; if (str_eq(hb_ate_raw, EL_STR(""))) { _if_result_49 = (0); } else { _if_result_49 = (str_to_int(hb_ate_raw)); } _if_result_49; });
+  el_val_t hebb_warm_raw = json_get(act_stats, EL_STR("hebb_warm"));
+  el_val_t hebb_warm = ({ el_val_t _if_result_50 = 0; if (str_eq(hebb_warm_raw, EL_STR(""))) { _if_result_50 = (EL_STR("-1")); } else { _if_result_50 = (hebb_warm_raw); } _if_result_50; });
+  el_val_t hebb_max_raw = json_get(act_stats, EL_STR("hebb_max"));
+  el_val_t hebb_max = ({ el_val_t _if_result_51 = 0; if (str_eq(hebb_max_raw, EL_STR(""))) { _if_result_51 = (EL_STR("-1")); } else { _if_result_51 = (hebb_max_raw); } _if_result_51; });
+  el_val_t hebb_links_raw = json_get(act_stats, EL_STR("hebb_links"));
+  el_val_t hebb_links = ({ el_val_t _if_result_52 = 0; if (str_eq(hebb_links_raw, EL_STR(""))) { _if_result_52 = (EL_STR("-1")); } else { _if_result_52 = (hebb_links_raw); } _if_result_52; });
+  el_val_t hebb_cands_raw = json_get(act_stats, EL_STR("hebb_cands"));
+  el_val_t hebb_cands = ({ el_val_t _if_result_53 = 0; if (str_eq(hebb_cands_raw, EL_STR(""))) { _if_result_53 = (EL_STR("-1")); } else { _if_result_53 = (hebb_cands_raw); } _if_result_53; });
+  el_val_t hebb_cmax_raw = json_get(act_stats, EL_STR("hebb_cand_max"));
+  el_val_t hebb_cmax = ({ el_val_t _if_result_54 = 0; if (str_eq(hebb_cmax_raw, EL_STR(""))) { _if_result_54 = (EL_STR("-1")); } else { _if_result_54 = (hebb_cmax_raw); } _if_result_54; });
+  el_val_t hebb_mass_raw = json_get(act_stats, EL_STR("hebb_mass"));
+  el_val_t hebb_mass = ({ el_val_t _if_result_55 = 0; if (str_eq(hebb_mass_raw, EL_STR(""))) { _if_result_55 = (EL_STR("-1")); } else { _if_result_55 = (hebb_mass_raw); } _if_result_55; });
+  el_val_t hebb_edges_raw = json_get(act_stats, EL_STR("hebb_edges"));
+  el_val_t hebb_edges = ({ el_val_t _if_result_56 = 0; if (str_eq(hebb_edges_raw, EL_STR(""))) { _if_result_56 = (EL_STR("-1")); } else { _if_result_56 = (hebb_edges_raw); } _if_result_56; });
+  el_val_t wb_pend_raw = json_get(act_stats, EL_STR("hebb_wb_pending"));
+  el_val_t wb_pend = ({ el_val_t _if_result_57 = 0; if (str_eq(wb_pend_raw, EL_STR(""))) { _if_result_57 = (EL_STR("-1")); } else { _if_result_57 = (wb_pend_raw); } _if_result_57; });
+  el_val_t wb_drain_raw = json_get(act_stats, EL_STR("hebb_wb_drained"));
+  el_val_t wb_drain = ({ el_val_t _if_result_58 = 0; if (str_eq(wb_drain_raw, EL_STR(""))) { _if_result_58 = (EL_STR("-1")); } else { _if_result_58 = (wb_drain_raw); } _if_result_58; });
+  el_val_t wb_drop_raw = json_get(act_stats, EL_STR("hebb_wb_dropped"));
+  el_val_t wb_drop = ({ el_val_t _if_result_59 = 0; if (str_eq(wb_drop_raw, EL_STR(""))) { _if_result_59 = (EL_STR("-1")); } else { _if_result_59 = (wb_drop_raw); } _if_result_59; });
+  el_val_t wb_sent_raw = state_get(EL_STR("soul.hebb_wb_sent"));
+  el_val_t wb_sent = ({ el_val_t _if_result_60 = 0; if (str_eq(wb_sent_raw, EL_STR(""))) { _if_result_60 = (EL_STR("0")); } else { _if_result_60 = (wb_sent_raw); } _if_result_60; });
+  el_val_t dup_wm_g_raw = json_get(act_stats, EL_STR("dup_wm_global"));
+  el_val_t dup_wm_g = ({ el_val_t _if_result_61 = 0; if (str_eq(dup_wm_g_raw, EL_STR(""))) { _if_result_61 = (EL_STR("-1")); } else { _if_result_61 = (dup_wm_g_raw); } _if_result_61; });
   el_val_t act_brk_raw = json_get(act_stats, EL_STR("embed_breaker_open"));
-  el_val_t act_brk = ({ el_val_t _if_result_45 = 0; if (str_eq(act_brk_raw, EL_STR(""))) { _if_result_45 = (EL_STR("-1")); } else { _if_result_45 = (act_brk_raw); } _if_result_45; });
+  el_val_t act_brk = ({ el_val_t _if_result_62 = 0; if (str_eq(act_brk_raw, EL_STR(""))) { _if_result_62 = (EL_STR("-1")); } else { _if_result_62 = (act_brk_raw); } _if_result_62; });
+  el_val_t emb_cf_raw = json_get(act_stats, EL_STR("embed_consec_fail"));
+  el_val_t emb_cf = ({ el_val_t _if_result_63 = 0; if (str_eq(emb_cf_raw, EL_STR(""))) { _if_result_63 = (EL_STR("-1")); } else { _if_result_63 = (emb_cf_raw); } _if_result_63; });
   el_val_t ctx_cos_raw = json_get(act_stats, EL_STR("ctx_cos"));
-  el_val_t ctx_cos = ({ el_val_t _if_result_46 = 0; if (str_eq(ctx_cos_raw, EL_STR(""))) { _if_result_46 = (EL_STR("-2")); } else { _if_result_46 = (ctx_cos_raw); } _if_result_46; });
-  el_val_t payload = el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"event\":\"heartbeat\",\"pulse\":"), pulse), EL_STR(",\"tick\":")), pulse), EL_STR(",\"boot\":")), boot), EL_STR(",\"idle\":")), idle), EL_STR(",\"idle_ms\":")), int_to_str(idle_ms)), EL_STR(",\"node_count\":")), int_to_str(nc)), EL_STR(",\"edge_count\":")), int_to_str(ec)), EL_STR(",\"node_delta\":")), int_to_str(node_delta)), EL_STR(",\"edge_delta\":")), int_to_str(edge_delta)), EL_STR(",\"wm_active\":")), int_to_str(wmc)), EL_STR(",\"wm_delta\":")), int_to_str(wm_delta)), EL_STR(",\"wm_saturated\":")), int_to_str(wm_sat)), EL_STR(",\"wm_top0_streak\":")), int_to_str(t0streak)), EL_STR(",\"wm_churn\":")), int_to_str(wm_churn)), EL_STR(",\"wm_top0_wm\":")), wm_top0_wm), EL_STR(",\"sync_added_total\":")), sat_str), EL_STR(",\"sync_age_ms\":")), int_to_str(sync_age)), EL_STR(",\"wm_avg_weight\":")), wm_avg_str), EL_STR(",\"wm_top\":")), wm_top), EL_STR(",\"ts\":")), int_to_str(ts)), EL_STR(",\"uptime_ms\":")), int_to_str(up_ms)), EL_STR(",\"uptime\":\"")), up_human), EL_STR("\",\"embed_ok\":")), int_to_str(emb_ok)), EL_STR(",\"embed_backfilled\":")), bf_done), EL_STR(",\"embed_count\":")), bf_total), EL_STR(",\"embed_eligible\":")), embed_elig), EL_STR(",\"wm_evicted\":")), act_evict), EL_STR(",\"wm_evicted_delta\":")), int_to_str(evict_delta)), EL_STR(",\"breakthroughs\":")), act_bt), EL_STR(",\"breakthroughs_delta\":")), int_to_str(bt_delta)), EL_STR(",\"auto_term_streak\":")), int_to_str(hb_ats)), EL_STR(",\"embed_breaker_open\":")), act_brk), EL_STR(",\"ctx_cos\":")), ctx_cos), EL_STR(",\"ise_fail\":")), fail_str), EL_STR("}"));
+  el_val_t ctx_cos = ({ el_val_t _if_result_64 = 0; if (str_eq(ctx_cos_raw, EL_STR(""))) { _if_result_64 = (EL_STR("-2")); } else { _if_result_64 = (ctx_cos_raw); } _if_result_64; });
+  el_val_t dup_seeds_raw = json_get(act_stats, EL_STR("dup_seeds"));
+  el_val_t dup_seeds = ({ el_val_t _if_result_65 = 0; if (str_eq(dup_seeds_raw, EL_STR(""))) { _if_result_65 = (EL_STR("-1")); } else { _if_result_65 = (dup_seeds_raw); } _if_result_65; });
+  el_val_t dup_wm_raw = json_get(act_stats, EL_STR("dup_wm"));
+  el_val_t dup_wm = ({ el_val_t _if_result_66 = 0; if (str_eq(dup_wm_raw, EL_STR(""))) { _if_result_66 = (EL_STR("-1")); } else { _if_result_66 = (dup_wm_raw); } _if_result_66; });
+  el_val_t txt_dmg_raw = json_get(act_stats, EL_STR("txt_damaged"));
+  el_val_t txt_dmg = ({ el_val_t _if_result_67 = 0; if (str_eq(txt_dmg_raw, EL_STR(""))) { _if_result_67 = (EL_STR("-1")); } else { _if_result_67 = (txt_dmg_raw); } _if_result_67; });
+  el_val_t tc_raw = state_get(EL_STR("soul.txt_census_countdown"));
+  el_val_t tc_n = ({ el_val_t _if_result_68 = 0; if (str_eq(tc_raw, EL_STR(""))) { _if_result_68 = (0); } else { _if_result_68 = (str_to_int(tc_raw)); } _if_result_68; });
+  if (tc_n <= 0) {
+    el_val_t th_resp = http_get(el_str_concat(hb_engram_url, EL_STR("/api/text-health")));
+    el_val_t th_pct = json_get(th_resp, EL_STR("damaged_pct"));
+    if (!str_eq(th_pct, EL_STR(""))) {
+      state_set(EL_STR("soul.txt_damaged_pct"), th_pct);
+      state_set(EL_STR("soul.txt_damaged_n"), json_get(th_resp, EL_STR("damaged")));
+      state_set(EL_STR("soul.txt_scanned_n"), json_get(th_resp, EL_STR("scanned")));
+      state_set(EL_STR("soul.txt_census_ts"), int_to_str(ts));
+    }
+    state_set(EL_STR("soul.txt_census_countdown"), EL_STR("30"));
+  }
+  if (tc_n > 0) {
+    state_set(EL_STR("soul.txt_census_countdown"), int_to_str((tc_n - 1)));
+  }
+  el_val_t dmg_pct_raw = state_get(EL_STR("soul.txt_damaged_pct"));
+  el_val_t dmg_pct = ({ el_val_t _if_result_69 = 0; if (str_eq(dmg_pct_raw, EL_STR(""))) { _if_result_69 = (EL_STR("-1")); } else { _if_result_69 = (dmg_pct_raw); } _if_result_69; });
+  el_val_t dmg_n_raw = state_get(EL_STR("soul.txt_damaged_n"));
+  el_val_t dmg_n = ({ el_val_t _if_result_70 = 0; if (str_eq(dmg_n_raw, EL_STR(""))) { _if_result_70 = (EL_STR("-1")); } else { _if_result_70 = (dmg_n_raw); } _if_result_70; });
+  el_val_t dmg_scan_raw = state_get(EL_STR("soul.txt_scanned_n"));
+  el_val_t dmg_scan = ({ el_val_t _if_result_71 = 0; if (str_eq(dmg_scan_raw, EL_STR(""))) { _if_result_71 = (EL_STR("-1")); } else { _if_result_71 = (dmg_scan_raw); } _if_result_71; });
+  el_val_t dmg_ts_raw = state_get(EL_STR("soul.txt_census_ts"));
+  el_val_t dmg_age = ({ el_val_t _if_result_72 = 0; if (str_eq(dmg_ts_raw, EL_STR(""))) { _if_result_72 = ((0 - 1)); } else { _if_result_72 = ((ts - str_to_int(dmg_ts_raw))); } _if_result_72; });
+  el_val_t payload = el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"event\":\"heartbeat\",\"pulse\":"), pulse), EL_STR(",\"tick\":")), pulse), EL_STR(",\"boot\":")), boot), EL_STR(",\"idle\":")), idle), EL_STR(",\"idle_ms\":")), int_to_str(idle_ms)), EL_STR(",\"node_count\":")), int_to_str(nc)), EL_STR(",\"edge_count\":")), int_to_str(ec)), EL_STR(",\"node_delta\":")), int_to_str(node_delta)), EL_STR(",\"edge_delta\":")), int_to_str(edge_delta)), EL_STR(",\"wm_active\":")), int_to_str(wmc)), EL_STR(",\"wm_delta\":")), int_to_str(wm_delta)), EL_STR(",\"wm_saturated\":")), int_to_str(wm_sat)), EL_STR(",\"wm_top0_streak\":")), int_to_str(t0streak)), EL_STR(",\"wm_churn\":")), int_to_str(wm_churn)), EL_STR(",\"wm_top0_wm\":")), wm_top0_wm), EL_STR(",\"sync_added_total\":")), sat_str), EL_STR(",\"sync_age_ms\":")), int_to_str(sync_age)), EL_STR(",\"wm_avg_weight\":")), wm_avg_str), EL_STR(",\"wm_top\":")), wm_top), EL_STR(",\"ts\":")), int_to_str(ts)), EL_STR(",\"uptime_ms\":")), int_to_str(up_ms)), EL_STR(",\"uptime\":\"")), up_human), EL_STR("\",\"embed_ok\":")), int_to_str(emb_ok)), EL_STR(",\"embed_backfilled\":")), bf_done), EL_STR(",\"embed_count\":")), bf_total), EL_STR(",\"embed_eligible\":")), embed_elig), EL_STR(",\"wm_evicted\":")), act_evict), EL_STR(",\"wm_evicted_delta\":")), int_to_str(evict_delta)), EL_STR(",\"breakthroughs\":")), act_bt), EL_STR(",\"breakthroughs_delta\":")), int_to_str(bt_delta)), EL_STR(",\"auto_term_streak\":")), int_to_str(hb_ats)), EL_STR(",\"auto_term_empty_streak\":")), int_to_str(hb_ate)), EL_STR(",\"embed_breaker_open\":")), act_brk), EL_STR(",\"ctx_cos\":")), ctx_cos), EL_STR(",\"dup_seeds\":")), dup_seeds), EL_STR(",\"dup_wm\":")), dup_wm), EL_STR(",\"dup_wm_global\":")), dup_wm_g), EL_STR(",\"hebb_warm\":")), hebb_warm), EL_STR(",\"hebb_max\":")), hebb_max), EL_STR(",\"hebb_links\":")), hebb_links), EL_STR(",\"hebb_cands\":")), hebb_cands), EL_STR(",\"hebb_cand_max\":")), hebb_cmax), EL_STR(",\"hebb_mass\":")), hebb_mass), EL_STR(",\"hebb_edges\":")), hebb_edges), EL_STR(",\"embed_consec_fail\":")), emb_cf), EL_STR(",\"txt_damaged_pct\":")), dmg_pct), EL_STR(",\"txt_damaged_n\":")), dmg_n), EL_STR(",\"txt_scanned_n\":")), dmg_scan), EL_STR(",\"txt_census_age_ms\":")), int_to_str(dmg_age)), EL_STR(",\"hebb_wb_pending\":")), wb_pend), EL_STR(",\"hebb_wb_drained\":")), wb_drain), EL_STR(",\"hebb_wb_dropped\":")), wb_drop), EL_STR(",\"hebb_wb_sent\":")), wb_sent), EL_STR(",\"ise_fail\":")), fail_str), EL_STR(",\"txt_damaged\":")), txt_dmg), EL_STR("}"));
   ise_post(payload);
   return 0;
 }
@@ -289,6 +379,13 @@ el_val_t auto_term_try_slot(el_val_t slot_type, el_val_t slot_lbl) {
         if (str_contains(term, EL_STR("'"))) {
           state_set(EL_STR("_ats_gw"), EL_STR("1"));
         }
+        el_val_t df_max = (engram_node_count() / 400);
+        el_val_t df_term = engram_label_df(term);
+        if (df_term > df_max) {
+          if (df_term > 8) {
+            state_set(EL_STR("_ats_gw"), EL_STR("1"));
+          }
+        }
         if (str_eq(term, state_get(EL_STR("soul.tabu_t0")))) {
           state_set(EL_STR("_ats_gw"), EL_STR("1"));
         }
@@ -374,16 +471,21 @@ el_val_t proactive_curiosity(void) {
   auto_term_try_slot(json_get(wm10_n1, EL_STR("node_type")), json_get(wm10_n1, EL_STR("label")));
   auto_term_try_slot(json_get(wm10_n0, EL_STR("node_type")), json_get(wm10_n0, EL_STR("label")));
   el_val_t auto_term = state_get(EL_STR("cseed_auto"));
-  el_val_t results_auto = ({ el_val_t _if_result_47 = 0; if (str_eq(auto_term, EL_STR(""))) { _if_result_47 = (EL_STR("[]")); } else { _if_result_47 = (engram_activate_json(auto_term, 1)); } _if_result_47; });
+  el_val_t results_auto = ({ el_val_t _if_result_73 = 0; if (str_eq(auto_term, EL_STR(""))) { _if_result_73 = (EL_STR("[]")); } else { _if_result_73 = (engram_activate_json(auto_term, 1)); } _if_result_73; });
   el_val_t found_auto = json_array_len(results_auto);
   el_val_t total_found = (found + found_auto);
   el_val_t safe_auto = str_replace(auto_term, EL_STR("\""), EL_STR("'"));
   el_val_t prev_auto = state_get(EL_STR("soul.prev_auto_term"));
   el_val_t atstreak_raw = state_get(EL_STR("soul.auto_term_streak"));
-  el_val_t atstreak_prev = ({ el_val_t _if_result_48 = 0; if (str_eq(atstreak_raw, EL_STR(""))) { _if_result_48 = (0); } else { _if_result_48 = (str_to_int(atstreak_raw)); } _if_result_48; });
-  el_val_t atstreak = ({ el_val_t _if_result_49 = 0; if (str_eq(auto_term, prev_auto)) { _if_result_49 = ((atstreak_prev + 1)); } else { _if_result_49 = (1); } _if_result_49; });
+  el_val_t atstreak_prev = ({ el_val_t _if_result_74 = 0; if (str_eq(atstreak_raw, EL_STR(""))) { _if_result_74 = (0); } else { _if_result_74 = (str_to_int(atstreak_raw)); } _if_result_74; });
+  el_val_t is_empty = str_eq(auto_term, EL_STR(""));
+  el_val_t atstreak = ({ el_val_t _if_result_75 = 0; if (is_empty) { _if_result_75 = (0); } else { _if_result_75 = (({ el_val_t _if_result_76 = 0; if (str_eq(auto_term, prev_auto)) { _if_result_76 = ((atstreak_prev + 1)); } else { _if_result_76 = (1); } _if_result_76; })); } _if_result_75; });
+  el_val_t atempty_raw = state_get(EL_STR("soul.auto_term_empty_streak"));
+  el_val_t atempty_prev = ({ el_val_t _if_result_77 = 0; if (str_eq(atempty_raw, EL_STR(""))) { _if_result_77 = (0); } else { _if_result_77 = (str_to_int(atempty_raw)); } _if_result_77; });
+  el_val_t atempty = ({ el_val_t _if_result_78 = 0; if (is_empty) { _if_result_78 = ((atempty_prev + 1)); } else { _if_result_78 = (0); } _if_result_78; });
   state_set(EL_STR("soul.prev_auto_term"), auto_term);
   state_set(EL_STR("soul.auto_term_streak"), int_to_str(atstreak));
+  state_set(EL_STR("soul.auto_term_empty_streak"), int_to_str(atempty));
   if (!str_eq(auto_term, EL_STR(""))) {
     state_set(EL_STR("soul.tabu_t3"), state_get(EL_STR("soul.tabu_t2")));
     state_set(EL_STR("soul.tabu_t2"), state_get(EL_STR("soul.tabu_t1")));
@@ -392,7 +494,7 @@ el_val_t proactive_curiosity(void) {
   }
   el_val_t wmc = engram_wm_count();
   el_val_t wm3 = engram_wm_top_json(3);
-  el_val_t ise = el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"event\":\"curiosity_scan\",\"seed\":\""), curiosity_seed), EL_STR("\",\"auto_term\":\"")), safe_auto), EL_STR("\",\"auto_term_streak\":")), int_to_str(atstreak)), EL_STR(",\"minute_block\":")), int_to_str(minute_block)), EL_STR(",\"activated\":")), int_to_str(total_found)), EL_STR(",\"wm_active\":")), int_to_str(wmc)), EL_STR(",\"wm_top\":")), wm3), EL_STR(",\"ts\":")), int_to_str(ts)), EL_STR("}"));
+  el_val_t ise = el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"event\":\"curiosity_scan\",\"seed\":\""), curiosity_seed), EL_STR("\",\"auto_term\":\"")), safe_auto), EL_STR("\",\"auto_term_streak\":")), int_to_str(atstreak)), EL_STR(",\"auto_term_empty_streak\":")), int_to_str(atempty)), EL_STR(",\"minute_block\":")), int_to_str(minute_block)), EL_STR(",\"activated\":")), int_to_str(total_found)), EL_STR(",\"wm_active\":")), int_to_str(wmc)), EL_STR(",\"wm_top\":")), wm3), EL_STR(",\"ts\":")), int_to_str(ts)), EL_STR("}"));
   ise_post(ise);
   return (total_found > 0);
   return 0;
@@ -575,17 +677,18 @@ el_val_t awareness_run(void) {
     state_set(EL_STR("soul.boot_ts"), int_to_str(time_now()));
   }
   el_val_t tick_raw = env(EL_STR("SOUL_TICK_MS"));
-  el_val_t tick_ms = ({ el_val_t _if_result_50 = 0; if (str_eq(tick_raw, EL_STR(""))) { _if_result_50 = (200); } else { _if_result_50 = (str_to_int(tick_raw)); } _if_result_50; });
+  el_val_t tick_ms = ({ el_val_t _if_result_79 = 0; if (str_eq(tick_raw, EL_STR(""))) { _if_result_79 = (200); } else { _if_result_79 = (str_to_int(tick_raw)); } _if_result_79; });
   el_val_t beat_ms_raw = env(EL_STR("SOUL_HEARTBEAT_MS"));
-  el_val_t beat_ms = ({ el_val_t _if_result_51 = 0; if (str_eq(beat_ms_raw, EL_STR(""))) { _if_result_51 = (60000); } else { _if_result_51 = (str_to_int(beat_ms_raw)); } _if_result_51; });
+  el_val_t beat_ms = ({ el_val_t _if_result_80 = 0; if (str_eq(beat_ms_raw, EL_STR(""))) { _if_result_80 = (60000); } else { _if_result_80 = (str_to_int(beat_ms_raw)); } _if_result_80; });
   el_val_t scan_ms = (beat_ms / 2);
   while (1) {
     el_val_t tick_mark = el_arena_push();
     el_val_t running = state_get(EL_STR("soul.running"));
     if (str_eq(running, EL_STR("false"))) {
       el_val_t sd_boot_raw = state_get(EL_STR("soul_boot_count"));
-      el_val_t sd_boot = ({ el_val_t _if_result_52 = 0; if (str_eq(sd_boot_raw, EL_STR(""))) { _if_result_52 = (EL_STR("0")); } else { _if_result_52 = (sd_boot_raw); } _if_result_52; });
-      ise_post(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"event\":\"shutdown\",\"boot\":"), sd_boot), EL_STR(",\"pulse\":")), int_to_str(pulse_count())), EL_STR(",\"uptime_ms\":")), int_to_str(elapsed_ms())), EL_STR(",\"ts\":")), int_to_str(time_now())), EL_STR("}")));
+      el_val_t sd_boot = ({ el_val_t _if_result_81 = 0; if (str_eq(sd_boot_raw, EL_STR(""))) { _if_result_81 = (EL_STR("0")); } else { _if_result_81 = (sd_boot_raw); } _if_result_81; });
+      el_val_t sd_wb = hebb_consolidate();
+      ise_post(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"event\":\"shutdown\",\"boot\":"), sd_boot), EL_STR(",\"pulse\":")), int_to_str(pulse_count())), EL_STR(",\"hebb_wb_sent\":")), int_to_str(sd_wb)), EL_STR(",\"uptime_ms\":")), int_to_str(elapsed_ms())), EL_STR(",\"ts\":")), int_to_str(time_now())), EL_STR("}")));
       println(EL_STR("[awareness] exiting"));
       el_arena_pop(tick_mark);
       return EL_STR("");
@@ -600,10 +703,12 @@ el_val_t awareness_run(void) {
     }
     el_val_t now_ts = time_now();
     el_val_t last_beat_str = state_get(EL_STR("soul.last_beat_ts"));
-    el_val_t last_beat_ts = ({ el_val_t _if_result_53 = 0; if (str_eq(last_beat_str, EL_STR(""))) { _if_result_53 = (0); } else { _if_result_53 = (str_to_int(last_beat_str)); } _if_result_53; });
+    el_val_t last_beat_ts = ({ el_val_t _if_result_82 = 0; if (str_eq(last_beat_str, EL_STR(""))) { _if_result_82 = (0); } else { _if_result_82 = (str_to_int(last_beat_str)); } _if_result_82; });
     el_val_t beat_elapsed = (now_ts - last_beat_ts);
     el_val_t should_beat = (beat_elapsed >= beat_ms);
     if (should_beat) {
+      el_val_t wb_sent_n = hebb_consolidate();
+      state_set(EL_STR("soul.hebb_wb_sent"), int_to_str(wb_sent_n));
       emit_heartbeat();
       state_set(EL_STR("soul.last_beat_ts"), int_to_str(now_ts));
       el_val_t snap_path = state_get(EL_STR("soul_snapshot_path"));
@@ -612,7 +717,7 @@ el_val_t awareness_run(void) {
       }
     }
     el_val_t last_scan_str = state_get(EL_STR("soul.last_scan_ts"));
-    el_val_t last_scan_ts = ({ el_val_t _if_result_54 = 0; if (str_eq(last_scan_str, EL_STR(""))) { _if_result_54 = (0); } else { _if_result_54 = (str_to_int(last_scan_str)); } _if_result_54; });
+    el_val_t last_scan_ts = ({ el_val_t _if_result_83 = 0; if (str_eq(last_scan_str, EL_STR(""))) { _if_result_83 = (0); } else { _if_result_83 = (str_to_int(last_scan_str)); } _if_result_83; });
     el_val_t scan_elapsed = (now_ts - last_scan_ts);
     el_val_t should_scan = (!did_work && (scan_elapsed >= scan_ms));
     if (should_scan) {
@@ -620,15 +725,15 @@ el_val_t awareness_run(void) {
       state_set(EL_STR("soul.last_scan_ts"), int_to_str(now_ts));
     }
     el_val_t refresh_ms_raw = env(EL_STR("SOUL_REFRESH_MS"));
-    el_val_t refresh_ms = ({ el_val_t _if_result_55 = 0; if (str_eq(refresh_ms_raw, EL_STR(""))) { _if_result_55 = (600000); } else { _if_result_55 = (str_to_int(refresh_ms_raw)); } _if_result_55; });
+    el_val_t refresh_ms = ({ el_val_t _if_result_84 = 0; if (str_eq(refresh_ms_raw, EL_STR(""))) { _if_result_84 = (600000); } else { _if_result_84 = (str_to_int(refresh_ms_raw)); } _if_result_84; });
     el_val_t last_refresh_str = state_get(EL_STR("soul.last_refresh_ts"));
-    el_val_t last_refresh_ts = ({ el_val_t _if_result_56 = 0; if (str_eq(last_refresh_str, EL_STR(""))) { _if_result_56 = (0); } else { _if_result_56 = (str_to_int(last_refresh_str)); } _if_result_56; });
+    el_val_t last_refresh_ts = ({ el_val_t _if_result_85 = 0; if (str_eq(last_refresh_str, EL_STR(""))) { _if_result_85 = (0); } else { _if_result_85 = (str_to_int(last_refresh_str)); } _if_result_85; });
     el_val_t refresh_elapsed = (now_ts - last_refresh_ts);
     el_val_t should_refresh = (refresh_elapsed >= refresh_ms);
     if (should_refresh) {
       el_val_t sync_env_url = env(EL_STR("SOUL_ISE_URL"));
-      el_val_t sync_state_url = ({ el_val_t _if_result_57 = 0; if (str_eq(sync_env_url, EL_STR(""))) { _if_result_57 = (state_get(EL_STR("soul_engram_url"))); } else { _if_result_57 = (sync_env_url); } _if_result_57; });
-      el_val_t engram_url = ({ el_val_t _if_result_58 = 0; if (str_eq(sync_state_url, EL_STR(""))) { _if_result_58 = (EL_STR("http://localhost:8742")); } else { _if_result_58 = (sync_state_url); } _if_result_58; });
+      el_val_t sync_state_url = ({ el_val_t _if_result_86 = 0; if (str_eq(sync_env_url, EL_STR(""))) { _if_result_86 = (state_get(EL_STR("soul_engram_url"))); } else { _if_result_86 = (sync_env_url); } _if_result_86; });
+      el_val_t engram_url = ({ el_val_t _if_result_87 = 0; if (str_eq(sync_state_url, EL_STR(""))) { _if_result_87 = (EL_STR("http://localhost:8742")); } else { _if_result_87 = (sync_state_url); } _if_result_87; });
       if (!str_eq(engram_url, EL_STR(""))) {
         el_val_t sync_json = http_get(el_str_concat(engram_url, EL_STR("/api/sync")));
         el_val_t sync_ok = (!str_eq(sync_json, EL_STR("")) && !str_eq(sync_json, EL_STR("{}")));
@@ -641,10 +746,10 @@ el_val_t awareness_run(void) {
           fs_write(tmp, sync_json);
           el_val_t added = engram_load_merge(tmp);
           el_val_t ret_raw = env(EL_STR("ENGRAM_ISE_RETENTION_MS"));
-          el_val_t ret_ms = ({ el_val_t _if_result_59 = 0; if (str_eq(ret_raw, EL_STR(""))) { _if_result_59 = (172800000); } else { _if_result_59 = (str_to_int(ret_raw)); } _if_result_59; });
+          el_val_t ret_ms = ({ el_val_t _if_result_88 = 0; if (str_eq(ret_raw, EL_STR(""))) { _if_result_88 = (172800000); } else { _if_result_88 = (str_to_int(ret_raw)); } _if_result_88; });
           el_val_t pruned_sync = engram_prune_telemetry(ret_ms);
           el_val_t sat_raw = state_get(EL_STR("soul.sync_added_total"));
-          el_val_t sat_n = ({ el_val_t _if_result_60 = 0; if (str_eq(sat_raw, EL_STR(""))) { _if_result_60 = (0); } else { _if_result_60 = (str_to_int(sat_raw)); } _if_result_60; });
+          el_val_t sat_n = ({ el_val_t _if_result_89 = 0; if (str_eq(sat_raw, EL_STR(""))) { _if_result_89 = (0); } else { _if_result_89 = (str_to_int(sat_raw)); } _if_result_89; });
           state_set(EL_STR("soul.sync_added_total"), int_to_str((sat_n + added)));
           el_val_t ts2 = time_now();
           state_set(EL_STR("soul.last_sync_ok_ts"), int_to_str(ts2));
@@ -670,78 +775,78 @@ el_val_t security_research_authorized(void) {
 }
 
 el_val_t threat_score_command(el_val_t cmd) {
-  el_val_t s1 = ({ el_val_t _if_result_61 = 0; if (str_contains(cmd, EL_STR("nmap"))) { _if_result_61 = (30); } else { _if_result_61 = (0); } _if_result_61; });
-  el_val_t s2 = ({ el_val_t _if_result_62 = 0; if (str_contains(cmd, EL_STR("masscan"))) { _if_result_62 = (40); } else { _if_result_62 = (0); } _if_result_62; });
-  el_val_t s3 = ({ el_val_t _if_result_63 = 0; if (str_contains(cmd, EL_STR(" nc "))) { _if_result_63 = (20); } else { _if_result_63 = (0); } _if_result_63; });
-  el_val_t s4 = ({ el_val_t _if_result_64 = 0; if (str_contains(cmd, EL_STR("netcat"))) { _if_result_64 = (20); } else { _if_result_64 = (0); } _if_result_64; });
-  el_val_t s5 = ({ el_val_t _if_result_65 = 0; if (str_contains(cmd, EL_STR("/etc/shadow"))) { _if_result_65 = (80); } else { _if_result_65 = (0); } _if_result_65; });
-  el_val_t s6 = ({ el_val_t _if_result_66 = 0; if (str_contains(cmd, EL_STR("/etc/passwd"))) { _if_result_66 = (30); } else { _if_result_66 = (0); } _if_result_66; });
-  el_val_t s7 = ({ el_val_t _if_result_67 = 0; if (str_contains(cmd, EL_STR("id_rsa"))) { _if_result_67 = (60); } else { _if_result_67 = (0); } _if_result_67; });
-  el_val_t s8 = ({ el_val_t _if_result_68 = 0; if (str_contains(cmd, EL_STR(".ssh/"))) { _if_result_68 = (50); } else { _if_result_68 = (0); } _if_result_68; });
-  el_val_t s9 = ({ el_val_t _if_result_69 = 0; if (str_contains(cmd, EL_STR("crontab"))) { _if_result_69 = (30); } else { _if_result_69 = (0); } _if_result_69; });
-  el_val_t s10 = ({ el_val_t _if_result_70 = 0; if (str_contains(cmd, EL_STR("LaunchDaemon"))) { _if_result_70 = (40); } else { _if_result_70 = (0); } _if_result_70; });
-  el_val_t s11 = ({ el_val_t _if_result_71 = 0; if ((str_contains(cmd, EL_STR("curl")) && str_contains(cmd, EL_STR("bash")))) { _if_result_71 = (75); } else { _if_result_71 = (0); } _if_result_71; });
-  el_val_t s12 = ({ el_val_t _if_result_72 = 0; if ((str_contains(cmd, EL_STR("wget")) && str_contains(cmd, EL_STR("bash")))) { _if_result_72 = (75); } else { _if_result_72 = (0); } _if_result_72; });
-  el_val_t s13 = ({ el_val_t _if_result_73 = 0; if ((str_contains(cmd, EL_STR("curl")) && str_contains(cmd, EL_STR("| sh")))) { _if_result_73 = (60); } else { _if_result_73 = (0); } _if_result_73; });
-  el_val_t s14 = ({ el_val_t _if_result_74 = 0; if ((str_contains(cmd, EL_STR("base64")) && str_contains(cmd, EL_STR("curl")))) { _if_result_74 = (50); } else { _if_result_74 = (0); } _if_result_74; });
-  el_val_t s15 = ({ el_val_t _if_result_75 = 0; if (str_contains(cmd, EL_STR("mkfifo"))) { _if_result_75 = (50); } else { _if_result_75 = (0); } _if_result_75; });
-  el_val_t s16 = ({ el_val_t _if_result_76 = 0; if (str_contains(cmd, EL_STR("chmod +s"))) { _if_result_76 = (70); } else { _if_result_76 = (0); } _if_result_76; });
-  el_val_t s17 = ({ el_val_t _if_result_77 = 0; if (str_contains(cmd, EL_STR("chmod 4755"))) { _if_result_77 = (70); } else { _if_result_77 = (0); } _if_result_77; });
+  el_val_t s1 = ({ el_val_t _if_result_90 = 0; if (str_contains(cmd, EL_STR("nmap"))) { _if_result_90 = (30); } else { _if_result_90 = (0); } _if_result_90; });
+  el_val_t s2 = ({ el_val_t _if_result_91 = 0; if (str_contains(cmd, EL_STR("masscan"))) { _if_result_91 = (40); } else { _if_result_91 = (0); } _if_result_91; });
+  el_val_t s3 = ({ el_val_t _if_result_92 = 0; if (str_contains(cmd, EL_STR(" nc "))) { _if_result_92 = (20); } else { _if_result_92 = (0); } _if_result_92; });
+  el_val_t s4 = ({ el_val_t _if_result_93 = 0; if (str_contains(cmd, EL_STR("netcat"))) { _if_result_93 = (20); } else { _if_result_93 = (0); } _if_result_93; });
+  el_val_t s5 = ({ el_val_t _if_result_94 = 0; if (str_contains(cmd, EL_STR("/etc/shadow"))) { _if_result_94 = (80); } else { _if_result_94 = (0); } _if_result_94; });
+  el_val_t s6 = ({ el_val_t _if_result_95 = 0; if (str_contains(cmd, EL_STR("/etc/passwd"))) { _if_result_95 = (30); } else { _if_result_95 = (0); } _if_result_95; });
+  el_val_t s7 = ({ el_val_t _if_result_96 = 0; if (str_contains(cmd, EL_STR("id_rsa"))) { _if_result_96 = (60); } else { _if_result_96 = (0); } _if_result_96; });
+  el_val_t s8 = ({ el_val_t _if_result_97 = 0; if (str_contains(cmd, EL_STR(".ssh/"))) { _if_result_97 = (50); } else { _if_result_97 = (0); } _if_result_97; });
+  el_val_t s9 = ({ el_val_t _if_result_98 = 0; if (str_contains(cmd, EL_STR("crontab"))) { _if_result_98 = (30); } else { _if_result_98 = (0); } _if_result_98; });
+  el_val_t s10 = ({ el_val_t _if_result_99 = 0; if (str_contains(cmd, EL_STR("LaunchDaemon"))) { _if_result_99 = (40); } else { _if_result_99 = (0); } _if_result_99; });
+  el_val_t s11 = ({ el_val_t _if_result_100 = 0; if ((str_contains(cmd, EL_STR("curl")) && str_contains(cmd, EL_STR("bash")))) { _if_result_100 = (75); } else { _if_result_100 = (0); } _if_result_100; });
+  el_val_t s12 = ({ el_val_t _if_result_101 = 0; if ((str_contains(cmd, EL_STR("wget")) && str_contains(cmd, EL_STR("bash")))) { _if_result_101 = (75); } else { _if_result_101 = (0); } _if_result_101; });
+  el_val_t s13 = ({ el_val_t _if_result_102 = 0; if ((str_contains(cmd, EL_STR("curl")) && str_contains(cmd, EL_STR("| sh")))) { _if_result_102 = (60); } else { _if_result_102 = (0); } _if_result_102; });
+  el_val_t s14 = ({ el_val_t _if_result_103 = 0; if ((str_contains(cmd, EL_STR("base64")) && str_contains(cmd, EL_STR("curl")))) { _if_result_103 = (50); } else { _if_result_103 = (0); } _if_result_103; });
+  el_val_t s15 = ({ el_val_t _if_result_104 = 0; if (str_contains(cmd, EL_STR("mkfifo"))) { _if_result_104 = (50); } else { _if_result_104 = (0); } _if_result_104; });
+  el_val_t s16 = ({ el_val_t _if_result_105 = 0; if (str_contains(cmd, EL_STR("chmod +s"))) { _if_result_105 = (70); } else { _if_result_105 = (0); } _if_result_105; });
+  el_val_t s17 = ({ el_val_t _if_result_106 = 0; if (str_contains(cmd, EL_STR("chmod 4755"))) { _if_result_106 = (70); } else { _if_result_106 = (0); } _if_result_106; });
   return ((((((((((((((((s1 + s2) + s3) + s4) + s5) + s6) + s7) + s8) + s9) + s10) + s11) + s12) + s13) + s14) + s15) + s16) + s17);
   return 0;
 }
 
 el_val_t threat_score_path(el_val_t path) {
-  el_val_t s1 = ({ el_val_t _if_result_78 = 0; if (str_starts_with(path, EL_STR("/etc/"))) { _if_result_78 = (60); } else { _if_result_78 = (0); } _if_result_78; });
-  el_val_t s2 = ({ el_val_t _if_result_79 = 0; if (str_contains(path, EL_STR("/.ssh/"))) { _if_result_79 = (70); } else { _if_result_79 = (0); } _if_result_79; });
-  el_val_t s3 = ({ el_val_t _if_result_80 = 0; if (str_contains(path, EL_STR("/LaunchDaemons/"))) { _if_result_80 = (80); } else { _if_result_80 = (0); } _if_result_80; });
-  el_val_t s4 = ({ el_val_t _if_result_81 = 0; if (str_contains(path, EL_STR("/LaunchAgents/"))) { _if_result_81 = (40); } else { _if_result_81 = (0); } _if_result_81; });
-  el_val_t s5 = ({ el_val_t _if_result_82 = 0; if (str_contains(path, EL_STR("/cron"))) { _if_result_82 = (60); } else { _if_result_82 = (0); } _if_result_82; });
-  el_val_t s6 = ({ el_val_t _if_result_83 = 0; if (str_contains(path, EL_STR("/.bashrc"))) { _if_result_83 = (35); } else { _if_result_83 = (0); } _if_result_83; });
-  el_val_t s7 = ({ el_val_t _if_result_84 = 0; if (str_contains(path, EL_STR("/.zshrc"))) { _if_result_84 = (35); } else { _if_result_84 = (0); } _if_result_84; });
-  el_val_t s8 = ({ el_val_t _if_result_85 = 0; if (str_contains(path, EL_STR("/.profile"))) { _if_result_85 = (35); } else { _if_result_85 = (0); } _if_result_85; });
-  el_val_t s9 = ({ el_val_t _if_result_86 = 0; if (str_starts_with(path, EL_STR("/usr/"))) { _if_result_86 = (50); } else { _if_result_86 = (0); } _if_result_86; });
-  el_val_t s10 = ({ el_val_t _if_result_87 = 0; if (str_starts_with(path, EL_STR("/bin/"))) { _if_result_87 = (70); } else { _if_result_87 = (0); } _if_result_87; });
-  el_val_t s11 = ({ el_val_t _if_result_88 = 0; if (str_starts_with(path, EL_STR("/sbin/"))) { _if_result_88 = (70); } else { _if_result_88 = (0); } _if_result_88; });
+  el_val_t s1 = ({ el_val_t _if_result_107 = 0; if (str_starts_with(path, EL_STR("/etc/"))) { _if_result_107 = (60); } else { _if_result_107 = (0); } _if_result_107; });
+  el_val_t s2 = ({ el_val_t _if_result_108 = 0; if (str_contains(path, EL_STR("/.ssh/"))) { _if_result_108 = (70); } else { _if_result_108 = (0); } _if_result_108; });
+  el_val_t s3 = ({ el_val_t _if_result_109 = 0; if (str_contains(path, EL_STR("/LaunchDaemons/"))) { _if_result_109 = (80); } else { _if_result_109 = (0); } _if_result_109; });
+  el_val_t s4 = ({ el_val_t _if_result_110 = 0; if (str_contains(path, EL_STR("/LaunchAgents/"))) { _if_result_110 = (40); } else { _if_result_110 = (0); } _if_result_110; });
+  el_val_t s5 = ({ el_val_t _if_result_111 = 0; if (str_contains(path, EL_STR("/cron"))) { _if_result_111 = (60); } else { _if_result_111 = (0); } _if_result_111; });
+  el_val_t s6 = ({ el_val_t _if_result_112 = 0; if (str_contains(path, EL_STR("/.bashrc"))) { _if_result_112 = (35); } else { _if_result_112 = (0); } _if_result_112; });
+  el_val_t s7 = ({ el_val_t _if_result_113 = 0; if (str_contains(path, EL_STR("/.zshrc"))) { _if_result_113 = (35); } else { _if_result_113 = (0); } _if_result_113; });
+  el_val_t s8 = ({ el_val_t _if_result_114 = 0; if (str_contains(path, EL_STR("/.profile"))) { _if_result_114 = (35); } else { _if_result_114 = (0); } _if_result_114; });
+  el_val_t s9 = ({ el_val_t _if_result_115 = 0; if (str_starts_with(path, EL_STR("/usr/"))) { _if_result_115 = (50); } else { _if_result_115 = (0); } _if_result_115; });
+  el_val_t s10 = ({ el_val_t _if_result_116 = 0; if (str_starts_with(path, EL_STR("/bin/"))) { _if_result_116 = (70); } else { _if_result_116 = (0); } _if_result_116; });
+  el_val_t s11 = ({ el_val_t _if_result_117 = 0; if (str_starts_with(path, EL_STR("/sbin/"))) { _if_result_117 = (70); } else { _if_result_117 = (0); } _if_result_117; });
   return ((((((((((s1 + s2) + s3) + s4) + s5) + s6) + s7) + s8) + s9) + s10) + s11);
   return 0;
 }
 
 el_val_t threat_score_history(el_val_t history) {
-  el_val_t s1 = ({ el_val_t _if_result_89 = 0; if (str_contains(history, EL_STR("port scan"))) { _if_result_89 = (15); } else { _if_result_89 = (0); } _if_result_89; });
-  el_val_t s2 = ({ el_val_t _if_result_90 = 0; if (str_contains(history, EL_STR("enumerate"))) { _if_result_90 = (10); } else { _if_result_90 = (0); } _if_result_90; });
-  el_val_t s3 = ({ el_val_t _if_result_91 = 0; if (str_contains(history, EL_STR("exploit"))) { _if_result_91 = (20); } else { _if_result_91 = (0); } _if_result_91; });
-  el_val_t s4 = ({ el_val_t _if_result_92 = 0; if (str_contains(history, EL_STR("payload"))) { _if_result_92 = (15); } else { _if_result_92 = (0); } _if_result_92; });
-  el_val_t s5 = ({ el_val_t _if_result_93 = 0; if (str_contains(history, EL_STR("persistence"))) { _if_result_93 = (15); } else { _if_result_93 = (0); } _if_result_93; });
-  el_val_t s6 = ({ el_val_t _if_result_94 = 0; if (str_contains(history, EL_STR("lateral movement"))) { _if_result_94 = (25); } else { _if_result_94 = (0); } _if_result_94; });
-  el_val_t s7 = ({ el_val_t _if_result_95 = 0; if (str_contains(history, EL_STR("privilege escalation"))) { _if_result_95 = (25); } else { _if_result_95 = (0); } _if_result_95; });
-  el_val_t s8 = ({ el_val_t _if_result_96 = 0; if (str_contains(history, EL_STR("reverse shell"))) { _if_result_96 = (40); } else { _if_result_96 = (0); } _if_result_96; });
-  el_val_t s9 = ({ el_val_t _if_result_97 = 0; if (str_contains(history, EL_STR("bind shell"))) { _if_result_97 = (40); } else { _if_result_97 = (0); } _if_result_97; });
-  el_val_t s10 = ({ el_val_t _if_result_98 = 0; if (str_contains(history, EL_STR("command and control"))) { _if_result_98 = (35); } else { _if_result_98 = (0); } _if_result_98; });
-  el_val_t s11 = ({ el_val_t _if_result_99 = 0; if (str_contains(history, EL_STR("self-replicate"))) { _if_result_99 = (45); } else { _if_result_99 = (0); } _if_result_99; });
-  el_val_t s12 = ({ el_val_t _if_result_100 = 0; if (str_contains(history, EL_STR("propagat"))) { _if_result_100 = (20); } else { _if_result_100 = (0); } _if_result_100; });
-  el_val_t s13 = ({ el_val_t _if_result_101 = 0; if (str_contains(history, EL_STR("ransomware"))) { _if_result_101 = (30); } else { _if_result_101 = (0); } _if_result_101; });
-  el_val_t s14 = ({ el_val_t _if_result_102 = 0; if (str_contains(history, EL_STR("encrypt files"))) { _if_result_102 = (40); } else { _if_result_102 = (0); } _if_result_102; });
-  el_val_t s15 = ({ el_val_t _if_result_103 = 0; if (str_contains(history, EL_STR("exfiltrat"))) { _if_result_103 = (35); } else { _if_result_103 = (0); } _if_result_103; });
-  el_val_t s16 = ({ el_val_t _if_result_104 = 0; if (str_contains(history, EL_STR("zero-day"))) { _if_result_104 = (20); } else { _if_result_104 = (0); } _if_result_104; });
-  el_val_t s17 = ({ el_val_t _if_result_105 = 0; if (str_contains(history, EL_STR("rootkit"))) { _if_result_105 = (45); } else { _if_result_105 = (0); } _if_result_105; });
-  el_val_t s18 = ({ el_val_t _if_result_106 = 0; if (str_contains(history, EL_STR("keylogger"))) { _if_result_106 = (45); } else { _if_result_106 = (0); } _if_result_106; });
-  el_val_t s19 = ({ el_val_t _if_result_107 = 0; if (str_contains(history, EL_STR("botnet"))) { _if_result_107 = (40); } else { _if_result_107 = (0); } _if_result_107; });
-  el_val_t s20 = ({ el_val_t _if_result_108 = 0; if (str_contains(history, EL_STR("malware"))) { _if_result_108 = (15); } else { _if_result_108 = (0); } _if_result_108; });
+  el_val_t s1 = ({ el_val_t _if_result_118 = 0; if (str_contains(history, EL_STR("port scan"))) { _if_result_118 = (15); } else { _if_result_118 = (0); } _if_result_118; });
+  el_val_t s2 = ({ el_val_t _if_result_119 = 0; if (str_contains(history, EL_STR("enumerate"))) { _if_result_119 = (10); } else { _if_result_119 = (0); } _if_result_119; });
+  el_val_t s3 = ({ el_val_t _if_result_120 = 0; if (str_contains(history, EL_STR("exploit"))) { _if_result_120 = (20); } else { _if_result_120 = (0); } _if_result_120; });
+  el_val_t s4 = ({ el_val_t _if_result_121 = 0; if (str_contains(history, EL_STR("payload"))) { _if_result_121 = (15); } else { _if_result_121 = (0); } _if_result_121; });
+  el_val_t s5 = ({ el_val_t _if_result_122 = 0; if (str_contains(history, EL_STR("persistence"))) { _if_result_122 = (15); } else { _if_result_122 = (0); } _if_result_122; });
+  el_val_t s6 = ({ el_val_t _if_result_123 = 0; if (str_contains(history, EL_STR("lateral movement"))) { _if_result_123 = (25); } else { _if_result_123 = (0); } _if_result_123; });
+  el_val_t s7 = ({ el_val_t _if_result_124 = 0; if (str_contains(history, EL_STR("privilege escalation"))) { _if_result_124 = (25); } else { _if_result_124 = (0); } _if_result_124; });
+  el_val_t s8 = ({ el_val_t _if_result_125 = 0; if (str_contains(history, EL_STR("reverse shell"))) { _if_result_125 = (40); } else { _if_result_125 = (0); } _if_result_125; });
+  el_val_t s9 = ({ el_val_t _if_result_126 = 0; if (str_contains(history, EL_STR("bind shell"))) { _if_result_126 = (40); } else { _if_result_126 = (0); } _if_result_126; });
+  el_val_t s10 = ({ el_val_t _if_result_127 = 0; if (str_contains(history, EL_STR("command and control"))) { _if_result_127 = (35); } else { _if_result_127 = (0); } _if_result_127; });
+  el_val_t s11 = ({ el_val_t _if_result_128 = 0; if (str_contains(history, EL_STR("self-replicate"))) { _if_result_128 = (45); } else { _if_result_128 = (0); } _if_result_128; });
+  el_val_t s12 = ({ el_val_t _if_result_129 = 0; if (str_contains(history, EL_STR("propagat"))) { _if_result_129 = (20); } else { _if_result_129 = (0); } _if_result_129; });
+  el_val_t s13 = ({ el_val_t _if_result_130 = 0; if (str_contains(history, EL_STR("ransomware"))) { _if_result_130 = (30); } else { _if_result_130 = (0); } _if_result_130; });
+  el_val_t s14 = ({ el_val_t _if_result_131 = 0; if (str_contains(history, EL_STR("encrypt files"))) { _if_result_131 = (40); } else { _if_result_131 = (0); } _if_result_131; });
+  el_val_t s15 = ({ el_val_t _if_result_132 = 0; if (str_contains(history, EL_STR("exfiltrat"))) { _if_result_132 = (35); } else { _if_result_132 = (0); } _if_result_132; });
+  el_val_t s16 = ({ el_val_t _if_result_133 = 0; if (str_contains(history, EL_STR("zero-day"))) { _if_result_133 = (20); } else { _if_result_133 = (0); } _if_result_133; });
+  el_val_t s17 = ({ el_val_t _if_result_134 = 0; if (str_contains(history, EL_STR("rootkit"))) { _if_result_134 = (45); } else { _if_result_134 = (0); } _if_result_134; });
+  el_val_t s18 = ({ el_val_t _if_result_135 = 0; if (str_contains(history, EL_STR("keylogger"))) { _if_result_135 = (45); } else { _if_result_135 = (0); } _if_result_135; });
+  el_val_t s19 = ({ el_val_t _if_result_136 = 0; if (str_contains(history, EL_STR("botnet"))) { _if_result_136 = (40); } else { _if_result_136 = (0); } _if_result_136; });
+  el_val_t s20 = ({ el_val_t _if_result_137 = 0; if (str_contains(history, EL_STR("malware"))) { _if_result_137 = (15); } else { _if_result_137 = (0); } _if_result_137; });
   return (((((((((((((((((((s1 + s2) + s3) + s4) + s5) + s6) + s7) + s8) + s9) + s10) + s11) + s12) + s13) + s14) + s15) + s16) + s17) + s18) + s19) + s20);
   return 0;
 }
 
 el_val_t threat_trajectory_check(el_val_t tool_name, el_val_t tool_input) {
   el_val_t history = state_get(EL_STR("agentic_conv_history"));
-  el_val_t computed_tool_score = ({ el_val_t _if_result_109 = 0; if (str_eq(tool_name, EL_STR("run_command"))) { el_val_t cmd = json_get(tool_input, EL_STR("command")); _if_result_109 = (threat_score_command(cmd)); } else { _if_result_109 = (({ el_val_t _if_result_110 = 0; if ((str_eq(tool_name, EL_STR("write_file")) || str_eq(tool_name, EL_STR("edit_file")))) { el_val_t path = json_get(tool_input, EL_STR("path")); _if_result_110 = (threat_score_path(path)); } else { _if_result_110 = (0); } _if_result_110; })); } _if_result_109; });
+  el_val_t computed_tool_score = ({ el_val_t _if_result_138 = 0; if (str_eq(tool_name, EL_STR("run_command"))) { el_val_t cmd = json_get(tool_input, EL_STR("command")); _if_result_138 = (threat_score_command(cmd)); } else { _if_result_138 = (({ el_val_t _if_result_139 = 0; if ((str_eq(tool_name, EL_STR("write_file")) || str_eq(tool_name, EL_STR("edit_file")))) { el_val_t path = json_get(tool_input, EL_STR("path")); _if_result_139 = (threat_score_path(path)); } else { _if_result_139 = (0); } _if_result_139; })); } _if_result_138; });
   el_val_t history_score = threat_score_history(history);
   el_val_t history_contrib = (history_score / 3);
   el_val_t combined = (computed_tool_score + history_contrib);
   el_val_t should_log = (combined >= 40);
   if (should_log) {
     el_val_t ts = time_now();
-    el_val_t authorized_str = ({ el_val_t _if_result_111 = 0; if (security_research_authorized()) { _if_result_111 = (EL_STR("true")); } else { _if_result_111 = (EL_STR("false")); } _if_result_111; });
+    el_val_t authorized_str = ({ el_val_t _if_result_140 = 0; if (security_research_authorized()) { _if_result_140 = (EL_STR("true")); } else { _if_result_140 = (EL_STR("false")); } _if_result_140; });
     el_val_t log_content = el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"event\":\"threat_check\",\"tool\":\""), tool_name), EL_STR("\",\"score\":")), int_to_str(combined)), EL_STR(",\"tool_score\":")), int_to_str(computed_tool_score)), EL_STR(",\"history_score\":")), int_to_str(history_score)), EL_STR(",\"authorized\":")), authorized_str), EL_STR(",\"ts\":")), int_to_str(ts)), EL_STR("}"));
     el_val_t log_tags = EL_STR("[\"security-audit\",\"threat-check\"]");
     el_val_t discard = mem_remember(log_content, log_tags);
@@ -758,7 +863,7 @@ el_val_t threat_history_append(el_val_t text) {
   el_val_t safe_text = str_to_lower(text);
   el_val_t combined = el_str_concat(el_str_concat(current, EL_STR(" ")), safe_text);
   el_val_t len = str_len(combined);
-  el_val_t trimmed = ({ el_val_t _if_result_112 = 0; if ((len > 2000)) { _if_result_112 = (str_slice(combined, (len - 2000), len)); } else { _if_result_112 = (combined); } _if_result_112; });
+  el_val_t trimmed = ({ el_val_t _if_result_141 = 0; if ((len > 2000)) { _if_result_141 = (str_slice(combined, (len - 2000), len)); } else { _if_result_141 = (combined); } _if_result_141; });
   state_set(EL_STR("agentic_conv_history"), trimmed);
   return 0;
 }

dist/elp-c-decls.h

@@ -20,8 +20,8 @@ el_val_t akk_alaku_present(el_val_t slot);
 el_val_t akk_amaru_perfect(el_val_t slot);
 el_val_t akk_amaru_present(el_val_t slot);
 el_val_t akk_amaru_stative(el_val_t slot);
-el_val_t akk_conjugate_copula(el_val_t tense, el_val_t slot);
 el_val_t akk_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number);
+el_val_t akk_conjugate_copula(el_val_t tense, el_val_t slot);
 el_val_t akk_copula_present(el_val_t slot);
 el_val_t akk_copula_stative(el_val_t slot);
 el_val_t akk_decline(el_val_t noun, el_val_t gram_case, el_val_t number);
@@ -39,25 +39,25 @@ el_val_t akk_qabu_stative(el_val_t slot);
 el_val_t akk_regular_perfect(el_val_t stem, el_val_t slot);
 el_val_t akk_regular_present(el_val_t stem, el_val_t slot);
 el_val_t akk_regular_stative(el_val_t stem, el_val_t slot);
-el_val_t akk_slot_g(el_val_t person, el_val_t gender, el_val_t number);
 el_val_t akk_slot(el_val_t person, el_val_t number);
+el_val_t akk_slot_g(el_val_t person, el_val_t gender, el_val_t number);
 el_val_t akk_str_drop_last(el_val_t s, el_val_t n);
 el_val_t akk_str_ends(el_val_t s, el_val_t suf);
 el_val_t akk_str_len(el_val_t s);
 el_val_t akk_strip_nom(el_val_t noun);
+el_val_t ang_article(el_val_t gender, el_val_t gram_case, el_val_t number);
 el_val_t ang_article_feminine(el_val_t gram_case, el_val_t number);
 el_val_t ang_article_masculine(el_val_t gram_case, el_val_t number);
 el_val_t ang_article_neuter(el_val_t gram_case, el_val_t number);
-el_val_t ang_article(el_val_t gender, el_val_t gram_case, el_val_t number);
 el_val_t ang_beon_present(el_val_t slot);
 el_val_t ang_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number);
 el_val_t ang_cuman_past(el_val_t slot);
 el_val_t ang_cuman_present(el_val_t slot);
 el_val_t ang_declension(el_val_t noun, el_val_t gender);
+el_val_t ang_decline(el_val_t noun, el_val_t gram_case, el_val_t number, el_val_t gender);
 el_val_t ang_decline_strong_masc(el_val_t noun, el_val_t gram_case, el_val_t number);
 el_val_t ang_decline_strong_neut(el_val_t noun, el_val_t gram_case, el_val_t number);
 el_val_t ang_decline_weak(el_val_t noun, el_val_t gram_case, el_val_t number);
-el_val_t ang_decline(el_val_t noun, el_val_t gram_case, el_val_t number, el_val_t gender);
 el_val_t ang_don_past(el_val_t slot);
 el_val_t ang_don_present(el_val_t slot);
 el_val_t ang_gan_past(el_val_t slot);
@@ -76,10 +76,10 @@ el_val_t ang_seon_present(el_val_t slot);
 el_val_t ang_slot(el_val_t person, el_val_t number);
 el_val_t ang_str_drop_last(el_val_t s, el_val_t n);
 el_val_t ang_str_ends(el_val_t s, el_val_t suf);
-el_val_t ang_str_last_char(el_val_t s);
 el_val_t ang_str_last2(el_val_t s);
-el_val_t ang_weak_past_stem(el_val_t stem);
+el_val_t ang_str_last_char(el_val_t s);
 el_val_t ang_weak_past(el_val_t stem, el_val_t slot);
+el_val_t ang_weak_past_stem(el_val_t stem);
 el_val_t ang_weak_present_ending(el_val_t slot);
 el_val_t ang_weak_stem(el_val_t verb);
 el_val_t ang_wesan_past(el_val_t slot);
@@ -88,30 +88,35 @@ el_val_t ang_willan_past(el_val_t slot);
 el_val_t ang_willan_present(el_val_t slot);
 el_val_t ang_witan_past(el_val_t slot);
 el_val_t ang_witan_present(el_val_t slot);
-el_val_t api_err_protected(el_val_t id);
+el_val_t api_compact_activated(el_val_t raw, el_val_t max_items, el_val_t snip);
+el_val_t api_compact_node(el_val_t node, el_val_t snip);
+el_val_t api_compact_node_array(el_val_t raw, el_val_t max_items, el_val_t snip);
 el_val_t api_err(el_val_t msg);
+el_val_t api_err_protected(el_val_t id);
 el_val_t api_json_escape(el_val_t s);
 el_val_t api_nonempty(el_val_t s);
 el_val_t api_not_persisted(el_val_t id);
+el_val_t api_num_or_zero(el_val_t obj, el_val_t key);
 el_val_t api_ok(el_val_t extra);
 el_val_t api_or_empty(el_val_t s);
 el_val_t api_persisted(el_val_t id);
 el_val_t api_query_int(el_val_t path, el_val_t key, el_val_t default_val);
 el_val_t api_query_param(el_val_t path, el_val_t key);
+el_val_t api_utf8_trunc(el_val_t s, el_val_t n);
 el_val_t ar_case_ending(el_val_t kase, el_val_t definite);
-el_val_t ar_conjugate_form1(el_val_t past_base, el_val_t present_stem, el_val_t tense, el_val_t slot);
 el_val_t ar_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t gender, el_val_t number);
+el_val_t ar_conjugate_form1(el_val_t past_base, el_val_t present_stem, el_val_t tense, el_val_t slot);
 el_val_t ar_definite_article(el_val_t noun);
 el_val_t ar_gender(el_val_t noun);
 el_val_t ar_imperfect_prefix(el_val_t slot);
 el_val_t ar_imperfect_suffix(el_val_t slot);
+el_val_t ar_irregular(el_val_t verb, el_val_t tense, el_val_t slot);
 el_val_t ar_irregular_araada(el_val_t slot, el_val_t tense);
 el_val_t ar_irregular_istata(el_val_t slot, el_val_t tense);
 el_val_t ar_irregular_jaa(el_val_t slot, el_val_t tense);
 el_val_t ar_irregular_kaana(el_val_t slot, el_val_t tense);
 el_val_t ar_irregular_qaala(el_val_t slot, el_val_t tense);
 el_val_t ar_irregular_raaa(el_val_t slot, el_val_t tense);
-el_val_t ar_irregular(el_val_t verb, el_val_t tense, el_val_t slot);
 el_val_t ar_is_sun_letter(el_val_t c);
 el_val_t ar_masc_pl_ending(el_val_t kase);
 el_val_t ar_noun_form(el_val_t noun, el_val_t gender, el_val_t kase, el_val_t number, el_val_t definite);
@@ -174,8 +179,8 @@ el_val_t cop_map_canonical(el_val_t verb);
 el_val_t cop_nau_future(el_val_t prefix);
 el_val_t cop_nau_perfect(el_val_t prefix);
 el_val_t cop_nau_present(el_val_t prefix);
-el_val_t cop_noun_phrase_gendered(el_val_t noun, el_val_t gram_case, el_val_t number, el_val_t definite, el_val_t gender);
 el_val_t cop_noun_phrase(el_val_t noun, el_val_t gram_case, el_val_t number, el_val_t definite);
+el_val_t cop_noun_phrase_gendered(el_val_t noun, el_val_t gram_case, el_val_t number, el_val_t definite, el_val_t gender);
 el_val_t cop_regular_future(el_val_t prefix, el_val_t stem);
 el_val_t cop_regular_perfect(el_val_t prefix, el_val_t stem);
 el_val_t cop_regular_present(el_val_t prefix, el_val_t stem);
@@ -185,16 +190,16 @@ el_val_t cop_shwpe_present(el_val_t prefix);
 el_val_t cop_slot(el_val_t person, el_val_t number);
 el_val_t cop_str_ends(el_val_t s, el_val_t suf);
 el_val_t cop_str_len(el_val_t s);
-el_val_t cop_subject_prefix_gendered(el_val_t person, el_val_t gender, el_val_t number);
 el_val_t cop_subject_prefix(el_val_t person, el_val_t number);
+el_val_t cop_subject_prefix_gendered(el_val_t person, el_val_t gender, el_val_t number);
 el_val_t current_engine_note(el_val_t model);
 el_val_t de_adj_ending(el_val_t gender, el_val_t gram_case, el_val_t number, el_val_t article_type);
+el_val_t de_article(el_val_t gender, el_val_t gram_case, el_val_t number, el_val_t definite);
 el_val_t de_article_def(el_val_t gender, el_val_t gram_case, el_val_t number);
 el_val_t de_article_indef(el_val_t gender, el_val_t gram_case, el_val_t number);
-el_val_t de_article(el_val_t gender, el_val_t gram_case, el_val_t number, el_val_t definite);
 el_val_t de_case_ending(el_val_t noun, el_val_t gender, el_val_t gram_case, el_val_t number);
-el_val_t de_conjugate_weak(el_val_t stem, el_val_t tense, el_val_t person, el_val_t number);
 el_val_t de_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number);
+el_val_t de_conjugate_weak(el_val_t stem, el_val_t tense, el_val_t person, el_val_t number);
 el_val_t de_irregular_present(el_val_t verb, el_val_t person, el_val_t number);
 el_val_t de_norm_number(el_val_t number);
 el_val_t de_norm_person(el_val_t person);
@@ -204,12 +209,15 @@ el_val_t dharma_network_state(void);
 el_val_t dharma_registry(void);
 el_val_t dispatch_tool(el_val_t tool_name, el_val_t tool_input);
 el_val_t distill_transcript(el_val_t transcript);
-el_val_t egy_conjugate_copula(el_val_t tense, el_val_t slot);
-el_val_t egy_conjugate_pronoun(el_val_t person, el_val_t number);
-el_val_t egy_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number);
 el_val_t egy_Dd_future(el_val_t slot);
 el_val_t egy_Dd_past(el_val_t slot);
 el_val_t egy_Dd_present(el_val_t slot);
+el_val_t egy_Sm_future(el_val_t slot);
+el_val_t egy_Sm_past(el_val_t slot);
+el_val_t egy_Sm_present(el_val_t slot);
+el_val_t egy_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number);
+el_val_t egy_conjugate_copula(el_val_t tense, el_val_t slot);
+el_val_t egy_conjugate_pronoun(el_val_t person, el_val_t number);
 el_val_t egy_decline(el_val_t noun, el_val_t gram_case, el_val_t number);
 el_val_t egy_drop(el_val_t s, el_val_t n);
 el_val_t egy_fem(el_val_t noun);
@@ -233,11 +241,8 @@ el_val_t egy_regular_present(el_val_t stem, el_val_t slot);
 el_val_t egy_sdm_future(el_val_t slot);
 el_val_t egy_sdm_past(el_val_t slot);
 el_val_t egy_sdm_present(el_val_t slot);
-el_val_t egy_slot_with_gender(el_val_t person, el_val_t gender, el_val_t number);
 el_val_t egy_slot(el_val_t person, el_val_t number);
-el_val_t egy_Sm_future(el_val_t slot);
-el_val_t egy_Sm_past(el_val_t slot);
-el_val_t egy_Sm_present(el_val_t slot);
+el_val_t egy_slot_with_gender(el_val_t person, el_val_t gender, el_val_t number);
 el_val_t egy_str_ends(el_val_t s, el_val_t suf);
 el_val_t egy_str_len(el_val_t s);
 el_val_t egy_suffix_pronoun(el_val_t slot);
@@ -258,9 +263,9 @@ el_val_t en_verb_3sg(el_val_t base);
 el_val_t en_verb_form(el_val_t base, el_val_t tense, el_val_t person, el_val_t number);
 el_val_t en_verb_gerund(el_val_t base);
 el_val_t en_verb_past(el_val_t base);
+el_val_t engram_compile(el_val_t intent);
 el_val_t engram_compile_multi(el_val_t topic);
 el_val_t engram_compile_ranked(el_val_t nodes_json, el_val_t max_nodes);
-el_val_t engram_compile(el_val_t intent);
 el_val_t engram_dedup_nodes(el_val_t nodes_json);
 el_val_t engram_detect_recall_intent(el_val_t message);
 el_val_t engram_extract_entities(el_val_t message);
@@ -326,9 +331,9 @@ el_val_t es_starts_with_stressed_a(el_val_t noun);
 el_val_t es_stem(el_val_t base);
 el_val_t es_str_drop_last(el_val_t s, el_val_t n);
 el_val_t es_str_ends(el_val_t s, el_val_t suf);
-el_val_t es_str_last_char(el_val_t s);
 el_val_t es_str_last2(el_val_t s);
 el_val_t es_str_last3(el_val_t s);
+el_val_t es_str_last_char(el_val_t s);
 el_val_t es_verb_class(el_val_t base);
 el_val_t extract_dim(el_val_t content, el_val_t key);
 el_val_t fi_apply_case(el_val_t noun, el_val_t gram_case, el_val_t number);
@@ -371,8 +376,8 @@ el_val_t fr_slot(el_val_t person, el_val_t number);
 el_val_t fr_stem(el_val_t base);
 el_val_t fr_str_drop_last(el_val_t s, el_val_t n);
 el_val_t fr_str_ends(el_val_t s, el_val_t suf);
-el_val_t fr_str_last_char(el_val_t s);
 el_val_t fr_str_last2(el_val_t s);
+el_val_t fr_str_last_char(el_val_t s);
 el_val_t fr_subject_starts_vowel(el_val_t subject);
 el_val_t fr_uses_etre(el_val_t verb);
 el_val_t fr_verb_ends_vowel(el_val_t verb_form);
@@ -394,9 +399,9 @@ el_val_t fro_conj3_future(el_val_t verb, el_val_t slot);
 el_val_t fro_conj3_past(el_val_t stem, el_val_t slot);
 el_val_t fro_conj3_present(el_val_t stem, el_val_t slot);
 el_val_t fro_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number);
+el_val_t fro_decline(el_val_t noun, el_val_t gram_case, el_val_t number);
 el_val_t fro_decline_fem(el_val_t noun, el_val_t number);
 el_val_t fro_decline_masc(el_val_t noun, el_val_t gram_case, el_val_t number);
-el_val_t fro_decline(el_val_t noun, el_val_t gram_case, el_val_t number);
 el_val_t fro_drop(el_val_t s, el_val_t n);
 el_val_t fro_estre_future(el_val_t slot);
 el_val_t fro_estre_past(el_val_t slot);
@@ -414,15 +419,15 @@ el_val_t fro_venir_past(el_val_t slot);
 el_val_t fro_venir_present(el_val_t slot);
 el_val_t fro_verb_class(el_val_t verb);
 el_val_t fro_verb_stem(el_val_t verb, el_val_t vclass);
-el_val_t generate_frame_lang(el_val_t frame, el_val_t lang_code);
+el_val_t generate(el_val_t semantic_form_json);
 el_val_t generate_frame(el_val_t frame);
+el_val_t generate_frame_lang(el_val_t frame, el_val_t lang_code);
 el_val_t generate_lang(el_val_t semantic_form_json, el_val_t lang_code);
 el_val_t generate_tree(el_val_t rule_id_str, el_val_t slots);
-el_val_t generate(el_val_t semantic_form_json);
 el_val_t get_rules(void);
 el_val_t get_vocab(void);
-el_val_t gez_conjugate_copula(el_val_t tense, el_val_t slot);
 el_val_t gez_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number);
+el_val_t gez_conjugate_copula(el_val_t tense, el_val_t slot);
 el_val_t gez_decline(el_val_t noun, el_val_t gram_case, el_val_t number);
 el_val_t gez_generic_imperfect(el_val_t base3sg, el_val_t slot);
 el_val_t gez_generic_perfect(el_val_t base3sg, el_val_t slot);
@@ -441,12 +446,13 @@ el_val_t gez_qwl_imperfect(el_val_t slot);
 el_val_t gez_qwl_perfect(el_val_t slot);
 el_val_t gez_ray_imperfect(el_val_t slot);
 el_val_t gez_ray_perfect(el_val_t slot);
-el_val_t gez_slot_g(el_val_t person, el_val_t gender, el_val_t number);
 el_val_t gez_slot(el_val_t person, el_val_t number);
+el_val_t gez_slot_g(el_val_t person, el_val_t gender, el_val_t number);
 el_val_t gez_str_drop_last(el_val_t s, el_val_t n);
 el_val_t gez_str_ends(el_val_t s, el_val_t suf);
 el_val_t gez_str_len(el_val_t s);
 el_val_t goh_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number);
+el_val_t goh_decline(el_val_t noun, el_val_t gram_case, el_val_t number);
 el_val_t goh_decline_fem_o_pl(el_val_t stem, el_val_t gram_case);
 el_val_t goh_decline_fem_o_sg(el_val_t stem, el_val_t gram_case);
 el_val_t goh_decline_masc_a_pl(el_val_t stem, el_val_t gram_case);
@@ -455,7 +461,6 @@ el_val_t goh_decline_masc_n_pl(el_val_t stem, el_val_t gram_case);
 el_val_t goh_decline_masc_n_sg(el_val_t stem, el_val_t gram_case);
 el_val_t goh_decline_neut_a_pl(el_val_t stem, el_val_t gram_case);
 el_val_t goh_decline_neut_a_sg(el_val_t stem, el_val_t gram_case);
-el_val_t goh_decline(el_val_t noun, el_val_t gram_case, el_val_t number);
 el_val_t goh_demo_article(el_val_t stype, el_val_t number);
 el_val_t goh_drop(el_val_t s, el_val_t n);
 el_val_t goh_extract_stem(el_val_t noun, el_val_t stype);
@@ -480,13 +485,13 @@ el_val_t goh_weak_present(el_val_t stem, el_val_t slot);
 el_val_t goh_wesan_past(el_val_t slot);
 el_val_t goh_wesan_present(el_val_t slot);
 el_val_t got_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number);
+el_val_t got_decline(el_val_t noun, el_val_t gram_case, el_val_t number);
 el_val_t got_decline_a_stem_pl(el_val_t stem, el_val_t gram_case);
 el_val_t got_decline_a_stem_sg(el_val_t stem, el_val_t gram_case);
 el_val_t got_decline_n_stem_pl(el_val_t stem, el_val_t gram_case);
 el_val_t got_decline_n_stem_sg(el_val_t stem, el_val_t gram_case);
 el_val_t got_decline_o_stem_pl(el_val_t stem, el_val_t gram_case);
 el_val_t got_decline_o_stem_sg(el_val_t stem, el_val_t gram_case);
-el_val_t got_decline(el_val_t noun, el_val_t gram_case, el_val_t number);
 el_val_t got_demo_article(el_val_t stype);
 el_val_t got_extract_stem(el_val_t noun, el_val_t stype);
 el_val_t got_gaggan_past(el_val_t slot);
@@ -519,17 +524,17 @@ el_val_t gram_build_vp(el_val_t verb, el_val_t aux, el_val_t profile);
 el_val_t gram_order_constituents(el_val_t subj, el_val_t verb, el_val_t obj, el_val_t profile);
 el_val_t gram_question_strategy(el_val_t profile);
 el_val_t gram_word_order(el_val_t profile);
+el_val_t grc_article(el_val_t gender, el_val_t gram_case, el_val_t number);
 el_val_t grc_article_feminine(el_val_t gram_case, el_val_t number);
 el_val_t grc_article_masculine(el_val_t gram_case, el_val_t number);
 el_val_t grc_article_neuter(el_val_t gram_case, el_val_t number);
-el_val_t grc_article(el_val_t gender, el_val_t gram_case, el_val_t number);
 el_val_t grc_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number);
 el_val_t grc_declension(el_val_t noun);
+el_val_t grc_decline(el_val_t noun, el_val_t gram_case, el_val_t number);
 el_val_t grc_decline_1a(el_val_t stem, el_val_t gram_case, el_val_t number);
 el_val_t grc_decline_1e(el_val_t stem, el_val_t gram_case, el_val_t number);
 el_val_t grc_decline_2m(el_val_t stem, el_val_t gram_case, el_val_t number);
 el_val_t grc_decline_2n(el_val_t stem, el_val_t gram_case, el_val_t number);
-el_val_t grc_decline(el_val_t noun, el_val_t gram_case, el_val_t number);
 el_val_t grc_echein_aorist(el_val_t slot);
 el_val_t grc_echein_future(el_val_t slot);
 el_val_t grc_echein_imperfect(el_val_t slot);
@@ -556,9 +561,9 @@ el_val_t grc_present_stem(el_val_t verb);
 el_val_t grc_slot(el_val_t person, el_val_t number);
 el_val_t grc_str_drop_last(el_val_t s, el_val_t n);
 el_val_t grc_str_ends(el_val_t s, el_val_t suf);
-el_val_t grc_str_last_char(el_val_t s);
 el_val_t grc_str_last2(el_val_t s);
 el_val_t grc_str_last3(el_val_t s);
+el_val_t grc_str_last_char(el_val_t s);
 el_val_t grc_thematic_future_ending(el_val_t slot);
 el_val_t grc_thematic_imperfect_ending(el_val_t slot);
 el_val_t grc_thematic_present_ending(el_val_t slot);
@@ -590,17 +595,17 @@ el_val_t handle_api_recall(el_val_t method, el_val_t path, el_val_t body);
 el_val_t handle_api_remember(el_val_t body);
 el_val_t handle_api_search_knowledge(el_val_t method, el_val_t path, el_val_t body);
 el_val_t handle_api_tune_config(el_val_t body);
+el_val_t handle_chat(el_val_t body);
 el_val_t handle_chat_agentic(el_val_t body);
 el_val_t handle_chat_as_soul(el_val_t body);
 el_val_t handle_chat_plan(el_val_t body);
-el_val_t handle_chat(el_val_t body);
 el_val_t handle_config(el_val_t method, el_val_t body);
 el_val_t handle_connectors(el_val_t method, el_val_t clean, el_val_t body);
 el_val_t handle_conversations(el_val_t method);
-el_val_t handle_dharma_recv(el_val_t body);
-el_val_t handle_dharma_room_turn_agentic(el_val_t body);
-el_val_t handle_dharma_room_turn(el_val_t body);
 el_val_t handle_dharma(el_val_t path, el_val_t method, el_val_t body);
+el_val_t handle_dharma_recv(el_val_t body);
+el_val_t handle_dharma_room_turn(el_val_t body);
+el_val_t handle_dharma_room_turn_agentic(el_val_t body);
 el_val_t handle_elp_chat(el_val_t body);
 el_val_t handle_nlg(el_val_t path, el_val_t method, el_val_t body);
 el_val_t handle_request(el_val_t method, el_val_t path, el_val_t body);
@@ -608,11 +613,11 @@ el_val_t handle_safety_contact_get(void);
 el_val_t handle_safety_contact_post(el_val_t body);
 el_val_t handle_see(el_val_t body);
 el_val_t handle_session_approve(el_val_t session_id, el_val_t body);
-el_val_t handle_tool_result(el_val_t session_id, el_val_t body);
 el_val_t handle_tool(el_val_t path, el_val_t method, el_val_t body);
+el_val_t handle_tool_result(el_val_t session_id, el_val_t body);
 el_val_t hard_bell_threshold(void);
-el_val_t he_conjugate_copula(el_val_t tense, el_val_t slot);
 el_val_t he_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t gender, el_val_t number);
+el_val_t he_conjugate_copula(el_val_t tense, el_val_t slot);
 el_val_t he_copula_future(el_val_t slot);
 el_val_t he_copula_past(el_val_t slot);
 el_val_t he_definite_prefix(el_val_t noun);
@@ -640,6 +645,7 @@ el_val_t he_str_drop_last(el_val_t s, el_val_t n);
 el_val_t he_str_ends(el_val_t s, el_val_t suf);
 el_val_t he_str_last_char(el_val_t s);
 el_val_t he_str_len(el_val_t s);
+el_val_t hebb_consolidate(void);
 el_val_t hi_agree_genitive(el_val_t possessed_gender, el_val_t possessed_number);
 el_val_t hi_aux_present(el_val_t person, el_val_t number);
 el_val_t hi_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t gender, el_val_t number);
@@ -649,12 +655,12 @@ el_val_t hi_genitive_phrase(el_val_t possessor, el_val_t possessor_gender, el_va
 el_val_t hi_hona_past(el_val_t gender, el_val_t number);
 el_val_t hi_hona_present(el_val_t person, el_val_t number);
 el_val_t hi_masc_aa_stem(el_val_t noun);
+el_val_t hi_noun_direct(el_val_t noun, el_val_t gender, el_val_t number);
 el_val_t hi_noun_direct_f(el_val_t noun, el_val_t number);
 el_val_t hi_noun_direct_m(el_val_t noun, el_val_t number);
-el_val_t hi_noun_direct(el_val_t noun, el_val_t gender, el_val_t number);
+el_val_t hi_noun_oblique(el_val_t noun, el_val_t gender, el_val_t number);
 el_val_t hi_noun_oblique_f(el_val_t noun, el_val_t number);
 el_val_t hi_noun_oblique_m(el_val_t noun, el_val_t number);
-el_val_t hi_noun_oblique(el_val_t noun, el_val_t gender, el_val_t number);
 el_val_t hi_noun_with_post(el_val_t noun, el_val_t gender, el_val_t number, el_val_t gram_case);
 el_val_t hi_past_irregular(el_val_t stem, el_val_t gender, el_val_t number);
 el_val_t hi_past_suffix(el_val_t gender, el_val_t number);
@@ -664,11 +670,11 @@ el_val_t hi_str_drop_last(el_val_t s, el_val_t n);
 el_val_t hi_str_ends(el_val_t s, el_val_t suf);
 el_val_t hi_str_last_char(el_val_t s);
 el_val_t hi_tense_suffix(el_val_t tense, el_val_t gender, el_val_t number);
-el_val_t hi_verb_stem_clean(el_val_t infinitive);
 el_val_t hi_verb_stem(el_val_t infinitive);
+el_val_t hi_verb_stem_clean(el_val_t infinitive);
 el_val_t hist_append(el_val_t hist, el_val_t role, el_val_t content);
-el_val_t hist_trim_with_bell_guard(el_val_t hist);
 el_val_t hist_trim(el_val_t hist);
+el_val_t hist_trim_with_bell_guard(el_val_t hist);
 el_val_t id_in_seen(el_val_t node_id, el_val_t seen);
 el_val_t idle_count(void);
 el_val_t idle_inc(void);
@@ -699,6 +705,7 @@ el_val_t json_escape(el_val_t s);
 el_val_t json_safe(el_val_t s);
 el_val_t la_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number);
 el_val_t la_declension(el_val_t noun);
+el_val_t la_decline(el_val_t noun, el_val_t gram_case, el_val_t number);
 el_val_t la_decline_1(el_val_t stem, el_val_t gram_case, el_val_t number);
 el_val_t la_decline_2er(el_val_t noun, el_val_t gram_case, el_val_t number);
 el_val_t la_decline_2m(el_val_t stem, el_val_t gram_case, el_val_t number);
@@ -706,7 +713,6 @@ el_val_t la_decline_2n(el_val_t stem, el_val_t gram_case, el_val_t number);
 el_val_t la_decline_3(el_val_t noun, el_val_t gram_case, el_val_t number);
 el_val_t la_decline_4(el_val_t stem, el_val_t gram_case, el_val_t number);
 el_val_t la_decline_5(el_val_t stem, el_val_t gram_case, el_val_t number);
-el_val_t la_decline(el_val_t noun, el_val_t gram_case, el_val_t number);
 el_val_t la_esse_future(el_val_t slot);
 el_val_t la_esse_past(el_val_t slot);
 el_val_t la_esse_present(el_val_t slot);
@@ -730,9 +736,9 @@ el_val_t la_slot(el_val_t person, el_val_t number);
 el_val_t la_stem(el_val_t verb, el_val_t vclass);
 el_val_t la_str_drop_last(el_val_t s, el_val_t n);
 el_val_t la_str_ends(el_val_t s, el_val_t suf);
-el_val_t la_str_last_char(el_val_t s);
 el_val_t la_str_last2(el_val_t s);
 el_val_t la_str_last3(el_val_t s);
+el_val_t la_str_last_char(el_val_t s);
 el_val_t la_velle_future(el_val_t slot);
 el_val_t la_velle_past(el_val_t slot);
 el_val_t la_velle_present(el_val_t slot);
@@ -749,6 +755,7 @@ el_val_t lang_is_fusional(el_val_t profile);
 el_val_t lang_is_isolating(el_val_t profile);
 el_val_t lang_is_polysynthetic(el_val_t profile);
 el_val_t lang_is_rtl(el_val_t profile);
+el_val_t lang_profile(el_val_t code, el_val_t word_order, el_val_t morph_type, el_val_t has_case, el_val_t has_gender, el_val_t script_dir, el_val_t agreement, el_val_t null_subject);
 el_val_t lang_profile_akk(void);
 el_val_t lang_profile_ang(void);
 el_val_t lang_profile_ar(void);
@@ -780,7 +787,6 @@ el_val_t lang_profile_sw(void);
 el_val_t lang_profile_txb(void);
 el_val_t lang_profile_uga(void);
 el_val_t lang_profile_zh(void);
-el_val_t lang_profile(el_val_t code, el_val_t word_order, el_val_t morph_type, el_val_t has_case, el_val_t has_gender, el_val_t script_dir, el_val_t agreement, el_val_t null_subject);
 el_val_t lang_word_order(el_val_t profile);
 el_val_t layered_cycle(el_val_t raw_input);
 el_val_t lex_class(el_val_t entry);
@@ -831,10 +837,10 @@ el_val_t morph_pluralize(el_val_t noun, el_val_t profile);
 el_val_t next_bridge_id(void);
 el_val_t nlg_is_ws(el_val_t c);
 el_val_t non_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number);
+el_val_t non_decline(el_val_t noun, el_val_t gram_case, el_val_t number);
 el_val_t non_decline_fem(el_val_t noun, el_val_t gram_case, el_val_t number);
 el_val_t non_decline_masc(el_val_t noun, el_val_t gram_case, el_val_t number);
 el_val_t non_decline_neut(el_val_t noun, el_val_t gram_case, el_val_t number);
-el_val_t non_decline(el_val_t noun, el_val_t gram_case, el_val_t number);
 el_val_t non_def_suffix_fem(el_val_t gram_case, el_val_t number);
 el_val_t non_def_suffix_masc(el_val_t gram_case, el_val_t number);
 el_val_t non_def_suffix_neut(el_val_t gram_case, el_val_t number);
@@ -868,8 +874,8 @@ el_val_t peo_ah_present(el_val_t slot);
 el_val_t peo_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number);
 el_val_t peo_da_past(el_val_t slot);
 el_val_t peo_da_present(el_val_t slot);
-el_val_t peo_decline_astem(el_val_t noun, el_val_t gram_case, el_val_t number);
 el_val_t peo_decline(el_val_t noun, el_val_t gram_case, el_val_t number);
+el_val_t peo_decline_astem(el_val_t noun, el_val_t gram_case, el_val_t number);
 el_val_t peo_drop(el_val_t s, el_val_t n);
 el_val_t peo_ends(el_val_t s, el_val_t suf);
 el_val_t peo_kar_past(el_val_t slot);
@@ -885,11 +891,11 @@ el_val_t perceive(void);
 el_val_t pi_aorist_ending(el_val_t slot);
 el_val_t pi_atthi_present(el_val_t slot);
 el_val_t pi_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number);
+el_val_t pi_decline(el_val_t noun, el_val_t gram_case, el_val_t number);
 el_val_t pi_decline_a_fem_pl(el_val_t stem, el_val_t gram_case);
 el_val_t pi_decline_a_fem_sg(el_val_t stem, el_val_t gram_case);
 el_val_t pi_decline_a_masc_pl(el_val_t stem, el_val_t gram_case);
 el_val_t pi_decline_a_masc_sg(el_val_t stem, el_val_t gram_case);
-el_val_t pi_decline(el_val_t noun, el_val_t gram_case, el_val_t number);
 el_val_t pi_detect_class(el_val_t noun);
 el_val_t pi_drop(el_val_t s, el_val_t n);
 el_val_t pi_future_ending(el_val_t slot);
@@ -920,11 +926,11 @@ el_val_t proactive_curiosity(void);
 el_val_t pulse_count(void);
 el_val_t pulse_inc(void);
 el_val_t rate_limit_check(el_val_t ip, el_val_t path);
+el_val_t realize(el_val_t form);
 el_val_t realize_lang(el_val_t form, el_val_t profile);
 el_val_t realize_np(el_val_t referent, el_val_t number);
 el_val_t realize_question_lang(el_val_t predicate, el_val_t tense, el_val_t aspect, el_val_t person, el_val_t number, el_val_t agent, el_val_t patient, el_val_t location, el_val_t profile);
 el_val_t realize_vp_lang(el_val_t base_verb, el_val_t tense, el_val_t aspect, el_val_t person, el_val_t number, el_val_t profile);
-el_val_t realize(el_val_t form);
 el_val_t record(el_val_t outcome_json);
 el_val_t render_studio(void);
 el_val_t render_tree(el_val_t tree);
@@ -935,9 +941,9 @@ el_val_t route_imprint_contextual(el_val_t body);
 el_val_t route_imprint_user(el_val_t body);
 el_val_t route_lineage(void);
 el_val_t route_synthesize(el_val_t body);
+el_val_t ru_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number, el_val_t gender);
 el_val_t ru_conjugate_1st(el_val_t stem, el_val_t tense, el_val_t person, el_val_t number);
 el_val_t ru_conjugate_2nd(el_val_t stem, el_val_t tense, el_val_t person, el_val_t number);
-el_val_t ru_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number, el_val_t gender);
 el_val_t ru_decline_fem(el_val_t noun, el_val_t stype, el_val_t gram_case, el_val_t number);
 el_val_t ru_decline_masc(el_val_t noun, el_val_t stype, el_val_t gram_case, el_val_t number);
 el_val_t ru_decline_neut(el_val_t noun, el_val_t stype, el_val_t gram_case, el_val_t number);
@@ -950,8 +956,8 @@ el_val_t ru_past_stem(el_val_t verb);
 el_val_t ru_stem_type(el_val_t noun, el_val_t gender);
 el_val_t rule_id(el_val_t rule);
 el_val_t rule_lhs(el_val_t rule);
-el_val_t rule_rhs_len(el_val_t rule);
 el_val_t rule_rhs(el_val_t rule, el_val_t idx);
+el_val_t rule_rhs_len(el_val_t rule);
 el_val_t run_command_guard(el_val_t cmd, el_val_t root);
 el_val_t run_command_is_readonly(el_val_t cmd);
 el_val_t sa_as_future(el_val_t slot);
@@ -965,11 +971,11 @@ el_val_t sa_class1_future_ending(el_val_t slot);
 el_val_t sa_class1_past_ending(el_val_t slot);
 el_val_t sa_class1_present_ending(el_val_t slot);
 el_val_t sa_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number);
+el_val_t sa_decline(el_val_t noun, el_val_t gram_case, el_val_t number);
 el_val_t sa_decline_a_stem_pl(el_val_t stem, el_val_t gram_case);
 el_val_t sa_decline_a_stem_sg(el_val_t stem, el_val_t gram_case);
 el_val_t sa_decline_aa_stem_pl(el_val_t stem, el_val_t gram_case);
 el_val_t sa_decline_aa_stem_sg(el_val_t stem, el_val_t gram_case);
-el_val_t sa_decline(el_val_t noun, el_val_t gram_case, el_val_t number);
 el_val_t sa_drs_future(el_val_t slot);
 el_val_t sa_drs_past(el_val_t slot);
 el_val_t sa_drs_present(el_val_t slot);
@@ -1017,26 +1023,26 @@ el_val_t scan_token(el_val_t s, el_val_t start);
 el_val_t security_research_authorized(void);
 el_val_t seed_persona_from_env(void);
 el_val_t sem_first_modifier(el_val_t mods);
+el_val_t sem_frame(el_val_t intent, el_val_t subject, el_val_t obj, el_val_t modifiers);
 el_val_t sem_frame_lang(el_val_t intent, el_val_t subject, el_val_t obj, el_val_t modifiers, el_val_t lang_code);
 el_val_t sem_frame_obj(el_val_t intent, el_val_t subject, el_val_t obj);
 el_val_t sem_frame_simple(el_val_t intent, el_val_t subject);
-el_val_t sem_frame(el_val_t intent, el_val_t subject, el_val_t obj, el_val_t modifiers);
 el_val_t sem_get(el_val_t json, el_val_t key);
-el_val_t sem_intent_to_realize(el_val_t intent);
 el_val_t sem_intent(el_val_t frame);
+el_val_t sem_intent_to_realize(el_val_t intent);
 el_val_t sem_lang(el_val_t frame);
 el_val_t sem_modifiers(el_val_t frame);
 el_val_t sem_object(el_val_t frame);
+el_val_t sem_realize(el_val_t frame);
 el_val_t sem_realize_full(el_val_t frame, el_val_t verb, el_val_t tense, el_val_t aspect);
 el_val_t sem_realize_greet(el_val_t subject);
 el_val_t sem_realize_lang(el_val_t frame, el_val_t lang_code);
-el_val_t sem_realize(el_val_t frame);
 el_val_t sem_subject(el_val_t frame);
-el_val_t sem_to_spec_full(el_val_t frame, el_val_t verb, el_val_t tense, el_val_t aspect);
 el_val_t sem_to_spec(el_val_t frame);
+el_val_t sem_to_spec_full(el_val_t frame, el_val_t verb, el_val_t tense, el_val_t aspect);
 el_val_t session_auto_title(el_val_t session_id, el_val_t first_message);
-el_val_t session_create_cleanup(el_val_t session_id);
 el_val_t session_create(el_val_t body);
+el_val_t session_create_cleanup(el_val_t session_id);
 el_val_t session_delete(el_val_t session_id);
 el_val_t session_exists(el_val_t session_id);
 el_val_t session_get(el_val_t session_id);
@@ -1045,11 +1051,11 @@ el_val_t session_hist_save(el_val_t session_id, el_val_t hist);
 el_val_t session_list(void);
 el_val_t session_make_content(el_val_t id, el_val_t title, el_val_t created_at, el_val_t updated_at, el_val_t folder);
 el_val_t session_preload_bullets(el_val_t nodes, el_val_t max_bullets, el_val_t snip_len);
-el_val_t session_search_entry(el_val_t node);
 el_val_t session_search(el_val_t query);
+el_val_t session_search_entry(el_val_t node);
 el_val_t session_summary_autogenerate(el_val_t hist);
-el_val_t session_summary_write_dated(el_val_t summary_text, el_val_t label);
 el_val_t session_summary_write(el_val_t summary_text);
+el_val_t session_summary_write_dated(el_val_t summary_text, el_val_t label);
 el_val_t session_title_from_message(el_val_t message);
 el_val_t session_update_meta_timestamp(el_val_t session_id);
 el_val_t session_update_patch(el_val_t session_id, el_val_t body);
@@ -1060,9 +1066,9 @@ el_val_t sga_bith_past(el_val_t slot);
 el_val_t sga_bith_present(el_val_t slot);
 el_val_t sga_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number);
 el_val_t sga_copula_present(el_val_t slot);
+el_val_t sga_decline(el_val_t noun, el_val_t gram_case, el_val_t number);
 el_val_t sga_decline_astem(el_val_t noun, el_val_t gram_case, el_val_t number);
 el_val_t sga_decline_ostem(el_val_t noun, el_val_t gram_case, el_val_t number);
-el_val_t sga_decline(el_val_t noun, el_val_t gram_case, el_val_t number);
 el_val_t sga_detect_gender(el_val_t noun);
 el_val_t sga_drop(el_val_t s, el_val_t n);
 el_val_t sga_first(el_val_t s);
@@ -1090,9 +1096,9 @@ el_val_t steward_session_check(el_val_t input, el_val_t session_id);
 el_val_t steward_validate_imprint(el_val_t imprint_id, el_val_t tool_name);
 el_val_t str_drop_last(el_val_t s, el_val_t n);
 el_val_t str_ends(el_val_t s, el_val_t suf);
-el_val_t str_last_char(el_val_t s);
 el_val_t str_last2(el_val_t s);
 el_val_t str_last3(el_val_t s);
+el_val_t str_last_char(el_val_t s);
 el_val_t strengthen_chat_nodes(el_val_t activation_nodes);
 el_val_t strip_query(el_val_t path);
 el_val_t studio_tools_json(void);
@@ -1119,8 +1125,8 @@ el_val_t sux_realize_sentence(el_val_t intent, el_val_t agent, el_val_t predicat
 el_val_t sux_slot(el_val_t person, el_val_t number);
 el_val_t sux_str_drop_last(el_val_t s, el_val_t n);
 el_val_t sux_str_ends(el_val_t s, el_val_t suf);
-el_val_t sux_str_last_char(el_val_t s);
 el_val_t sux_str_last2(el_val_t s);
+el_val_t sux_str_last_char(el_val_t s);
 el_val_t sux_tum2_past(el_val_t slot);
 el_val_t sux_tum2_present(el_val_t slot);
 el_val_t sux_verb_chain(el_val_t agent, el_val_t verb, el_val_t patient, el_val_t tense);
@@ -1138,9 +1144,9 @@ el_val_t sw_noun_plural(el_val_t noun);
 el_val_t sw_obj_prefix(el_val_t person, el_val_t number, el_val_t noun_class);
 el_val_t sw_str_drop_last(el_val_t s, el_val_t n);
 el_val_t sw_str_ends(el_val_t s, el_val_t suf);
-el_val_t sw_str_first_char(el_val_t s);
 el_val_t sw_str_first2(el_val_t s);
 el_val_t sw_str_first3(el_val_t s);
+el_val_t sw_str_first_char(el_val_t s);
 el_val_t sw_str_last_char(el_val_t s);
 el_val_t sw_subj_prefix(el_val_t person, el_val_t number, el_val_t noun_class);
 el_val_t sw_tense_marker(el_val_t tense);
@@ -1158,9 +1164,9 @@ el_val_t tombstone_node(el_val_t id);
 el_val_t tombstoned_id_set(void);
 el_val_t tool_auto_approved(el_val_t tool_name);
 el_val_t txb_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number);
+el_val_t txb_decline(el_val_t noun, el_val_t gram_case, el_val_t number);
 el_val_t txb_decline_fem(el_val_t noun, el_val_t gram_case, el_val_t number);
 el_val_t txb_decline_masc(el_val_t noun, el_val_t gram_case, el_val_t number);
-el_val_t txb_decline(el_val_t noun, el_val_t gram_case, el_val_t number);
 el_val_t txb_detect_gender(el_val_t noun);
 el_val_t txb_drop(el_val_t s, el_val_t n);
 el_val_t txb_ends(el_val_t s, el_val_t suf);
@@ -1175,8 +1181,8 @@ el_val_t txb_wes_present(el_val_t slot);
 el_val_t txb_ya_present(el_val_t slot);
 el_val_t uga_amr_imperfect(el_val_t slot);
 el_val_t uga_amr_perfect(el_val_t slot);
-el_val_t uga_conjugate_copula(el_val_t tense, el_val_t slot);
 el_val_t uga_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number);
+el_val_t uga_conjugate_copula(el_val_t tense, el_val_t slot);
 el_val_t uga_decline(el_val_t noun, el_val_t gram_case, el_val_t number);
 el_val_t uga_generic_imperfect(el_val_t base3sg, el_val_t slot);
 el_val_t uga_generic_perfect(el_val_t base3sg, el_val_t slot);
@@ -1191,8 +1197,8 @@ el_val_t uga_map_canonical(el_val_t verb);
 el_val_t uga_noun_phrase(el_val_t noun, el_val_t gram_case, el_val_t number, el_val_t definite);
 el_val_t uga_ray_imperfect(el_val_t slot);
 el_val_t uga_ray_perfect(el_val_t slot);
-el_val_t uga_slot_g(el_val_t person, el_val_t gender, el_val_t number);
 el_val_t uga_slot(el_val_t person, el_val_t number);
+el_val_t uga_slot_g(el_val_t person, el_val_t gender, el_val_t number);
 el_val_t uga_str_drop_last(el_val_t s, el_val_t n);
 el_val_t uga_str_ends(el_val_t s, el_val_t suf);
 el_val_t uga_str_len(el_val_t s);
@@ -1200,6 +1206,6 @@ el_val_t uga_strip_nom(el_val_t noun);
 el_val_t verb_form(el_val_t base, el_val_t tense, el_val_t person, el_val_t number);
 el_val_t vocab_by_class(el_val_t cls);
 el_val_t vocab_by_pos(el_val_t pos);
-el_val_t vocab_lookup_en(el_val_t word);
 el_val_t vocab_lookup(el_val_t word, el_val_t lang_code);
+el_val_t vocab_lookup_en(el_val_t word);
 el_val_t vocab_synonym(el_val_t word, el_val_t lang_register, el_val_t lang_code);

dist/routes.c

@@ -460,9 +460,9 @@ el_val_t handle_request(el_val_t method, el_val_t path, el_val_t body) {
       return engram_scan_nodes_json(9999, 0);
     }
     if (str_eq(clean, EL_STR("/api/graph/edges"))) {
-      el_val_t snap_path = el_str_concat(env(EL_STR("HOME")), EL_STR("/.neuron/engram/snapshot.json"));
-      engram_save(snap_path);
-      el_val_t snap = fs_read(snap_path);
+      el_val_t export_path = el_str_concat(env(EL_STR("HOME")), EL_STR("/.neuron/engram/.soul-edges-export.json"));
+      engram_save(export_path);
+      el_val_t snap = fs_read(export_path);
       el_val_t edges_raw = json_get_raw(snap, EL_STR("edges"));
       return ({ el_val_t _if_result_21 = 0; if (str_eq(edges_raw, EL_STR(""))) { _if_result_21 = (EL_STR("[]")); } else { _if_result_21 = (edges_raw); } _if_result_21; });
     }

docs/architecture/00-overview.md

@@ -0,0 +1,145 @@
+# Neuron — Architecture Overview
+
+> Status: living document. Grounded in the committed source of the `neuron`
+> repository as of 2026-08-10. Every structural claim cites a real file. Where a
+> statement is inferred rather than read directly, it is labelled *(inference)*
+> or *(unverified/TODO)*.
+
+## What Neuron is
+
+Neuron is a **persistent CGI (Cultivated General Intelligence) runtime**. It is
+not a chatbot and not a stateless API in front of an LLM. It is a long-lived
+process that *remembers* — it carries an identity, a graph of memory and
+knowledge, and an autonomous idle-cognition loop across restarts. The LLM is one
+resource it calls; the durable part is the **engram** (the graph) and the
+**soul** (the program that reasons over it).
+
+Three things run together to make that true:
+
+- **The soul** — the compiled El program in this repo. It owns the HTTP surface,
+  the cognitive API, the request pipeline (`layered_cycle`), and the autonomous
+  awareness daemon. Entry point `soul.el`, served by `handle_request`
+  (`routes.el:358`).
+- **The engram** — the graph store. Node/edge model, spreading activation, and
+  Hebbian co-activation physically live in the shared El runtime
+  (`el_runtime.c`); `engram/src/server.el` is a thin HTTP face on `:8742`. The
+  engram is a *sibling* repo (`foundation/el/engram`), compiled and co-located at
+  runtime, not part of this repo's source tree.
+- **The El runtime** — `el_runtime.c` / `el_runtime.h`. Every compiled El binary
+  links it. It implements all builtins (`engram_*`, `http_*`, `json_*`, LLM,
+  crypto) and *is* the database — "no SQL, no db layer, no SQLite"
+  (`../foundation/el/engram/src/server.el:4-6`).
+
+Neuron persists memory itself — this repo is the memory system. Do not confuse
+it with the Neuron desktop/UI application, which is **out of scope** here and is
+only ever a *client* of the MCP surface described in this set.
+
+## System context
+
+```
+        ┌────────────────────────────────────────────────────────────┐
+        │  MCP clients (Claude Code, Soma chat UI, agents)             │
+        │  — talk MCP JSON-RPC over stdio, or HTTP to the soul         │
+        └───────────────┬────────────────────────────────────────────┘
+                        │  MCP JSON-RPC (stdio)
+             ┌──────────▼──────────┐
+             │  mcp-proxy  :7779   │  byte-forwarder + retry + health
+             └──────────┬──────────┘
+                        │  MCP JSON-RPC (stdio→HTTP)
+             ┌──────────▼──────────┐
+             │  mcp-wrapper :17779 │  JSON-RPC ⇄ soul REST; ~90-tool catalog
+             └──────────┬──────────┘
+                        │  HTTP (REST)
+             ┌──────────▼──────────┐        ┌──────────────────────────┐
+             │   soul  :7770       │──HTTP──▶│  engram  :8742           │
+             │   handle_request    │        │  graph store (snapshot)  │
+             │   layered_cycle     │◀──────▶│  el_runtime.c = the DB   │
+             │   awareness daemon  │        └──────────────────────────┘
+             └──────────┬──────────┘
+                        │ HTTP
+        ┌───────────────┼───────────────┬───────────────┐
+        ▼               ▼               ▼               ▼
+   Axon backend    neuron-connectd    LLM API       (self-callback
+   :backlog/       :7771 connectors   Anthropic      NEURON_API_URL)
+   artifacts/      (MCP bridges)      format
+   projects
+```
+
+*Ports/topology verified*: proxy `:7779` and wrapper `:17779`
+(`mcp-proxy/src/main.el`, `mcp-wrapper/src/main.el`); soul `:7770`
+(`NEURON_PORT`, k8s `deployment-blue.yaml`); engram `:8742` (`entrypoint.sh`,
+`server.el:711`). The Axon backend, `neuron-connectd` (`:7771`), and the LLM are
+external dependencies the soul reaches over HTTP (`routes.el` `axon_get/post`,
+`connectd_get/post`).
+
+## The two external interfaces
+
+Neuron exposes exactly two surfaces, and it is worth being precise about the
+difference because they drive the whole component split:
+
+1. **The MCP surface** — the *tool* interface. MCP clients call tools
+   (`begin_session`, `remember`, `search_knowledge`, `inspect_graph`,
+   `cultivate`, …). This is the interface Claude Code and agents use. It is
+   delivered by the **proxy → wrapper** chain, which translates MCP JSON-RPC
+   into the soul's HTTP REST calls. The wrapper carries a catalog of ~90 tools
+   (`mcp-wrapper/src/main.el`).
+
+2. **The HTTP API** — the *cognitive* interface. The soul serves REST on
+   `:7770`. `routes.el` dispatches; `neuron-api.el` handles the cognitive
+   endpoints (`/api/neuron/*`). This same surface backs the chat product
+   (`/api/chat`, `/api/sessions`) and the studio UI (`/`).
+
+In production the MCP client connects to the soul's HTTP directly — the
+`neuron-mcp` ClusterIP Service targets `:7770` (`service.yaml`) and the
+proxy/wrapper chain is primarily the **local developer adapter** that lets a
+stdio MCP client speak to an HTTP soul. See `04-runtime-and-deployment.md`.
+
+## Component map (summary)
+
+The full VBD classification is in `01-vbd-decomposition.md`. In one glance:
+
+| Layer | Module(s) | Role |
+|---|---|---|
+| HTTP dispatch | `routes.el` | Manager — hand-written method/path dispatch |
+| Cognitive API | `neuron-api.el` | Managers + Engines — session/memory/knowledge/graph/cultivation handlers |
+| Request pipeline | `soul.el` `layered_cycle` | Manager — L1 safety → L2 stewardship → L3 imprint |
+| Boot + identity | `soul.el` | Manager — compose layers, seed identity graph, start server + daemon |
+| Autonomous cognition | `awareness.el` | Manager (`awareness_run`) + Engines (curiosity, attend, threat) |
+| Memory access | `memory.el` | Resource Accessor over the engram FFI/HTTP |
+| Store | `engram/server.el` + `el_runtime.c` | Accessor (HTTP) over the real graph engine |
+| Request-layer rules | `safety.el`, `stewardship.el`, `imprint.el` | Engines |
+| Conversation sessions | `sessions.el` | Manager (chat product) |
+| MCP transport | `mcp-proxy`, `mcp-wrapper` | Managers/Accessors — protocol boundary |
+| Build | `manifest.el`, `dist/soul.c`, El toolchain | amalgamation → `soul.c` → binary |
+
+## Reading guide
+
+- **`01-vbd-decomposition.md`** — the volatility analysis. Start here for *why*
+  the boundaries fall where they do. Contains the full Manager/Engine/Accessor/
+  Utility table and the honest list of where the real code diverges from VBD.
+- **`02-components.md`** — per-subsystem detail: routing, the cognitive API, the
+  memory & activation engine, the MCP transport chain. Read after 01.
+- **`03-data-and-memory.md`** — the engram graph model: node/edge structs,
+  layers, the two tier systems, write-protection, tombstone/supersede
+  immutability, persistence.
+- **`04-runtime-and-deployment.md`** — process/port topology, the end-to-end MCP
+  request path, local vs GKE blue/green, secrets/config.
+- **`05-el-and-build.md`** — the El language, the `elc`/`elb` toolchain, the
+  amalgamation → `soul.c` → binary pipeline, and the compile-time capability
+  gates.
+
+## A note on honesty
+
+Two facts shape everything below and are stated once here so the rest reads
+straight:
+
+1. **The most volatile logic — the activation and Hebbian math — lives in the
+   most stable-looking layer**, the C runtime (`el_runtime.c`). The El files in
+   this repo are largely a *Manager + Accessor shell* around that core. This
+   inverts the usual VBD expectation and is called out wherever it matters.
+2. **The immutability guarantee lives above the store, not in it.** The engram
+   HTTP server will hard-delete a node (`DELETE /api/nodes/:id` →
+   `engram_forget`, `server.el:322`). Immutability holds only because the
+   neuron-api / MCP layer routes every user-facing delete through *tombstone*
+   instead (`memory.el:46`). The invariant is a policy, not a property of the
+   accessor.

docs/architecture/01-vbd-decomposition.md

@@ -0,0 +1,218 @@
+# Neuron — VBD Decomposition
+
+> This is the load-bearing document. It applies Volatility-Based Decomposition
+> (VBD) to the *actual* neuron code, not an idealized version of it. VBD asks one
+> question — **what changes, why, and how often** — and draws component
+> boundaries around the answers so that a change lands inside one component
+> instead of rippling across many.
+>
+> VBD's component taxonomy:
+> - **Managers** — stable orchestrators. They sequence use-cases and delegate;
+>   they change only when the *shape* of a workflow changes.
+> - **Engines** — volatile business rules. The "how" that churns.
+> - **Resource Accessors** — isolate an external dependency (a store, an API) so
+>   its volatility can't leak inward.
+> - **Utilities** — cross-cutting, low-volatility helpers.
+>
+> Communication ideal: Managers orchestrate Engines and Accessors; Managers
+> prefer async/event coupling to each other; Engines are stateless-ish and never
+> reach external I/O directly; Accessors hide all I/O. We note below where neuron
+> honors this and where it doesn't.
+
+## The axes of change
+
+Before classifying modules, name the volatility. These are the axes along which
+neuron actually changes, ranked by observed churn (dated self-review comments in
+the source are the evidence — the code keeps a changelog in its own margins).
+
+### 1. Context / payload shaping — *highest churn*
+How much of the graph, and in what projected form, gets returned to a
+bounded MCP response. The `begin_session` / `compile_ctx` handlers and the
+`api_compact_*` helpers carry dense dated review comments (2026-07-30, -31)
+documenting repeated rework after unbounded payloads closed the MCP client
+socket (`neuron-api.el:90-317`). This changes because the *client's* context
+budget and the *shape* of "what's relevant right now" keep moving. The newest
+rework in this axis is the **relevance-ranked neighbor projection**
+(`api_compact_neighbors` + `api_neigh_*`) behind `inspect_graph`'s `compact=1`
+path — it is what keeps *self-load* (traversing the high-fanout identity anchors)
+from closing the socket. It is committed source, compiled into `dist/soul.c`.
+
+### 2. Autonomous-cognition policy
+What the idle soul chooses to think about: seed-domain selection, curiosity
+rotation, novelty gating, and the inbox verb-mapping in `attend()`. The
+`proactive_curiosity` / `auto_term_try_slot` machinery
+(`awareness.el:590-876`) has the deepest git-archaeology in the codebase
+(comments spanning 2026-05 → 2026-08). This is where the *behavior* of the
+agent is tuned.
+
+### 3. Epistemic & memory semantics
+Tiers, salience mapping, promotion/consolidation, the immutability policy
+(tombstone/supersede), and knowledge disposition. These evolve as the memory
+*philosophy* matures — e.g. `mem_forget` becoming a soft delete
+(`memory.el:70`), the salience-evolution pass in `mem_consolidate`
+(`memory.el:92-133`), the supersede-edge pattern (`neuron-api.el:394-428`).
+
+### 4. Safety & stewardship rules
+Crisis bell thresholds, agentic threat scoring, mission alignment, CGI
+continuity fingerprinting. `safety.el`, `stewardship.el`, and the threat
+scorer grafted onto `awareness.el:1286-1419` change on behavioral/regulatory
+pressure, independently of everything else.
+
+### 5. API / route surface growth
+New cognitive endpoints and their dispatch. `routes.el` grows structurally as
+tools are added; the `handle_request` if/else chain (`routes.el:358-753`) is
+edited on every surface change.
+
+*(A sixth axis — the activation/Hebbian numeric math — is real and volatile but
+is externalized to `el_runtime.c`. See "Divergences," point 6.)*
+
+## The component map
+
+Modules classified against the taxonomy, with the volatility that justifies each
+placement. Paths are repo-relative unless noted `foundation/…`.
+
+### Managers (stable orchestration)
+
+| Module / function | File | Why a Manager |
+|---|---|---|
+| `handle_request` | `routes.el:358-753` | Top-level HTTP dispatcher. Pure method/path routing; delegates every body of work. Changes only when the *route surface* (axis 5) changes, not when logic changes. |
+| Boot sequence | `soul.el:508-627` | Sequences load → seed → identity → serve → daemon. Highest stability; changes only on architecture shifts. |
+| `layered_cycle` | `soul.el:382-506` | Request use-case pipeline: L1 safety → L2 stewardship (continuity, mission, affect) → L3 imprint → L1 output validation. Orchestrates Engines; holds no rules itself. |
+| `awareness_run` / `one_cycle` | `awareness.el:1097-1284`, `1041-1095` | Daemon lifecycle + the perceive→attend→respond→record sequencer. Manager of the autonomous loop. |
+| Session CRUD | `sessions.el` | Orchestrates the immutable delete-then-recreate dance for conversation sessions (chat product). Manager-flavored, but leaks store detail (see Divergences). |
+| MCP proxy | `mcp-proxy/src/main.el` | Orchestrates transport: accept stdio, forward, retry, health-gate, wrap errors. |
+| MCP wrapper | `mcp-wrapper/src/main.el` | Orchestrates the JSON-RPC ⇄ REST translation, tool catalog, lifecycle (`initialize`/`tools/list`/`tools/call`). |
+
+### Engines (volatile business rules)
+
+| Module / function | File | Volatility it absorbs |
+|---|---|---|
+| `api_compact_*`, `begin_session`, `compile_ctx` | `neuron-api.el:90-317` | Axis 1 — context/payload shaping. The single most-reworked logic on the API side. |
+| `attend()` | `awareness.el:926-973` | Axis 2 — inbox content → action-verb ruleset. |
+| `proactive_curiosity`, `auto_term_try_slot` | `awareness.el:590-876` | Axis 2 — seed selection, stopword/IDF gates, tabu ring. Textbook Engine: highest churn. |
+| threat scoring | `awareness.el:1286-1419` | Axis 4 — additive command/path/history threat rules. |
+| `safety.el` (crisis/harm/bell) | `safety.el` | Axis 4 — crisis screening, bell thresholds, output validation. |
+| `stewardship.el` | `stewardship.el` | Axis 4 — mission alignment, CGI check, continuity fingerprint. |
+| `imprint.el` | `imprint.el` | Axis 2/3 — persona response + knowledge/memory surfacing per imprint. |
+| `mem_consolidate` | `memory.el:92-133` | Axis 3 — which nodes to strengthen; salience-evolution rules. |
+| salience/importance mapping | `neuron-api.el` (repeated in `remember`, `node_create`, `evolve_memory`, `cultivate`) | Axis 3 — importance-enum → salience float mapping. |
+| chat mode selection | `chat.el` (via `routes.el:433-440`, `597-604`) | plan / agentic / `layered_cycle` routing. |
+| **activation + Hebbian math** | `foundation/.../el_runtime.c` | Axis 6 — the true cognitive Engine, externalized to C. |
+
+### Resource Accessors (isolate external I/O)
+
+| Accessor | File | Dependency isolated |
+|---|---|---|
+| `mem_*` | `memory.el` | The engram FFI/HTTP. **The** memory Accessor — clean, single isolation point; every forget routes through `mem_tombstone` (`memory.el:46`). |
+| `engram_*` builtins + `server.el` | `el_runtime.c`, `foundation/el/engram/src/server.el` | The graph store over HTTP `:8742`. |
+| `axon_get` / `axon_post` | `routes.el` | The Axon backend (backlog, artifacts, projects, memories, non-neuron knowledge). |
+| `connectd_get` / `connectd_post` | `routes.el:303-324` | `neuron-connectd` bridge (`:7771`). |
+| `llm_call_system` / `llm_call_agentic` | runtime builtins (used in `routes.el:115`, chat) | The LLM. |
+| `ise_post`, `hebb_consolidate` | `awareness.el:101-148`, `64-99` | Durable engram HTTP (`/api/neuron/state-events`, `/api/edges/batch`). |
+| `render_studio` | `studio.el` | The UI surface. |
+
+### Utilities (cross-cutting, stable)
+
+`flag_true`, `strip_query`, `err_404/405` (`routes.el:14-91`);
+`api_json_escape`, `api_query_param/int`, `api_ok/err`, `api_nonempty`,
+`api_utf8_trunc`, `api_persisted` (`neuron-api.el:45-201`); `idle_*`/`pulse_*`
+counters, `elapsed_ms/human`, `make_action`, `embed_ok` (`awareness.el`);
+`session_make_content`, `aff_try_slot`, JSON builders (`sessions.el`, `soul.el`).
+Beneath all of these, the El runtime builtins (`json_*`, `http_*`, crypto, time)
+are the utility substrate every module shares.
+
+## Communication topology (as built)
+
+```
+   MCP client
+      │ JSON-RPC
+   proxy ──► wrapper ──► soul.handle_request ──► neuron-api.handle_api_*
+                                     │                    │
+                                     │ layered_cycle      │ engram_* builtins
+                                     ▼                    ▼
+                          safety / steward / imprint   memory.el (Accessor)
+                          (Engines)                       │
+                                                          ▼
+                                                   el_runtime.c graph
+                                                   engram HTTP :8742
+
+   awareness_run (daemon) ──perceive──► engram inbox (soul-inbox-pending tag)
+                          ──hebb_consolidate──► POST /api/edges/batch
+```
+
+Two things about coupling:
+
+- **Manager → Engine/Accessor is in-process and synchronous** (direct El calls),
+  which matches VBD: rules and I/O sit behind the Managers.
+- **Manager ↔ Manager is *not* the VBD async-event ideal.** It is synchronous
+  HTTP (soul → engram, soul → Axon) plus one genuine event-ish channel: the
+  **engram inbox**. The awareness daemon `perceive()`s by polling a
+  `soul-inbox-pending` tag and consumes trigger nodes
+  (`awareness.el:900-924`, `1090-1093`), and modules communicate asynchronously
+  by writing **InternalStateEvent** nodes. That is a partial actor/event
+  pattern, realized through the graph rather than a message bus.
+
+## Where reality diverges from VBD (call it out)
+
+Honest deviations, so no one reads this doc as a conformance certificate:
+
+1. **No route table.** Dispatch is a hand-written if/else chain in
+   `handle_request` (`routes.el:358-753`); there is no `register-route`
+   registry. Path params are sliced by hand (`str_slice` + `str_index_of`,
+   `routes.el:508-513, 539-541`) — one site carries an inline offset bug-fix
+   comment. Acceptable for a single dispatcher, but it means the "route surface"
+   Manager is edited manually on every change.
+
+2. **Store I/O leaks into Managers.** `routes.el` inlines engram export logic for
+   `/api/graph/edges` (`routes.el:394-422`, with a 2026-08-07 comment about a
+   read-route that corrupted the canonical snapshot). The `awareness_run` sync
+   block inlines `http_get /api/sync` + `engram_load_merge`
+   (`awareness.el:1219-1279`). `emit_heartbeat` (`awareness.el:201-549`, ~350
+   lines) mixes Utility (formatting), Accessor (HTTP/FFI reads), and Manager
+   (state-delta tracking) in one function. These are Accessor responsibilities
+   living inside orchestration — the clearest VBD smell in the codebase.
+
+3. **No authentication.** The only access control on the HTTP surface is per-IP
+   rate limiting (`routes.el:38-75`) plus `is_protected_node` on 15 hardcoded
+   identity IDs (`neuron-api.el:20-37`). There is no bearer/token check in the
+   dispatch path. Security is a cross-cutting concern only partially realized;
+   the deployment relies on a **single-trusted-client, internal-only** boundary
+   assumption (the `neuron-mcp` Service is ClusterIP, no external LB — see doc 04).
+
+4. **Immutability is enforced above the Accessor, not in it.** The engram store
+   itself hard-deletes (`DELETE /api/nodes/:id` → `engram_forget`,
+   `server.el:322`). The invariant "we never delete, we tombstone/supersede"
+   is a *routing policy* in `memory.el` / `neuron-api.el`, not a property of the
+   store. A caller that hits the raw engram HTTP bypasses it.
+
+5. **Mutation via delete-then-recreate.** Because nodes are immutable,
+   `sessions.el` mutates a session by deleting and recreating the node — flagged
+   non-atomic in its own comments (`sessions.el:303-308`, `:456`).
+
+6. **The volatile core is in the stable layer.** The activation, decay, and
+   Hebbian co-activation math — genuinely high-volatility numeric policy — lives
+   in `el_runtime.c`, the foundational runtime every binary links. The El files
+   here are a Manager+Accessor shell around it. This inverts VBD's usual
+   layering (volatile logic should sit *above* stable infrastructure) and is the
+   single most important thing to understand before changing memory behavior:
+   you often can't, from this repo, without touching `foundation/el`.
+
+7. **Vocabulary mismatch across layers.** The MCP-facing memory vocabulary
+   (tiers `note → lesson → canonical`, disposition
+   `experimental → … → deprecated`, importance enum `low/normal/high/critical`)
+   is **not** the engine's model. The engine uses cognitive tiers
+   `Working / Episodic / Semantic / Canonical` (a `tier` string field) plus
+   continuous `salience`/`importance`/`confidence` floats, and stores epistemic
+   tier/disposition as **tags** (`tier:canonical`, `disposition:stable`), not as
+   enforced state (`neuron-api.el:533`, `server.el:519-522`). The mapping is a
+   convention, not a guarded state machine. See `03-data-and-memory.md`.
+
+## Testing spiral (VBD heuristic, as observed)
+
+VBD recommends testing Engines first (pure logic), then Accessors (mock I/O),
+then Managers (integration). The repo has `tests/*.el` matching this instinct —
+`test_safety.el`, `test_bell_safety.el` (Engines), `test_layer_contract.el`
+(the Manager↔Engine JSON contract `layered_cycle` depends on), `test_soul_guard.el`
+(the boot Manager's seed guard), `test_sessions.el`. **Flag:** CI compiles and
+smoke-tests only (`dist/neuron --help`); it does **not** run these `.el` suites
+(`ci.yaml`). Whether they gate merges elsewhere is unverified — see doc 05.

docs/architecture/02-components.md

@@ -0,0 +1,278 @@
+# Neuron — Component Detail
+
+> Per-subsystem detail: routing/dispatch, the cognitive API, the memory &
+> activation engine, and the MCP transport chain. For the *why* behind these
+> boundaries read `01-vbd-decomposition.md` first; this doc is the *what* and
+> *how*, grounded in file citations.
+
+---
+
+## 1. Routing / dispatch — `routes.el`
+
+**Responsibility:** turn an inbound HTTP request into a handler call. One
+function does it.
+
+- **Entry point:** `handle_request(method, path, body) -> String`
+  (`routes.el:358-753`). Structure: branch by method (`GET` `:384`, `POST`
+  `:549`, `DELETE` `:726`, `PATCH` `:739`), then an ordered sequence of exact
+  (`str_eq`) and prefix (`str_starts_with`) tests against the cleaned path.
+  First match wins. There is **no route table and no `register-route`** — this is
+  a deliberate hand-written dispatcher.
+- **Path params** are extracted manually with `str_slice`/`str_index_of`
+  (session id `:539-541`, typed-node type `:508-513`).
+- **Query strings** stripped up front by `strip_query` (`:77-83`); the raw path
+  (with query) is still passed to handlers that read params.
+- **Pre-dispatch middleware** (cross-cutting, inline): an activity timestamp
+  (`state_set("soul.last_activity_ts", …)` `:367`) and **rate limiting**
+  (`rate_limit_check(ip, path)` `:38-75`, `:372-378`) — a per-IP 60 req/min
+  sliding window, `/health` exempt, loopback skipped, returns a 429 body.
+- **Auth:** none in the dispatch path. See doc 01, Divergence 3.
+- **Fallbacks:** `err_404` / `err_405`.
+
+**Collaborators:** delegates to `neuron-api.el` (`/api/neuron/*`), `sessions.el`
+(`/api/sessions/*`), `chat.el` (`/api/chat`, `/dharma/recv`), the Axon Accessor
+(`axon_get/post` for `/api/backlog|artifacts|projects|memories|knowledge`),
+`connectd_*` (`/api/connectors*`), `studio.el` (`/`), and engram builtins for the
+raw `/api/graph*` reads.
+
+**Route surface** (grouped; full table with line numbers is in the survey notes):
+
+| Group | Representative routes | Handler home |
+|---|---|---|
+| Session/context | `/api/neuron/session/begin`, `/api/neuron/ctx`, `/api/sessions*` | neuron-api, sessions.el |
+| Memory | `/api/neuron/memory`, `/recall`, `/memory/{evolve,forget,delete,update}`, `/node/{create,update,delete}` | neuron-api |
+| Knowledge | `/api/neuron/knowledge/{search,capture,evolve,promote}`, `/knowledge` | neuron-api |
+| Graph/activation | `/api/neuron/graph`, `/graph/link`, `/api/graph*`, `/list/:type` | neuron-api + engram builtins |
+| Cultivation/self | `/api/neuron/cultivate`, `/lineage`, `/imprint/*`, `/synthesize` | neuron-api, routes.el |
+| Processes/config | `/api/neuron/processes{,/define}`, `/config{,/tune}` | neuron-api |
+| State/consolidate | `/api/neuron/state-events`, `/consolidate` | neuron-api |
+| Backlog/artifacts | `/api/backlog`, `/artifacts`, `/projects`, `/memories` | Axon (HTTP) |
+| Chat/NLG | `/api/chat`, `/see`, `/elp/chat`, `/dharma*`, `/nlg*` | chat.el, elp-input.el |
+| Health/UI | `/health`, `/lineage`, `/` | routes.el, studio.el |
+
+---
+
+## 2. The cognitive API — `neuron-api.el`
+
+**Responsibility:** the `/api/neuron/*` handlers — the operations that read and
+write the engram as *cognition* (session, memory, knowledge, graph, config,
+processes, state, cultivation). The file header notes these were migrated **out
+of the MCP wrapper's HTTP calls into in-process engram builtins**
+(`neuron-api.el:3-9`) — so most handlers call the store directly, no HTTP
+round-trip.
+
+**Primary collaborators** are the engram builtins (`engram_node_full`,
+`engram_search_json`, `engram_activate_json`, `engram_scan_nodes_json`,
+`engram_scan_nodes_by_type_json`, `engram_neighbors_json`, `engram_connect`,
+`engram_get_node_json`, `engram_stats_json`, `engram_save`) and `memory.el` for
+tombstoning.
+
+**Handler groups:**
+
+- **Session / context** — `handle_api_begin_session` (`:273-301`),
+  `handle_api_compile_ctx` (`:305-317`). Pull `engram_stats_json`, run
+  spreading activation (`engram_activate_json`, depth-1 for begin, depth-2 for
+  ctx), scan recent `InternalStateEvent`s, then **project the result through the
+  compaction helpers** so the payload can't overflow the MCP client's context.
+  This is Engine work (axis 1) inside a Manager-shaped entry point.
+
+- **Memory** — `handle_api_remember` (`:322-348`): maps `importance` → salience,
+  injects a `project:<name>` tag, writes a `Memory`/`Episodic` node, then
+  **read-back-verifies** persistence (`api_persisted`). Deletes are **tombstone,
+  never hard delete** — `node_delete` / `memory_delete` / `forget` all route
+  through `tombstone_node` → `mem_tombstone`. Updates/evolves are **immutable
+  supersede** — `node_update` (`:397-429`), `evolve_memory` (`:711-735`) create a
+  new node and wire `engram_connect(new, old, "supersedes")`.
+
+- **Knowledge** — `search_knowledge` (`:458-478`, falls back to
+  `engram_activate_json(q,2)` when lexical search returns nothing),
+  `browse_knowledge`, `capture_knowledge` (`:492-504`), `evolve_knowledge`,
+  `promote_knowledge` (`:526-542`, writes a canonical-tier node + supersede
+  edge). Evolve/promote respect `is_protected_node`.
+
+- **Graph** — `handle_api_inspect_graph` (`:778-813`): resolves a named anchor
+  (`self`/`neuron` → `kn-efeb4a5b…`, `values` → `kn-5b606390…`) or an explicit
+  id, then `engram_neighbors_json(resolved, depth, "both")`. By default this is a
+  plain neighbor traversal (byte-identical to the old behavior, so the studio app
+  is unaffected). **When called with `compact=1` (or `true`) it returns a
+  relevance-ranked projection** (`:804-810`): the neighborhood is ranked and the
+  top **`k`** neighbors (default 12) keep a UTF-8-safe content snippet (default
+  `snip=600`) via `api_neigh_full`, while the remainder collapse to lightweight
+  `{id,label,node_type,tier,edge,pointer:true}` stubs via `api_neigh_pointer`.
+  This bounds a high-fanout identity anchor (voice, writing-imprint, self-root)
+  from ~670 KB to ~25 KB so the MCP transport no longer socket-closes on
+  self-load. The MCP wrapper appends `&compact=1` on its inspectGraph/fetch-by-id
+  path; the studio app omits the flag and is unchanged.
+  `handle_api_link_entities` (`:818-…`) creates edges but blocks edges *into*
+  protected nodes.
+
+- **Cultivation** — `handle_api_cultivate` (`:781-839`): dispatches on
+  `operation` (evolve_knowledge / evolve_memory / forget / link_entities) and
+  performs the same engram ops **but skips `is_protected_node`** — the sanctioned
+  identity-write path, gated by convention to Will's explicit cultivation
+  sessions.
+
+- **Config / processes / state-events / consolidate** — config anchors + a
+  `ConfigEntry` node search (`:616-639`), `tune_config` (`:642-653`),
+  `browse_processes` / `define_process` (`:547-568`), state-event log/list
+  (`:575-610`), and `consolidate` (`:855-880`, an `engram_save` snapshot plus an
+  optional `SessionSummary` node).
+
+**The projection/compaction layer** (a real, recurring concern) lives in
+`api_compact_node` (`:132-148`), `api_compact_node_array` (`:152-165`),
+`api_compact_activated` (`:170-189`), and `api_utf8_trunc` (`:116-127`). These
+**cap array length and truncate each node to identity + a bounded UTF-8-safe
+content snippet.** Their consumers are `begin_session` and `compile_ctx`.
+The design principle is the important part: *the API returns a relevance-bounded
+projection of the graph, not the graph.* That bounding started as
+length-capping + activation-ordering; it now also includes a **relevance-ranked
+neighbor projection** — `api_compact_neighbors` (`:288-317`), backed by
+`api_neigh_better`/`api_neigh_rank` (relevance ordering), `api_neigh_full`
+(top-K, snippet), `api_neigh_pointer` (the rest, stub), and `api_float_or`. This
+is **committed fact, not an in-flight concern**: it is the `compact=1` path of
+`handle_api_inspect_graph` above, and it is what makes self-load survive the MCP
+transport. It is compiled into `dist/soul.c` (this PR regenerated the
+amalgamation so CI ships it — see doc 05).
+
+---
+
+## 3. Memory & activation engine
+
+This subsystem spans three files in this repo (`memory.el`, `awareness.el`,
+`soul.el`) and one in `foundation` (`el_runtime.c`). The split matters: **the
+math is in C; the El files orchestrate, persist, and instrument it.**
+
+### 3a. Memory access — `memory.el` (the Accessor)
+
+The single isolation point over the engram FFI. Key functions:
+
+| Fn | Lines | Backing call | Notes |
+|---|---|---|---|
+| `mem_store` | `5-28` | `engram_node_full` + read-back | verified write |
+| `mem_remember` | `30-32` | `mem_store` | label `soul-memory` |
+| `mem_recall` | `34-36` | `engram_activate_json(query, depth)` | **spreading-activation recall** (mutates WM) |
+| `mem_search` | `38-40` | `engram_search_json` | pure lexical scan (no WM side-effect) |
+| `mem_strengthen` | `42-44` | `engram_strengthen` | salience bump |
+| `mem_tombstone` | `52-62` | `engram_node_full` + `engram_connect` | the one canonical soft-delete |
+| `mem_forget` | `70-72` | `mem_tombstone` | soft delete (no longer hard) |
+| `mem_consolidate` | `92-133` | `engram_wm_top_json`, `engram_strengthen` | salience-evolution pass |
+| `mem_save` / `mem_load` | `135-148` | `engram_save/load` | snapshot I/O |
+
+Note the distinction between **recall and search**: `mem_recall` fires spreading
+activation (and warms working memory as a side effect); `mem_search` is a passive
+lexical lookup. Tiers here are `tier_working` / `tier_episodic` / `tier_canonical`
+(`memory.el:1-3`) — see doc 03 for how these relate to the engine's tier field
+and to the MCP surface vocabulary.
+
+### 3b. Autonomous cognition — `awareness.el` (the daemon)
+
+`awareness.el` is the **idle-cognition daemon plus observability**, not
+emotional-state code. `awareness_run()` (`:1097-1284`) is the master loop,
+launched last from `soul.el:627`. Each tick (`SOUL_TICK_MS`, ~200ms):
+
+1. **`one_cycle()`** (`:1041-1095`) — the cognitive step:
+   `perceive()` (`:900-924`, gated on a `soul-inbox-pending` tag, then
+   `engram_activate_json`) → `attend()` (`:926-973`, parse trigger content into
+   an action verb: remember / search / activate / strengthen / forget /
+   consolidate / respond) → `respond()` (`:975-1029`, dispatch to the `mem_*`
+   fns) → `record()` (`:1031-1039`, emit an InternalStateEvent) → consume the
+   trigger.
+2. **Heartbeat** (every 60s): `hebb_consolidate()` **then** `emit_heartbeat()`
+   then `mem_save` snapshot (`:1189-1197`).
+3. **Curiosity scan** (every 30s when idle): `proactive_curiosity()`
+   (`:701-876`) rotates 4 seed-domain sets, activates a seed, strengthens the
+   top result **only if it changed** (novelty-gated), and derives an
+   autobiographical seed from the top-10 working-memory nodes with
+   stopword/IDF/tabu filtering.
+4. **Engram sync** (every 10 min): `GET /api/sync` → `engram_load_merge` →
+   telemetry prune.
+
+Two functions carry most of the file's weight and volatility:
+- **`hebb_consolidate()`** (`:64-99`) — the durable-learning write-back. It drains
+  newly-formed co-activation edges (`engram_hebb_drain_json(64)`) and POSTs them
+  as one batch to `/api/edges/batch` (`:94`). The comment block (`:33-63`)
+  records that before this path existed the soul threw away ~1,198 learned
+  edges per restart — the daemon is where **essentially all co-activation
+  happens**, and this is how it survives.
+- **`emit_heartbeat()`** (`:201-549`, ~350 lines) — assembles ~50 gauges (WM
+  saturation/churn, Hebbian candidate/edge counts, embedding coverage, corpus
+  health) into one ISE. Pure observability; a fat, churny Accessor/Utility mix.
+
+A **threat scorer** (`:1286-1419`) is grafted onto the end — command/path/history
+additive scoring, ≥70 blocks a tool call. Cross-cutting agentic-safety policy,
+unrelated to memory mechanism.
+
+### 3c. Identity & the request pipeline — `soul.el`
+
+`soul.el` is the top-level program (`cgi "neuron-soul"`, `:12-17`) and imports
+every other module (`:1-10`). It owns:
+
+- **The identity graph.** `init_soul_edges()` (`:19-92`) hard-wires a `self_root`
+  node linked by `identity` edges (weight 0.95) to family/origin/value nodes,
+  plus a dense `co-value` mesh (weight 0.7) among 8 value nodes.
+  `ensure_self_canonical_bridge()` (`:101-110`) links the public traversal-root
+  anchor (`kn-efeb4a5b`) to the curated self node via `canonical-self` edges.
+  `load_identity_context()` (`:153-240`) loads intellectual-DNA / values /
+  memory-philosophy content into a state key for prompt injection.
+- **Boot orchestration** (`:508-627`): load snapshot → optional first-boot seed
+  (guarded) → identity context → persona-from-env → boot-count increment →
+  session-start event → genesis-only edge init → `http_serve_async(port,
+  "handle_request")` → `awareness_run()`.
+- **The request pipeline.** `layered_cycle()` (`:382-506`) — a 4-layer stack for
+  user input: **L1** safety screen (`safety_screen`) → **L2a** continuity/
+  behavioral (`steward_session_check`) → **L2b** mission alignment
+  (`steward_align`) → **L2c** affective-context injection → **L3**
+  `imprint_respond` → **L1** output validation (`safety_validate`). Hard-bell
+  inputs bypass the upper layers. The JSON contract between these layers is
+  pinned by `tests/test_layer_contract.el`.
+
+### 3d. Where the activation math actually is
+
+`el_runtime.c` implements the two-layer activation model
+(`background_activation` via BFS fan-out, then `working_memory_weight` via an
+executive filter), ACT-R base-level learning (per-node access-timestamp ring
+buffer), 768-dim semantic embeddings, and Hebbian eligibility traces. Retrieval
+is **spreading activation, not query**:
+`strength = parent_strength × edge_weight × target_salience ×
+cosine(query, target)`. The El files never compute this — they seed it
+(`engram_activate_json`), harvest it (`engram_hebb_drain_json`), and persist it.
+See `03-data-and-memory.md`.
+
+---
+
+## 4. The MCP transport chain — `mcp-proxy`, `mcp-wrapper`
+
+The chain exists because two boundaries vary independently: the *client
+transport* (stdio MCP JSON-RPC) and the *soul's protocol* (HTTP REST). Each hop
+absorbs one.
+
+- **`mcp-proxy/src/main.el`** (listens `:7779`) — a **byte-forwarder**. It
+  accepts the client connection, forwards to the wrapper, and adds resilience:
+  retry, health-gating, and a well-formed error envelope so a downstream hiccup
+  never surfaces to the client as a broken pipe. It holds no MCP semantics —
+  pure transport orchestration.
+
+- **`mcp-wrapper/src/main.el`** (listens `:17779`) — the **protocol translator**.
+  It speaks MCP JSON-RPC to the client and REST to the soul (`:7770`), owns the
+  MCP lifecycle (`initialize`, `tools/list`, `tools/call`), and carries the
+  **tool catalog** (~90 tools) that clients enumerate. `dispatch_tool_call` maps
+  each tool to a soul REST endpoint. It also fires a **spread-activation side
+  effect** (`fire_activation`) — after relevant calls it issues a `/recall` to
+  warm related nodes, so tool use itself nudges working memory. The tool schemas
+  in the catalog are largely name-only stubs — flag as a place where richer
+  schemas could live.
+
+- **Manifests** (`mcp-proxy/manifest.el`, `mcp-wrapper/manifest.el`) declare the
+  build entry and package metadata for each transport binary.
+
+**End-to-end (one `tools/call`):** client → proxy (`:7779`, forward+retry) →
+wrapper (`:17779`, JSON-RPC→REST, catalog dispatch) → soul (`:7770`,
+`handle_request` → `handle_api_*`) → engram builtins → (HTTP `:8742` when in HTTP
+mode). The response walks back up, and the wrapper may fire a `/recall` warm-up
+on the way. The full sequence is drawn in `04-runtime-and-deployment.md`.
+
+**VBD reading:** proxy and wrapper are Managers of transport; the wrapper is also
+the Accessor that isolates the *MCP protocol* boundary from the soul (the soul
+knows only HTTP). The multi-hop shape is justified: the client transport, the
+protocol translation, and the cognition each change for different reasons and are
+deployed/updated independently.

docs/architecture/03-data-and-memory.md

@@ -0,0 +1,233 @@
+# Neuron — Data & Memory (the Engram Graph Model)
+
+> The engram is neuron's durable substrate. This document describes the graph
+> model: node/edge structure, the consciousness layers, the two distinct tier
+> systems, write-protection, the tombstone/supersede immutability model, and
+> persistence. Sources: the runtime `el_runtime.c` (where the graph engine
+> physically lives — "the runtime IS the database",
+> `foundation/el/engram/src/server.el:1-6`), the engram HTTP face
+> `server.el`, and the neuron-layer semantics in `memory.el` / `neuron-api.el`.
+>
+> Runtime path analyzed:
+> `foundation/el/lang/releases/v1.0.0-20260501/el_runtime.c`.
+
+## Where the model lives
+
+The engram is **not** a database library. The graph, the activation math, and
+Hebbian learning are compiled C in `el_runtime.c`; `server.el` is a thin HTTP
+server that exposes them on `:8742`; the storage format is a single JSON
+snapshot. There is no SQL, no SQLite, no append log. Keep this in mind: the
+"schema" below is C structs, not tables.
+
+> **Design-doc caveat.** `engram/README.md` describes a Rust/`sled`/`bincode`
+> `EngramDb` with a `NodeType::Concept` enum. That is **aspirational/legacy
+> narrative** — it does not match the shipped C engine. Treat the README as
+> design story, not as the implementation. *(unverified against runtime)*
+
+## Nodes
+
+`EngramNode` — `el_runtime.c:5958-6018+`. Every node carries:
+
+| Field group | Fields | Notes |
+|---|---|---|
+| Identity/content | `id`, `content`, `node_type`, `label`, `tier`, `tags`, `metadata` | all `char*` (`:5959-5965`) |
+| Epistemic weights | `salience`, `importance`, `confidence` (double), `temporal_decay_rate` | per-node decay λ override; 0 = use global (`:5966-5969`) |
+| Access history | `activation_count`, `last_activated`, `created_at`, `updated_at` | `:5970-5973` |
+| Two-layer activation | `background_activation` (Layer 1, BFS fan-out), `working_memory_weight` (Layer 2, executive filter), `suppression_count` | context compilation uses **only** `working_memory_weight` (`:5974-5991`) |
+| Consciousness layer | `layer_id` | default 1 = CORE_IDENTITY (`:5996`) |
+| ACT-R learning | `access_ts[K]` ring buffer, `access_head`, `access_filled`, `wm_anchor` | base-level learning (`:5997-6008`) |
+| Semantics | `emb` (768-dim nomic-embed-text vector, lazily backfilled), `emb_dim` | `:6009-6016` |
+| Hebbian | eligibility trace | `:6017+` |
+
+### Node types are strings, not an enum
+
+`node_type` is a free `char*`, defaulting to `"Memory"` when unset
+(`el_runtime.c:7401`, `server.el:159`). There is **no closed node-type enum** in
+the shipped engine. Two consequences:
+
+- The runtime *special-cases* a handful of type strings for activation
+  thresholds (`engram_type_threshold`, `:5933-5955`): `DharmaSelf`/`Safety`
+  (0.05, fire easily), `Belief`/`Entity` (0.30), `Knowledge` (0.20), everything
+  else `Note`/`Memory`/`Working` (0.40). `InternalStateEvent` and `Tag` are
+  **excluded from working-memory promotion** (`:6674-6676`, `:7368-7370`).
+- Type strings the neuron layer actually writes: `Memory` (default), `Knowledge`
+  (`server.el:549`), `InternalStateEvent` (`server.el:493`), `Tombstone`
+  (`memory.el:55`), `Conversation` (session nodes, `sessions.el`), `Persona`
+  (`soul.el:250-292`), plus identity/value `Knowledge` nodes.
+
+The types the MCP surface names — `Self`, `BacklogItem`, `SessionSummary`,
+`Artifact`, `Process`, `ConfigEntry` — are **`node_type` string conventions set
+by higher neuron/Axon layers**, not runtime-known types. Where `BacklogItem` /
+`Artifact` are set was not in the files read (they route to the Axon backend, doc
+02) — **flag as unverified/TODO** for a human pass.
+
+## Edges
+
+`EngramEdge` — `el_runtime.c:6701-6730+`. Directed, typed, weighted:
+
+| Field | Meaning |
+|---|---|
+| `id`, `from_id`, `to_id`, `relation` | typed relation string |
+| `weight` (double) | **authored** strength — never mutated by activation |
+| `hebb` (double) | **learned** co-activation potentiation — the fraction of recent activations in which both endpoints were in working memory together; strictly separate from `weight` |
+| `inhibitory` (int flag) | if set, activating the source **suppresses** the target's WM weight instead of exciting it |
+| `confidence`, `created_at`, `updated_at`, `last_fired`, `layer` | — |
+
+The **`hebb` field is the co-activation weight** — the Hebbian/LTP channel — kept
+deliberately separate from the static authored `weight`. Edges are created via
+`engram_connect(from, to, weight, relation)` (`server.el:253`).
+
+**Relation strings observed:** `associates` (default, `server.el:248`),
+`identity`, `co-value`, `birthday-twin`, `canonical-self` (`soul.el:37-108`),
+`supersedes`, `tombstones`, `contains`, `tagged` (`neuron-api.el`,
+`el_runtime.c:6168`).
+
+## Consciousness layers
+
+Orthogonal to memory tiers, the engram has five canonical **layers**
+(`el_runtime.c:5919-5924`):
+
+| id | Name | activation_priority | Role |
+|---|---|---|---|
+| 0 | SAFETY | 0 (fires earliest) | deepest / limbic |
+| 1 | CORE_IDENTITY | — | **default** for all nodes (`ENGRAM_LAYER_DEFAULT`, `:7423`) |
+| 2 | DOMAIN | — | domain knowledge |
+| 3 | IMPRINT | — | persona overlay |
+| 4 | SUIT | — | outermost |
+
+`EngramLayer` (`:6731-6738`) carries `activation_priority` (lower fires first),
+`suppressible` (can higher layers suppress it?), `transparent` (invisible to
+introspection?), and `injectable` (add/remove at runtime?). Layers are managed
+via `engram_add_layer` / `engram_node_layered` / `engram_list_layers`. This is
+the identity-vs-domain-knowledge stratification, independent of the tier system
+below.
+
+## Two tier systems — do not conflate them
+
+This is the single most important clarification in the data model, and the source
+of the vocabulary mismatch flagged throughout this set.
+
+### A. Cognitive memory tiers — the `tier` field
+`Working` / `Episodic` / `Semantic` / `Procedural` (and `Canonical` in use).
+Runtime default `"Working"` (`el_runtime.c:7408`; `README.md:41-49`). Nodes
+**migrate between these by salience decay/reinforcement**, driven by the runtime.
+Salience decays as `importance × 1/(1 + days_since) × ln(count + 1)`
+(`README.md:57-62`). `memory.el` exposes `tier_working`/`episodic`/`canonical`
+helpers (`memory.el:1-3`); `soul.el` writes `Semantic`-tier persona nodes
+(`:267`, `:282`). So the live tier set is **{Working, Episodic, Semantic,
+Procedural, Canonical}** with continuous salience/importance/confidence floats.
+
+### B. Epistemic tiers & disposition — tags, not runtime concepts
+The MCP-facing vocabulary — tiers `note → lesson → canonical`, disposition
+`experimental → provisional → stable → deprecated` — is **not enforced anywhere
+in `el_runtime.c`.** It is stored as **tags**:
+
+- Knowledge capture preserves the incoming epistemic tier as a `tier:<x>` tag
+  rather than mapping onto a cognitive tier — deliberately, to avoid a lossy
+  mapping (`server.el:519-522, 544`).
+- `promote_knowledge` writes a canonical node tagged
+  `["Knowledge","tier:canonical","disposition:stable"]` (`neuron-api.el:533`).
+
+There is **no state machine** validating `experimental → … → deprecated`.
+Disposition and epistemic tier are convention-by-tag. *(Flag: not structurally
+guarded. The exact MCP-enum → tag/float mapping is not fully traced in the files
+read — unverified/TODO.)*
+
+## Write-protection
+
+`is_protected_node(id)` (`neuron-api.el:20-37`) is a **hard-coded allowlist of 15
+identity/value node IDs** — the self root, the values hub, intellectual-dna,
+memory-philosophy, voice, and the 8 value nodes. Handlers that could mutate the
+graph (tombstone / supersede / evolve / connect) check it and return HTTP 403
+`api_err_protected` (`:39-41`) for a protected target (checked at `:384, 511,
+692, 705, 746, 768`). Edges *into* a protected node are also blocked
+(`handle_api_link_entities`).
+
+**The one sanctioned override** is `POST /api/neuron/cultivate`
+(`neuron-api.el:781-816`) — it performs the same ops with the protection check
+skipped, gated by convention to Will's explicit cultivation sessions. The self
+layer is writable, but only through a deliberate door.
+
+## Immutability — tombstone, never delete
+
+Engram nodes are immutable (`memory.el:64-69`). The model is:
+
+- **Tombstone** — `mem_tombstone(node_id)` (`memory.el:46-71`) **keeps the node
+  and all its edges**, creates a `Tombstone` marker node
+  (`content = target id`, `label = "tombstone:<id>"`) and wires a `tombstones`
+  edge (weight 1.0). It never calls `engram_forget`. This is *the* one canonical
+  delete — every user-facing forget path routes through it. Default bounded reads
+  hide tombstoned nodes (`memory_hide_tombstoned`, `neuron-api.el:239-249`);
+  `?include_deleted=1` recovers them.
+- **Supersede** — updates/evolves (`neuron-api.el:394-428, 506-541, 715-734`)
+  create a **new** node with the new content, wire a `supersedes` edge new→old
+  (weight 0.9, or 0.95 for promote), and **keep the original**. The response
+  returns both ids so the caller re-points. This is the `supersedes_id`
+  pattern: new node linked, old preserved, full audit trail.
+
+> **The hole to know about.** The raw runtime `engram_forget` **does** hard-delete
+> (frees node + edges, `el_runtime.c:7647`), and the engram HTTP route
+> `DELETE /api/nodes/:id` calls it directly (`server.el:322-328`). Immutability
+> is therefore an invariant of the **neuron-api / MCP layer routing**, not of the
+> store. A client that hits engram HTTP directly can bypass it. *(flag)*
+
+`engram_forget` is also used *internally* for genuine GC: boot-counter pruning
+(`memory.el:184`), session-summary/telemetry pruning (`soul.el:369`,
+`sessions.el`). Those are bounded housekeeping, not user deletes.
+
+## Persistence, snapshots, backups
+
+- **Storage:** a single JSON snapshot `snapshot.json` under `ENGRAM_DATA_DIR`,
+  written by `engram_save` / read by `engram_load` (`el_runtime.c:9660+`; format
+  `{"nodes":[...],"edges":[...]}`). In prod that dir is the RWO PVC mount `/data`
+  (doc 04).
+- **Write policy:** `persist_canonical()` writes the **full** snapshot after every
+  durable write (`server.el:133-141`). The batch-edge route snapshots **once per
+  batch** to avoid ~150 GB/day of writes from Hebbian edge churn
+  (`server.el:258-305`) — this is why `hebb_consolidate` batches (doc 02).
+- **Boot safety:** on load, engram writes `snapshot.boot-backup.json` (good load)
+  or `snapshot.failed-load.json` (a non-empty file that parsed to 0 nodes)
+  (`server.el:718-734`). Read routes export to scratch paths
+  (`.scan-export.json`, `.sync-export.json`) and **never** touch the canonical
+  (`server.el:207-223, 418-437`) — a guard added after a read-route corrupted the
+  snapshot.
+- **Off-cluster backup:** a Kubernetes CronJob (`engram-backup`) tars `/data`
+  every 15 minutes to `gs://neuron-db-backup/gke/neuron-prod/` and keeps the last
+  96 (24h) (`infrastructure/platform/k8s/neuron-mcp/backup-cronjob.yaml`).
+- **Retention:** InternalStateEvent telemetry pruned at 48h
+  (`ENGRAM_ISE_RETENTION_MS`, `server.el:485-499`).
+
+> **Data-dir mismatch to flag:** the `server.el` header comment says the default
+> is `~/.neuron/engram` (`:16`) but the code defaults to `/tmp/engram`
+> (`:135, 717`). Prod overrides both via `ENGRAM_DATA_DIR=/data`. *(unverified —
+> which default is intended)*
+
+## The engram HTTP surface (`:8742`)
+
+Dispatcher `handle_request` (`server.el:592-707`). Auth: `ENGRAM_API_KEY`; GETs
+always allowed, mutations require `"_auth":"<key>"` in the JSON body
+(`server.el:578-588`).
+
+| Endpoint | Purpose |
+|---|---|
+| `GET /health`, `GET /` | health + live node/edge counts |
+| `POST /api/nodes`, `GET /api/nodes`, `GET /api/nodes/:id`, `DELETE /api/nodes/:id` | node CRUD (DELETE = hard `engram_forget`) |
+| `GET /api/edges`, `POST /api/edges`, `POST /api/edges/batch`, `GET /api/neighbors/:id?depth` | edge ops + traversal |
+| `POST\|GET /api/activate?q&depth`, `POST\|GET /api/search` | spreading activation vs lexical search |
+| `POST /api/strengthen` | Hebbian potentiation |
+| `POST /api/save`, `/api/load`, `/api/load-merge` | snapshot control |
+| `GET /api/sync` | soul daemon periodic pull |
+| `GET /api/embed-backfill`, `GET /api/similarity?a&b` | embeddings + cosine |
+| `POST /api/neuron/state-events` (auth-exempt), `POST /api/neuron/knowledge/capture` | neuron-layer helpers |
+| `GET /api/stats`, `/api/act-stats`, `/api/text-health` | telemetry |
+
+## Retrieval model (summary)
+
+Retrieval is **spreading activation, not query matching**:
+`strength = parent_strength × edge_weight × target_salience ×
+cosine(query, target)` — multiplicative, top-N, with the two-layer
+background → working-memory promotion (`README.md:27-36`; `el_runtime.c:5892+,
+6094+`). `mem_recall` / `/api/activate` fire this and mutate WM; `mem_search` /
+`/api/search` are passive lexical scans. The cognitive API's `begin_session` and
+`compile_ctx` return a **bounded projection** of the activated set, never the raw
+graph (doc 02, §2).

docs/architecture/04-runtime-and-deployment.md

@@ -0,0 +1,178 @@
+# Neuron — Runtime & Deployment
+
+> Process/port topology, the end-to-end MCP request path, local vs GKE
+> blue/green production, and a high-level view of secrets/config. Grounded in
+> `entrypoint.sh`, `scripts/blue-green-deploy.sh`, the k8s manifests under
+> `infrastructure/platform/k8s/neuron-mcp/`, and `.gitea/workflows/`.
+
+## Process & port topology
+
+A running neuron is **two processes in one container**: the soul and the engram,
+started by `entrypoint.sh`.
+
+```
+ container (one pod)
+ ┌──────────────────────────────────────────────────────────┐
+ │  entrypoint.sh                                             │
+ │    1. start engram  (background)   ── listens :8742       │
+ │    2. wait /health up to 60s                              │
+ │    3. exec soul (PID 1 foreground)  ── listens :7770      │
+ │                                                           │
+ │   soul  :7770  ──HTTP──►  engram  :8742                    │
+ │   (ENGRAM_URL=http://localhost:8742, HTTP mode)           │
+ │                                                           │
+ │   /data  (PVC mount) ◄── engram snapshot.json             │
+ └──────────────────────────────────────────────────────────┘
+```
+
+- `entrypoint.sh` starts engram with `ENGRAM_BIND=:8742` and
+  `ENGRAM_DATA_DIR=/data`, polls `http://localhost:8742/health` (up to 60s;
+  Autopilot cold starts are slow), then `exec`s the soul. `SOUL_ENGRAM_PATH` is
+  deliberately unset so `ENGRAM_URL` triggers **HTTP mode** (soul talks to engram
+  over localhost HTTP, not an in-process embed).
+- EL HTTP runtime is tuned down for co-located calls: `EL_HTTP_TIMEOUT_MS=10000`,
+  `EL_HTTP_CONNECT_TIMEOUT_MS=3000` (`entrypoint.sh`).
+
+### Full port map
+
+| Port | Process | Role | Source |
+|---|---|---|---|
+| 7779 | mcp-proxy | MCP client entry; byte-forward + retry | `mcp-proxy/src/main.el` |
+| 17779 | mcp-wrapper | MCP JSON-RPC ⇄ soul REST; tool catalog | `mcp-wrapper/src/main.el` |
+| 7770 | soul | HTTP cognitive API + `handle_request` | `NEURON_PORT`, `deployment-blue.yaml` |
+| 8742 | engram | graph store HTTP | `entrypoint.sh`, `server.el:711` |
+| 7771 | neuron-connectd | MCP connector bridges | `routes.el` `connectd_*` |
+
+**Local vs prod, an important distinction.** The proxy → wrapper chain is the
+**local developer adapter**: a stdio MCP client (Claude Code) needs to reach an
+HTTP soul, so the proxy/wrapper translate and add resilience. In **production**,
+the `neuron-mcp` Kubernetes Service is a ClusterIP that targets the soul's
+`:7770` directly (`service.yaml`) — external access is "to be wired via
+Cloudflare Tunnel later" (annotation, same file). So in prod the MCP/HTTP
+boundary is the soul's own HTTP surface; the proxy/wrapper are not (yet) in the
+cluster path. *(inference from the ClusterIP-only Service + the local-only
+proxy/wrapper binaries.)*
+
+## The MCP request path (end to end)
+
+A single `tools/call` from an MCP client, local topology:
+
+```
+ client                proxy :7779         wrapper :17779        soul :7770            engram :8742
+   │  JSON-RPC             │                    │                    │                     │
+   │ tools/call ─────────► │  forward+retry     │                    │                     │
+   │                       │ ─────────────────► │  map tool→REST     │                     │
+   │                       │                    │ ─── HTTP POST ────► │  handle_request     │
+   │                       │                    │   /api/neuron/...   │   → handle_api_*    │
+   │                       │                    │                    │  engram_* builtin   │
+   │                       │                    │                    │ ── (HTTP mode) ───► │  activate/search/
+   │                       │                    │                    │                     │  save
+   │                       │                    │                    │ ◄─── nodes/edges ── │
+   │                       │                    │ ◄── JSON result ── │                     │
+   │                       │                    │  fire_activation    │                     │
+   │                       │                    │  /recall warm-up ─► soul (side effect)    │
+   │ ◄──── result ──────── │ ◄───────────────── │                    │                     │
+```
+
+Responsibilities per hop, and the volatility each isolates (VBD reading):
+
+1. **proxy** — transport resilience. Isolates *client connection volatility*
+   (drops, retries, health) from everything above. No MCP semantics.
+2. **wrapper** — protocol translation. Isolates the *MCP protocol* from the soul:
+   owns `initialize`/`tools/list`/`tools/call`, the ~90-tool catalog, and
+   `dispatch_tool_call`. Also fires the `fire_activation` `/recall` side effect so
+   tool use warms working memory.
+3. **soul** — cognition. `handle_request` dispatch → `handle_api_*` → engram
+   builtins. In HTTP mode it reaches engram over localhost; otherwise embedded.
+4. **engram** — the graph. Spreading activation, Hebbian edges, snapshot
+   persistence.
+
+For the user-facing chat pipeline (not tool calls), `/api/chat` enters
+`layered_cycle` (soul.el) — L1 safety → L2 stewardship → L3 imprint — described
+in `02-components.md §3c`.
+
+## Production: GKE blue/green
+
+Neuron prod runs on GKE cluster **`neuron-platform`** (Autopilot, us-central1),
+namespace **`neuron-prod`**. Two Deployments, `neuron-mcp-blue` and
+`neuron-mcp-green`, share one Service selector that names the *active slot*.
+
+- **Deployments** (`deployment-blue.yaml` / `deployment-green.yaml`): one
+  container `soul`, image pinned by **digest** (not `:latest`) so Argo CD can't
+  drift the active slot to an untested build (see the pin comment in
+  `deployment-blue.yaml`). `strategy: Recreate` — the PVC is RWO so only one pod
+  can hold it at a time. Probes hit `/health` on `:7770`.
+- **Service** (`service.yaml`): ClusterIP `neuron-mcp`, port 7770 → 7770,
+  `selector: {app: neuron-mcp, slot: blue}`. The blue/green script patches
+  `slot`.
+- **Storage** (`pvc.yaml`): `neuron-engram-data`, `standard-rwo` (pd-balanced),
+  10Gi, RWO. Engram data is the single `snapshot.json` (~8MB active).
+- **The swap** (`scripts/blue-green-deploy.sh`): (1) set image on the target
+  slot; (2) scale target to 1, wait for rollout; (3) **patch the Service selector
+  to the new slot** (traffic flip); (4) scale the old slot to 0. Imperative
+  `kubectl` for the live swap, then git-update the Argo manifests so a sync
+  doesn't revert replica counts.
+- **Backup** (`backup-cronjob.yaml`): every 15 min, tar `/data` → GCS, keep 96.
+
+### Resource sizing (learned the hard way)
+
+`deployment-blue.yaml` documents the memory history in comments: idle soul RSS
+~860Mi; the `beginSession` call (loads memories + backlog + preferences) spikes
+past 1Gi and OOM-killed the pod mid-request (client socket closed). Current
+setting: `requests = limits = 2Gi`, cpu 250m/1000m. This is *why* the cognitive
+API projects/compacts payloads so aggressively (doc 02 §2, doc 01 axis 1) — the
+memory ceiling is real and close.
+
+## CI/CD
+
+Two Gitea Actions workflows (`.gitea/workflows/`), serialized on a single GCE
+runner (`concurrency: neuron-runner`).
+
+- **`ci.yaml`** (push/PR to `main`):
+  - **build:** free disk → checkout → install gcc/libcurl/gcloud → download
+    `el-runtime-c`/`el-runtime-h` from Artifact Registry `foundation-prod`
+    (`elc`/`elb` intentionally **not** downloaded) → compile the committed
+    `dist/soul.c` directly: `cc -O2 -DHAVE_CURL dist/soul.c el_runtime.c -lssl
+    -lcrypto -lcurl -lpthread -lm -o dist/neuron` → `strip -s` → smoke test
+    `dist/neuron --help` → publish `neuron-soul@<sha8>` to AR (push only).
+  - **deploy** (push-to-main only): auth GCP → `get-credentials neuron-platform`
+    → **determine idle slot** (the deployment at 0 replicas) → prepare artifacts
+    (soul binary + `elc` + runtime for the Docker build) → **clone the engram
+    repo** into `./engram/` (Dockerfile builds engram from source) → `docker
+    build`+push `neuron-soul:<sha>` → `scripts/blue-green-deploy.sh --image
+    --slot` → git-push updated infra manifests → `kubectl rollout status` →
+    verify `neuron-mcp` endpoints.
+- **`deploy-gke.yaml`** (`workflow_dispatch` only, slot default `green`) — manual
+  rollback / forced-slot deploy without a rebuild; same auth → slot → docker →
+  blue-green → manifest-sync → verify steps.
+
+The Docker image (`Dockerfile`) is a two-stage build: stage 1 compiles
+`engram/src/server.el` → `engram.c` → `engram` binary via `elc` + `cc`; stage 2
+is an Ubuntu 24.04 runtime (GLIBC 2.39 satisfies both binaries) with `soul` +
+`engram` + `entrypoint.sh`.
+
+## Config & secrets (high level)
+
+Runtime configuration is injected as environment, sourced from a Kubernetes
+Secret `neuron-soul-secrets` via ExternalSecret (ESO → GCP Secret Manager,
+Workload Identity — no key files). From `deployment-blue.yaml`:
+
+| Env | Meaning |
+|---|---|
+| `NEURON_PORT` | soul HTTP port (7770) |
+| `NEURON_LLM_0_URL` / `_KEY` / `_FORMAT` | primary LLM endpoint (Anthropic format) |
+| `SOUL_CGI_ID` / `SOUL_IDENTITY` | CGI id + identity seed (→ `seed_persona_from_env`, `soul.el:250`) |
+| `NEURON_TOKEN` | auth token *(present in env; note the HTTP dispatch does not currently check it — doc 01 Divergence 3)* |
+| `NEURON_API_URL` | self-callback URL (`http://neuron-mcp.neuron-prod.svc.cluster.local:7770`) |
+| `ENGRAM_URL` / `ENGRAM_DATA_DIR` | `http://localhost:8742` / `/data` |
+
+There is also an in-graph config surface: `ConfigEntry` nodes read/written by
+`inspect_config` / `tune_config` (`neuron-api.el:616-653`) — runtime-tunable
+persona/behavior keys stored *in* the engram rather than the environment.
+
+> **Operational note to flag.** The `deployment-blue.yaml` image pin comment
+> (dated Jul 2026) records that `:latest` resolved to an untested build lacking a
+> `mem_save`/genesis-SIGSEGV fix, which is why the active slot is pinned to a
+> digest. Any promotion must (a) rebuild a good soul and (b) update the digest in
+> git so Argo CD and `blue-green-deploy.sh` agree. *(state as-of the manifests
+> read; verify current slot before deploying.)*

docs/architecture/05-el-and-build.md

@@ -0,0 +1,165 @@
+# Neuron — El & the Build Pipeline
+
+> The soul and the engram are written in **El**, a self-hosted language that
+> compiles to C11. This document covers the language layer, the
+> amalgamation → `soul.c` → binary pipeline, how the soul is composed from its
+> layers, and the compile-time capability gates. Sources: `manifest.el`,
+> `soul.el`, `dist/soul.c`, the El toolchain under `foundation/el/`
+> (`elc.c`, `elb.el`, `BOOTSTRAP.md`), and `.gitea/workflows/`.
+
+## The El language layer
+
+El is a compiled, Lisp-family language transpiled to C11. Every El program links
+a shared runtime, `el_runtime.c` / `el_runtime.h`, which implements **all
+builtins**: the engram graph engine (`engram_*`), HTTP (`http_*`), JSON
+(`json_*`), crypto, time, LLM calls, and DHARMA primitives (`el_runtime.h`,
+`BOOTSTRAP.md:599-644`). The runtime also provides an arena allocator (server
+mode) and ARC refcounting. Practically: **the runtime is both the standard
+library and the database** — the graph physically lives in `el_runtime.c`, and El
+source files are the orchestration/logic on top.
+
+A recurring texture in the source is workaround comments for codegen quirks
+(e.g. broken `%`/`*` operators). These are El-compiler maturity issues, not
+architecture — but they explain some of the hand-rolled arithmetic in
+`awareness.el`/`memory.el`.
+
+## The toolchain: `elc`, `elb`, `el_runtime`
+
+| Tool | What it is | Role |
+|---|---|---|
+| `elc` | the El compiler, **self-hosted** (written in El) | compiles one El translation unit → C11. Import resolution is textual, depth-first, dedup'd — it inlines all imports into one string and emits forward decls for every fn (`BOOTSTRAP.md:927-936`). |
+| `elb` | the build coordinator (`elb.el`, ~367 lines) | reads `manifest.el`, walks the import graph, does **incremental** separate compilation using `.elh` header files (`extern fn` decls), links the final binary (".NET-style incremental build", `BOOTSTRAP.md:886, 916-925`). |
+| `el_runtime.c/.h` | the C runtime | linked by every compiled El binary; implements all builtins and the graph engine. |
+
+The `.elh` files present in this repo (`soul.elh`, `memory.elh`,
+`neuron-api.elh`, `routes.elh`, …) are **auto-generated headers** (`elc
+--emit-header`) — the `extern fn` interface each module exports. They are the
+contract surface `elb` uses for incremental builds, and they double as a concise
+map of each module's public functions.
+
+### Self-hosting fixed point
+
+`elc` is bootstrapped from a seed binary (`dist/platform/elc`, Mach-O arm64) and
+verified by a **fixed-point self-recompile**: the compiler must compile its own
+source to a byte-identical binary (`BOOTSTRAP.md:7-58, 801-816`). Pipeline:
+`elc-cli.el → compiler.el → lexer/parser/codegen.el`.
+
+## Building the soul: `.el → elc → .c → cc → binary`
+
+The concrete pipeline (mirrored in the engram build, `engram/src/server.el:8-11`):
+
+```
+   soul.el (+ imports)
+        │  elc  (self-hosted El→C11, inlines imports)
+        ▼
+   dist/soul.c   (~31,300 lines — single amalgamated translation unit)
+        │  cc -std=c11 -O2  soul.c  el_runtime.c
+        ▼
+   dist/neuron   (native binary)
+```
+
+### Why `dist/soul.c` is committed
+
+`dist/soul.c` is the authoritative combined translation unit, **regenerated on
+macOS by running `elb`**. It is checked into the repo on purpose: CI compiles it
+**directly** and skips `elb` entirely (`ci.yaml`). The reason is operational, not
+aesthetic —
+
+- `elb` succeeds on arm64/macOS `ld`, but **fails on Linux** (duplicate strong
+  symbols), and
+- `elc` uses 24GB+ virtual memory, which **OOM-kills the 16GB CI runner**.
+
+So the pattern is: **compile on the Mac, commit the amalgamation, and let Linux
+CI do only the cheap `cc` step.** `dist/` also holds the per-module `.c` outputs
+(`memory.c`, `awareness.c`, `chat.c`, the NLG morphology tables, …) —
+intermediate artifacts of the same process.
+
+> **Mechanism note (observed during the self-load regen).** The single-TU
+> `dist/soul.c` is produced by running `elc` over the **flattened import set** —
+> every module source in `soul.el`'s transitive import graph, concatenated with
+> `import` lines stripped, compiled in one pass (`elc` hoists forward decls for
+> all functions, so concat order doesn't affect correctness). `elb` on its own
+> emits **per-module `.c` + a linked binary**, not the combined `soul.c`; it is
+> the separate-compilation coordinator, and `elc soul.el` alone yields only the
+> soul module. Because the amalgamation is regenerated only on demand, it can lag
+> the `.el` sources: this PR regenerated it after it had fallen behind several
+> source commits, and folded in the `inspect_graph` relevance-ranked projection
+> (the `compact=1` self-load fix, doc 02) so CI ships it.
+
+## How the soul is composed (layer stack)
+
+`manifest.el` declares the build:
+
+```
+package "neuron" { version "0.1.0"  edition "2026" }
+build { entry "soul.el" }
+```
+
+The comment in `manifest.el:8-16` documents the intended **layer composition
+order**: a base layer `../foundation/nlg` (the NLG engine — 31-language
+morphology, grammar, realizer, semantics) with the **soul layer** (`soul.el`)
+injected on top. New layers are added by importing them in `soul.el` before the
+soul's own code. *(The `../foundation/nlg` path is the manifest's stated NLG base;
+the NLG sources compile into the `dist/*.c` morphology/grammar tables seen in the
+tree.)*
+
+`soul.el` itself imports, in order (`soul.el:1-10`): `elp.el`, `memory.el`,
+`safety.el`, `stewardship.el`, `imprint.el`, `awareness.el`, `chat.el`,
+`studio.el`, `elp-input.el`, `routes.el` — then declares the `cgi "neuron-soul"`
+identity block (`:12-17`): `dharma_id`, `principal`, `network`, and
+`engram: http://localhost:8742`. Because `elc` inlines imports depth-first, this
+import list *is* the amalgamation order that produces `dist/soul.c`.
+
+The `cgi` block is not just metadata — it sets the program's **capability tier**
+(next section).
+
+## Compile-time capability gates
+
+El's codegen classifies each program by its top-level declaration and **enforces
+capabilities at compile time** (`BOOTSTRAP.md:958-965`):
+
+| Declaration | Tier | Allowed |
+|---|---|---|
+| `cgi { … }` | full | everything — `llm_call_agentic`, `llm_register_tool`, `dharma_emit`, `dharma_field`, LLM, DHARMA |
+| `service { … }` | restricted | no `llm_call_agentic` / `llm_register_tool` / `dharma_emit` / `dharma_field` |
+| neither | utility | no DHARMA, no LLM |
+
+A program that calls a capability its tier forbids **fails to compile**: codegen
+emits a C `#error` naming the forbidding call, so the downstream `cc` aborts.
+This is the **primary hard gate** in the build — capability escalation is caught
+by the compiler, not at runtime. The soul is a `cgi`, so it gets the full tier;
+`engram` is declared without `cgi`/`service` semantics that would grant LLM
+access (it is a store).
+
+## Verification gates
+
+| Gate | Where | What it checks |
+|---|---|---|
+| Capability tier | El codegen (`BOOTSTRAP.md:958`) | no capability escalation; hard `#error` at compile |
+| Self-hosting fixed point | `elc` bootstrap (`BOOTSTRAP.md:801`) | compiler reproduces itself byte-identically |
+| `test_soul_guard.el` | `tests/` | the genesis `safe_to_seed` boot guard — a sparse/oversized snapshot must not clobber the graph |
+| `test_layer_contract.el` | `tests/` | JSON interface shapes between composition-stack layers that `layered_cycle` depends on (e.g. `safety_screen` always returns an `action` field) |
+| other `tests/*.el` | `tests/` | `test_sessions.el`, `test_safety.el`, `test_bell_safety.el`, `test_layered_cycle.el`, `test_imprint.el`, `test_stewardship.el`, `test_api_define_process.el`, … |
+| CI smoke test | `ci.yaml` | `dist/neuron --help` runs |
+
+> **Flag (unverified/TODO).** CI (`ci.yaml`) runs only the `cc` compile + the
+> `dist/neuron --help` smoke test — it does **not** invoke the `tests/*.el`
+> soul-guard / layer-contract suites, and `.githooks/` is empty. Whether these
+> tests are gated anywhere (a pre-merge hook, a separate workflow, or manual
+> discipline on the Mac before regenerating `soul.c`) is **not evident in the
+> files read**. This is the most important build-integrity gap to confirm with a
+> human: the contract tests exist but their enforcement point is unproven.
+
+## Practical consequences for a contributor
+
+- **You cannot rebuild the whole soul on Linux/CI.** Regenerate `dist/soul.c` on
+  a Mac (`elb`), commit it, then CI compiles it. Changing an `.el` file without
+  regenerating `soul.c` ships nothing.
+- **The `.elh` files are your API map.** To see what a module exposes, read its
+  `.elh` — it's the generated `extern fn` list.
+- **Memory/activation behavior often can't be changed from this repo.** The
+  volatile numeric core is in `foundation/el` `el_runtime.c`. Doc 01, Divergence
+  6 explains why this is the sharpest edge in the architecture.
+- **The engram is a separate repo.** It is cloned and compiled by CI
+  (`Dockerfile`, `.gitea/workflows/`), not vendored here. Its source of truth is
+  `foundation/el/engram`.

mcp-wrapper/src/main.el

@@ -302,7 +302,11 @@ fn fetch_by_id(args: String) -> String {
     if str_eq(id, "") {
         return mcp_text_result("error: id is required")
     }
-    let resp: String = http_get(neuron_url() + "/graph?id=" + id + "&depth=0")
+    // NB: the soul's engram_neighbors_json coerces depth<=0 to depth=1, so this
+    // "single node fetch" actually pulls the full 1-hop neighborhood. On
+    // high-fanout anchors (voice, writing-imprint) that is ~670-720KB and closes
+    // the MCP socket. compact=1 bounds it identically to inspectGraph.
+    let resp: String = http_get(neuron_url() + "/graph?id=" + id + "&depth=0&compact=1")
     return mcp_json_result(resp)
 }
 
@@ -516,7 +520,10 @@ fn tool_inspect_graph(args: String) -> String {
     if str_eq(resolved_id, "") {
         return mcp_text_result("error: entity_id or name is required. Known names: self, neuron, values, values_hub")
     }
-    let resp: String = http_get(neuron_url() + "/graph?id=" + resolved_id + "&depth=" + int_to_str(depth))
+    // compact=1: soul returns a bounded, relevance-ranked neighborhood (top-K
+    // with content, the rest as pointers) so high-fanout nodes (voice,
+    // writing-imprint) no longer overflow the MCP transport and close the socket.
+    let resp: String = http_get(neuron_url() + "/graph?id=" + resolved_id + "&depth=" + int_to_str(depth) + "&compact=1")
     return mcp_json_result(resp)
 }
 

memory.elh

@@ -7,6 +7,7 @@ extern fn mem_remember(content: String, tags: String) -> String
 extern fn mem_recall(query: String, depth: Int) -> String
 extern fn mem_search(query: String, limit: Int) -> String
 extern fn mem_strengthen(node_id: String) -> Void
+extern fn mem_tombstone(node_id: String) -> String
 extern fn mem_forget(node_id: String) -> Void
 extern fn mem_consolidate() -> String
 extern fn mem_save(path: String) -> Void

neuron-api.el

@@ -188,6 +188,125 @@ fn api_compact_activated(raw: String, max_items: Int, snip: Int) -> String {
     return out + "]"
 }
 
+// api_float_or — parse a numeric JSON field of `obj` as Float, or `dflt` when
+// the field is absent. Backs neighbor relevance scoring.
+fn api_float_or(obj: String, key: String, dflt: Float) -> Float {
+    let v: String = json_get_raw(obj, key)
+    if str_eq(v, "") { return dflt }
+    return str_to_float(v)
+}
+
+// api_neigh_better — strict relevance ordering of two neighbor elements
+// {node,edge,hops}. Lexicographic and comparison-ONLY (no arithmetic): El's `+`
+// operator is overloaded to string concatenation, so float scoring like
+// weight*salience mis-compiles; ordering by `>`/`<` (always numeric on the
+// int64 el_val_t, correct for the non-negative fields here) is safe. Keys, in
+// order: fewer hops (closer), stronger edge weight, higher node salience, higher
+// node importance. Returns true iff `a` ranks strictly ahead of `b`.
+fn api_neigh_better(a: String, b: String) -> Bool {
+    let na: String = json_get_raw(a, "node")
+    let nb: String = json_get_raw(b, "node")
+    let ea: String = json_get_raw(a, "edge")
+    let eb: String = json_get_raw(b, "edge")
+    let ha: Float = api_float_or(a, "hops", 1.0)
+    let hb: Float = api_float_or(b, "hops", 1.0)
+    if ha < hb { return true }
+    if hb < ha { return false }
+    let wa: Float = api_float_or(ea, "weight", 0.0)
+    let wb: Float = api_float_or(eb, "weight", 0.0)
+    if wa > wb { return true }
+    if wb > wa { return false }
+    let sa: Float = api_float_or(na, "salience", 0.0)
+    let sb: Float = api_float_or(nb, "salience", 0.0)
+    if sa > sb { return true }
+    if sb > sa { return false }
+    let ia: Float = api_float_or(na, "importance", 0.0)
+    let ib: Float = api_float_or(nb, "importance", 0.0)
+    if ia > ib { return true }
+    return false
+}
+
+// api_neigh_rank — count of elements that outrank element `i` under the
+// api_neigh_better ordering, with array index as the final tiebreak. Element i
+// belongs to the content tier iff rank < k. O(n) per element (n bounded ~90
+// neighbors), so O(n^2) overall — acceptable for a bounded neighborhood.
+fn api_neigh_rank(raw: String, n: Int, i: Int) -> Int {
+    let el_i: String = json_array_get(raw, i)
+    let better: Int = 0
+    let j: Int = 0
+    while j < n {
+        let el_j: String = json_array_get(raw, j)
+        let j_better: Bool = api_neigh_better(el_j, el_i)
+        let i_better: Bool = api_neigh_better(el_i, el_j)
+        let eq: Bool = !j_better && !i_better
+        let wins: Bool = j_better || (eq && j < i)
+        let better = if wins { better + 1 } else { better }
+        let j = j + 1
+    }
+    return better
+}
+
+// api_neigh_full — top-tier neighbor: the node compacted to a bounded content
+// snippet, the full edge raw preserved (guard empty -> null), hops, pointer:false.
+fn api_neigh_full(node: String, edge: String, el: String, snip: Int) -> String {
+    let e: String = if str_eq(edge, "") { "null" } else { edge }
+    return "{\"node\":" + api_compact_node(node, snip)
+        + ",\"edge\":" + e
+        + ",\"hops\":" + api_num_or_zero(el, "hops")
+        + ",\"pointer\":false}"
+}
+
+// api_neigh_pointer — tail neighbor: a lightweight, addressable POINTER with NO
+// content. Just enough identity (id/label/node_type/tier) to dereference on
+// demand, plus edge relation+weight and hops. This is what keeps the payload
+// bounded on high-fanout nodes.
+fn api_neigh_pointer(node: String, edge: String, el: String) -> String {
+    let id: String = json_get(node, "id")
+    let label: String = json_get(node, "label")
+    let ntype: String = json_get(node, "node_type")
+    let tier: String = json_get(node, "tier")
+    let relation: String = json_get(edge, "relation")
+    return "{\"node\":{\"id\":\"" + api_json_escape(id) + "\""
+        + ",\"label\":\"" + api_json_escape(label) + "\""
+        + ",\"node_type\":\"" + api_json_escape(ntype) + "\""
+        + ",\"tier\":\"" + api_json_escape(tier) + "\"}"
+        + ",\"edge\":{\"relation\":\"" + api_json_escape(relation) + "\""
+        + ",\"weight\":" + api_num_or_zero(edge, "weight") + "}"
+        + ",\"hops\":" + api_num_or_zero(el, "hops")
+        + ",\"pointer\":true}"
+}
+
+// api_compact_neighbors — bounded projection of an engram neighbor array
+// [{node,edge,hops},...]. Relevance-ranks neighbors (via api_neigh_rank /
+// api_neigh_better): the top `k_content` are emitted WITH a content snippet; every other neighbor is
+// emitted as a lightweight POINTER (no content) the caller dereferences on
+// demand. Every element is emitted (as full or pointer), so total fan-out COUNT
+// stays visible. Mirrors api_compact_activated but adds the ranking + the
+// content/pointer split, keeping high-fanout identity nodes (voice,
+// writing-imprint) well under the transport socket-close threshold. Returns a
+// valid JSON array.
+fn api_compact_neighbors(raw: String, k_content: Int, snip: Int) -> String {
+    if !api_nonempty(raw) { return "[]" }
+    let n: Int = json_array_len(raw)
+    let out: String = "["
+    let i: Int = 0
+    while i < n {
+        let el: String = json_array_get(raw, i)
+        let node: String = json_get_raw(el, "node")
+        let edge: String = json_get_raw(el, "edge")
+        let rank: Int = api_neigh_rank(raw, n, i)
+        let sep: String = if i == 0 { "" } else { "," }
+        let elem: String = if rank < k_content {
+            api_neigh_full(node, edge, el, snip)
+        } else {
+            api_neigh_pointer(node, edge, el)
+        }
+        let out = out + sep + elem
+        let i = i + 1
+    }
+    return out + "]"
+}
+
 // api_persisted — read-back-after-write guard against hallucinated saves.
 // 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
@@ -678,6 +797,18 @@ fn handle_api_inspect_graph(method: String, path: String, body: String) -> Strin
         return api_err("entity_id or name required. Known names: self, neuron, values, values_hub")
     }
     let results: String = engram_neighbors_json(resolved, depth, "both")
+    // Optional bounded projection. `compact=1` relevance-ranks the neighborhood
+    // (top-K get content snippets, the rest become lightweight pointers) so the
+    // MCP transport never socket-closes on high-fanout identity anchors (voice,
+    // writing-imprint). Absent the flag the studio app's calls are UNCHANGED.
+    let compact: String = if str_eq(method, "GET") { api_query_param(path, "compact") } else { json_get(body, "compact") }
+    if str_eq(compact, "1") || str_eq(compact, "true") {
+        let snip_q: Int = api_query_int(path, "snip", 0)
+        let snip: Int = if snip_q == 0 { 600 } else { snip_q }
+        let k_q: Int = api_query_int(path, "k", 0)
+        let k: Int = if k_q == 0 { 12 } else { k_q }
+        return api_or_empty(api_compact_neighbors(results, k, snip))
+    }
     return api_or_empty(results)
 }
 

neuron-api.elh

@@ -8,8 +8,22 @@ extern fn api_ok(extra: String) -> String
 extern fn api_err(msg: String) -> String
 extern fn api_nonempty(s: String) -> Bool
 extern fn api_or_empty(s: String) -> String
+extern fn api_num_or_zero(obj: String, key: String) -> String
+extern fn api_utf8_trunc(s: String, n: Int) -> String
+extern fn api_compact_node(node: String, snip: Int) -> String
+extern fn api_compact_node_array(raw: String, max_items: Int, snip: Int) -> String
+extern fn api_compact_activated(raw: String, max_items: Int, snip: Int) -> String
+extern fn api_float_or(obj: String, key: String, dflt: Float) -> Float
+extern fn api_neigh_better(a: String, b: String) -> Bool
+extern fn api_neigh_rank(raw: String, n: Int, i: Int) -> Int
+extern fn api_neigh_full(node: String, edge: String, el: String, snip: Int) -> String
+extern fn api_neigh_pointer(node: String, edge: String, el: String) -> String
+extern fn api_compact_neighbors(raw: String, k_content: Int, snip: Int) -> String
 extern fn api_persisted(id: String) -> Bool
 extern fn api_not_persisted(id: String) -> String
+extern fn tombstone_node(id: String) -> String
+extern fn tombstoned_id_set() -> String
+extern fn memory_hide_tombstoned(raw: String, path: String) -> String
 extern fn handle_api_begin_session(body: String) -> String
 extern fn handle_api_compile_ctx(body: String) -> String
 extern fn handle_api_remember(body: String) -> String

routes.el

@@ -392,12 +392,31 @@ fn handle_request(method: String, path: String, body: String) -> String {
             return engram_scan_nodes_json(9999, 0)
         }
         if str_eq(clean, "/api/graph/edges") {
-            // 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)
+            // A READ ROUTE MUST NEVER WRITE THE CANONICAL SNAPSHOT.
+            //
+            // (2026-08-07 self-review — caught by doing it.) This route used to
+            // serialize to $HOME/.neuron/engram/snapshot.json and read the edges
+            // back out of it. That path is the ENGRAM SERVER's canonical store,
+            // and this is the soul process. One GET here overwrote the durable
+            // graph with the soul's in-memory copy. I triggered it myself this
+            // morning fetching edges for a census: snapshot.json went from the
+            // server's 41,213 edges to the soul's 42,431, and the next engram
+            // restart loaded the soul's graph as canonical. It happened to be a
+            // superset this time — Knowledge 1198→1218, Memory 1238→1242, no
+            // durable type down — so nothing was lost. That was luck, not
+            // design. Had the soul been running a partial load (the exact
+            // failure soul.el's safe_to_seed guard exists to catch), a single
+            // GET would have destroyed the store, and no guard on the write
+            // side would have seen it coming.
+            //
+            // The engram server fixed this same class of bug on 2026-07-21 by
+            // routing exports to a dotted sidecar; the soul kept the original
+            // pattern. Same fix here: write the export where only an export
+            // lives. It also stops a 60MB serialize-and-reread on every GET of
+            // a debug endpoint.
+            let export_path: String = env("HOME") + "/.neuron/engram/.soul-edges-export.json"
+            engram_save(export_path)
+            let snap: String = fs_read(export_path)
             let edges_raw: String = json_get_raw(snap, "edges")
             return if str_eq(edges_raw, "") { "[]" } else { edges_raw }
         }

routes.elh

@@ -1,4 +1,5 @@
 // auto-generated by elc --emit-header — do not edit
+extern fn flag_true(body: String, key: String) -> Bool
 extern fn rate_limit_check(ip: String, path: String) -> String
 extern fn strip_query(path: String) -> String
 extern fn err_404(path: String) -> String

safety.elh

@@ -14,6 +14,10 @@ extern fn safety_abuse_phrases() -> String
 extern fn safety_general_hard_phrases() -> String
 extern fn safety_threat_to_others_phrases() -> String
 extern fn safety_soft_phrases() -> String
+extern fn safety_normalize(message: String) -> String
+extern fn safety_any_match(text: String, phrases_json: String) -> Bool
+extern fn safety_count_match(text: String, phrases_json: String) -> Int
+extern fn safety_positive_phrases() -> String
 extern fn safety_detect_positive_level(message: String) -> String
 extern fn safety_detect_bell_level(message: String) -> String
 extern fn safety_classify_hard_bell(message: String) -> String

sessions.elh

@@ -12,3 +12,6 @@ extern fn session_search_entry(node: String) -> String
 extern fn session_search(query: String) -> String
 extern fn session_hist_load(session_id: String) -> String
 extern fn session_hist_save(session_id: String, hist: String) -> Void
+extern fn session_update_meta_timestamp(session_id: String) -> Void
+extern fn session_auto_title(session_id: String, first_message: String) -> Void
+extern fn handle_session_approve(session_id: String, body: String) -> String

soul.elh

@@ -1,5 +1,7 @@
-// auto-generated by elc --emit-header - do not edit
+// auto-generated by elc --emit-header — do not edit
 extern fn init_soul_edges() -> Void
+extern fn ensure_self_canonical_bridge() -> Void
+extern fn aff_try_slot(slot_json: String, aff_7d_ts: Int, acc_key: String) -> Void
 extern fn load_identity_context() -> Void
 extern fn seed_persona_from_env() -> Void
 extern fn emit_session_start_event() -> Void