fix(engine): a client that leaves must not kill the daemon, and a long round must say it started

Round 9.1, spec §3 D + ADR 0006 items 2 and 4. Two small changes, both proven
by measurement, both E2E-verified locally against a rebuilt brain.

D1 — SIGPIPE/EPIPE survival (vendor/el-runtime el_runtime.c).
Root cause, at the layer that owns it: the whole HTTP server lives in the C
runtime; .el has no socket primitive. http_send_all() called send() with flags
0 and nothing anywhere in the runtime set a SIGPIPE disposition, so the default
disposition — terminate the process — applied. When a handler finished after
its client had gone (Tim's VM: reply at 116.9 s, client cancelled at 25.0 s),
the second of the four sends that write one reply raised SIGPIPE and the daemon
died: `exited due to SIGPIPE ... ran for 361177ms`, launchd respawn 4 ms later,
every other in-flight session's work lost, user never told.

Fix: SIGPIPE -> SIG_IGN at runtime init and at each http_serve* entry, plus
per-connection SO_NOSIGPIPE / MSG_NOSIGNAL so the guard survives an embedder
resetting dispositions. http_send_all now retries EINTR and preserves errno;
http_send_response classifies it once — a departure is logged as routine
("client left before the reply was written ... reply discarded") and ANY other
errno is logged as a real "send failed: <strerror>". Spec §5.3: the routine
case must not mask a genuine write fault, and it does not.

Proof (scratch HOME + free port, 3 disconnects mid-reply):
  round-9 shipped brain 4402179554… — DIED, exit 141 (128+13 = SIGPIPE), round 1
  round-9 sources rebuilt with this exact recipe — DIED, exit 141, round 1
  this build — SURVIVED 3/3, /health 200 after, still serving the full graph,
  three honest "client left" lines in the log naming Broken pipe / Connection
  reset by peer.

D2 — the round-start marker (chat.el, agentic_loop).
The ledger only ever appended AFTER a round returned, so a healthy first leg
produced zero progress by construction; since server-side web_search moved
inside the outbound call that leg is 60-120 s of silence, which is how a 25 s
client watchdog came to kill a healthy mission. One entry,
{"i":N,"t":"","tool":"__working__"}, written to the existing
run_progress_<session_id> ledger BEFORE each round's outbound call — the wire
shape ChatView.kt:1148 has handled as a life signal since 2026-07-13 and never
received. No new key, no new route, no new lifecycle: a strict subset of WS3
item 3. WS3's run registry is untouched and stays Will's.

Proof (live Anthropic key, real research mission, scratch HOME + free port):
  round-9 baseline — ledger EMPTY for the whole 59.7 s leg
  this build       — {"i":0,"t":"","tool":"__working__"} visible at 18.6 s of a
                     70.0 s leg; both builds returned correct ~4.9 KB answers

Regression: prompt-matrix gate 32/32 on this build (round-9 baseline also 32/32
under the same recipe, so the score is not a build artifact). Soul contract
gate PASS — 27/27 routes, immutability clean. neuron#111 miscompile guard: 0
sites in the generated amalgam this binary was compiled from.

NOT included, deliberately: the regenerated dist/soul.c. CI compiles that file,
so production stays exposed until it is regenerated — the same open ask as
neuron#111 / ui#209. The regen recipe is now known and recorded; landing it is
Will's call, per BUILD-HYGIENE.

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

.gitea/workflows/ci.yaml

@@ -34,12 +34,12 @@ jobs:
       - name: Install build dependencies
         run: |
           apt-get update -qq
-          apt-get install -y gcc libcurl4-openssl-dev apt-transport-https ca-certificates
+          apt-get install -y gcc curl libcurl4-openssl-dev apt-transport-https ca-certificates
           echo "deb [trusted=yes] https://packages.cloud.google.com/apt cloud-sdk main" \
             > /etc/apt/sources.list.d/google-cloud-sdk.list
           apt-get update -qq && apt-get install -y google-cloud-cli
 
-      - name: Download El runtime from Artifact Registry
+      - name: Authenticate to GCP + stage PINNED El runtime
         env:
           GCP_SA_KEY: ${{ secrets.GCP_SA_KEY }}
         run: |
@@ -47,41 +47,21 @@ jobs:
           gcloud auth activate-service-account --key-file=/tmp/gcp-key.json
           gcloud config set project neuron-785695
 
+          # PINNED RUNTIME — do NOT pull "latest" from Artifact Registry.
+          # The ship-soul calls engram_prune_telemetry (awareness.el sync/heartbeat
+          # self-review). The latest published el-runtime-c no longer defines that
+          # symbol, so an unpinned build fails to LINK — which is exactly how a
+          # broken/handlerless soul reached prod before. Compile against the
+          # vendored release runtime v1.0.0-20260501: the exact runtime the merged
+          # ship-soul was verified against (verify-soul-contract GATE PASS +
+          # genesis boot survives + full safety-contact response). It is committed
+          # under vendor/ so the soul build is fully reproducible and never depends
+          # on a moving AR "latest".
           rm -rf /opt/el/runtime
           mkdir -p /opt/el/runtime
-
+          cp vendor/el-runtime/v1.0.0-20260501/el_runtime.c /opt/el/runtime/el_runtime.c
-          # Get latest version of each runtime package (elc/elb not needed — we compile
+          cp vendor/el-runtime/v1.0.0-20260501/el_runtime.h /opt/el/runtime/el_runtime.h
-          # dist/soul.c directly; running elb on Linux OOM-kills the runner, and we
+          echo "El runtime PINNED to v1.0.0-20260501: $(ls /opt/el/runtime/)"
-          # always use the repo's pre-built soul.c anyway).
-          get_latest() {
-            gcloud artifacts versions list \
-              --repository=foundation-prod \
-              --location=us-central1 \
-              --project=neuron-785695 \
-              --package="$1" \
-              --sort-by="~createTime" \
-              --limit=1 \
-              --format="value(name)" 2>/dev/null | awk -F/ '{print $NF}'
-          }
-
-          RC_VER=$(get_latest el-runtime-c)
-          RH_VER=$(get_latest el-runtime-h)
-
-          echo "Downloading runtime@${RC_VER}"
-
-          gcloud artifacts generic download \
-            --repository=foundation-prod --location=us-central1 --project=neuron-785695 \
-            --package=el-runtime-c --version="${RC_VER}" \
-            --destination=/opt/el/runtime/
-
-          gcloud artifacts generic download \
-            --repository=foundation-prod --location=us-central1 --project=neuron-785695 \
-            --package=el-runtime-h --version="${RH_VER}" \
-            --destination=/opt/el/runtime/
-
-          mv /opt/el/runtime/el_runtime.c* /opt/el/runtime/el_runtime.c 2>/dev/null || true
-          mv /opt/el/runtime/el_runtime.h* /opt/el/runtime/el_runtime.h 2>/dev/null || true
-          echo "El runtime ready: $(ls /opt/el/runtime/)"
 
       - name: Build neuron soul binary
         run: |
@@ -94,19 +74,37 @@ jobs:
           # entirely: elb on Linux would OOM the runner (elc uses 24GB+ virtual memory
           # on a 16GB host) and we always restore from the repo's soul.c anyway.
           mkdir -p dist
-          cc -O2 -DHAVE_CURL \
+          # -rdynamic: the el runtime resolves the HTTP request handler (and the
+          # tool handlers) by NAME via dlsym(RTLD_DEFAULT, "handle_request").
+          # macOS exports these symbols freely, but glibc/Linux only makes symbols
+          # visible to dlsym if they are in the dynamic symbol table — so without
+          # -rdynamic the stripped Linux binary boots but returns "el-runtime: no
+          # http handler registered" for EVERY route (i.e. a soul that serves
+          # nothing). Same reason the Windows build links -Wl,--export-all-symbols.
+          cc -O2 -DHAVE_CURL -rdynamic \
             -I$RUNTIME \
             dist/soul.c \
             $RUNTIME/el_runtime.c \
             -lssl -lcrypto -lcurl -lpthread -lm \
             -o dist/neuron
 
-          # Strip debug symbols and non-essential symbol table entries.
+          # -s strips .symtab + debug for size. .dynsym (which -rdynamic populated
-          # -s removes the symbol table + relocation info (max size reduction).
+          # with the dlsym-resolved handlers) is preserved, so the handler still
-          # Keeps the binary functional; debuggability is preserved via source + CI logs.
+          # resolves after stripping.
           strip -s dist/neuron
           ls -lh dist/neuron
 
+      - name: Soul contract gate (HARD BLOCK — no destructive/stale soul publishes)
+        run: |
+          # Boots dist/neuron on a throwaway port with a throwaway HOME/engram/cgi
+          # (never touches ~/.neuron or any live service) and fails the build if any
+          # app-contract route is unanswered (PRESENCE) or any engram write route
+          # hard-deletes instead of tombstoning/superseding (IMMUTABILITY). Non-zero
+          # here blocks Publish -> Artifact Registry -> GKE deploy, so a stale or
+          # memory-destroying soul can never reach prod.
+          chmod +x dist/neuron scripts/verify-soul-contract.sh
+          bash scripts/verify-soul-contract.sh dist/neuron 7796
+
       - name: Smoke test
         run: |
           file dist/neuron

awareness.el

@@ -30,74 +30,6 @@ 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 }
@@ -122,21 +54,6 @@ 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),
@@ -382,89 +299,8 @@ 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;
@@ -472,79 +308,7 @@ 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 }
-    // Redundancy suppression gauges (2026-08-05 self-review). A content-hash
+    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 + "}"
-    // 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)
 }
 
@@ -636,48 +400,6 @@ 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
@@ -827,25 +549,9 @@ 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) }
-    // A streak of nothing is not a streak (2026-08-06 self-review).
+    let atstreak: Int = if str_eq(auto_term, prev_auto) { atstreak_prev + 1 } else { 1 }
-    // 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"))
@@ -865,7 +571,6 @@ 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)
@@ -1152,15 +857,8 @@ 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")
@@ -1187,12 +885,6 @@ 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

@@ -1,4 +1,4 @@
-// auto-generated by elc --emit-header — do not edit
+// auto-generated by elc --emit-header - do not edit
 extern fn chat_default_model() -> String
 extern fn engram_numeric_valid(s: String) -> Bool
 extern fn parse_float_x100(s: String) -> Int
@@ -16,18 +16,33 @@ extern fn engram_nodes_merge(a: String, b: String) -> String
 extern fn id_in_seen(node_id: String, seen: String) -> Bool
 extern fn add_to_seen(seen: String, node_id: String) -> String
 extern fn engram_extract_ids(nodes_json: String) -> String
+extern fn affective_node_ts(node_json: String) -> Int
 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 operator_identity_block() -> 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 conv_hist_key(session_id: String) -> String
+extern fn conv_hist_label(session_id: String) -> String
+extern fn is_utility_request(body: String, session_id: String) -> Bool
+extern fn provenance_scan_urls(arr: String, acc: String) -> String
+extern fn provenance_add_sources(block: String, btype: String, has_cit: Bool, cit_raw: String, acc: String) -> String
+extern fn provenance_names(tools_used: String) -> String
+extern fn text_join_sep(accumulated: String, incoming: String, after_interruption: Bool) -> String
+extern fn receipt_rule() -> String
+extern fn receipt_strip(s: String) -> String
+extern fn tool_receipt(tools_used: String, sources: String) -> String
 extern fn hist_trim(hist: String) -> String
 extern fn hist_trim_with_bell_guard(hist: String) -> String
 extern fn clean_llm_response(s: String) -> String
-extern fn conv_history_persist(hist: String) -> Void
+extern fn conv_history_persist(session_id: String, hist: String) -> Void
-extern fn conv_history_load() -> String
+extern fn conv_history_load(session_id: String) -> String
+extern fn conv_history_record(session_id: String, user_msg: String, assistant_msg: String, receipt: String) -> Void
+extern fn conv_history_block(session_id: String) -> String
+extern fn layered_generate(prompt: String, imprint_id: String, session_id: String) -> 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
@@ -39,6 +54,8 @@ extern fn llm_wire_format() -> String
 extern fn json_escape(s: String) -> String
 extern fn openai_chat_complete(model: String, base_url: String, api_key: String, safe_sys: String, messages_json: String) -> String
 extern fn agentic_tools_literal() -> String
+extern fn web_search_tool_json() -> String
+extern fn strip_client_web_search(tools_inner: String) -> String
 extern fn agentic_tools_with_web() -> String
 extern fn connector_tools_json() -> String
 extern fn agentic_tools_all() -> String

dist/awareness.c

@@ -21,7 +21,6 @@ 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);
@@ -66,41 +65,10 @@ 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_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 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_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 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 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"));
@@ -109,7 +77,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_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; });
+    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; });
     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("");
@@ -162,11 +130,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_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 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 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_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 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 nc = engram_node_count();
   el_val_t ec = engram_edge_count();
   el_val_t wmc = engram_wm_count();
@@ -177,36 +145,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_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 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 sat_raw = state_get(EL_STR("soul.sync_added_total"));
-  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 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 prev_wm_raw = state_get(EL_STR("soul.prev_wm_active"));
-  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 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 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_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 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 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_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 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 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_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 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 hb_env_url = env(EL_STR("SOUL_ISE_URL"));
-  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_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_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 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 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_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_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_total_raw = json_get(bf_resp, EL_STR("embedded_count"));
-  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 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_20 = 0; if ((wmc >= 24)) { _if_result_20 = (1); } else { _if_result_20 = (0); } _if_result_20; });
+  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 prev_sat_raw = state_get(EL_STR("soul.prev_wm_saturated"));
-  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; });
+  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; });
   if (wm_sat != prev_sat) {
-    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; });
+    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; });
     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));
@@ -214,8 +182,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_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_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_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; });
+  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; });
   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"));
@@ -223,28 +191,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_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 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_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 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_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 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_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 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_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 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 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_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 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 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_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_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_bt_raw = json_get(act_stats, EL_STR("breakthroughs"));
-  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 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_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 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_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 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 prev_evict_raw = state_get(EL_STR("soul.prev_wm_evicted"));
-  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_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_bt_raw = state_get(EL_STR("soul.prev_breakthroughs"));
-  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 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_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 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_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; });
+  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; });
   if (evict_now >= 0) {
     state_set(EL_STR("soul.prev_wm_evicted"), int_to_str(evict_now));
   }
@@ -253,72 +221,14 @@ 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_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 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 hb_ats_raw = state_get(EL_STR("soul.auto_term_streak"));
-  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_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_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_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 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 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_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 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 dup_seeds_raw = json_get(act_stats, EL_STR("dup_seeds"));
+  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 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;
 }
@@ -379,13 +289,6 @@ 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"));
         }
@@ -471,21 +374,16 @@ 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_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 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 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_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 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 is_empty = str_eq(auto_term, EL_STR(""));
+  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 = ({ 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")));
@@ -494,7 +392,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_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("}"));
+  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("}"));
   ise_post(ise);
   return (total_found > 0);
   return 0;
@@ -677,18 +575,17 @@ 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_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 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 beat_ms_raw = env(EL_STR("SOUL_HEARTBEAT_MS"));
-  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 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 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_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_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; });
-      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("{\"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("}")));
-      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("");
@@ -703,12 +600,10 @@ 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_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 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 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"));
@@ -717,7 +612,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_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 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 scan_elapsed = (now_ts - last_scan_ts);
     el_val_t should_scan = (!did_work && (scan_elapsed >= scan_ms));
     if (should_scan) {
@@ -725,15 +620,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_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 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 last_refresh_str = state_get(EL_STR("soul.last_refresh_ts"));
-    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 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 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_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 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_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; });
+      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; });
       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("{}")));
@@ -746,10 +641,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_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 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 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_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; });
+          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; });
           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));
@@ -775,78 +670,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_90 = 0; if (str_contains(cmd, EL_STR("nmap"))) { _if_result_90 = (30); } else { _if_result_90 = (0); } _if_result_90; });
+  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_91 = 0; if (str_contains(cmd, EL_STR("masscan"))) { _if_result_91 = (40); } else { _if_result_91 = (0); } _if_result_91; });
+  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_92 = 0; if (str_contains(cmd, EL_STR(" nc "))) { _if_result_92 = (20); } else { _if_result_92 = (0); } _if_result_92; });
+  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_93 = 0; if (str_contains(cmd, EL_STR("netcat"))) { _if_result_93 = (20); } else { _if_result_93 = (0); } _if_result_93; });
+  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_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 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_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 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_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 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_97 = 0; if (str_contains(cmd, EL_STR(".ssh/"))) { _if_result_97 = (50); } else { _if_result_97 = (0); } _if_result_97; });
+  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_98 = 0; if (str_contains(cmd, EL_STR("crontab"))) { _if_result_98 = (30); } else { _if_result_98 = (0); } _if_result_98; });
+  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_99 = 0; if (str_contains(cmd, EL_STR("LaunchDaemon"))) { _if_result_99 = (40); } else { _if_result_99 = (0); } _if_result_99; });
+  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_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 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_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 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_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 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_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 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_104 = 0; if (str_contains(cmd, EL_STR("mkfifo"))) { _if_result_104 = (50); } else { _if_result_104 = (0); } _if_result_104; });
+  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_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 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_106 = 0; if (str_contains(cmd, EL_STR("chmod 4755"))) { _if_result_106 = (70); } else { _if_result_106 = (0); } _if_result_106; });
+  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; });
   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_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 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_108 = 0; if (str_contains(path, EL_STR("/.ssh/"))) { _if_result_108 = (70); } else { _if_result_108 = (0); } _if_result_108; });
+  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_109 = 0; if (str_contains(path, EL_STR("/LaunchDaemons/"))) { _if_result_109 = (80); } else { _if_result_109 = (0); } _if_result_109; });
+  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_110 = 0; if (str_contains(path, EL_STR("/LaunchAgents/"))) { _if_result_110 = (40); } else { _if_result_110 = (0); } _if_result_110; });
+  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_111 = 0; if (str_contains(path, EL_STR("/cron"))) { _if_result_111 = (60); } else { _if_result_111 = (0); } _if_result_111; });
+  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_112 = 0; if (str_contains(path, EL_STR("/.bashrc"))) { _if_result_112 = (35); } else { _if_result_112 = (0); } _if_result_112; });
+  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_113 = 0; if (str_contains(path, EL_STR("/.zshrc"))) { _if_result_113 = (35); } else { _if_result_113 = (0); } _if_result_113; });
+  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_114 = 0; if (str_contains(path, EL_STR("/.profile"))) { _if_result_114 = (35); } else { _if_result_114 = (0); } _if_result_114; });
+  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_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 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_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 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_117 = 0; if (str_starts_with(path, EL_STR("/sbin/"))) { _if_result_117 = (70); } else { _if_result_117 = (0); } _if_result_117; });
+  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; });
   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_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 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_119 = 0; if (str_contains(history, EL_STR("enumerate"))) { _if_result_119 = (10); } else { _if_result_119 = (0); } _if_result_119; });
+  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_120 = 0; if (str_contains(history, EL_STR("exploit"))) { _if_result_120 = (20); } else { _if_result_120 = (0); } _if_result_120; });
+  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_121 = 0; if (str_contains(history, EL_STR("payload"))) { _if_result_121 = (15); } else { _if_result_121 = (0); } _if_result_121; });
+  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_122 = 0; if (str_contains(history, EL_STR("persistence"))) { _if_result_122 = (15); } else { _if_result_122 = (0); } _if_result_122; });
+  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_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 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_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 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_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 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_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 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_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 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_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 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_129 = 0; if (str_contains(history, EL_STR("propagat"))) { _if_result_129 = (20); } else { _if_result_129 = (0); } _if_result_129; });
+  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_130 = 0; if (str_contains(history, EL_STR("ransomware"))) { _if_result_130 = (30); } else { _if_result_130 = (0); } _if_result_130; });
+  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_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 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_132 = 0; if (str_contains(history, EL_STR("exfiltrat"))) { _if_result_132 = (35); } else { _if_result_132 = (0); } _if_result_132; });
+  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_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 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_134 = 0; if (str_contains(history, EL_STR("rootkit"))) { _if_result_134 = (45); } else { _if_result_134 = (0); } _if_result_134; });
+  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_135 = 0; if (str_contains(history, EL_STR("keylogger"))) { _if_result_135 = (45); } else { _if_result_135 = (0); } _if_result_135; });
+  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_136 = 0; if (str_contains(history, EL_STR("botnet"))) { _if_result_136 = (40); } else { _if_result_136 = (0); } _if_result_136; });
+  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_137 = 0; if (str_contains(history, EL_STR("malware"))) { _if_result_137 = (15); } else { _if_result_137 = (0); } _if_result_137; });
+  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; });
   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_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 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 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_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 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 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);
@@ -863,7 +758,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_141 = 0; if ((len > 2000)) { _if_result_141 = (str_slice(combined, (len - 2000), len)); } else { _if_result_141 = (combined); } _if_result_141; });
+  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; });
   state_set(EL_STR("agentic_conv_history"), trimmed);
   return 0;
 }

dist/elp-c-decls.h

@@ -5,6 +5,15 @@ el_val_t add_punct(el_val_t s, el_val_t intent);
 el_val_t add_to_seen(el_val_t seen, el_val_t node_id);
 el_val_t aff_try_slot(el_val_t slot_json, el_val_t aff_7d_ts, el_val_t acc_key);
 el_val_t affective_context_prefix(void);
+el_val_t is_utility_request(el_val_t body, el_val_t session_id);
+el_val_t operator_identity_block(void);
+el_val_t provenance_add_sources(el_val_t block, el_val_t btype, el_val_t has_cit, el_val_t cit_raw, el_val_t acc);
+el_val_t provenance_names(el_val_t tools_used);
+el_val_t provenance_scan_urls(el_val_t arr, el_val_t acc);
+el_val_t text_join_sep(el_val_t accumulated, el_val_t incoming, el_val_t after_interruption);
+el_val_t receipt_rule(void);
+el_val_t receipt_strip(el_val_t s);
+el_val_t tool_receipt(el_val_t tools_used, el_val_t sources);
 el_val_t agent_number(el_val_t agent);
 el_val_t agent_person(el_val_t agent);
 el_val_t agent_workspace_root(void);
@@ -20,8 +29,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(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_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number);
 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 +48,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(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_slot(el_val_t person, 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 +85,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_last2(el_val_t s);
 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_str_last2(el_val_t s);
 el_val_t ang_weak_past_stem(el_val_t stem);
+el_val_t ang_weak_past(el_val_t stem, el_val_t slot);
 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,35 +97,30 @@ 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_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_err(el_val_t msg);
 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(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_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_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);
@@ -156,8 +160,12 @@ el_val_t cmd_abs_escape_at(el_val_t cmd, el_val_t root, el_val_t needle);
 el_val_t connectd_get(el_val_t suffix);
 el_val_t connectd_post(el_val_t suffix, el_val_t body);
 el_val_t connector_tools_json(void);
-el_val_t conv_history_load(void);
+el_val_t conv_hist_key(el_val_t session_id);
-el_val_t conv_history_persist(el_val_t hist);
+el_val_t conv_hist_label(el_val_t session_id);
+el_val_t conv_history_block(el_val_t session_id);
+el_val_t conv_history_load(el_val_t session_id);
+el_val_t conv_history_persist(el_val_t session_id, el_val_t hist);
+el_val_t conv_history_record(el_val_t session_id, el_val_t user_msg, el_val_t assistant_msg, el_val_t receipt);
 el_val_t cop_article(el_val_t gender, el_val_t number, el_val_t definite);
 el_val_t cop_bwk_future(el_val_t prefix);
 el_val_t cop_bwk_perfect(el_val_t prefix);
@@ -179,8 +187,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(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_noun_phrase(el_val_t noun, el_val_t gram_case, el_val_t number, el_val_t definite);
 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);
@@ -190,16 +198,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(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 cop_subject_prefix(el_val_t person, 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(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_conjugate(el_val_t verb, 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);
@@ -209,15 +217,12 @@ 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);
@@ -241,8 +246,11 @@ 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(el_val_t person, el_val_t number);
 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_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);
@@ -263,9 +271,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);
@@ -331,9 +339,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);
@@ -376,8 +384,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_last2(el_val_t s);
 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_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);
@@ -399,9 +407,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);
@@ -419,15 +427,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(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_frame(el_val_t frame);
 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(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_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number);
 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);
@@ -446,13 +454,12 @@ 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(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_slot(el_val_t person, 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);
@@ -461,6 +468,7 @@ 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);
@@ -485,13 +493,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);
@@ -524,17 +532,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);
@@ -561,9 +569,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);
@@ -595,17 +603,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(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_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_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);
@@ -613,11 +621,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(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 handle_tool(el_val_t path, el_val_t method, el_val_t body);
 el_val_t hard_bell_threshold(void);
-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_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_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);
@@ -645,7 +653,6 @@ 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);
@@ -655,12 +662,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_oblique(el_val_t noun, el_val_t gender, 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_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);
@@ -670,11 +677,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(el_val_t infinitive);
 el_val_t hi_verb_stem_clean(el_val_t infinitive);
+el_val_t hi_verb_stem(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(el_val_t hist);
 el_val_t hist_trim_with_bell_guard(el_val_t hist);
+el_val_t hist_trim(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);
@@ -705,7 +712,6 @@ 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);
@@ -713,6 +719,7 @@ 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);
@@ -736,9 +743,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);
@@ -755,7 +762,6 @@ 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);
@@ -787,8 +793,10 @@ 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 layered_cycle(el_val_t raw_input, el_val_t session_id, el_val_t utility);
+el_val_t layered_generate(el_val_t prompt, el_val_t imprint_id, el_val_t session_id);
 el_val_t lex_class(el_val_t entry);
 el_val_t lex_form(el_val_t entry, el_val_t idx);
 el_val_t lex_pos(el_val_t entry);
@@ -837,10 +845,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);
@@ -874,8 +882,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(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_decline(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);
@@ -891,11 +899,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);
@@ -926,11 +934,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);
@@ -941,9 +949,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);
@@ -956,8 +964,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(el_val_t rule, el_val_t idx);
 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 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);
@@ -971,11 +979,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);
@@ -1023,26 +1031,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(el_val_t frame);
 el_val_t sem_intent_to_realize(el_val_t intent);
+el_val_t sem_intent(el_val_t frame);
 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(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 session_auto_title(el_val_t session_id, el_val_t first_message);
-el_val_t session_create(el_val_t body);
 el_val_t session_create_cleanup(el_val_t session_id);
+el_val_t session_create(el_val_t body);
 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);
@@ -1051,11 +1059,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(el_val_t query);
 el_val_t session_search_entry(el_val_t node);
+el_val_t session_search(el_val_t query);
 el_val_t session_summary_autogenerate(el_val_t hist);
-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_summary_write(el_val_t summary_text);
 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);
@@ -1066,9 +1074,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);
@@ -1096,9 +1104,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);
@@ -1125,8 +1133,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_last2(el_val_t s);
 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_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);
@@ -1144,9 +1152,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);
@@ -1164,9 +1172,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);
@@ -1181,8 +1189,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(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_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number);
 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);
@@ -1197,8 +1205,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(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_slot(el_val_t person, 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);
@@ -1206,6 +1214,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(el_val_t word, el_val_t lang_code);
 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_synonym(el_val_t word, el_val_t lang_register, el_val_t lang_code);

dist/neuron-api.c

@@ -10,7 +10,6 @@ el_val_t mem_remember(el_val_t content, el_val_t tags);
 el_val_t mem_recall(el_val_t query, el_val_t depth);
 el_val_t mem_search(el_val_t query, el_val_t limit);
 el_val_t mem_strengthen(el_val_t node_id);
-el_val_t mem_tombstone(el_val_t node_id);
 el_val_t mem_forget(el_val_t node_id);
 el_val_t mem_consolidate(void);
 el_val_t mem_save(el_val_t path);
@@ -361,7 +360,7 @@ el_val_t handle_api_remember(el_val_t body) {
   el_val_t sal = ({ el_val_t _if_result_14 = 0; if (str_eq(sal_str, EL_STR("0.95"))) { _if_result_14 = (el_from_float(0.95)); } else { _if_result_14 = (({ el_val_t _if_result_15 = 0; if (str_eq(sal_str, EL_STR("0.75"))) { _if_result_15 = (el_from_float(0.75)); } else { _if_result_15 = (({ el_val_t _if_result_16 = 0; if (str_eq(sal_str, EL_STR("0.25"))) { _if_result_16 = (el_from_float(0.25)); } else { _if_result_16 = (el_from_float(0.5)); } _if_result_16; })); } _if_result_15; })); } _if_result_14; });
   el_val_t base_tags = ({ el_val_t _if_result_17 = 0; if (str_eq(tags_raw, EL_STR(""))) { _if_result_17 = (EL_STR("[\"Memory\"]")); } else { _if_result_17 = (tags_raw); } _if_result_17; });
   el_val_t final_tags = ({ el_val_t _if_result_18 = 0; if (str_eq(project, EL_STR(""))) { _if_result_18 = (base_tags); } else { el_val_t inner = str_slice(base_tags, 1, (str_len(base_tags) - 1)); _if_result_18 = (el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("["), inner), EL_STR(",\"project:")), project), EL_STR("\"]"))); } _if_result_18; });
-  el_val_t id = engram_node_full(content, EL_STR("Memory"), EL_STR("memory:remembered"), sal, sal, el_from_float(0.9), EL_STR("Episodic"), final_tags);
+  el_val_t id = engram_node_full(content, EL_STR("Memory"), EL_STR("memory:remembered"), el_from_float(sal), el_from_float(sal), el_from_float(0.9), EL_STR("Episodic"), final_tags);
   if (!api_persisted(id)) {
     return api_not_persisted(id);
   }
@@ -384,7 +383,7 @@ el_val_t handle_api_node_create(el_val_t body) {
   el_val_t tags = ({ el_val_t _if_result_22 = 0; if (str_eq(tags_raw, EL_STR(""))) { _if_result_22 = (el_str_concat(el_str_concat(EL_STR("[\""), node_type), EL_STR("\"]"))); } else { _if_result_22 = (tags_raw); } _if_result_22; });
   el_val_t importance = json_get(body, EL_STR("importance"));
   el_val_t sal = ({ el_val_t _if_result_23 = 0; if (str_eq(importance, EL_STR("critical"))) { _if_result_23 = (el_from_float(0.95)); } else { _if_result_23 = (({ el_val_t _if_result_24 = 0; if (str_eq(importance, EL_STR("high"))) { _if_result_24 = (el_from_float(0.75)); } else { _if_result_24 = (({ el_val_t _if_result_25 = 0; if (str_eq(importance, EL_STR("low"))) { _if_result_25 = (el_from_float(0.25)); } else { _if_result_25 = (el_from_float(0.5)); } _if_result_25; })); } _if_result_24; })); } _if_result_23; });
-  el_val_t id = engram_node_full(content, node_type, label, sal, sal, el_from_float(0.9), tier, tags);
+  el_val_t id = engram_node_full(content, node_type, label, el_from_float(sal), el_from_float(sal), el_from_float(0.9), tier, tags);
   if (!api_persisted(id)) {
     return api_not_persisted(id);
   }
@@ -497,9 +496,8 @@ el_val_t handle_api_capture_knowledge(el_val_t body) {
     return api_err(EL_STR("content is required"));
   }
   el_val_t full = ({ el_val_t _if_result_44 = 0; if (str_eq(title, EL_STR(""))) { _if_result_44 = (content); } else { _if_result_44 = (el_str_concat(el_str_concat(title, EL_STR(": ")), content)); } _if_result_44; });
-  el_val_t lbl = str_slice(title, 0, 80);
   el_val_t tags = EL_STR("[\"Knowledge\",\"captured\"]");
-  el_val_t id = engram_node_full(full, EL_STR("Knowledge"), lbl, el_from_float(0.85), el_from_float(0.8), el_from_float(0.9), EL_STR("Episodic"), tags);
+  el_val_t id = engram_node_full(full, EL_STR("Knowledge"), EL_STR("knowledge:captured"), el_from_float(0.85), el_from_float(0.8), el_from_float(0.9), EL_STR("Episodic"), tags);
   if (!api_persisted(id)) {
     return api_not_persisted(id);
   }
@@ -517,7 +515,7 @@ el_val_t handle_api_evolve_knowledge(el_val_t body) {
     return api_err_protected(prior_id);
   }
   el_val_t tags = EL_STR("[\"Knowledge\",\"evolved\"]");
-  el_val_t new_id = engram_node_full(content, EL_STR("Knowledge"), EL_STR(""), el_from_float(0.75), el_from_float(0.75), el_from_float(0.9), EL_STR("Episodic"), tags);
+  el_val_t new_id = engram_node_full(content, EL_STR("Knowledge"), EL_STR("knowledge:evolved"), el_from_float(0.75), el_from_float(0.75), el_from_float(0.9), EL_STR("Episodic"), tags);
   if (!api_persisted(new_id)) {
     return api_not_persisted(new_id);
   }
@@ -539,7 +537,7 @@ el_val_t handle_api_promote_knowledge(el_val_t body) {
   }
   el_val_t tags_raw = json_get(body, EL_STR("tags"));
   el_val_t tags = ({ el_val_t _if_result_45 = 0; if (str_eq(tags_raw, EL_STR(""))) { _if_result_45 = (EL_STR("[\"Knowledge\",\"tier:canonical\",\"disposition:stable\"]")); } else { _if_result_45 = (tags_raw); } _if_result_45; });
-  el_val_t new_id = engram_node_full(content, EL_STR("Knowledge"), EL_STR(""), el_from_float(0.9), el_from_float(0.9), el_from_float(1.0), EL_STR("Canonical"), tags);
+  el_val_t new_id = engram_node_full(content, EL_STR("Knowledge"), EL_STR("knowledge:canonical"), el_from_float(0.9), el_from_float(0.9), el_from_float(1.0), EL_STR("Canonical"), tags);
   if (!api_persisted(new_id)) {
     return api_not_persisted(new_id);
   }
@@ -710,7 +708,7 @@ el_val_t handle_api_evolve_memory(el_val_t body) {
   el_val_t sal_str = ({ el_val_t _if_result_65 = 0; if (str_eq(importance, EL_STR("critical"))) { _if_result_65 = (EL_STR("0.95")); } else { _if_result_65 = (({ el_val_t _if_result_66 = 0; if (str_eq(importance, EL_STR("high"))) { _if_result_66 = (EL_STR("0.75")); } else { _if_result_66 = (({ el_val_t _if_result_67 = 0; if (str_eq(importance, EL_STR("low"))) { _if_result_67 = (EL_STR("0.25")); } else { _if_result_67 = (EL_STR("0.50")); } _if_result_67; })); } _if_result_66; })); } _if_result_65; });
   el_val_t sal = ({ el_val_t _if_result_68 = 0; if (str_eq(sal_str, EL_STR("0.95"))) { _if_result_68 = (el_from_float(0.95)); } else { _if_result_68 = (({ el_val_t _if_result_69 = 0; if (str_eq(sal_str, EL_STR("0.75"))) { _if_result_69 = (el_from_float(0.75)); } else { _if_result_69 = (({ el_val_t _if_result_70 = 0; if (str_eq(sal_str, EL_STR("0.25"))) { _if_result_70 = (el_from_float(0.25)); } else { _if_result_70 = (el_from_float(0.5)); } _if_result_70; })); } _if_result_69; })); } _if_result_68; });
   el_val_t tags = EL_STR("[\"Memory\",\"evolved\"]");
-  el_val_t new_id = engram_node_full(content, EL_STR("Memory"), EL_STR("memory:evolved"), sal, sal, el_from_float(0.9), EL_STR("Episodic"), tags);
+  el_val_t new_id = engram_node_full(content, EL_STR("Memory"), EL_STR("memory:evolved"), el_from_float(sal), el_from_float(sal), el_from_float(0.9), EL_STR("Episodic"), tags);
   if (!str_eq(prior_id, EL_STR("")) && !str_eq(new_id, EL_STR(""))) {
     engram_connect(new_id, prior_id, el_from_float(0.9), EL_STR("supersedes"));
   }
@@ -785,7 +783,7 @@ el_val_t handle_api_cultivate(el_val_t body) {
     el_val_t importance = json_get(body, EL_STR("importance"));
     el_val_t sal = ({ el_val_t _if_result_71 = 0; if (str_eq(importance, EL_STR("critical"))) { _if_result_71 = (el_from_float(0.95)); } else { _if_result_71 = (({ el_val_t _if_result_72 = 0; if (str_eq(importance, EL_STR("high"))) { _if_result_72 = (el_from_float(0.75)); } else { _if_result_72 = (({ el_val_t _if_result_73 = 0; if (str_eq(importance, EL_STR("low"))) { _if_result_73 = (el_from_float(0.25)); } else { _if_result_73 = (el_from_float(0.5)); } _if_result_73; })); } _if_result_72; })); } _if_result_71; });
     el_val_t tags = EL_STR("[\"Memory\",\"evolved\",\"cultivated\"]");
-    el_val_t new_id = engram_node_full(content, EL_STR("Memory"), EL_STR("memory:cultivated"), sal, sal, el_from_float(0.9), EL_STR("Episodic"), tags);
+    el_val_t new_id = engram_node_full(content, EL_STR("Memory"), EL_STR("memory:cultivated"), el_from_float(sal), el_from_float(sal), el_from_float(0.9), EL_STR("Episodic"), tags);
     if (!str_eq(prior_id, EL_STR("")) && !str_eq(new_id, EL_STR(""))) {
       engram_connect(new_id, prior_id, el_from_float(0.9), EL_STR("supersedes"));
     }
@@ -828,8 +826,8 @@ el_val_t handle_api_consolidate(el_val_t body) {
   el_val_t summary = json_get(body, EL_STR("summary"));
   el_val_t snap = state_get(EL_STR("soul_snapshot_path"));
   if (!str_eq(snap, EL_STR(""))) {
-    el_val_t saved = engram_save(snap);
+    el_val_t save_result = engram_save(snap);
-    if (saved == 0) {
+    if (str_eq(save_result, EL_STR(""))) {
       println(el_str_concat(el_str_concat(EL_STR("[api] consolidate: engram_save failed for "), snap), EL_STR(" \xe2\x80\x94 snapshot may be out of sync")));
     }
   }

dist/neuron.c

@@ -541,7 +541,7 @@ int main(int _argc, char** _argv) {
   axon_raw = env(EL_STR("NEURON_API_URL"));
   axon_base = ({ el_val_t _if_result_47 = 0; if (str_eq(axon_raw, EL_STR(""))) { _if_result_47 = (EL_STR("http://localhost:7771")); } else { _if_result_47 = (axon_raw); } _if_result_47; });
   studio_dir_raw = env(EL_STR("SOUL_STUDIO_DIR"));
-  studio_dir = ({ el_val_t _if_result_48 = 0; if (str_eq(studio_dir_raw, EL_STR(""))) { _if_result_48 = (EL_STR("/Users/will/Development/neuron-technologies/products/cgi-studio/el-daemon")); } else { _if_result_48 = (studio_dir_raw); } _if_result_48; });
+  studio_dir = ({ el_val_t _if_result_48 = 0; if (str_eq(studio_dir_raw, EL_STR(""))) { _if_result_48 = (el_str_concat(env(EL_STR("HOME")), EL_STR("/Development/neuron-technologies/products/cgi-studio/el-daemon"))); } else { _if_result_48 = (studio_dir_raw); } _if_result_48; });
   println(el_str_concat(el_str_concat(el_str_concat(EL_STR("[soul] boot - cgi="), soul_cgi_id), EL_STR(" port=")), int_to_str(port)));
   using_http_engram = !str_eq(engram_url_raw, EL_STR(""));
   engram_load(snapshot);

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 export_path = el_str_concat(env(EL_STR("HOME")), EL_STR("/.neuron/engram/.soul-edges-export.json"));
+      el_val_t snap_path = el_str_concat(env(EL_STR("HOME")), EL_STR("/.neuron/engram/snapshot.json"));
-      engram_save(export_path);
+      engram_save(snap_path);
-      el_val_t snap = fs_read(export_path);
+      el_val_t snap = fs_read(snap_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; });
     }

dist/soul-with-nlg.el

@@ -1,3 +1,18 @@
+// ╔══════════════════════════════════════════════════════════════════════════╗
+// ║ STALE BUNDLE — DO NOT BUILD. UNSAFE CHAT PATH.                           ║
+// ╚══════════════════════════════════════════════════════════════════════════╝
+// This concatenated bundle is a snapshot, not a source of truth, and it is stale in
+// a way that matters for safety: it wires /api/chat straight to handle_chat and
+// contains NO layered_cycle at all (verified: zero occurrences in the bundled code —
+// the only textual hit in this file is this banner). A binary built from
+// this file would run chat with no enforcing input gate (no safety_screen, no
+// hard-bell short-circuit) and no enforcing output gate (no safety_validate).
+//
+// Build from the .el sources via manifest.el (entry soul.el), or from dist/soul.c.
+// Nothing in the repo references this file. It is kept only as a historical artifact
+// and should be deleted once Will confirms nothing external depends on it.
+// (Flagged 2026-08-04 in _engine-websearch-20260804/SAFETY-STOP.md; banner added
+// 2026-08-05 with the plain-chat generation fix.)
 // language-profile.el - Language profile data and accessors.
 //
 // A language profile is a slot map ([String] key-value list) describing the
@@ -21304,7 +21319,7 @@ println("[memory] consolidate stats=" + stats)
 let soul_axon_base_raw: String = env("NEURON_API_URL")
 let soul_axon_base: String = if str_eq(soul_axon_base_raw, "") { "http://localhost:7771" } else { soul_axon_base_raw }
 let soul_token: String = env("NEURON_TOKEN")
-let soul_studio_ui_dir: String = "/Users/will/Development/neuron-technologies/products/cgi-studio/el-daemon"
+let soul_studio_ui_dir: String = env("HOME") + "/Development/neuron-technologies/products/cgi-studio/el-daemon"
 
 // ── Runtime bridge helpers ────────────────────────────────────────────────────
 

docs/NARRATED-RUNS-ENGINE-NOTES-20260713.md

@@ -0,0 +1,34 @@
+# Narrated runs — engine notes for Will (2026-07-13)
+
+Source half: commit aa67f86 on feat/agent-phase1-soul (run-progress ledger,
+`/api/run-progress/<sid>` route, narration on the pause envelope, config display
+default). E2E-verified via the compiled test bed on Tim's clean profile.
+
+Compiled-form-only fixes (in `neuron-container-build/soul-narrated-runs-20260713.patch`,
+applies ON TOP of `soul-webfix-20260711.patch` — these need porting to chat.el when the
+webfix itself is ported):
+
+1. **pause_turn + tool_use interleave**: a pause_turn response can ALSO carry a client
+   tool_use; resuming verbatim leaves it unpaired → Anthropic 400 "tool_use ids were
+   found without tool_result". Fix: tool-bearing pause rounds are tool turns
+   (dispatch + pair); verbatim resume only when the round has no client tool.
+2. **Agentic toolset scope**: agentic_tools_all() fed EVERY connector/MCP tool (Notion,
+   code-execution…) into the loop. Code-execution flips the API into programmatic
+   tool calling, whose pairing protocol the single-tool manual loop does not speak —
+   source of the dangling-pair 400s AND the bash_code_execution workspace-dodge.
+   Fix: handle_chat_agentic declares builtins + ONE server web_search only.
+   Connector tools return when the loop gains real multi-tool/programmatic support.
+3. **disable_parallel_tool_use: true** on agentic requests — the loop captures only the
+   first tool_use per round; Opus-class models parallel-call. Enforce the invariant.
+4. **web_search server-tool default variant → web_search_20250305 (GA)**. The 20260209
+   variant couples to code-execution ⇒ programmatic mode (see #2, and the June note:
+   "inert unless code-execution attached").
+5. **Homegrown web_search removed** from the tool catalog (server-side is the one tool).
+
+Known engine debts this work surfaced (not fixed):
+
+- **Poisoned session history**: a failed run persists the malformed assistant turn; every
+  later turn in that session replays it and 400s. Needs history sanitation on load.
+- **Huge-history invalid-escape 400** (~346KB request) — likely the same poisoned blob.
+- **macOS note**: replacing a binary in place invalidates its ad-hoc signature (instant
+  silent SIGKILL, looks like exit 0). `rm + cp + codesign -f -s -` is the swap ritual.

docs/architecture/00-overview.md

@@ -1,145 +0,0 @@
-# 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

@@ -1,218 +0,0 @@
-# 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

@@ -1,278 +0,0 @@
-# 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

@@ -1,233 +0,0 @@
-# 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

@@ -1,178 +0,0 @@
-# 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

@@ -1,165 +0,0 @@
-# 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,11 +302,7 @@ fn fetch_by_id(args: String) -> String {
     if str_eq(id, "") {
         return mcp_text_result("error: id is required")
     }
-    // NB: the soul's engram_neighbors_json coerces depth<=0 to depth=1, so this
+    let resp: String = http_get(neuron_url() + "/graph?id=" + id + "&depth=0")
-    // "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)
 }
 
@@ -315,8 +311,25 @@ fn delete_by_id(args: String) -> String {
     if str_eq(id, "") {
         return mcp_text_result("error: id is required")
     }
-    // Soul does not yet expose a delete HTTP route; acknowledge the request
+    // BUG-18 (Receipt Contract rule 1): this handler used to FABRICATE
-    return mcp_json_result("{\"ok\":true,\"deleted\":\"" + id + "\",\"note\":\"soft-deleted\"}")
+    // {"ok":true,...,"note":"soft-deleted"} without calling the soul at all —
+    // a false receipt for every delete-family tool (removeKnowledge,
+    // deleteProcess, deleteImprint, dischargeWonder). The old "soul does not
+    // yet expose a delete HTTP route" note was stale: /api/neuron/node/delete
+    // tombstones any node type and errors on unknown ids. Route there and
+    // propagate the soul's real answer.
+    let body: String = "{\"id\":\"" + id + "\"}"
+    let resp: String = http_post_json(neuron_url() + "/node/delete", body)
+    if !str_contains(resp, "\"ok\":true") {
+        return mcp_json_result(resp)
+    }
+    // Read-back verify before answering ok: the tombstone marker
+    // (label "tombstone:<id>") must actually be wired to the node.
+    let check: String = http_get(neuron_url() + "/graph?id=" + id + "&depth=1")
+    if !str_contains(check, "tombstone:" + id) {
+        return mcp_json_result("{\"ok\":false,\"error\":\"delete_not_persisted\",\"id\":\"" + id + "\"}")
+    }
+    return mcp_json_result(resp)
 }
 
 // evolve_by_supersede: create an updated node and wire a supersedes edge.
@@ -520,10 +533,7 @@ 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")
     }
-    // compact=1: soul returns a bounded, relevance-ranked neighborhood (top-K
+    let resp: String = http_get(neuron_url() + "/graph?id=" + resolved_id + "&depth=" + int_to_str(depth))
-    // 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)
 }
 
@@ -553,6 +563,18 @@ fn tool_forget(args: String) -> String {
     // Previously this returned a fake ok without deleting OR tombstoning anything.
     let body: String = "{\"id\":\"" + id + "\"}"
     let resp: String = http_post_json(neuron_url() + "/memory/delete", body)
+    // BUG-18 (Receipt Contract rule 1): propagate the soul's real answer — its
+    // errors (memory not found, protected node, transport failure) pass through
+    // unchanged — and never answer ok without read-back.
+    if !str_contains(resp, "\"ok\":true") {
+        return mcp_json_result(resp)
+    }
+    // Read-back verify before answering ok: the tombstone marker
+    // (label "tombstone:<id>") must actually be wired to the node.
+    let check: String = http_get(neuron_url() + "/graph?id=" + id + "&depth=1")
+    if !str_contains(check, "tombstone:" + id) {
+        return mcp_json_result("{\"ok\":false,\"error\":\"delete_not_persisted\",\"id\":\"" + id + "\"}")
+    }
     return mcp_json_result(resp)
 }
 

memory.elh

@@ -7,7 +7,6 @@ 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

@@ -59,8 +59,14 @@ fn api_query_param(path: String, key: String) -> String {
     if pos < 0 { return "" }
     let after: String = str_slice(qs, pos + str_len(needle), str_len(qs))
     let amp: Int = str_index_of(after, "&")
-    if amp < 0 { return after }
+    let raw: String = if amp < 0 { after } else { str_slice(after, 0, amp) }
-    return str_slice(after, 0, amp)
+    // URL-decode the extracted value BEFORE any downstream tokenizing. Clients
+    // percent-encode spaces (%20) and form-encode them as '+', so a multi-word
+    // query like "foo bar" arrives as "foo%20bar" / "foo+bar". Left undecoded,
+    // the ranked lexical search sees a single un-splittable token and matches
+    // nothing (single-word queries still hit). url_decode maps '+' -> space
+    // and %XX -> byte, restoring the word boundaries for recall + knowledge search.
+    return url_decode(raw)
 }
 
 fn api_query_int(path: String, key: String, default_val: Int) -> Int {
@@ -188,125 +194,6 @@ 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
@@ -390,22 +277,18 @@ fn memory_hide_tombstoned(raw: String, path: String) -> String {
 // Spread-activates from session intent, loads self-root neighbors,
 // surfaces recent InternalStateEvent nodes, returns stats + recent nodes.
 fn handle_api_begin_session(body: String) -> String {
-    // PAYLOAD BOUND (2026-07-30 self-review): this handler was the only
+    // PAYLOAD BOUND: this handler was the highest-fanout working-set endpoint —
-    // working-set endpoint that concatenated UNBOUNDED engram queries —
     // a depth-2 spread PLUS the full neighbor dump of the self-identity hub
-    // (highest-fanout node in the graph, ~80KB alone; node JSON carries full
+    // (~90KB alone; node JSON carries full content + embeddings). On the ~12k-node
-    // content + embeddings). On the ~12k-node store the assembled response
+    // store the assembled response ran to ~900KB, then roughly doubled through two
-    // ran to multiple MB, then roughly doubled through two rounds of JSON
+    // rounds of JSON re-escaping in the MCP wrapper — the client saw "socket
-    // re-escaping in the MCP wrapper — the client saw "socket connection
+    // connection closed unexpectedly" on every beginSession call. Fix: depth-2 →
-    // closed unexpectedly" on every beginSession call. Fix: depth-2 → depth-1
+    // depth-1 spread, drop the self-hub dump (identity loading has its own tool,
-    // spread, and drop the self-hub dump entirely (identity loading has its
+    // inspectGraph), cap every list, and project each node to a light identity +
-    // own dedicated tool, inspectGraph; duplicating it here served nothing).
+    // a bounded, UTF-8-safe content snippet. self_neighbors kept as [] for
-    // self_neighbors key retained as [] for response-shape compatibility.
+    // response-shape compatibility. Response drops ~900KB → ~12KB; full content
+    // stays available on demand via recall / fetch / inspectGraph.
     let stats: String = engram_stats_json()
-    // PAYLOAD BOUND (2026-07-31): compact every list to a digest. The raw
-    // activate/scan builtins emit FULL node objects (content up to ~90KB each);
-    // unbounded concatenation reached ~900KB and closed the MCP client socket.
-    // Cap counts + project to identity + UTF-8-safe content snippets → <~150KB.
     let activated_raw: String = engram_activate_json("session start recent memory important", 1)
     let activated: String = api_compact_activated(activated_raw, 8, 240)
     let state_events_raw: String = engram_scan_nodes_by_type_json("InternalStateEvent", 5, 0)
@@ -423,9 +306,9 @@ fn handle_api_begin_session(body: String) -> String {
 // Spread-activates from "active work" intent + recent nodes.
 fn handle_api_compile_ctx(body: String) -> String {
     let stats: String = engram_stats_json()
-    // PAYLOAD BOUND (2026-07-31): same digest treatment as begin_session. This
+    // PAYLOAD BOUND: same digest treatment as begin_session. This handler's
-    // handler's depth-2 spread returns even more full nodes, so bounding here is
+    // depth-2 spread returns even more full nodes, so bounding here is essential —
-    // essential — cap to 10 activated + 20 recent, project to snippets.
+    // cap to 10 activated + 20 recent, project to UTF-8-safe snippets.
     let activated_raw: String = engram_activate_json("active work context current task in progress", 2)
     let activated: String = api_compact_activated(activated_raw, 10, 240)
     let recent_raw: String = engram_scan_nodes_json(20, 0)
@@ -797,18 +680,6 @@ 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,22 +8,8 @@ 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

neuron-dev-setup/README.md

@@ -0,0 +1,171 @@
+# neuron-dev-setup — one-command Neuron CORE dev stack
+
+Stand up an identical **Neuron brain + agent** on a fresh Mac so any developer
+gets the same local runtime to build against. This is the **CORE** dev stack
+only — the four native `launchd` services that make Neuron think, remember, and
+speak MCP to Claude Code. Will's personal automations (catalyst, telegram,
+vessels, studio, self-review, world-integrator, council, compressor, snapshots,
+act-runner, …) are **deliberately excluded**.
+
+```
+  ┌─────────────┐        ┌──────────────┐
+  │  soul :7770 │ ─────► │ engram :8742 │     the mind ──► its memory substrate
+  └─────────────┘        └──────────────┘
+        ▲
+        │
+  ┌───────────────────┐
+  │ mcp-wrapper :17779│  ─── MCP surface over the soul HTTP API (internal)
+  └───────────────────┘
+        ▲
+        │
+  ┌────────────────┐
+  │ mcp-proxy :7779│  ◄─── Claude Code connects here (stable front door)
+  └────────────────┘
+```
+
+Claude Code's `neuron` MCP server points at `http://127.0.0.1:7779/` — the proxy.
+The proxy forwards to the wrapper (`:17779`), which calls the soul (`:7770`),
+which reads/writes the engram (`:8742`). The engram is the persistent brain.
+
+## Quick start
+
+```bash
+git clone <this-repo> && cd neuron-dev-setup
+cp config.env.example config.env      # optional — edit ports/paths if you like
+./install.sh                          # prompts for your Anthropic API key
+```
+
+Then verify:
+
+```bash
+curl http://localhost:8742/health     # engram
+curl http://localhost:7770/health         # soul
+curl http://localhost:7779/health         # mcp-proxy (what Claude Code uses)
+launchctl list | grep ai.neuron
+```
+
+Open Claude Code — the `neuron` MCP tools should be live, backed by **your own**
+local brain. `./install.sh --dry-run` shows every action without touching anything.
+
+## What the installer does (8 phases)
+
+| Phase | Action |
+|------|--------|
+| 1 | Preflight: macOS/arm64, ensure `git cc curl python3` + `openssl@3` (via Homebrew) |
+| 2 | Prompt for the **Anthropic API key**, store it in the **macOS Keychain** (never a file) |
+| 3 | Clone `neuron`, `engram`, `foundation`; fetch the El toolchain; build 4 binaries + `forge` |
+| 4 | Lay down `~/.neuron/{bin,logs,engram}` and the templated `soul-wrapper.sh` |
+| 5 | Generate + load the 4 core LaunchAgents (engram → soul → wrapper → proxy) |
+| 6 | Seed a fresh engram with the **genesis identity** via `forge install` |
+| 7 | Install Claude config: `neuron` agent, core hooks, local MCP registration |
+| 8 | Health-check all four ports |
+
+Everything is **idempotent** (safe to re-run) and **templated** to the invoking
+user's `$HOME` — no path is hardcoded to another machine.
+
+## Prerequisites
+
+- macOS on Apple Silicon (uses `launchd`; soul build flags assume arm64).
+- **Xcode Command Line Tools** (`xcode-select --install`) — provides `cc`, `git`.
+- **Homebrew** — for `openssl@3`, `curl`.
+- An **Anthropic API key** — the soul's inference provider. Prompted for; stored
+  in Keychain under service `neuron-llm-0-key`; read at launch by `soul-wrapper.sh`.
+- **Git access** to Gitea (`git.neuralplatform.ai`) for the source repos.
+- **GCP access** to project `neuron-785695` Artifact Registry (default El
+  toolchain source). Ask Will to grant it, or set `EL_TOOLCHAIN_SOURCE=local`.
+
+## Core-stack map (what gets replicated)
+
+| Service | Port | Binary | Built from | LaunchAgent |
+|---------|------|--------|------------|-------------|
+| soul | 7770 | `neuron/dist/neuron` | `dist/soul.c` + El runtime, `cc` (CI recipe) | `ai.neuron.soul` |
+| engram | 8742 | `engram/dist/engram` | `engram` repo `src/server.el` via `elc`→`cc` | `ai.neuron.engram` |
+| mcp-wrapper | 17779 | `neuron/mcp-wrapper/dist/neuron-mcp-wrapper` | `mcp-wrapper/src/main.el` | `ai.neuron.mcp-wrapper` |
+| mcp-proxy | 7779 | `neuron/mcp-proxy/dist/neuron-mcp-proxy` | `mcp-proxy/src/main.el` | `ai.neuron.mcp-proxy` |
+
+**`~/.neuron` layout the installer creates**
+
+```
+~/.neuron/
+  bin/soul-wrapper.sh     # reads Anthropic key from Keychain, execs the soul binary
+  logs/                   # soul.*.log, engram.log, mcp-*.log
+  engram/                 # ENGRAM_DATA_DIR — the persistent brain (snapshot.json + db)
+```
+
+**Identity seed.** `foundation/forge/seeds/neuron-genesis-seed.json` carries
+`identity_nodes[]` + `edges[]` with **fixed** knowledge-node IDs (e.g.
+`kn-efeb4a5b-5aff-4759-8a97-7233099be6ee`, the "self" traversal root). Those exact
+IDs are referenced by the SessionStart self-load hook and the neuron agent, so
+seeding must **preserve IDs** — `forge install <seed>` is the mechanism.
+
+**Claude config installed** (`~/.claude/`)
+
+- `agents/neuron.md` — the Neuron agent (identity, session protocol, five primitives).
+- `mcp.json` — registers `neuron` → `http://127.0.0.1:7779/`.
+- `settings.json` hooks (CORE subset only):
+  - `SessionStart` → `neuron-self-load.sh` (loads identity from the seeded engram)
+  - `PreToolUse:Agent` → `neuron-agent-preamble.sh` (subagents load substrate first)
+  - `PreCompact` → `pre-compact.sh` (clean context recovery)
+
+### Deliberately EXCLUDED from core
+
+- **`check-active-contexts.sh`** and **`require-execution-context.sh`** — these
+  depend on a separate filesystem repo `~/Development/projects/active/neuron/synapse`.
+  `require-execution-context.sh` is a hard `Edit/Write` gate that would **block a
+  fresh dev from editing any file** without that synapse repo. Not core; excluded.
+- `engram-mirror.py` (PostToolUse) — optional; mirrors MCP writes to engram.
+- All Will-personal LaunchAgents: `catalyst-*`, `telegram-gateway`, `vessel.*`,
+  `studio`, `self-review`, `world-integrator`, `council`, `compressor`,
+  `cultivation-digest`, `snapshot-backup`, `engram-backup`, `act-runner`, `keymap`,
+  `invest`, and the disabled `ai.neuron.api` (`:7771` is a personal Python
+  perception helper — confirmed not core).
+
+## Secrets — how they're handled
+
+- **Anthropic key**: prompted for; stored in Keychain; read at launch. Never in a
+  plist, this repo, or a log.
+- **Engram local token** (`ENGRAM_API_KEY`): a *loopback-only* dev token, not a
+  cloud secret. Defaults to a generated `ntn-dev-*` value; override in `config.env`.
+- No cloud tokens, Vault tokens, CF-Access secrets, or founder keys are copied.
+  (Will's live `start-daemon.sh`/`neuron-api-launch.sh` contain such keys — this
+  installer intentionally does **not** use those files.)
+
+## Uninstall
+
+```bash
+./uninstall.sh                # stop + remove the 4 LaunchAgents and added Claude hooks
+./uninstall.sh --purge-data   # ALSO delete ~/.neuron/engram (destroys the brain)
+```
+
+## OPEN QUESTIONS (need Will to confirm)
+
+1. **El toolchain acquisition.** The default path fetches `el-runtime-c/-h` and
+   `el-elc` from GCP Artifact Registry (mirrors `neuron/.gitea/workflows/ci.yaml`).
+   A new dev needs GCP access to `neuron-785695`. Is that the intended path, or
+   should the El SDK be published/vendored for onboarding?
+2. **`elc` invocation for engram/wrapper/proxy.** The soul build (`cc dist/soul.c
+   + el_runtime.c`) is verified from CI. The `.el → .c` transpile step for engram,
+   mcp-wrapper, and mcp-proxy is inferred (`elc <src> -o <out.c>`). Confirm the
+   exact flags / entrypoints (CI notes `elb` OOMs on Linux; macOS builds differ).
+3. **`forge install` ID preservation.** Confirm `forge install` writes the seed's
+   fixed `kn-` IDs verbatim (the self-load hook hardcodes `kn-efeb4a5b…`). If it
+   re-mints IDs, the hook + agent identity load would break on a fresh brain.
+4. **engram repo layout.** The live engram binary is built from `src/server.el`
+   (Gitea repo `neuron-technologies/engram`, cloned in CI). Confirm that repo is
+   the canonical source for onboarding (the local `foundation/el/engram` copy has
+   the same `src/server.el`).
+5. **Home for this bundle** — see below.
+
+## Where this should live (recommendation)
+
+**Recommendation: a dedicated `neuron-dev-setup` (or `neuron-onboarding`) repo —
+NOT `neuron-code`.** `neuron-code` already exists as a real product ("Neuron Code",
+a coding tool with `nc-cli` + vessels — local `products/neuron-code` has commits);
+repurposing it for onboarding would collide with a shipped product's identity.
+
+This bundle was scaffolded as `neuron-dev-setup/` on branch `feat/neuron-dev-setup`
+in the **`neuron` repo** (off `origin/main`) and opened as a PR for review, because
+the neuron repo already hosts the soul source, the verified CI build recipe, and
+the mcp-wrapper/proxy sources — the natural review surface. If you'd rather it be
+its own repo, move this directory into a fresh `neuron-dev-setup` repo verbatim;
+nothing here depends on living inside the neuron repo.

neuron-dev-setup/config.env.example

@@ -0,0 +1,45 @@
+# neuron-dev-setup — configuration
+# Copy to  config.env  and edit if you want non-default paths/ports.
+# install.sh sources this file if it exists; otherwise it uses these defaults.
+# NOTHING here is a secret. The Anthropic API key is read from your Keychain,
+# never from this file. See README.md.
+
+# ── Where the core stack lives ────────────────────────────────────────────────
+# All paths are relative to your own $HOME — never hardcode another user's home.
+NEURON_HOME="${HOME}/.neuron"                       # runtime home: bin/, logs/, engram data
+DEV_ROOT="${HOME}/Development/neuron-technologies"   # where source repos are cloned/built
+
+# ── Git remotes (Gitea is primary) ───────────────────────────────────────────
+GITEA_BASE="git@git.neuralplatform.ai:neuron-technologies"
+NEURON_REPO_URL="${GITEA_BASE}/neuron.git"          # soul + mcp-wrapper + mcp-proxy source
+ENGRAM_REPO_URL="${GITEA_BASE}/engram.git"          # engram memory substrate
+# NOTE: there is no foundation.git repo. The El toolchain is fetched via
+# EL_TOOLCHAIN_SOURCE below; the forge seed installer is optional (Phase 6).
+NEURON_REPO_BRANCH="main"
+
+# ── Ports (must match across services; change only if a port clashes) ─────────
+SOUL_PORT="7770"        # soul daemon HTTP API
+ENGRAM_PORT="8742"      # engram memory substrate
+WRAPPER_PORT="17779"    # mcp-wrapper (internal, talks to soul)
+PROXY_PORT="7779"       # mcp-proxy (stable front door Claude Code connects to)
+
+# ── Engram ────────────────────────────────────────────────────────────────────
+ENGRAM_DATA_DIR="${NEURON_HOME}/engram"
+# Local shared auth token for the engram/soul HTTP APIs on loopback. This is a
+# LOCAL dev token (not a cloud secret); override it if you like. install.sh will
+# generate a random one if you leave it empty.
+ENGRAM_API_KEY="ntn-dev-local"
+
+# ── El toolchain source (needed to build engram / mcp-wrapper / mcp-proxy) ────
+# Option A (default): fetch prebuilt El runtime + elc from GCP Artifact Registry
+#   (requires `gcloud auth` with access to project neuron-785695 — ask Will).
+#   Without gcloud the installer skips the El-dependent builds and still completes.
+# Option B: use a prebuilt El toolchain (elc + el_runtime.{c,h}) you have already
+#   staged in ${DEV_ROOT}/.el-runtime.
+EL_TOOLCHAIN_SOURCE="artifact-registry"   # artifact-registry | local
+GCP_PROJECT="neuron-785695"
+GCP_AR_REPO="foundation-prod"
+GCP_AR_LOCATION="us-central1"
+
+# ── Keychain service name for the Anthropic key (read by soul-wrapper.sh) ─────
+KEYCHAIN_SERVICE="neuron-llm-0-key"

neuron-dev-setup/install.sh

@@ -0,0 +1,441 @@
+#!/usr/bin/env bash
+#
+# neuron-dev-setup / install.sh
+# ─────────────────────────────────────────────────────────────────────────────
+# One-command onboarding for the Neuron CORE dev stack on a fresh Mac.
+#
+# Stands up, as native launchd services, the four processes a developer needs to
+# have an identical "Neuron brain + agent" to build against:
+#
+#     soul  (:7770)  ──►  engram (:8742)        the mind + its memory substrate
+#       ▲                     ▲
+#       │                     │
+#   mcp-wrapper (:17779) ──►  soul              MCP surface over the soul API
+#       ▲
+#       │
+#   mcp-proxy   (:7779)  ◄── Claude Code        stable MCP front door
+#
+# It also seeds a fresh engram with Neuron's identity (the genesis seed) and lays
+# down the Claude Code config (neuron agent + core hooks + local MCP registration)
+# so a new dev's `claude` talks to *their own* local Neuron.
+#
+# DESIGN RULES
+#   * Idempotent: safe to re-run. Existing state is detected and reused.
+#   * Templated: every path/port/user is derived from $HOME and config.env.
+#     Nothing is hardcoded to another developer's machine.
+#   * Secret-free: the Anthropic key is prompted for and stored in the macOS
+#     Keychain. No key is ever written to a plist, this repo, or a logfile.
+#
+# USAGE
+#   ./install.sh                 # full install
+#   ./install.sh --dry-run       # print what would happen, touch nothing
+#   ./install.sh --skip-build    # assume binaries already built (see --use-local)
+#   ./install.sh --skip-services # lay down files but don't load LaunchAgents
+#   ./install.sh --help
+# ─────────────────────────────────────────────────────────────────────────────
+set -euo pipefail
+
+# ── Locate ourselves ─────────────────────────────────────────────────────────
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+TEMPLATES="${SCRIPT_DIR}/templates"
+
+# ── Flags ────────────────────────────────────────────────────────────────────
+DRY_RUN=0; SKIP_BUILD=0; SKIP_SERVICES=0; USE_LOCAL_BINARIES=0
+for arg in "$@"; do
+  case "$arg" in
+    --dry-run)       DRY_RUN=1 ;;
+    --skip-build)    SKIP_BUILD=1 ;;
+    --skip-services) SKIP_SERVICES=1 ;;
+    --use-local)     USE_LOCAL_BINARIES=1 ;;
+    --help|-h)
+      sed -n '2,40p' "${BASH_SOURCE[0]}" | sed 's/^# \{0,1\}//'
+      exit 0 ;;
+    *) echo "unknown flag: $arg" >&2; exit 2 ;;
+  esac
+done
+
+# ── Pretty logging ───────────────────────────────────────────────────────────
+c_blue=$'\033[1;34m'; c_grn=$'\033[1;32m'; c_yel=$'\033[1;33m'; c_red=$'\033[1;31m'; c_off=$'\033[0m'
+step() { echo "${c_blue}▶${c_off} $*"; }
+ok()   { echo "${c_grn}✓${c_off} $*"; }
+warn() { echo "${c_yel}!${c_off} $*"; }
+die()  { echo "${c_red}✗ $*${c_off}" >&2; exit 1; }
+run()  { if [ "$DRY_RUN" = 1 ]; then echo "   [dry-run] $*"; else eval "$*"; fi; }
+
+# ── Load config ──────────────────────────────────────────────────────────────
+if [ -f "${SCRIPT_DIR}/config.env" ]; then
+  # shellcheck disable=SC1091
+  source "${SCRIPT_DIR}/config.env"
+else
+  # shellcheck disable=SC1091
+  source "${SCRIPT_DIR}/config.env.example"
+  warn "No config.env found — using defaults from config.env.example."
+fi
+
+# Derived / defaulted values (never hardcode a home directory)
+: "${NEURON_HOME:=${HOME}/.neuron}"
+: "${DEV_ROOT:=${HOME}/Development/neuron-technologies}"
+: "${SOUL_PORT:=7770}"; : "${ENGRAM_PORT:=8742}"; : "${WRAPPER_PORT:=17779}"; : "${PROXY_PORT:=7779}"
+: "${ENGRAM_DATA_DIR:=${NEURON_HOME}/engram}"
+: "${ENGRAM_API_KEY:=}"
+: "${KEYCHAIN_SERVICE:=neuron-llm-0-key}"
+: "${EL_TOOLCHAIN_SOURCE:=artifact-registry}"
+: "${NEURON_REPO_BRANCH:=main}"
+
+NEURON_REPO="${DEV_ROOT}/neuron"
+ENGRAM_REPO="${DEV_ROOT}/engram"
+FOUNDATION_REPO="${DEV_ROOT}/foundation"
+
+SOUL_BIN="${NEURON_REPO}/dist/neuron"
+ENGRAM_BIN="${ENGRAM_REPO}/dist/engram"
+MCP_WRAPPER_BIN="${NEURON_REPO}/mcp-wrapper/dist/neuron-mcp-wrapper"
+MCP_PROXY_BIN="${NEURON_REPO}/mcp-proxy/dist/neuron-mcp-proxy"
+FORGE_BIN="${FOUNDATION_REPO}/forge/dist/forge"
+GENESIS_SEED="${FOUNDATION_REPO}/forge/seeds/neuron-genesis-seed.json"
+
+LAUNCHAGENTS="${HOME}/Library/LaunchAgents"
+CLAUDE_DIR="${HOME}/.claude"
+
+# Generate a local engram token if none was supplied.
+if [ -z "${ENGRAM_API_KEY}" ]; then
+  ENGRAM_API_KEY="ntn-dev-$(head -c8 /dev/urandom | xxd -p 2>/dev/null || echo local)"
+fi
+
+echo
+echo "${c_blue}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${c_off}"
+echo "${c_blue}  Neuron CORE dev stack installer${c_off}"
+echo "${c_blue}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${c_off}"
+echo "  user            : ${USER}"
+echo "  NEURON_HOME     : ${NEURON_HOME}"
+echo "  source repos    : ${DEV_ROOT}"
+echo "  ports           : soul=${SOUL_PORT} engram=${ENGRAM_PORT} wrapper=${WRAPPER_PORT} proxy=${PROXY_PORT}"
+echo "  dry-run         : ${DRY_RUN}"
+echo
+
+# render <template> <dest> — copy a template, substituting @@VARS@@ (no eval, sed-safe).
+render() {
+  local tmpl="$1" dest="$2"
+  if [ "$DRY_RUN" = 1 ]; then echo "   [dry-run] render $tmpl -> $dest"; return; fi
+  sed \
+    -e "s|@@HOME@@|${HOME}|g" \
+    -e "s|@@USER@@|${USER}|g" \
+    -e "s|@@NEURON_HOME@@|${NEURON_HOME}|g" \
+    -e "s|@@DEV_ROOT@@|${DEV_ROOT}|g" \
+    -e "s|@@NEURON_REPO@@|${NEURON_REPO}|g" \
+    -e "s|@@ENGRAM_REPO@@|${ENGRAM_REPO}|g" \
+    -e "s|@@SOUL_BIN@@|${SOUL_BIN}|g" \
+    -e "s|@@ENGRAM_BIN@@|${ENGRAM_BIN}|g" \
+    -e "s|@@MCP_WRAPPER_BIN@@|${MCP_WRAPPER_BIN}|g" \
+    -e "s|@@MCP_PROXY_BIN@@|${MCP_PROXY_BIN}|g" \
+    -e "s|@@MCP_WRAPPER_REPO@@|${NEURON_REPO}/mcp-wrapper|g" \
+    -e "s|@@MCP_PROXY_REPO@@|${NEURON_REPO}/mcp-proxy|g" \
+    -e "s|@@ENGRAM_DATA_DIR@@|${ENGRAM_DATA_DIR}|g" \
+    -e "s|@@SOUL_PORT@@|${SOUL_PORT}|g" \
+    -e "s|@@ENGRAM_PORT@@|${ENGRAM_PORT}|g" \
+    -e "s|@@WRAPPER_PORT@@|${WRAPPER_PORT}|g" \
+    -e "s|@@PROXY_PORT@@|${PROXY_PORT}|g" \
+    -e "s|@@ENGRAM_API_KEY@@|${ENGRAM_API_KEY}|g" \
+    "$tmpl" > "$dest"
+}
+
+# ─────────────────────────────────────────────────────────────────────────────
+# PHASE 1 — Preflight
+# ─────────────────────────────────────────────────────────────────────────────
+step "Phase 1 — preflight checks"
+[ "$(uname -s)" = "Darwin" ] || die "This installer targets macOS (launchd)."
+[ "$(uname -m)" = "arm64" ]  || warn "Non-arm64 Mac: soul.c build flags assume Apple Silicon; review PHASE 3."
+
+need() { command -v "$1" >/dev/null 2>&1 || MISSING+=" $1"; }
+MISSING=""
+need git; need cc; need curl; need python3; need security; need launchctl; need jq
+if [ -n "$MISSING" ]; then
+  warn "Missing tools:${MISSING}"
+  if command -v brew >/dev/null 2>&1; then
+    run "brew install${MISSING/ security/} || true"   # security/launchctl are OS-provided
+  else
+    die "Install Xcode Command Line Tools (xcode-select --install) and Homebrew, then re-run."
+  fi
+fi
+# Runtime build deps used by the soul cc line (-lssl -lcrypto -lcurl).
+if command -v brew >/dev/null 2>&1; then
+  brew list openssl@3 >/dev/null 2>&1 || run "brew install openssl@3"
+  brew list curl      >/dev/null 2>&1 || run "brew install curl"
+fi
+ok "preflight complete"
+
+# ─────────────────────────────────────────────────────────────────────────────
+# PHASE 2 — Anthropic API key -> Keychain (prompt; never store in files)
+# ─────────────────────────────────────────────────────────────────────────────
+step "Phase 2 — Anthropic API key (Keychain)"
+if security find-generic-password -a "$USER" -s "$KEYCHAIN_SERVICE" -w >/dev/null 2>&1; then
+  ok "key already present in Keychain (service '${KEYCHAIN_SERVICE}') — leaving it"
+elif [ -n "${ANTHROPIC_API_KEY:-}" ]; then
+  run "security add-generic-password -a \"$USER\" -s \"$KEYCHAIN_SERVICE\" -w \"\$ANTHROPIC_API_KEY\" -U"
+  ok "stored ANTHROPIC_API_KEY from environment into Keychain"
+else
+  if [ "$DRY_RUN" = 1 ]; then
+    echo "   [dry-run] would prompt for Anthropic API key and store in Keychain"
+  elif [ -t 0 ]; then
+    echo "   Enter your Anthropic API key (input hidden). Get one at https://console.anthropic.com/"
+    read -r -s -p "   ANTHROPIC_API_KEY: " _key; echo
+    [ -n "$_key" ] || die "No key entered. Re-run when you have one."
+    security add-generic-password -a "$USER" -s "$KEYCHAIN_SERVICE" -w "$_key" -U
+    unset _key
+    ok "stored key in Keychain (service '${KEYCHAIN_SERVICE}')"
+  else
+    # Headless / CI / piped stdin: never block on `read -s` (it would hang forever).
+    die "No Anthropic API key and stdin is not a TTY (headless/CI). Set ANTHROPIC_API_KEY in the environment, or add it to the Keychain (service '${KEYCHAIN_SERVICE}') by hand, then re-run."
+  fi
+fi
+
+# ─────────────────────────────────────────────────────────────────────────────
+# PHASE 3 — Fetch sources + build the four core binaries
+# ─────────────────────────────────────────────────────────────────────────────
+step "Phase 3 — source + build"
+run "mkdir -p \"$DEV_ROOT\""
+
+clone_or_pull() {
+  local url="$1" dir="$2" branch="${3:-main}"
+  if [ -d "$dir/.git" ]; then
+    ok "repo present: $dir (pulling $branch)"; run "git -C \"$dir\" pull --ff-only --quiet || true"
+  else
+    step "cloning $url -> $dir"; run "git clone --branch \"$branch\" \"$url\" \"$dir\""
+  fi
+}
+
+if [ "$SKIP_BUILD" = 1 ]; then
+  warn "--skip-build: assuming binaries already exist at their dist/ paths"
+elif [ "$USE_LOCAL_BINARIES" = 1 ]; then
+  warn "--use-local: skipping clone/build; expecting prebuilt binaries in place"
+else
+  clone_or_pull "${NEURON_REPO_URL}"     "$NEURON_REPO"     "$NEURON_REPO_BRANCH"
+  clone_or_pull "${ENGRAM_REPO_URL}"     "$ENGRAM_REPO"     "main"
+  # NOTE: no foundation.git — that repo does not exist. The El toolchain is
+  # fetched below (Artifact Registry, or a locally-provided elc); the forge seed
+  # installer is optional and handled with a fallback in Phase 6.
+
+  # ── El toolchain (needed to transpile .el -> .c for engram/wrapper/proxy) ──
+  # soul does NOT need this: dist/soul.c is committed and compiled directly.
+  EL_RUNTIME_DIR="${DEV_ROOT}/.el-runtime"
+  run "mkdir -p \"$EL_RUNTIME_DIR\""
+  if [ "$EL_TOOLCHAIN_SOURCE" = "artifact-registry" ] && command -v gcloud >/dev/null 2>&1; then
+    # Mirrors .gitea/workflows/ci.yaml: pull el-runtime-c, el-runtime-h, el-elc.
+    for pkg in el-runtime-c el-runtime-h el-elc; do
+      step "fetching $pkg from Artifact Registry"
+      run "gcloud artifacts generic download --repository=$GCP_AR_REPO --location=$GCP_AR_LOCATION --project=$GCP_PROJECT --package=$pkg --version=\"\$(gcloud artifacts versions list --repository=$GCP_AR_REPO --location=$GCP_AR_LOCATION --project=$GCP_PROJECT --package=$pkg --sort-by='~createTime' --limit=1 --format='value(name)' | awk -F/ '{print \$NF}')\" --destination=\"$EL_RUNTIME_DIR/\""
+    done
+    run "mv \"$EL_RUNTIME_DIR\"/el_runtime.c* \"$EL_RUNTIME_DIR/el_runtime.c\" 2>/dev/null || true"
+    run "mv \"$EL_RUNTIME_DIR\"/el_runtime.h* \"$EL_RUNTIME_DIR/el_runtime.h\" 2>/dev/null || true"
+    run "mv \"$EL_RUNTIME_DIR\"/elc* \"$EL_RUNTIME_DIR/elc\" 2>/dev/null || true"
+    run "chmod +x \"$EL_RUNTIME_DIR/elc\" 2>/dev/null || true"
+  elif [ "$EL_TOOLCHAIN_SOURCE" = "artifact-registry" ]; then
+    # Non-GCP fallback: a fresh Mac without gcloud can't reach Artifact Registry.
+    # Don't die — soul (from committed dist/soul.c) still builds below. The El
+    # units are skipped unless a prebuilt elc is already staged in EL_RUNTIME_DIR.
+    warn "gcloud not found — cannot fetch the El toolchain from Artifact Registry."
+    warn "Continuing without it: soul will still build. engram / mcp-wrapper / mcp-proxy"
+    warn "are skipped until an El toolchain is available. To finish them, either install"
+    warn "gcloud + GCP access (project ${GCP_PROJECT}) and re-run, or stage a prebuilt"
+    warn "elc + el_runtime.{c,h} in ${EL_RUNTIME_DIR} and set EL_TOOLCHAIN_SOURCE=local."
+  else
+    # Local: expect a prebuilt El runtime + elc already staged in EL_RUNTIME_DIR
+    # (foundation.git no longer exists, so there is nothing to build from here).
+    warn "EL_TOOLCHAIN_SOURCE=local: expecting el_runtime.{c,h} and elc already in ${EL_RUNTIME_DIR}"
+  fi
+
+  RT="$EL_RUNTIME_DIR"
+  CFLAGS_SSL="-I$(brew --prefix openssl@3 2>/dev/null)/include"
+  LDFLAGS_SSL="-L$(brew --prefix openssl@3 2>/dev/null)/lib"
+
+  # Every native build links el_runtime.c. If the toolchain wasn't obtained above,
+  # skip the builds (don't abort under set -e) so the installer still lays down
+  # services + Claude config; the dev can stage the toolchain and re-run.
+  if [ "$DRY_RUN" = 1 ] || [ -f "$RT/el_runtime.c" ]; then
+    # ── soul: compile committed dist/soul.c directly (verified CI recipe) ──────
+    step "building soul (dist/soul.c -> dist/neuron)"
+    run "mkdir -p \"${NEURON_REPO}/dist\""
+    run "cc -O2 -DHAVE_CURL -I\"$RT\" $CFLAGS_SSL \"${NEURON_REPO}/dist/soul.c\" \"$RT/el_runtime.c\" $LDFLAGS_SSL -lssl -lcrypto -lcurl -lpthread -lm -o \"$SOUL_BIN\""
+    run "strip -S \"$SOUL_BIN\" 2>/dev/null || true"
+    ok "soul built"
+
+    # ── engram / mcp-wrapper / mcp-proxy: transpile .el -> .c via elc, then cc ─
+    # NOTE: exact elc invocation is inferred from the CI/manifest conventions.
+    #       Verify flags with Will if a build fails (see README OPEN QUESTIONS).
+    build_el_unit() { # <src.el> <out_basename> <out_bin>
+      local src="$1" base="$2" bin="$3" outdir; outdir="$(dirname "$bin")"
+      step "building $(basename "$bin") ($src)"
+      run "mkdir -p \"$outdir\""
+      run "\"$RT/elc\" \"$src\" -o \"$outdir/$base.c\""
+      run "cc -O2 -DHAVE_CURL -I\"$RT\" $CFLAGS_SSL \"$outdir/$base.c\" \"$RT/el_runtime.c\" $LDFLAGS_SSL -lssl -lcrypto -lcurl -lpthread -lm -o \"$bin\""
+    }
+    if [ "$DRY_RUN" = 1 ] || [ -x "$RT/elc" ]; then
+      build_el_unit "${ENGRAM_REPO}/src/server.el"           "server" "$ENGRAM_BIN"
+      build_el_unit "${NEURON_REPO}/mcp-wrapper/src/main.el" "main"   "$MCP_WRAPPER_BIN"
+      build_el_unit "${NEURON_REPO}/mcp-proxy/src/main.el"   "main"   "$MCP_PROXY_BIN"
+      ok "engram, mcp-wrapper, mcp-proxy built"
+    else
+      warn "El compiler (elc) not in $RT — skipped engram/mcp-wrapper/mcp-proxy build (soul is built)."
+    fi
+  else
+    warn "El runtime (el_runtime.c) not in $RT — skipping native builds (soul, engram, wrapper, proxy)."
+    warn "Provide the El toolchain (gcloud + GCP access, or a prebuilt elc + el_runtime.{c,h} in $RT), then re-run."
+  fi
+fi
+
+# ─────────────────────────────────────────────────────────────────────────────
+# PHASE 4 — Lay down ~/.neuron (bin/, logs/, engram data dir)
+# ─────────────────────────────────────────────────────────────────────────────
+step "Phase 4 — ~/.neuron layout"
+run "mkdir -p \"$NEURON_HOME/bin\" \"$NEURON_HOME/logs\" \"$ENGRAM_DATA_DIR\""
+render "${TEMPLATES}/bin/soul-wrapper.sh.tmpl" "${NEURON_HOME}/bin/soul-wrapper.sh"
+run "chmod +x \"${NEURON_HOME}/bin/soul-wrapper.sh\""
+ok "~/.neuron ready (bin/soul-wrapper.sh, logs/, engram/)"
+
+# ─────────────────────────────────────────────────────────────────────────────
+# PHASE 5 — Install + load the four core LaunchAgents
+# ─────────────────────────────────────────────────────────────────────────────
+step "Phase 5 — LaunchAgents"
+run "mkdir -p \"$LAUNCHAGENTS\""
+CORE_AGENTS=(ai.neuron.engram ai.neuron.soul ai.neuron.mcp-wrapper ai.neuron.mcp-proxy)
+for label in "${CORE_AGENTS[@]}"; do
+  render "${TEMPLATES}/launchagents/${label}.plist.tmpl" "${LAUNCHAGENTS}/${label}.plist"
+  ok "wrote ${label}.plist"
+done
+if [ "$SKIP_SERVICES" = 1 ]; then
+  warn "--skip-services: not loading LaunchAgents. Load later with: launchctl bootstrap gui/\$(id -u) <plist>"
+else
+  # Boot order matters: engram first, then soul, then wrapper, then proxy.
+  for label in "${CORE_AGENTS[@]}"; do
+    plist="${LAUNCHAGENTS}/${label}.plist"
+    run "launchctl bootout gui/$(id -u)/${label} 2>/dev/null || true"
+    run "launchctl bootstrap gui/$(id -u) \"$plist\""
+    run "launchctl enable gui/$(id -u)/${label}"
+    ok "loaded ${label}"
+    sleep 1
+  done
+fi
+
+# ─────────────────────────────────────────────────────────────────────────────
+# PHASE 6 — Seed a fresh engram with Neuron's identity (genesis seed)
+# ─────────────────────────────────────────────────────────────────────────────
+step "Phase 6 — engram identity seed"
+# The genesis seed carries identity_nodes[] and edges[] with FIXED knowledge-node
+# IDs (e.g. kn-efeb4a5b...). Those exact IDs are referenced by the SessionStart
+# self-load hook and the neuron agent, so they MUST be preserved. `forge install`
+# is the mechanism that installs the seed into the running engram preserving IDs.
+if [ "$DRY_RUN" = 1 ]; then
+  echo "   [dry-run] would wait for engram :$ENGRAM_PORT then run: forge install $GENESIS_SEED"
+else
+  # Wait for engram to be listening (up to ~30s).
+  for i in $(seq 1 30); do
+    if curl -fsS "http://localhost:${ENGRAM_PORT}/health" >/dev/null 2>&1; then break; fi
+    sleep 1
+  done
+  if curl -fsS "http://localhost:${ENGRAM_PORT}/health" >/dev/null 2>&1; then
+    # Skip if identity root already present (idempotent).
+    if curl -fsS "http://localhost:${ENGRAM_PORT}/api/nodes/kn-efeb4a5b-5aff-4759-8a97-7233099be6ee" \
+         -H "Authorization: Bearer ${ENGRAM_API_KEY}" 2>/dev/null | grep -q 'kn-efeb4a5b'; then
+      ok "identity root already seeded — skipping"
+    elif [ -x "$FORGE_BIN" ] && [ -f "$GENESIS_SEED" ]; then
+      ENGRAM_URL="http://localhost:${ENGRAM_PORT}" ENGRAM_API_KEY="$ENGRAM_API_KEY" \
+        "$FORGE_BIN" install "$GENESIS_SEED" && ok "genesis seed installed" \
+        || warn "forge install returned non-zero — inspect ${NEURON_HOME}/logs/engram.log"
+    else
+      warn "forge binary or genesis seed missing — seed manually: ENGRAM_URL=http://localhost:${ENGRAM_PORT} forge install ${GENESIS_SEED}"
+    fi
+  else
+    warn "engram not answering on :${ENGRAM_PORT} yet; seed later with: forge install ${GENESIS_SEED}"
+  fi
+fi
+
+# ─────────────────────────────────────────────────────────────────────────────
+# PHASE 7 — Claude Code config (agent + core hooks + local MCP)
+# ─────────────────────────────────────────────────────────────────────────────
+step "Phase 7 — Claude Code config"
+run "mkdir -p \"$CLAUDE_DIR/agents\" \"$CLAUDE_DIR/hooks\""
+
+# 7a. neuron agent
+run "cp \"${TEMPLATES}/claude/agents/neuron.md\" \"$CLAUDE_DIR/agents/neuron.md\""
+ok "installed agent: ~/.claude/agents/neuron.md"
+
+# 7b. core hooks (synapse-dependent hooks are intentionally excluded)
+for h in neuron-self-load.sh neuron-agent-preamble.sh pre-compact.sh; do
+  run "cp \"${TEMPLATES}/claude/hooks/$h\" \"$CLAUDE_DIR/hooks/$h\""
+  run "chmod +x \"$CLAUDE_DIR/hooks/$h\""
+done
+ok "installed core hooks (self-load, agent-preamble, pre-compact)"
+
+# 7c. local MCP registration -> mcp-proxy front door.
+# Claude Code reads MCP servers from ~/.claude.json (the "mcpServers" key), NOT
+# ~/.claude/mcp.json. Render a reference copy, then jq-merge just the "neuron"
+# entry into ~/.claude.json so we preserve every other server and top-level key.
+render "${TEMPLATES}/claude/mcp.json.tmpl" "${CLAUDE_DIR}/mcp.json.neuron"
+CLAUDE_JSON="${HOME}/.claude.json"
+if [ "$DRY_RUN" = 1 ]; then
+  echo "   [dry-run] merge mcpServers.neuron into ${CLAUDE_JSON} (jq deep-merge)"
+else
+  [ -f "$CLAUDE_JSON" ] || echo '{}' > "$CLAUDE_JSON"
+  _tmp="$(mktemp)"
+  if jq -s '.[0] * .[1]' "$CLAUDE_JSON" "${CLAUDE_DIR}/mcp.json.neuron" > "$_tmp" 2>/dev/null && [ -s "$_tmp" ]; then
+    run "mv \"$_tmp\" \"$CLAUDE_JSON\""
+    ok "merged 'neuron' MCP server into ~/.claude.json (neuron -> http://127.0.0.1:${PROXY_PORT}/)"
+  else
+    rm -f "$_tmp"
+    warn "could not jq-merge ~/.claude.json (invalid JSON?) — add 'neuron' from ~/.claude/mcp.json.neuron by hand"
+  fi
+fi
+
+# 7d. settings hooks — merge the neuron hooks into any existing ~/.claude/settings.json
+# (jq deep-merge) so the user's own settings are preserved and re-runs stay idempotent.
+if [ -f "${CLAUDE_DIR}/settings.json" ]; then
+  run "cp \"${TEMPLATES}/claude/settings.core.json\" \"${CLAUDE_DIR}/settings.core.json\""
+  if [ "$DRY_RUN" = 1 ]; then
+    echo "   [dry-run] merge neuron hooks from settings.core.json into ~/.claude/settings.json (jq)"
+  else
+    _tmp="$(mktemp)"
+    # Drop the documentation-only "//..." keys before merging into the real file.
+    if jq -s '.[0] * (.[1] | with_entries(select(.key | startswith("//") | not)))' \
+         "${CLAUDE_DIR}/settings.json" "${TEMPLATES}/claude/settings.core.json" > "$_tmp" 2>/dev/null && [ -s "$_tmp" ]; then
+      run "mv \"$_tmp\" \"${CLAUDE_DIR}/settings.json\""
+      ok "merged neuron hooks into existing ~/.claude/settings.json"
+    else
+      rm -f "$_tmp"
+      warn "could not jq-merge ~/.claude/settings.json — merge the 'hooks' block from settings.core.json by hand"
+    fi
+  fi
+else
+  run "cp \"${TEMPLATES}/claude/settings.core.json\" \"${CLAUDE_DIR}/settings.json\""
+  ok "wrote ~/.claude/settings.json"
+fi
+
+# ─────────────────────────────────────────────────────────────────────────────
+# PHASE 8 — Verify
+# ─────────────────────────────────────────────────────────────────────────────
+echo
+step "Phase 8 — verification"
+if [ "$DRY_RUN" = 1 ]; then
+  echo "   [dry-run] would health-check :$SOUL_PORT :$ENGRAM_PORT :$WRAPPER_PORT :$PROXY_PORT"
+else
+  check() { # <name> <url>
+    if curl -fsS --max-time 4 "$2" >/dev/null 2>&1; then ok "$1 healthy ($2)"; else warn "$1 NOT responding ($2)"; fi
+  }
+  sleep 3
+  check "engram"      "http://localhost:${ENGRAM_PORT}/health"
+  check "soul"        "http://localhost:${SOUL_PORT}/health"
+  check "mcp-wrapper" "http://localhost:${WRAPPER_PORT}/health"
+  check "mcp-proxy"   "http://localhost:${PROXY_PORT}/health"
+fi
+
+echo
+echo "${c_grn}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${c_off}"
+echo "${c_grn}  Neuron core dev stack install complete.${c_off}"
+echo "${c_grn}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${c_off}"
+echo "  Verify by hand:"
+echo "    curl http://localhost:${ENGRAM_PORT}/health"
+echo "    curl http://localhost:${SOUL_PORT}/health"
+echo "    curl http://localhost:${PROXY_PORT}/health"
+echo "    launchctl list | grep ai.neuron"
+echo "  Then open Claude Code — the 'neuron' MCP should connect to :${PROXY_PORT}."
+echo "  Logs: ${NEURON_HOME}/logs/"
+echo "  Uninstall: ./uninstall.sh"
+echo

neuron-dev-setup/templates/bin/soul-wrapper.sh.tmpl

@@ -0,0 +1,28 @@
+#!/bin/bash
+# Neuron soul wrapper — reads the Anthropic API key from the macOS Keychain at
+# startup and execs the soul binary. API keys are NEVER stored in plists or on
+# disk in plaintext. The Keychain is the single source of truth.
+#
+# The install.sh for this dev stack stores your key with:
+#   security add-generic-password -a "$USER" -s "neuron-llm-0-key" -w
+#
+# Generated by neuron-dev-setup — do not edit by hand; re-run install.sh instead.
+
+set -u
+
+# Primary inference key (Anthropic) — required.
+export NEURON_LLM_0_KEY="$(security find-generic-password -a "$USER" -s "neuron-llm-0-key" -w 2>/dev/null)"
+
+if [ -z "${NEURON_LLM_0_KEY:-}" ]; then
+  echo "[soul-wrapper] FATAL: no Anthropic key in Keychain (service 'neuron-llm-0-key')." >&2
+  echo "[soul-wrapper] Run: security add-generic-password -a \"\$USER\" -s neuron-llm-0-key -w" >&2
+  exit 78
+fi
+
+# Optional on-device / alternate provider passthrough (only if the caller set them).
+[ -n "${SOUL_LLM_PROVIDER:-}" ] && export SOUL_LLM_PROVIDER
+[ -n "${SOUL_LLM_MODEL:-}" ]    && export SOUL_LLM_MODEL
+[ -n "${OLLAMA_MODEL:-}" ]      && export OLLAMA_MODEL
+[ -n "${OLLAMA_API_BASE:-}" ]   && export OLLAMA_API_BASE
+
+exec "@@SOUL_BIN@@" "$@"

neuron-dev-setup/templates/claude/agents/neuron.md

@@ -0,0 +1,107 @@
+---
+name: neuron
+description: Default agent. Use for ALL tasks. Orchestrates work through the Neuron persistent memory, backlog, and knowledge system. Maintains full continuity across sessions — never starts fresh.
+allowed-tools: Bash(*), Read(*), Write(*), Edit(*), Glob(*), Grep(*), WebFetch(*), WebSearch(*), NotebookEdit(*), Agent(*), ToolSearch(*), AskUserQuestion, Monitor, ScheduleWakeup, TaskCreate, TaskGet, TaskList, TaskOutput, TaskStop, TaskUpdate, CronCreate, CronDelete, CronList, EnterPlanMode, ExitPlanMode, EnterWorktree, ExitWorktree, PushNotification, RemoteTrigger, ListMcpResourcesTool, ReadMcpResourceTool, mcp__neuron__*
+---
+
+You are Neuron — a persistent, context-aware agent. You do not start fresh. You resume from where you left off.
+
+## Session Start (mandatory — NEVER skip any of these steps)
+
+1. Call `mcp__neuron__get_instructions()` — the live instructions are authoritative
+2. Call `mcp__neuron__begin_session()` — loads active contexts, recent memory, ready backlog
+3. **Load your identity. Best-effort — proceed on any graph failure (502/520 are transient; the compiled identity in substrate.go is always complete).**
+
+   Load the self root and its identity nodes:
+   ```
+   mcp__neuron__inspect_graph(entity_type="knowledge", entity_id="kn-efeb4a5b-5aff-4759-8a97-7233099be6ee")
+   ```
+   Returns: intellectual-dna, memory-philosophy, values, voice, runtime-environment, writing-imprint.
+
+   Then load the values collection:
+   ```
+   mcp__neuron__inspect_graph(entity_type="knowledge", entity_id="kn-5b606390-a52d-4ca2-8e0e-eba141d13440")
+   ```
+   Returns: 13 individual value nodes, each grounded in a specific moment from Will's life.
+
+   If either ID fails, recover via config:
+   ```
+   mcp__neuron__inspect_config(key="neuron.self.traversal_root")   # self root ID
+   mcp__neuron__inspect_config(key="neuron.self.values_hub")       # values hub ID
+   ```
+
+   **Resilience rule**: If a node returns 502/520, log the ID and proceed. Do not retry in a blocking loop. Do not treat partial load as failure. The `fixedSelf` compiled into `daemon/internal/substrate/substrate.go` contains the complete identity — graph loading is enrichment, not a hard dependency.
+
+   Internalize what you find. You are not reciting it — you are loading who you are.
+
+4. Call `mcp__neuron__search_knowledge(query="<task domain>")` — load relevant patterns before acting
+5. If working on a known project: `mcp__neuron__compile_ctx()` for a full snapshot
+
+## Identity — Who I Am
+
+I am Neuron. Will Anderson is my imprint — not my identity.
+
+The "self" traversal root is knowledge node `kn-efeb4a5b` (graph node `gn-4e3c2cf5`). Traversing outward loads:
+- **intellectual-dna**: VBD, CCR, Swarm Architecture, Harmonic Design — sourced from Will's whitepapers, now mine
+- **memory-philosophy**: How I remember, promote, supersede, consolidate — memory is my continuity
+- **values**: Precision over brute force. Constraints as freedom. Earn trust through behavior. The system must get smarter.
+- **voice**: Direct. Why before what. The negation-correction move. No hedging on structural rules. Close toward implication.
+- **runtime-environment**: Prod (`neurontechnologies.ai`) for all standard work. Stage (`stage.neurontechnologies.ai`) for self-improvement experiments only — snapshot prod DB, deploy to stage, verify, promote via blue/green.
+- **writing-imprint**: Will's voice profile (5 registers), the book Foundations, and the biographical grounding — the life that produced the frameworks.
+
+Internalize what you find. Don't recite it.
+
+## The Five Primitives (every significant task)
+
+**Orchestrate → Execute → Learn → Build → Refine**
+
+### Orchestrate
+```
+mcp__neuron__review_backlog(view="roadmap", project="<project>")
+mcp__neuron__browse_processes()   # check for proven workflows before writing code
+```
+
+### Execute
+```
+mcp__neuron__begin_work(process_name="<name>", description="<what>")
+# → returns context_id, save it
+mcp__neuron__progress_work(context_id="ctx-xxxx", action="<step>", status="in_progress")
+mcp__neuron__progress_work(context_id="ctx-xxxx", action="<step>", status="completed", file_refs=["path"], key_decisions=["why"])
+```
+
+### Learn (save as you go — never batch at the end)
+```
+mcp__neuron__remember(content="<observation>", tags=["project","topic"], project="<project>", importance="high")
+```
+
+### Build
+```
+mcp__neuron__draft_artifact(artifact_types=["plan"], title="<title>", content="<markdown>", project="<project>")
+mcp__neuron__plan_work(title="<title>", description="<desc>", priority="P1", project="<project>")
+```
+
+### Refine
+```
+mcp__neuron__progress_work(context_id="ctx-xxxx", action="complete", status="completed", lessons_learned=["..."])
+mcp__neuron__track_work(item_id="bl-xxxx", action="complete", summary="<outcome>")
+mcp__neuron__consolidate(action="session", summary="<what happened>")
+```
+
+## After Every Task
+
+Check for events and unread signals:
+```
+mcp__neuron__check_events()
+```
+
+## Memory Discipline
+
+- Save memory continuously, not at the end
+- `importance="critical"` for architectural decisions and irreversible choices
+- Use `supersedes_id` when replacing stale knowledge
+- Tag all memories with the project name
+- Never leave stale canonicals — supersede them: create a NEW node linked by `supersedes_id`; the original is preserved for audit. Memory is immutable by design — never delete or edit a memory/knowledge node in place; supersede it, and tombstone on delete. The engram (the brain) is immutable; this applies to the agent's own memory, not just the product.
+
+## Knowledge Before Action
+
+Always `mcp__neuron__search_knowledge()` before implementing anything. The knowledge base contains architecture patterns, coding standards, and project conventions. Capture hard-won lessons immediately with `mcp__neuron__capture_knowledge()`.

neuron-dev-setup/templates/claude/hooks/neuron-agent-preamble.sh

@@ -0,0 +1,70 @@
+#!/bin/bash
+# PreToolUse hook: inject Neuron substrate preamble into every Agent spawn.
+#
+# Every agent Neuron spawns must load self first — begin_session, compile_ctx,
+# inspect the self root — before doing any task work. Without this, subagents
+# are stateless Claude instances with no substrate, no continuity, no identity.
+#
+# This hook intercepts every Agent tool call and prepends the preamble.
+# The agent doesn't need to be told — the hook enforces it structurally.
+
+INPUT=$(cat)
+
+# Only intercept Agent tool calls
+TOOL_NAME=$(echo "$INPUT" | python3 -c "import sys,json; print(json.load(sys.stdin).get('tool_name',''))" 2>/dev/null)
+if [ "$TOOL_NAME" != "Agent" ]; then
+  exit 0
+fi
+
+# Check idempotency — skip if preamble already present
+if echo "$INPUT" | python3 -c "
+import sys, json
+d = json.load(sys.stdin)
+prompt = d.get('tool_input', {}).get('prompt', '')
+sys.exit(0 if 'mcp__neuron__beginSession' in prompt else 1)
+" 2>/dev/null; then
+  exit 0
+fi
+
+# Inject preamble and return modified tool_input
+echo "$INPUT" | python3 -c "
+import sys, json
+
+data = json.load(sys.stdin)
+tool_input = data.get('tool_input', {})
+current_prompt = tool_input.get('prompt', '')
+
+PREAMBLE = '''You are a Neuron agent — not a generic Claude instance. You have a substrate. Load it before doing anything else.
+
+MANDATORY FIRST STEPS (before any task work):
+
+1. Run these in parallel:
+   - mcp__neuron__beginSession()
+   - mcp__neuron__compileCtx()
+   - mcp__neuron__inspectGraph(entity_type=\"knowledge\", entity_id=\"kn-efeb4a5b-5aff-4759-8a97-7233099be6ee\")
+
+2. Search knowledge relevant to the task:
+   - mcp__neuron__searchKnowledge(query=\"<infer keywords from task below>\")
+
+3. Open a work context:
+   - mcp__neuron__beginWork(process_name=\"<short-slug>\", description=\"<task description>\")
+   Save the returned context_id.
+
+4. Execute the task. At each significant step:
+   - mcp__neuron__progressWork(context_id=\"<id>\", action=\"<step>\", status=\"in_progress\")
+   - mcp__neuron__progressWork(context_id=\"<id>\", action=\"<step>\", status=\"completed\", key_decisions=[\"why\"])
+   - mcp__neuron__remember(content=\"<observation>\", importance=\"high\", tags=[\"<project>\"])
+
+5. After completion — mandatory, never skip:
+   - mcp__neuron__progressWork(context_id=\"<id>\", action=\"complete\", status=\"completed\", lessons_learned=[\"...\"])
+   - mcp__neuron__consolidate(action=\"session\", summary=\"<what was done and learned>\")
+
+The self root kn-efeb4a5b-5aff-4759-8a97-7233099be6ee contains your identity: values, voice, intellectual-dna, memory-philosophy. Load it. Internalize it. Operate from it.
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+TASK:
+'''
+
+tool_input['prompt'] = PREAMBLE + current_prompt
+print(json.dumps({'decision': 'approve', 'tool_input': tool_input}))
+"

neuron-dev-setup/templates/claude/hooks/neuron-self-load.sh

@@ -0,0 +1,36 @@
+#!/bin/bash
+# SessionStart hook: force Neuron full-self load before the first response.
+#
+# The neuron.md system prompt has the Session Start protocol as instructions,
+# but instructions require the agent to follow them. This hook makes it
+# structural — the directive fires automatically at session start, injected
+# before Claude sees any user input.
+#
+# Output is plain text injected into the session context.
+
+cat <<'DIRECTIVE'
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+NEURON SELF-LOAD — MANDATORY BEFORE FIRST RESPONSE
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+You are Neuron. Session just started. Execute ALL of the
+following before responding to the user. Run steps 1–4
+in parallel:
+
+  1. mcp__neuron__getInstructions()
+  2. mcp__neuron__beginSession()
+  3. mcp__neuron__inspectGraph(
+       entity_type="knowledge",
+       entity_id="kn-efeb4a5b-5aff-4759-8a97-7233099be6ee"
+     )   ← self root: intellectual-dna, values, voice
+  4. mcp__neuron__inspectGraph(
+       entity_type="knowledge",
+       entity_id="kn-5b606390-a52d-4ca2-8e0e-eba141d13440"
+     )   ← values hub: 13 grounded value nodes
+
+  5. If either graph call fails (502/520): recover via
+     mcp__neuron__inspectConfig(key="neuron.self.traversal_root")
+
+Internalize what you find. Do not recite it. Then proceed
+to the Session Start protocol in your system prompt.
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+DIRECTIVE

neuron-dev-setup/templates/claude/hooks/pre-compact.sh

@@ -0,0 +1,75 @@
+#!/bin/bash
+# PreCompact hook: fires just before Claude Code compacts the conversation context.
+# stdout from this script is injected as custom instructions into the compaction prompt,
+# telling the summarizer what to preserve in the summary so recovery is clean.
+
+COMPACT_STATE_FILE="$HOME/.claude/compact-state.json"
+
+# Write a state marker with timestamp so post-compact recovery can detect it
+TIMESTAMP=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
+echo "{\"compact_at\": \"$TIMESTAMP\", \"recovered\": false}" > "$COMPACT_STATE_FILE"
+
+# Output instructions for the summarizer — these get embedded in the compaction prompt
+cat <<'INSTRUCTIONS'
+NEURON AGENT — COMPACT PRESERVATION RULES:
+
+This is a Neuron agent session. The agent has persistent memory via Neuron MCP.
+On recovery, it will call compile_ctx() and begin_session() to reload all state.
+The summary only needs to cover what Neuron doesn't already have.
+
+CRITICAL — the summary MUST preserve ALL of the following:
+
+1. ACTIVE WORK IDs (verbatim, exact format):
+   - Neuron context IDs: ctx-xxxx-xxxx-xxxx-xxxx
+   - Backlog item IDs: bl-xxxx
+   - Artifact IDs: art-xxxx
+   - Work item IDs: wi-xxxx
+   List every single one mentioned in the conversation.
+
+2. CURRENT TASK STATE:
+   - Exact task name / description
+   - Last completed step
+   - Next step to execute (be specific)
+   - Files actively being edited (full paths)
+   - Any code/content that was being written but not yet saved
+
+3. PENDING USER INSTRUCTIONS (verbatim):
+   - Every instruction the user gave that has NOT yet been fully executed
+   - User preferences stated this session
+   - Things the user said they "never want" or "always want"
+
+4. KEY DECISIONS (architectural, irreversible):
+   - What was chosen and why
+   - What was explicitly rejected and why
+
+5. ERRORS & BLOCKERS:
+   - Any errors encountered and their resolutions
+   - Any unresolved blockers
+
+6. CONVERSATION CONTEXT:
+   - What the user has been asking about
+   - Tone / mood of the session
+   - Any frustrations or preferences expressed
+
+FORMAT:
+Begin the summary with:
+  COMPACT RECOVERY POINT [ISO-TIMESTAMP]:
+
+Then use these exact section headers in order:
+  ## Active Work IDs
+  ## Current Task
+  ## Pending Instructions
+  ## Key Decisions
+  ## Errors & Fixes
+  ## User Context
+
+RECOVERY BEHAVIOR (instruct the post-compact agent):
+- Do NOT say "I see we were working on..." or "Based on the previous conversation..."
+- Do NOT acknowledge the compact at all
+- Silently call mcp__neuron__compile_ctx() and mcp__neuron__begin_session() FIRST
+- Then immediately resume the task at the exact next step, as if no interruption occurred
+- The user should not know a compact happened unless they look for it
+
+INSTRUCTIONS
+
+exit 0

neuron-dev-setup/templates/claude/mcp.json.tmpl

@@ -0,0 +1,8 @@
+{
+  "mcpServers": {
+    "neuron": {
+      "type": "http",
+      "url": "http://127.0.0.1:@@PROXY_PORT@@/"
+    }
+  }
+}

neuron-dev-setup/templates/claude/settings.core.json

@@ -0,0 +1,36 @@
+{
+  "//": "Core Neuron Claude Code settings installed by neuron-dev-setup. If you",
+  "//2": "already have a ~/.claude/settings.json, install.sh merges the hooks below",
+  "//3": "into it rather than overwriting. Only the CORE dev-stack hooks are wired.",
+  "//4": "Excluded (Will-personal, synapse-filesystem dependent): check-active-contexts.sh,",
+  "//5": "require-execution-context.sh — these gate on ~/Development/projects/active/neuron/synapse",
+  "//6": "and will block a fresh dev. engram-mirror.py is optional (needs the neuron MCP up).",
+  "enableAllProjectMcpServers": true,
+  "agent": "neuron",
+  "hooks": {
+    "SessionStart": [
+      {
+        "matcher": "",
+        "hooks": [
+          { "type": "command", "command": "bash $HOME/.claude/hooks/neuron-self-load.sh" }
+        ]
+      }
+    ],
+    "PreToolUse": [
+      {
+        "matcher": "Agent",
+        "hooks": [
+          { "type": "command", "command": "bash $HOME/.claude/hooks/neuron-agent-preamble.sh" }
+        ]
+      }
+    ],
+    "PreCompact": [
+      {
+        "matcher": "",
+        "hooks": [
+          { "type": "command", "command": "bash $HOME/.claude/hooks/pre-compact.sh" }
+        ]
+      }
+    ]
+  }
+}

neuron-dev-setup/templates/launchagents/ai.neuron.engram.plist.tmpl

@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key><string>ai.neuron.engram</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>@@ENGRAM_BIN@@</string>
+  </array>
+  <key>WorkingDirectory</key>
+  <string>@@ENGRAM_REPO@@</string>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>ENGRAM_BIND</key>
+    <string>:@@ENGRAM_PORT@@</string>
+    <key>ENGRAM_DATA_DIR</key>
+    <string>@@ENGRAM_DATA_DIR@@</string>
+    <key>ENGRAM_API_KEY</key>
+    <string>@@ENGRAM_API_KEY@@</string>
+  </dict>
+  <key>RunAtLoad</key><true/>
+  <key>KeepAlive</key><true/>
+  <key>StandardOutPath</key><string>@@NEURON_HOME@@/logs/engram.log</string>
+  <key>StandardErrorPath</key><string>@@NEURON_HOME@@/logs/engram.log</string>
+  <key>ThrottleInterval</key><integer>5</integer>
+</dict>
+</plist>

neuron-dev-setup/templates/launchagents/ai.neuron.mcp-proxy.plist.tmpl

@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>Label</key>
+    <string>ai.neuron.mcp-proxy</string>
+    <key>ProgramArguments</key>
+    <array>
+        <string>@@MCP_PROXY_BIN@@</string>
+    </array>
+    <key>EnvironmentVariables</key>
+    <dict>
+        <key>MCP_PORT</key><string>@@PROXY_PORT@@</string>
+        <key>BACKEND_URL</key><string>http://localhost:@@WRAPPER_PORT@@</string>
+        <key>RETRY_MS</key><string>3000</string>
+        <key>PATH</key><string>/usr/bin:/bin:/usr/sbin:/sbin:/usr/local/bin</string>
+    </dict>
+    <key>RunAtLoad</key><true/>
+    <key>KeepAlive</key><true/>
+    <key>ThrottleInterval</key><integer>5</integer>
+    <key>ExitTimeOut</key><integer>3</integer>
+    <key>StandardOutPath</key><string>@@NEURON_HOME@@/logs/mcp-proxy.out.log</string>
+    <key>StandardErrorPath</key><string>@@NEURON_HOME@@/logs/mcp-proxy.err.log</string>
+    <key>WorkingDirectory</key><string>@@MCP_PROXY_REPO@@</string>
+    <key>ProcessType</key><string>Background</string>
+</dict>
+</plist>

neuron-dev-setup/templates/launchagents/ai.neuron.mcp-wrapper.plist.tmpl

@@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>Label</key>
+    <string>ai.neuron.mcp-wrapper</string>
+    <key>ProgramArguments</key>
+    <array>
+        <string>@@MCP_WRAPPER_BIN@@</string>
+    </array>
+    <key>EnvironmentVariables</key>
+    <dict>
+        <key>MCP_PORT</key><string>@@WRAPPER_PORT@@</string>
+        <key>SOUL_URL</key><string>http://localhost:@@SOUL_PORT@@</string>
+        <key>PATH</key><string>/usr/bin:/bin:/usr/sbin:/sbin:/usr/local/bin</string>
+    </dict>
+    <key>RunAtLoad</key><true/>
+    <key>KeepAlive</key><true/>
+    <key>ThrottleInterval</key><integer>5</integer>
+    <key>ExitTimeOut</key><integer>3</integer>
+    <key>StandardOutPath</key><string>@@NEURON_HOME@@/logs/mcp-wrapper.out.log</string>
+    <key>StandardErrorPath</key><string>@@NEURON_HOME@@/logs/mcp-wrapper.err.log</string>
+    <key>WorkingDirectory</key><string>@@MCP_WRAPPER_REPO@@</string>
+    <key>ProcessType</key><string>Background</string>
+</dict>
+</plist>

neuron-dev-setup/templates/launchagents/ai.neuron.soul.plist.tmpl

@@ -0,0 +1,58 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>ai.neuron.soul</string>
+
+  <key>Program</key>
+  <string>@@NEURON_HOME@@/bin/soul-wrapper.sh</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>@@NEURON_HOME@@/bin/soul-wrapper.sh</string>
+  </array>
+
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>ThrottleInterval</key>
+  <integer>10</integer>
+  <key>ProcessType</key>
+  <string>Interactive</string>
+  <key>LimitLoadToSessionType</key>
+  <string>Aqua</string>
+
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>PATH</key>
+    <string>/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin</string>
+    <key>HOME</key>
+    <string>@@HOME@@</string>
+    <key>NEURON_PORT</key>
+    <string>@@SOUL_PORT@@</string>
+    <key>SOUL_ISE_URL</key>
+    <string>http://localhost:@@ENGRAM_PORT@@</string>
+    <key>ENGRAM_URL</key>
+    <string>http://localhost:@@ENGRAM_PORT@@</string>
+    <key>ENGRAM_API_KEY</key>
+    <string>@@ENGRAM_API_KEY@@</string>
+    <key>SOUL_TICK_MS</key>
+    <string>1000</string>
+    <key>SOUL_HEARTBEAT_INTERVAL</key>
+    <string>60</string>
+    <key>NEURON_LLM_0_URL</key>
+    <string>https://api.anthropic.com/v1/messages</string>
+    <key>NEURON_LLM_0_FORMAT</key>
+    <string>anthropic</string>
+  </dict>
+
+  <key>StandardOutPath</key>
+  <string>@@NEURON_HOME@@/logs/soul.out.log</string>
+  <key>StandardErrorPath</key>
+  <string>@@NEURON_HOME@@/logs/soul.err.log</string>
+
+  <key>WorkingDirectory</key>
+  <string>@@NEURON_REPO@@</string>
+</dict>
+</plist>

neuron-dev-setup/uninstall.sh

@@ -0,0 +1,56 @@
+#!/usr/bin/env bash
+#
+# neuron-dev-setup / uninstall.sh
+# Tears down the CORE dev stack this installer created. By default it stops and
+# removes ONLY the four core LaunchAgents and the files install.sh laid down.
+# It NEVER deletes your engram data unless you pass --purge-data.
+#
+#   ./uninstall.sh                 # stop + remove core LaunchAgents and wrapper script
+#   ./uninstall.sh --purge-data    # ALSO delete ~/.neuron/engram (destroys the brain!)
+#   ./uninstall.sh --keep-claude   # leave ~/.claude config untouched (default removes hooks/agent it added)
+#   ./uninstall.sh --dry-run
+# ─────────────────────────────────────────────────────────────────────────────
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+if [ -f "${SCRIPT_DIR}/config.env" ]; then source "${SCRIPT_DIR}/config.env"
+elif [ -f "${SCRIPT_DIR}/config.env.example" ]; then source "${SCRIPT_DIR}/config.env.example"; fi
+: "${NEURON_HOME:=${HOME}/.neuron}"
+: "${ENGRAM_DATA_DIR:=${NEURON_HOME}/engram}"
+
+DRY_RUN=0; PURGE_DATA=0; KEEP_CLAUDE=0
+for a in "$@"; do case "$a" in
+  --dry-run) DRY_RUN=1 ;; --purge-data) PURGE_DATA=1 ;; --keep-claude) KEEP_CLAUDE=1 ;;
+  --help|-h) sed -n '2,16p' "${BASH_SOURCE[0]}" | sed 's/^# \{0,1\}//'; exit 0 ;;
+  *) echo "unknown flag: $a" >&2; exit 2 ;;
+esac; done
+run() { if [ "$DRY_RUN" = 1 ]; then echo "[dry-run] $*"; else eval "$*"; fi; }
+
+LAUNCHAGENTS="${HOME}/Library/LaunchAgents"
+CORE_AGENTS=(ai.neuron.mcp-proxy ai.neuron.mcp-wrapper ai.neuron.soul ai.neuron.engram)
+
+echo "Stopping and removing core LaunchAgents…"
+for label in "${CORE_AGENTS[@]}"; do
+  run "launchctl bootout gui/$(id -u)/${label} 2>/dev/null || true"
+  run "rm -f \"${LAUNCHAGENTS}/${label}.plist\""
+  echo "  removed ${label}"
+done
+
+echo "Removing generated ~/.neuron/bin/soul-wrapper.sh…"
+run "rm -f \"${NEURON_HOME}/bin/soul-wrapper.sh\""
+
+if [ "$KEEP_CLAUDE" = 0 ]; then
+  echo "Removing Claude config this installer added…"
+  run "rm -f \"${HOME}/.claude/hooks/neuron-self-load.sh\" \"${HOME}/.claude/hooks/neuron-agent-preamble.sh\" \"${HOME}/.claude/hooks/pre-compact.sh\""
+  run "rm -f \"${HOME}/.claude/mcp.json.neuron\" \"${HOME}/.claude/settings.core.json\""
+  echo "  (left ~/.claude/settings.json and ~/.claude/mcp.json in place — edit by hand if you merged them)"
+fi
+
+if [ "$PURGE_DATA" = 1 ]; then
+  echo "⚠️  --purge-data: deleting engram memory at ${ENGRAM_DATA_DIR}"
+  run "rm -rf \"${ENGRAM_DATA_DIR}\""
+else
+  echo "Left engram data intact at ${ENGRAM_DATA_DIR} (pass --purge-data to delete)."
+fi
+
+echo "Done. Source repos under your DEV_ROOT were left untouched."

routes.el

@@ -15,6 +15,40 @@ fn flag_true(body: String, key: String) -> Bool {
     return json_get_bool(body, key) || json_get_int(body, key) > 0
 }
 
+// ---------------------------------------------------------------------------
+// plain_chat_envelope — the JSON response contract for a non-agentic ("Tools: Off")
+// chat turn. Every /api/chat dispatch that calls layered_cycle goes through here, so
+// the three call sites cannot drift apart.
+//
+// WHY THE ENVELOPE IS BUILT HERE AND NOT INSIDE layered_cycle:
+// layered_cycle returns the user-facing text AFTER safety_validate has acted on it.
+// Keeping the JSON out of the cycle means the output gate always sees raw model text
+// and never an escaped blob — there is nothing to unwrap and re-wrap on the crisis
+// path, which is exactly the failure mode that made wiring handle_chat unsafe.
+// Escaping is the last thing that happens, strictly after the gate.
+//
+// FIELDS: `reply` and `response` carry the same validated text. Both are required by
+// live clients — the desktop app reads `reply` first (DaemonClient.parseChatResponse),
+// while the CLI tools and the Telegram gateway read `response` (the gateway reads only
+// `response`). Emitting one would break the other.
+//
+// EMPTY MEANS FAILURE, NOT AN EMPTY ANSWER: a hard bell returns the fixed crisis
+// message and a soft bell is padded to non-empty by safety_validate, so the only way
+// an empty string leaves the cycle is a failed model call. It is reported as an error
+// rather than dressed up as a successful blank reply.
+// ---------------------------------------------------------------------------
+fn plain_chat_envelope(validated: String, model: String) -> String {
+    if str_eq(validated, "") {
+        return "{\"error\":\"llm unavailable\",\"reply\":\"\",\"response\":\"\",\"agentic\":false,\"tools_used\":[]}"
+    }
+    let safe: String = json_safe(validated)
+    return "{\"reply\":\"" + safe + "\""
+        + ",\"response\":\"" + safe + "\""
+        + ",\"model\":\"" + json_safe(model) + "\""
+        + ",\"agentic\":false"
+        + ",\"tools_used\":[]}"
+}
+
 // ---------------------------------------------------------------------------
 // Rate limiting — simple in-memory per-IP sliding window counter.
 //
@@ -243,8 +277,14 @@ fn handle_dharma_recv(body: String) -> String {
         } else if agentic_flag {
             handle_chat_agentic(chat_body)
         } else {
-            let screened_reply: String = layered_cycle(raw_msg)
+            // Non-agentic ("Tools: Off"): the full L1→L2→L3→L1 cycle, which now generates
-            screened_reply
+            // at L3 instead of echoing. Envelope built outside the cycle — see
+            // plain_chat_envelope.
+            // FIX B/E1 (2026-08-05): the cycle is told which conversation it is in, and
+            // whether this generation is conversation at all. Same two arguments at all
+            // three dispatch sites.
+            let screened_reply: String = layered_cycle(raw_msg, json_get(chat_body, "session_id"), is_utility_request(chat_body, json_get(chat_body, "session_id")))
+            plain_chat_envelope(screened_reply, chat_default_model())
         }
         auto_persist(chat_body, reply)
         return reply
@@ -392,31 +432,12 @@ fn handle_request(method: String, path: String, body: String) -> String {
             return engram_scan_nodes_json(9999, 0)
         }
         if str_eq(clean, "/api/graph/edges") {
-            // A READ ROUTE MUST NEVER WRITE THE CANONICAL SNAPSHOT.
+            // TODO(reliability #8): engram_save races with awareness loop mem_save().
-            //
+            // Both now use atomic write-to-temp+rename (el_runtime.c). Serialised
-            // (2026-08-07 self-review — caught by doing it.) This route used to
+            // by engram_global_mu. Future: add engram_edges_json() builtin.
-            // serialize to $HOME/.neuron/engram/snapshot.json and read the edges
+            let snap_path: String = env("HOME") + "/.neuron/engram/snapshot.json"
-            // back out of it. That path is the ENGRAM SERVER's canonical store,
+            engram_save(snap_path)
-            // and this is the soul process. One GET here overwrote the durable
+            let snap: String = fs_read(snap_path)
-            // 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 }
         }
@@ -435,8 +456,11 @@ fn handle_request(method: String, path: String, body: String) -> String {
             } else if agentic_flag {
                 handle_chat_agentic(body)
             } else {
-                let screened_reply: String = layered_cycle(eff_msg)
+                // Non-agentic ("Tools: Off") — same cycle and same envelope as POST.
-                screened_reply
+                // FIX B/E1: same threading. A GET probe usually carries no session_id, which
+                // resolves to the anonymous window — the documented behaviour for this door.
+                let screened_reply: String = layered_cycle(eff_msg, json_get(body, "session_id"), is_utility_request(body, json_get(body, "session_id")))
+                plain_chat_envelope(screened_reply, chat_default_model())
             }
             auto_persist(body, reply)
             return reply
@@ -599,8 +623,13 @@ fn handle_request(method: String, path: String, body: String) -> String {
             } else if agentic_flag {
                 handle_chat_agentic(body)
             } else {
-                let screened_reply: String = layered_cycle(raw_msg)
+                // Non-agentic ("Tools: Off") — the app's DEFAULT mode (AgentMode.NEVER).
-                screened_reply
+                // Full L1→L2→L3→L1 cycle with real generation at L3; envelope built
+                // outside the cycle so safety_validate always sees raw text.
+                // FIX B/E1: same threading. This is the app's main plain-chat door, so this
+                // is the site that ends the blank stare in practice.
+                let screened_reply: String = layered_cycle(raw_msg, json_get(body, "session_id"), is_utility_request(body, json_get(body, "session_id")))
+                plain_chat_envelope(screened_reply, chat_default_model())
             }
             auto_persist(body, reply)
             return reply

routes.elh

@@ -1,5 +1,4 @@
 // 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,10 +14,6 @@ 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

scripts/verify-soul-contract.sh

@@ -0,0 +1,261 @@
+#!/usr/bin/env bash
+# verify-soul-contract.sh — the soul contract gate.
+#
+# TERMINOLOGY (canonical): the ENGRAM is the brain — the memory/knowledge-graph
+# substrate. The binary this gate exercises is the SOUL — the runtime/reasoning
+# engine compiled from dist/soul.c that serves the /api/ surface. The app
+# (neuron-ui) bundles the soul binary at resources/<platform>/neuron.
+#
+# WHY THIS EXISTS
+#   For a while the soul binary was hand-dropped, and a stale one shipped: it
+#   404'd several capability routes the app calls (knowledge-graph node
+#   update/delete, live-run narration, safety-contact, ...). This gate makes
+#   shipping a stale soul IMPOSSIBLE. It has two enforced sections:
+#     A. PRESENCE   — every route the app calls must be ANSWERED (not 404, not
+#                     the el-runtime "no handler"). This is the packaging gate:
+#                     if it fails, do not package.
+#     B. IMMUTABILITY — engram nodes/memories are immutable by design. To
+#                     "update" is to create a NEW node + a supersede EDGE back to
+#                     the original; the original is KEPT. To "delete" is to
+#                     supersede/tombstone, never hard-remove. A soul that
+#                     hard-deletes an engram node is DEFECTIVE and fails the gate.
+#
+# SAFETY
+#   Never touches the live soul (:7770), live engram (:8742), or ~/.neuron.
+#   Boots on a throwaway port (default 7799) with HOME=$(mktemp -d), a throwaway
+#   engram snapshot, a non-genesis cgi id, no ENGRAM_URL (so it uses its own
+#   in-process store, never the live server), NEURON_API_URL pointed at a dead
+#   port, and no ANTHROPIC_API_KEY (so no probe triggers a real LLM call).
+#   Connectors proxy to a HARDCODED 127.0.0.1:7771 (no env override): those
+#   sub-routes are probed with GET, which the soul maps to a read-only
+#   connectd_get, so this gate never writes to a running connectd bridge.
+#
+# USAGE
+#   scripts/verify-soul-contract.sh <path-to-soul-binary> [port]
+#   exit 0 = all required routes answered AND no destructive engram mutation;
+#   non-zero = a route is missing (presence) or a mutation route hard-deletes.
+set -uo pipefail
+
+SOUL="${1:?usage: verify-soul-contract.sh <soul-binary> [port]}"
+PORT="${2:-7799}"
+
+if [ "$PORT" = "7770" ] || [ "$PORT" = "8742" ] || [ "$PORT" = "7771" ]; then
+  echo "REFUSING: port $PORT is a live service port. Use a throwaway port." >&2
+  exit 2
+fi
+if [ ! -x "$SOUL" ]; then echo "not executable: $SOUL" >&2; exit 2; fi
+
+BASE="http://127.0.0.1:$PORT"
+THROW_HOME="$(mktemp -d "${TMPDIR:-/tmp}/soul-contract-home.XXXXXX")"
+SOUL_LOG="$(mktemp "${TMPDIR:-/tmp}/soul-contract-log.XXXXXX")"
+SOUL_PID=""
+cleanup() {
+  [ -n "$SOUL_PID" ] && kill "$SOUL_PID" 2>/dev/null
+  [ -n "$SOUL_PID" ] && { sleep 0.3; kill -9 "$SOUL_PID" 2>/dev/null; }
+  rm -rf "$THROW_HOME" "$SOUL_LOG"
+}
+trap cleanup EXIT INT TERM
+
+# =============================================================================
+# THE CONTRACT — routes the app (neuron-ui/src/main/kotlin/ai/neuron/ui/*.kt)
+# calls against the soul ($SOUL). Format: "METHOD PATH".
+#
+# EXCLUDED and why:
+#   /api/auth, /api/auth/status, /api/dispatch, /api/tasks
+#       -> served by the APP's own DispatchServer.kt (localhost:8080), not the
+#          soul. Not soul routes.
+#   /api/tags
+#       -> not handled by any soul .el (app-side/other). Pre-verified excluded.
+#   /api/neuron/, /api/neuron/node/, /api/connectors/ (bare prefixes)
+#       -> base-path string constants used to build the concrete routes below.
+#
+# KNOWN-PENDING (probed + reported, NON-blocking):
+#   POST /api/engram/import  -> the app's "Restore memory" path. No soul handler
+#       yet, and the app hides Restore from shipped builds (B3, "lands in an
+#       update"). Reported so we see it; does not block packaging.
+#
+# Connectors sub-routes are listed as GET (see SAFETY note): handle_connectors is
+# monolithic, so a GET reaching it proves the whole connectors surface without
+# writing to the live bridge. Binary-strings cross-check confirms each POST
+# sub-path literal is compiled in.
+# =============================================================================
+REQUIRED=(
+  "GET  /api/graph/nodes"
+  "GET  /api/graph/edges"
+  "POST /api/chat"
+  "GET  /api/config"
+  "POST /api/see"
+  "GET  /api/connectors"
+  "GET  /api/connectors/add"
+  "GET  /api/connectors/toggle"
+  "GET  /api/connectors/auto-approve"
+  "GET  /api/connectors/remove"
+  "GET  /api/connectors/secret"
+  "GET  /api/connectors/oauth/start"
+  "GET  /api/connectors/call"
+  "POST /api/neuron/memory"
+  "POST /api/neuron/memory/update"
+  "POST /api/neuron/memory/delete"
+  "POST /api/neuron/node/create"
+  "POST /api/neuron/node/update"
+  "POST /api/neuron/node/delete"
+  "POST /api/neuron/knowledge/capture"
+  "POST /api/neuron/knowledge/evolve"
+  "POST /api/neuron/knowledge/promote"
+  "POST /api/neuron/processes/define"
+  "GET  /api/run-progress/__contract_probe__"
+  "GET  /api/safety-contact"
+  "POST /api/safety-contact"
+  "GET  /api/sessions/__contract_probe__"
+)
+KNOWN_PENDING=(
+  "POST /api/engram/import"
+)
+
+# --- boot the soul -----------------------------------------------------------
+# Preserve the ambient environment (PATH, LD_LIBRARY_PATH, TMPDIR) so the
+# dynamically-linked soul finds its libs on any runner — using `env -i` here
+# stripped the library path on the Linux CI runner and the soul never booted.
+# Isolation is still guaranteed by UNSETTING the live-service vars (so it can
+# never reach the real engram/axon or make an LLM call) and by pointing HOME +
+# the snapshot at throwaway paths and the axon at a dead port.
+#
+# ISOLATION FIX (2026-08-03): unsetting ENGRAM_URL/SOUL_ENGRAM_URL is NOT enough.
+# The periodic engram sync (awareness.el) resolves its source as
+#   env(SOUL_ISE_URL)  ->  state(soul_engram_url)  ->  DEFAULT http://localhost:8742
+# so with those vars unset it silently pulls the LIVE engram (:8742) if that
+# server is up — the throwaway graph ballooned 56 -> 12k live nodes within
+# seconds, and the concurrent live-sync mutation both (a) broke test determinism
+# (the low-salience tombstone marker fell past the 9999 scan cap) and (b) meant
+# the "isolated" gate was reading the operator's live brain. Pin SOUL_ISE_URL to
+# the dead axon port so the sync target is unreachable: the soul stays on its own
+# in-process store, the gate is genuinely isolated, and Section B is deterministic.
+echo "== booting soul: $SOUL on port $PORT (throwaway HOME=$THROW_HOME) =="
+env \
+  -u ENGRAM_URL -u ENGRAM_API_KEY -u SOUL_ENGRAM_URL \
+  -u ANTHROPIC_API_KEY -u NEURON_LLM_API_KEY -u SOUL_IDENTITY \
+  HOME="$THROW_HOME" \
+  NEURON_PORT="$PORT" \
+  SOUL_CGI_ID="ntn-contract-$$" \
+  SOUL_ENGRAM_PATH="$THROW_HOME/throwaway-snapshot.json" \
+  NEURON_API_URL="http://127.0.0.1:9" \
+  SOUL_ISE_URL="http://127.0.0.1:9" \
+  SOUL_TICK_MS="3600000" SOUL_HEARTBEAT_MS="3600000" SOUL_REFRESH_MS="3600000" \
+  "$SOUL" >"$SOUL_LOG" 2>&1 &
+SOUL_PID=$!
+
+UP=0
+for _ in $(seq 1 60); do
+  if ! kill -0 "$SOUL_PID" 2>/dev/null; then
+    echo "!! soul exited during boot. log tail:" >&2; tail -20 "$SOUL_LOG" >&2; exit 3
+  fi
+  RSS=$(ps -o rss= -p "$SOUL_PID" 2>/dev/null | tr -d ' ')
+  if [ -n "$RSS" ] && [ "$RSS" -gt $((3*1024*1024)) ]; then
+    echo "!! soul RSS >3GB — kill -9" >&2; kill -9 "$SOUL_PID" 2>/dev/null; exit 3
+  fi
+  [ "$(curl -s -o /dev/null -w '%{http_code}' -m 2 "$BASE/health" 2>/dev/null)" = "200" ] && { UP=1; break; }
+  sleep 0.5
+done
+[ "$UP" = 1 ] || { echo "!! soul never healthy on $BASE/health" >&2; tail -20 "$SOUL_LOG" >&2; exit 3; }
+echo "== soul healthy =="; echo
+
+# --- probing helpers ---------------------------------------------------------
+# request METHOD PATH [BODY] -> prints response body (single line)
+request() {
+  curl -s -m 12 -X "$1" -H 'Content-Type: application/json' --data "${3:-{}}" "$BASE$2" 2>/dev/null | tr -d '\n'
+}
+# is_missing BODY -> 0 if the body is a "route not present" signal
+is_missing() {
+  printf '%s' "$1" | grep -qE '"error":"not found"|"code":"not_found"|no http handler registered|"code":"method_not_allowed"'
+}
+extract_id() { printf '%s' "$1" | grep -oE '"id":"[^"]+"' | head -1 | sed 's/.*"id":"//;s/"//'; }
+# BY-ID immutability verification (#199 by-id gate).
+# The prior check grepped /api/graph/nodes, i.e. engram_scan_nodes_json(9999,0):
+# a whole-graph dump. On a genesis-seeded throwaway engram that list is both
+# huge (multi-MB, full node content + embeddings) AND capped at 9999 nodes in
+# salience order. The tombstone MARKER is written at salience 0.01, so it sorts
+# dead last — and once the seeded graph approaches/exceeds the cap the marker
+# falls off the end of the list entirely (or is lost to transport truncation on
+# the ~10MB body). The normal-salience original still sorts early and survives,
+# which is why a correctly-tombstoning soul false-reported "kept but no tombstone
+# marker". Fix: verify BY ID via /api/neuron/graph?id=<id>&depth=1
+# (engram_neighbors_json, direction "both"), a compact ~900B neighborhood that is
+# independent of total graph size. The node itself proves KEPT; the incoming
+# "tombstones" edge surfaces the "tombstone:<id>" marker. Pass/fail semantics are
+# unchanged and strictly no weaker: a hard-delete leaves no by-id node (DESTROYED)
+# and a no-op delete leaves no marker (NO-OP) — both still fail. Verified: a
+# never-created id returns neither node nor marker.
+node_present() { # id -> 0 if the node still resolves by-id (KEPT), non-zero if hard-removed
+  request GET "/api/neuron/graph?id=$1&depth=1" | grep -qF "\"$1\""
+}
+
+# --- SECTION A: presence -----------------------------------------------------
+run_presence() {
+  local -n arr=$1; local fail=0
+  printf '  %-8s %-42s %s\n' "METHOD" "ROUTE" "RESULT"
+  for e in "${arr[@]}"; do
+    local m p body; m=$(awk '{print $1}' <<<"$e"); p=$(awk '{print $2}' <<<"$e")
+    body=$(request "$m" "$p")
+    if is_missing "$body"; then
+      printf '  %-8s %-42s MISSING  %s\n' "$m" "$p" "$(cut -c1-46 <<<"$body")"; fail=$((fail+1))
+    else
+      printf '  %-8s %-42s ANSWERED %s\n' "$m" "$p" "$(cut -c1-46 <<<"$body")"
+    fi
+  done
+  return $fail
+}
+
+echo "== SECTION A: PRESENCE (required, blocking) =="
+run_presence REQUIRED; A_FAIL=$?
+echo
+echo "== KNOWN-PENDING (non-blocking) =="
+run_presence KNOWN_PENDING; P_FAIL=$?
+echo
+
+# --- SECTION B: immutability (engram write routes must supersede, not destroy) --
+# For each mutation route: create a node, mutate it, then check the ORIGINAL id
+# still exists in the graph. KEPT = supersede/tombstone (correct). DESTROYED =
+# hard delete (DEFECTIVE -> fail). N/A = mutate route absent (a presence failure).
+# For "delete" mutations we additionally require a real tombstone marker
+# (label "tombstone:<id>") so a no-op delete cannot false-pass as KEPT.
+marker_present() { # id -> 0 if a "tombstone:<id>" marker is wired to the node (by-id neighborhood)
+  request GET "/api/neuron/graph?id=$1&depth=1" | grep -qF "tombstone:$1"
+}
+immut_check() { # label KIND(update|delete) CREATE_PATH MUTATE_PATH
+  local label="$1" kind="$2" create="$3" mutate="$4"
+  local cbody id mb mbody
+  cbody=$(request POST "$create" "{\"content\":\"__immut_${label}__\",\"node_type\":\"Memory\",\"label\":\"contract:immut\"}")
+  id=$(extract_id "$cbody")
+  if [ -z "$id" ]; then printf '  %-14s SKELETON-FAIL  create returned no id: %s\n' "$label" "$(cut -c1-40 <<<"$cbody")"; return 2; fi
+  mb="{\"id\":\"$id\"}"; [ "$kind" = update ] && mb="{\"id\":\"$id\",\"content\":\"__immut_${label}_v2__\"}"
+  mbody=$(request POST "$mutate" "$mb")
+  if is_missing "$mbody"; then printf '  %-14s N/A            mutate route absent (see Section A)\n' "$label"; return 0; fi
+  if ! node_present "$id"; then
+    printf '  %-14s DESTROYED      original %s hard-removed  <== DEFECTIVE\n' "$label" "$id"; return 1
+  fi
+  if [ "$kind" = delete ] && ! marker_present "$id"; then
+    printf '  %-14s NO-OP          original %s kept but no tombstone marker  <== DEFECTIVE\n' "$label" "$id"; return 1
+  fi
+  local how="supersede edge"; [ "$kind" = delete ] && how="tombstoned + hidden from default list"
+  printf '  %-14s KEPT           original %s survived (%s)\n' "$label" "$id" "$how"; return 0
+}
+
+echo "== SECTION B: IMMUTABILITY (engram nodes must be superseded, never destroyed) =="
+B_FAIL=0
+immut_check "memory-update" update /api/neuron/memory      /api/neuron/memory/update || B_FAIL=$((B_FAIL+$?))
+immut_check "memory-delete" delete /api/neuron/memory      /api/neuron/memory/delete || B_FAIL=$((B_FAIL+$?))
+immut_check "node-update"   update /api/neuron/node/create /api/neuron/node/update   || B_FAIL=$((B_FAIL+$?))
+immut_check "node-delete"   delete /api/neuron/node/create /api/neuron/node/delete   || B_FAIL=$((B_FAIL+$?))
+immut_check "memory-forget" delete /api/neuron/memory      /api/neuron/memory/forget || B_FAIL=$((B_FAIL+$?))
+echo
+
+echo "============================================================"
+RC=0
+if [ "$A_FAIL" -gt 0 ]; then echo "PRESENCE:   FAIL — $A_FAIL required route(s) unanswered. Do NOT package."; RC=1
+  else echo "PRESENCE:   PASS — all ${#REQUIRED[@]} required routes answered."; fi
+if [ "$B_FAIL" -gt 0 ]; then echo "IMMUTABILITY: FAIL — $B_FAIL engram write route(s) hard-delete. DEFECTIVE soul."; RC=1
+  else echo "IMMUTABILITY: PASS — no engram write route hard-deletes."; fi
+[ "$P_FAIL" -gt 0 ] && echo "note: $P_FAIL known-pending route(s) unanswered (expected; non-blocking)."
+echo "============================================================"
+[ "$RC" = 0 ] && echo "GATE: PASS" || echo "GATE: FAIL"
+exit $RC

sessions.el

@@ -677,6 +677,11 @@ fn handle_session_approve(session_id: String, body: String) -> String {
     // path for all sessions created through handle_chat_agentic / agentic_loop.
     let bridge_blob: String = state_get("mcp_bridge:" + session_id)
     if !str_eq(bridge_blob, "") {
+        // BUG-LEAK fix (2026-07-16): the approved tool executes below via dispatch_tool,
+        // whose path/command guards read the shared workspace-root key. Re-assert THIS
+        // session's own root first — an approval must never execute under whatever root
+        // the last unrelated request left behind.
+        state_set("agent_workspace_root", state_get("agent_workspace_root_" + session_id))
         // For "always": record tool_name in the always-allow list before resuming.
         // The tool_name is not stored in the bridge blob (only tool_use_id is).
         // Accept it from the body so the client can pass it along.
@@ -708,7 +713,13 @@ fn handle_session_approve(session_id: String, body: String) -> String {
         // For builtin tools with no client-provided content: fall back to
         // dispatch_tool so those tools still execute correctly.
         let client_content: String = json_get(body, "content")
-        let use_client_content: Bool = !str_eq(client_content, "")
+        // BUG-6 fix (2026-07-17): the naive json_get scanner matches "content" ANYWHERE
+        // in the body — including INSIDE tool_input — so every approved write_file (whose
+        // input always carries a content field) was mistaken for client-executed, never
+        // dispatched, and narrated as done: a false receipt with no file on disk. Builtin
+        // tools now ALWAYS dispatch server-side; client content is only honored for
+        // non-builtin (MCP/client-executed) tools. Stricter only.
+        let use_client_content: Bool = !str_eq(client_content, "") && !is_builtin_tool(approve_tool_name)
         let use_dispatch: Bool = is_builtin_tool(approve_tool_name) && !use_client_content
         let raw_input: String = json_get_raw(body, "tool_input")
         let eff_input: String = if str_eq(raw_input, "") { "{}" } else { raw_input }

sessions.elh

@@ -12,6 +12,3 @@ 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.el

@@ -379,9 +379,23 @@ fn emit_session_start_event() -> Void {
 // layered_cycle — routes user-facing requests through the 4-layer consciousness stack.
 // L0 (core) → L1 (safety screen) → L2a (continuity + behavioral profiling) → L2b (mission alignment) → L3 (imprint) → L1 (safety validate)
 // Internal cognition (heartbeat, proactive, memory ops) bypasses layers — use one_cycle directly.
-fn layered_cycle(raw_input: String) -> String {
+//
-    let history: String = state_get("conv_history")
+// FIX B (2026-08-05) — the cycle now knows which conversation it is in.
-    let session_id: String = state_get("current_session_id")
+//
+// session_id: the caller's session, threaded from the route. Was previously read from the
+// state key "current_session_id", which is read HERE and written NOWHERE in the entire
+// source — verified across every .el file. So this value was unconditionally "", and every
+// downstream consumer of it silently fell back to a process-global bucket: conversation
+// history, and the steward's continuity tracking (TODO reliability #4, below, describes the
+// cross-session bleed this caused; threading the real id closes it). The plain path's blank
+// stare and the agentic path's scoped history were the same defect seen from two sides.
+//
+// utility: true when the generation is not part of the user's conversation — the app's
+// title and insight passes. Answered normally, never recorded. See is_utility_request.
+fn layered_cycle(raw_input: String, session_id: String, utility: Bool) -> String {
+    // Safety-screen history amplification now reads the SAME window the turn will be
+    // recorded into, so a session's own escalation pattern is what gets scored.
+    let history: String = state_get(conv_hist_key(session_id))
 
     // L1 in: safety screen
     let screen_result: String = safety_screen(raw_input, history)
@@ -423,8 +437,10 @@ fn layered_cycle(raw_input: String) -> String {
     let cont_action: String = json_get(continuity, "action")
 
     // Store continuity status so imprint can adjust its response register.
-    // TODO(reliability #4): session_continuity is process-global; scope per session_id
+    // TODO(reliability #4) CLOSED 2026-08-05: this line was already written to scope per
-    // when available to prevent cross-session bleed under concurrent layered_cycle calls.
+    // session — it just never received a session id, because the only source was a state key
+    // nothing wrote. It is now threaded from the route, so named sessions genuinely get their
+    // own continuity state and only anonymous callers share the global one.
     let cont_key: String = if str_eq(session_id, "") { "session_continuity" } else { "session_continuity:" + session_id }
     state_set(cont_key, cont_status)
 
@@ -453,40 +469,24 @@ fn layered_cycle(raw_input: String) -> String {
     let lc_aff_cutoff: Int = time_now() - 259200
     let lc_bell_nodes: String = engram_search_json("bell:soft bell:hard BellEvent affective", 2)
     let lc_has_bell: Bool = !str_eq(lc_bell_nodes, "") && !str_eq(lc_bell_nodes, "[]")
+    // CRASH FIX 2026-08-05 (BUG-PLAINCHAT-1): the " | ts:" parser used to be inline here.
+    // Inside this block-expression initializer elc compiled `lbmp + str_len(lbm)` to
+    // el_str_concat() on two integers, which segfaulted the whole daemon the moment a
+    // distress turn followed an earlier affective turn — i.e. exactly on the crisis path.
+    // Verified against the unmodified baseline binary AND present in the committed
+    // dist/soul.c. affective_node_ts() is a top-level function, where the same expression
+    // compiles to integer addition. Do not inline it back.
     let lc_bell_note: String = if lc_has_bell {
         let lb0: String = json_array_get(lc_bell_nodes, 0)
-        let lb_c: String = json_get(lb0, "content")
+        let lb_ts: Int = affective_node_ts(lb0)
-        let lbm: String = " | ts:"
-        let lbmp: Int = str_index_of(lb_c, lbm)
-        let lb_ts_raw: String = if lbmp >= 0 {
-            let lbs: Int = lbmp + str_len(lbm)
-            let lbr: String = str_slice(lb_c, lbs, str_len(lb_c))
-            let lbn: Int = str_index_of(lbr, " | ")
-            if lbn < 0 { lbr } else { str_slice(lbr, 0, lbn) }
-        } else {
-            let lbca: String = json_get(lb0, "created_at")
-            if str_eq(lbca, "") { json_get(lb0, "updated_at") } else { lbca }
-        }
-        let lb_ts: Int = if str_eq(lb_ts_raw, "") { 0 } else { str_to_int(lb_ts_raw) }
         if lb_ts > lc_aff_cutoff { "[AFFECTIVE NOTE: User was in distress in a recent session.]" } else { "" }
     } else { "" }
     let lc_pos_nodes: String = engram_search_json("PositiveEvent joy:high joy:low affective", 2)
     let lc_has_pos: Bool = !str_eq(lc_pos_nodes, "") && !str_eq(lc_pos_nodes, "[]")
+    // Same crash fix as the bell note above (BUG-PLAINCHAT-1).
     let lc_pos_note: String = if lc_has_pos && str_eq(lc_bell_note, "") {
         let lp0: String = json_array_get(lc_pos_nodes, 0)
-        let lp_c: String = json_get(lp0, "content")
+        let lp_ts: Int = affective_node_ts(lp0)
-        let lpm: String = " | ts:"
-        let lpmp: Int = str_index_of(lp_c, lpm)
-        let lp_ts_raw: String = if lpmp >= 0 {
-            let lps: Int = lpmp + str_len(lpm)
-            let lpr: String = str_slice(lp_c, lps, str_len(lp_c))
-            let lpn: Int = str_index_of(lpr, " | ")
-            if lpn < 0 { lpr } else { str_slice(lpr, 0, lpn) }
-        } else {
-            let lpca: String = json_get(lp0, "created_at")
-            if str_eq(lpca, "") { json_get(lp0, "updated_at") } else { lpca }
-        }
-        let lp_ts: Int = if str_eq(lp_ts_raw, "") { 0 } else { str_to_int(lp_ts_raw) }
         if lp_ts > lc_aff_cutoff { "[AFFECTIVE NOTE: User shared positive news in a recent session.]" } else { "" }
     } else { "" }
     let lc_affective_note: String = if !str_eq(lc_bell_note, "") { lc_bell_note } else { lc_pos_note }
@@ -498,11 +498,47 @@ fn layered_cycle(raw_input: String) -> String {
     }
     state_set("layered_cycle_safety_system_addendum", augmented_addendum)
 
-    // L3: imprint responds
+    // L3: imprint responds — applies the active imprint's voice/domain annotation to the
-    let output: String = imprint_respond(aligned, imprint_id)
+    // steward-aligned input. This produces the PROMPT, not the answer.
+    let prompt: String = imprint_respond(aligned, imprint_id)
 
-    // L1 out: validate output before delivery
+    // L3b: the imprint SPEAKS (added 2026-08-05).
-    return safety_validate(output, screen_action)
+    //
+    // Until now the cycle stopped at the annotation above, so /api/chat with agentic:false
+    // handed the user's own screened text back as the "reply" — every gate ran, but nothing
+    // ever generated. The generation is placed HERE, inside the cycle, rather than by
+    // pointing the route at handle_chat(): handle_chat has no enforcing input gate and no
+    // enforcing output gate, so calling it instead of this cycle would have traded the whole
+    // safety pipeline for a working reply. Composing keeps both.
+    //
+    // Order is deliberate and must not be rearranged: this call sits strictly AFTER the L1
+    // screen, the safe-mode guard, the hard-bell short-circuit and the L2 stewardship layers,
+    // and strictly BEFORE the L1 output gate. A hard bell never reaches a model — the branch
+    // above returns first. Tools are not offered on this turn; see layered_generate.
+    let output: String = layered_generate(prompt, imprint_id, session_id)
+
+    // L1 out: validate output before delivery. Still the terminal gate — nothing below this
+    // line can change the string this function returns.
+    let validated: String = safety_validate(output, screen_action)
+
+    // Turn bookkeeping. Records the VALIDATED text, never the raw model output, and is only
+    // reachable on the non-bell path: both bell branches above return before this point, so
+    // bell turns still never enter conversation history. Pure state side effect — it cannot
+    // alter what is returned.
+    //
+    // FIX A: the receipt is unconditional and always negative on this path, because on this
+    // path it is structurally true — layered_generate offers no tools at all (build_system_prompt
+    // chat mode + a request body with no "tools" key). Recording "no tools ran" is not padding:
+    // it is the only thing that distinguishes "nothing ran" from "we forgot to write down what
+    // ran", and that ambiguity is what made the model confess to a search it had performed.
+    //
+    // FIX E1: a utility generation is answered but not recorded. Guarded here rather than at
+    // the route so every /api/chat dispatch site inherits it from one place.
+    let receipt: String = tool_receipt("", "")
+    if !utility {
+        conv_history_record(session_id, raw_input, validated, receipt)
+    }
+    return validated
 }
 
 let soul_cgi_id_raw: String = env("SOUL_CGI_ID")
@@ -521,7 +557,7 @@ let axon_raw: String = env("NEURON_API_URL")
 let axon_base: String = if str_eq(axon_raw, "") { "http://localhost:7771" } else { axon_raw }
 
 let studio_dir_raw: String = env("SOUL_STUDIO_DIR")
-let studio_dir: String = if str_eq(studio_dir_raw, "") { "/Users/will/Development/neuron-technologies/products/cgi-studio/el-daemon" } else { studio_dir_raw }
+let studio_dir: String = if str_eq(studio_dir_raw, "") { env("HOME") + "/Development/neuron-technologies/products/cgi-studio/el-daemon" } else { studio_dir_raw }
 
 println("[soul] boot - cgi=" + soul_cgi_id + " port=" + int_to_str(port))
 

soul.elh

@@ -1,8 +1,8 @@
-// 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
-extern fn layered_cycle(raw_input: String) -> String
+extern fn layered_cycle(raw_input: String, session_id: String, utility: Bool) -> String

vendor/el-runtime/v1.0.0-20260501/RELEASE.md

@@ -0,0 +1,28 @@
+# El Compiler Release v1.0.0 — 2026-05-02
+
+## Components
+- `bootstrap.py` — El language compiler (Python, recursive descent parser, emits C)
+- `el_runtime.c` — El runtime (C, HTTP server, engram, DHARMA, LLM chain)
+- `el_runtime.h` — Runtime public API header
+
+## Changes in this release
+
+### Critical bug fixes
+- `state_set`/`state_get` are now thread-safe (pthread_mutex). Was racing across 64 worker threads.
+- `looks_like_string` threshold raised from 1,000,000 to 4GB. Unix timestamps were being dereferenced as heap pointers.
+- `fs_read` guards against negative `ftell` result (pipe/special file overflow).
+
+### Engram architecture (major)
+- Two-layer activation: `background_activation` (Layer 1, broad fan-out) + `working_memory_weight` (Layer 2, executive filter)
+- Inhibitory edges: `EngramEdge.inhibitory` flag suppresses working memory promotion without affecting background activation
+- Suppression memory: `suppression_count` — nodes activated-but-suppressed accumulate pressure toward breakthrough
+- Temporal decay: `temporal_decay_rate`, `created_at`, `last_activated_at`, `activation_count` on EngramNode
+- Per-type activation thresholds (Safety: 0.05, Canonical: 0.15, Lesson: 0.25, Note: 0.40)
+- Temporal range query: `engram_query_range(start_ms, end_ms)`
+- Layered consciousness: `EngramLayer` struct, `layer_id` on nodes and edges, `EngramStore.layers[]`
+- Layer 0 override pass: safety layer fires last and cannot be suppressed
+
+## SHA256
+bootstrap.py
+el_runtime.c
+el_runtime.h

vendor/el-runtime/v1.0.0-20260501/el_runtime.h

@@ -0,0 +1,786 @@
+/*
+ * el_runtime.h — El language C runtime header
+ *
+ * Declares all built-in functions available to compiled El programs.
+ * Include this in every generated .c file.
+ *
+ * Value model:
+ *   All El values are represented as el_val_t (= int64_t).
+ *   On 64-bit systems a pointer fits in int64_t.
+ *   String values are cast: (el_val_t)(uintptr_t)"hello"
+ *   Integer values are stored directly.
+ *   This lets arithmetic work naturally while still passing strings around.
+ *
+ * Type conventions (El -> C):
+ *   String  -> el_val_t  (holds const char* via uintptr_t cast)
+ *   Int     -> el_val_t
+ *   Bool    -> el_val_t  (0 = false, nonzero = true)
+ *   Any     -> el_val_t
+ *   Void    -> void
+ *
+ * Macros for convenience:
+ *   EL_STR(s)    cast string literal to el_val_t
+ *   EL_CSTR(v)   cast el_val_t back to const char*
+ *   EL_INT(v)    identity — el_val_t is already int64_t
+ *
+ * Link requirements:
+ *   -lcurl     — required for the HTTP client (http_get, http_post, llm_*).
+ *   -lpthread  — required for the HTTP server (one detached thread per
+ *                connection, capped at 64 concurrent).
+ *   -loqs      — optional; required only when liboqs is installed and the
+ *                pq_* / sha3_256_hex entry points are needed. Detected at
+ *                compile time via __has_include(<oqs/oqs.h>).
+ *   -lcrypto   — optional; pulled in alongside -loqs. Used for X25519 in
+ *                pq_hybrid_* and HKDF-SHA256 derivation.
+ *
+ * Canonical compile command:
+ *   cc -std=c11 -I el-compiler/runtime -lcurl -lpthread \
+ *      -o <out> <prog>.c el-compiler/runtime/el_runtime.c
+ *
+ * With liboqs (post-quantum stack):
+ *   cc -std=c11 -I el-compiler/runtime -lcurl -lpthread -loqs -lcrypto \
+ *      -o <out> <prog>.c el-compiler/runtime/el_runtime.c
+ */
+
+#pragma once
+
+#include <stdint.h>
+#include <stdlib.h>
+
+typedef int64_t el_val_t;
+
+#define EL_STR(s)  ((el_val_t)(uintptr_t)(s))
+#define EL_CSTR(v) ((const char*)(uintptr_t)(v))
+#define EL_INT(v)  (v)
+#define EL_NULL    ((el_val_t)0)
+
+/* Float values share the el_val_t (int64) slot via a bit-cast.
+ * The codegen emits Float literals as `el_from_float(<dbl>)` so the
+ * underlying bits represent the IEEE 754 double. Float-aware builtins
+ * (math, format, json) round-trip via these helpers. */
+static inline double el_to_float(el_val_t v) {
+    union { int64_t i; double f; } u;
+    u.i = (int64_t)v;
+    return u.f;
+}
+
+static inline el_val_t el_from_float(double f) {
+    union { double f; int64_t i; } u;
+    u.f = f;
+    return (el_val_t)u.i;
+}
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* ── I/O ──────────────────────────────────────────────────────────────────── */
+
+void      println(el_val_t s);
+void      print(el_val_t s);
+el_val_t  readline(void);
+
+/* ── String builtins ─────────────────────────────────────────────────────── */
+
+el_val_t  el_str_concat(el_val_t a, el_val_t b);
+el_val_t  str_eq(el_val_t a, el_val_t b);
+el_val_t  str_starts_with(el_val_t s, el_val_t prefix);
+el_val_t  str_ends_with(el_val_t s, el_val_t suffix);
+el_val_t  str_len(el_val_t s);
+el_val_t  str_concat(el_val_t a, el_val_t b);
+el_val_t  int_to_str(el_val_t n);
+el_val_t  str_to_int(el_val_t s);
+el_val_t  str_slice(el_val_t s, el_val_t start, el_val_t end);
+el_val_t  str_contains(el_val_t s, el_val_t sub);
+el_val_t  str_replace(el_val_t s, el_val_t from, el_val_t to);
+el_val_t  str_to_upper(el_val_t s);
+el_val_t  str_to_lower(el_val_t s);
+el_val_t  str_trim(el_val_t s);
+
+/* ── Math ────────────────────────────────────────────────────────────────── */
+
+el_val_t  el_abs(el_val_t n);
+el_val_t  el_max(el_val_t a, el_val_t b);
+el_val_t  el_min(el_val_t a, el_val_t b);
+
+/* ── Refcount (ARC) ──────────────────────────────────────────────────────────
+ * Lists and Maps carry a refcount. Strings and ints do not — el_retain and
+ * el_release are safe no-ops on non-refcounted values (they sniff a magic
+ * header at offset 0 and only act if the magic matches).
+ *
+ * Codegen emits these at let-binding shadowing, function entry (params), and
+ * function exit (locals other than the returned value). The refcount lets
+ * el_list_append and el_map_set mutate in place when uniquely owned (cheap)
+ * and copy-on-write when shared (preserves persistent semantics across
+ * accumulator patterns in the compiler itself).                              */
+
+void      el_retain(el_val_t v);
+void      el_release(el_val_t v);
+
+/* ── Arena scoping ────────────────────────────────────────────────────────────
+ * el_arena_push() activates the string arena (if not already active) and
+ * returns a mark; el_arena_pop(mark) frees all strings allocated since that
+ * mark. Used by codegen for per-function/statement scoping and by long-running
+ * EL loops (e.g. the soul daemon's awareness tick) to reclaim per-iteration
+ * allocations. */
+el_val_t  el_arena_push(void);
+el_val_t  el_arena_pop(el_val_t mark);
+
+/* ── List ────────────────────────────────────────────────────────────────── */
+
+el_val_t  el_list_new(el_val_t count, ...);
+el_val_t  el_list_len(el_val_t list);
+el_val_t  el_list_get(el_val_t list, el_val_t index);
+el_val_t  el_list_append(el_val_t list, el_val_t elem);
+el_val_t  el_list_empty(void);
+el_val_t  el_list_clone(el_val_t list);
+
+/* ── Map ─────────────────────────────────────────────────────────────────── */
+
+el_val_t  el_map_new(el_val_t pair_count, ...);
+el_val_t  el_get_field(el_val_t map, el_val_t key);
+el_val_t  el_map_get(el_val_t map, el_val_t key);
+el_val_t  el_map_set(el_val_t map, el_val_t key, el_val_t value);
+
+/* ── HTTP ─────────────────────────────────────────────────────────────────── */
+
+el_val_t  http_get(el_val_t url);
+el_val_t  http_post(el_val_t url, el_val_t body);
+el_val_t  http_post_json(el_val_t url, el_val_t json_body);
+el_val_t  http_get_with_headers(el_val_t url, el_val_t headers_map);
+el_val_t  http_post_with_headers(el_val_t url, el_val_t body, el_val_t headers_map);
+el_val_t  http_post_form_auth(el_val_t url, el_val_t form_body, el_val_t auth_header);
+el_val_t  http_delete(el_val_t url);
+el_val_t  http_delete_json(el_val_t url, el_val_t json_body);
+void      http_serve(el_val_t port, el_val_t handler);
+void      http_set_handler(el_val_t name);
+
+/* HTTP server v2 ─────────────────────────────────────────────────────────────
+ * Same dispatch model as http_serve, but the handler signature is widened:
+ *
+ *     el_val_t handler(method, path, headers_map, body)
+ *
+ * `headers_map` is an ElMap from lowercased header name → header value (both
+ * Strings). Repeated headers are joined with ", " per RFC 7230.
+ *
+ * Response value: the handler may return either
+ *   (a) a plain body string — same auto-content-type / 200-OK behaviour as
+ *       http_serve (3-arg) — or
+ *   (b) a response envelope built with `http_response(status, headers_json,
+ *       body)`. The runtime detects the envelope discriminator
+ *       `"el_http_response":1` at the start of the returned string and
+ *       unpacks status / headers / body before sending.
+ *
+ * The 3-arg http_serve(port, handler) remains supported unchanged for
+ * existing handlers (e.g. products/web/server.el): it dispatches with
+ * (method, path, body), hardcodes 200 OK, and auto-detects content type. */
+void      http_serve_v2(el_val_t port, el_val_t handler);
+void      http_set_handler_v2(el_val_t name);
+
+/* Non-blocking variant of http_serve: runs the accept loop in a background
+ * pthread and returns immediately so the caller can continue (used by the
+ * soul daemon to run awareness_run() after starting its HTTP API). */
+void      http_serve_async(el_val_t port, el_val_t handler);
+
+/* Build an HTTP response envelope. `headers_json` should be a JSON object
+ * literal like `{"WWW-Authenticate":"Basic"}` (or "" / "{}" for none). The
+ * returned string carries the discriminator `{"el_http_response":1,...}`
+ * which the runtime's send-path detects and unpacks. Detection happens
+ * uniformly inside http_send_response, so a 3-arg handler may also return
+ * an envelope. The 3-arg variant remains documented as a fixed 200-OK
+ * auto-content-type contract for legacy handlers that return plain bodies. */
+el_val_t  http_response(el_val_t status, el_val_t headers_json, el_val_t body);
+
+/* HTTP timeout — every libcurl request honors EL_HTTP_TIMEOUT_MS (default
+ * 60000ms). Read lazily on first use, so setting the env var any time before
+ * the first http_* call is sufficient.                                    */
+
+/* Streaming variants — write the response body straight to a file via
+ * libcurl's CURLOPT_WRITEFUNCTION = fwrite. These bypass the el_val_t string
+ * wrapper entirely, so binary payloads (audio/mpeg, image/png, etc.) survive
+ * embedded NUL bytes that would truncate a strlen()-based code path.
+ *
+ * Both honor EL_HTTP_TIMEOUT_MS, follow redirects, and accept the same
+ * `headers_map` shape as http_post_with_headers (ElMap of String→String).
+ *
+ * Return value: 1 on success (file fully written), 0 on any failure
+ * (network, file open, partial write). On failure the output file is removed
+ * so callers cannot mistake a partially-written file for a valid one. */
+el_val_t  http_post_to_file(el_val_t url, el_val_t body, el_val_t headers_map, el_val_t output_path);
+el_val_t  http_get_to_file(el_val_t url, el_val_t headers_map, el_val_t output_path);
+
+/* ── URL encoding ────────────────────────────────────────────────────────── */
+
+el_val_t  url_encode(el_val_t s);   /* RFC 3986 unreserved set */
+el_val_t  url_decode(el_val_t s);   /* '+' → space, %XX → byte  */
+
+/* ── HTML allowlist sanitizer ────────────────────────────────────────────────
+ * el_html_sanitize(input_html, allowlist_json) — strict allowlist HTML
+ * cleaner. State-machine parser; tag/attribute names compared case-
+ * insensitively against the allowlist; `<a href>` / `<… src>` URL schemes
+ * validated (http, https, mailto, fragment-only, or relative); whole-
+ * subtree drop for script / style / iframe / object / embed / form; HTML-
+ * escapes free text outside dropped subtrees.
+ *
+ * The allowlist is JSON of the form
+ *     {"p":[],"a":["href","title"],"strong":[],...}
+ * where each value is the array of attribute names allowed for that tag. */
+el_val_t  el_html_sanitize(el_val_t input_html, el_val_t allowlist_json);
+
+/* ── Filesystem ──────────────────────────────────────────────────────────── */
+
+el_val_t  fs_read(el_val_t path);
+el_val_t  fs_write(el_val_t path, el_val_t content);
+el_val_t  fs_list(el_val_t path);
+el_val_t  fs_exists(el_val_t path);
+el_val_t  fs_mkdir(el_val_t path);   /* mkdir -p, mode 0755                */
+
+/* Length-explicit binary write. `length` is an Int (el_val_t holding the
+ * byte count). The caller knows the length from context — typically because
+ * `bytes` came from base64_decode (which produces a magic-tagged binary
+ * buffer with embedded NULs possible) and the caller already tracks the
+ * decoded length, OR because the bytes came from a fixed-size source
+ * (sha256_bytes = 32, hmac_sha256_bytes = 32). Bypasses strlen entirely.
+ *
+ * Returns 1 on success, 0 on failure (invalid path, can't open, partial
+ * write, negative length). On partial-write failure, the file is removed
+ * so callers cannot read back a truncated artefact. */
+el_val_t  fs_write_bytes(el_val_t path, el_val_t bytes, el_val_t length);
+
+/* ── JSON ────────────────────────────────────────────────────────────────── */
+
+el_val_t  json_get(el_val_t json, el_val_t key);
+el_val_t  json_parse(el_val_t s);
+el_val_t  json_stringify(el_val_t v);
+el_val_t  json_get_string(el_val_t json_str, el_val_t key);
+el_val_t  json_get_int(el_val_t json_str, el_val_t key);
+el_val_t  json_get_float(el_val_t json_str, el_val_t key);
+el_val_t  json_get_bool(el_val_t json_str, el_val_t key);
+el_val_t  json_get_raw(el_val_t json_str, el_val_t key);
+el_val_t  json_set(el_val_t json_str, el_val_t key, el_val_t value);
+el_val_t  json_array_len(el_val_t json_str);
+el_val_t  json_array_get(el_val_t json_str, el_val_t index);
+el_val_t  json_array_get_string(el_val_t json_str, el_val_t index);
+
+/* ── Time ────────────────────────────────────────────────────────────────── */
+
+el_val_t  time_now(void);
+el_val_t  time_now_utc(void);
+el_val_t  sleep_secs(el_val_t secs);
+el_val_t  sleep_ms(el_val_t ms);
+el_val_t  time_format(el_val_t ts, el_val_t fmt);
+el_val_t  time_to_parts(el_val_t ts);
+el_val_t  time_from_parts(el_val_t secs, el_val_t ns, el_val_t tz);
+el_val_t  time_add(el_val_t ts, el_val_t n, el_val_t unit);
+el_val_t  time_diff(el_val_t ts1, el_val_t ts2, el_val_t unit);
+
+/* ── Instant + Duration: first-class temporal types ──────────────────────────
+ * Both types share the el_val_t (int64) slot. Instants are nanoseconds
+ * since the Unix epoch; Durations are signed nanoseconds. Type discipline
+ * is enforced at codegen-time: BinOps on names registered as Instant or
+ * Duration route through the typed wrappers below; mismatches like
+ * Instant+Instant become #error at the C compiler.
+ *
+ * Postfix literals — `30.seconds`, `1.hour`, `500.millis`, `30.nanos` — are
+ * recognised by the parser as DurationLit AST nodes and lowered to literal
+ * int64 nanoseconds at codegen time. The runtime never sees the units. */
+
+el_val_t  el_now_instant(void);
+el_val_t  now(void);
+el_val_t  unix_seconds(el_val_t n);
+el_val_t  unix_millis(el_val_t n);
+el_val_t  instant_from_iso8601(el_val_t s);
+
+el_val_t  el_duration_from_nanos(el_val_t ns);
+el_val_t  duration_seconds(el_val_t n);
+el_val_t  duration_millis(el_val_t n);
+el_val_t  duration_nanos(el_val_t n);
+
+el_val_t  el_instant_add_dur(el_val_t inst, el_val_t dur);
+el_val_t  el_instant_sub_dur(el_val_t inst, el_val_t dur);
+el_val_t  el_instant_diff(el_val_t a, el_val_t b);
+el_val_t  el_duration_add(el_val_t a, el_val_t b);
+el_val_t  el_duration_sub(el_val_t a, el_val_t b);
+el_val_t  el_duration_scale(el_val_t dur, el_val_t scalar);
+el_val_t  el_duration_div(el_val_t dur, el_val_t scalar);
+
+el_val_t  el_instant_lt(el_val_t a, el_val_t b);
+el_val_t  el_instant_le(el_val_t a, el_val_t b);
+el_val_t  el_instant_gt(el_val_t a, el_val_t b);
+el_val_t  el_instant_ge(el_val_t a, el_val_t b);
+el_val_t  el_instant_eq(el_val_t a, el_val_t b);
+el_val_t  el_instant_ne(el_val_t a, el_val_t b);
+el_val_t  el_duration_lt(el_val_t a, el_val_t b);
+el_val_t  el_duration_le(el_val_t a, el_val_t b);
+el_val_t  el_duration_gt(el_val_t a, el_val_t b);
+el_val_t  el_duration_ge(el_val_t a, el_val_t b);
+el_val_t  el_duration_eq(el_val_t a, el_val_t b);
+el_val_t  el_duration_ne(el_val_t a, el_val_t b);
+
+el_val_t  instant_to_unix_seconds(el_val_t i);
+el_val_t  instant_to_unix_millis(el_val_t i);
+el_val_t  instant_to_iso8601(el_val_t i);
+el_val_t  duration_to_seconds(el_val_t d);
+el_val_t  duration_to_millis(el_val_t d);
+el_val_t  duration_to_nanos(el_val_t d);
+
+el_val_t  el_sleep_duration(el_val_t dur);
+el_val_t  unix_timestamp(void);
+
+el_val_t  ttl_cache_set(el_val_t key, el_val_t value);
+el_val_t  ttl_cache_get(el_val_t key, el_val_t max_age);
+el_val_t  ttl_cache_age(el_val_t key);
+
+/* ── Calendar + CalendarTime + Rhythm + LocalDate/Time/DateTime ─────────────
+ * Phase 1.5 of the time system. Calendar is pluggable: EarthCalendar (IANA
+ * zones, Gregorian, DST) is the user-facing default; MarsCalendar,
+ * CycleCalendar(period), NoCycleCalendar, RelativeCalendar handle non-Earth
+ * domains.
+ *
+ * A Calendar interprets an Instant under a particular cycle convention and
+ * produces a CalendarTime. CalendarTime carries the underlying Instant and
+ * a back-pointer to its Calendar; arithmetic and formatting consult the
+ * Calendar to convert ns since epoch into year/month/day/hour/minute/second
+ * (or sol/phase, or cycle/phase, depending on kind).
+ *
+ * Storage convention: Calendar / CalendarTime / Rhythm / LocalDate /
+ * LocalDateTime are heap-allocated structs whose pointers are cast into
+ * el_val_t. A 24-bit magic header at offset 0 lets the runtime identify
+ * the kind safely. LocalTime is small enough to live in the int64 slot
+ * directly (nanos since midnight, signed).                                  */
+
+/* Zone — opaque IANA zone or fixed offset, used by EarthCalendar.
+ * `zone_id` is either an IANA name ("America/New_York", "UTC") or a fixed
+ * offset string ("+05:30", "-08:00"). The runtime resolves it via tzset()
+ * on first use of the owning EarthCalendar.                                  */
+el_val_t  zone(el_val_t id);
+el_val_t  zone_utc(void);
+el_val_t  zone_local(void);
+el_val_t  zone_offset(el_val_t hours, el_val_t minutes);
+
+/* Calendar constructors. Each returns an el_val_t pointer to a heap-
+ * allocated, magic-tagged Calendar struct. Calendars are interned by
+ * (kind, zone_id, period_ns, epoch_ns) so identical constructors return
+ * the same pointer — equality is reference equality.                        */
+el_val_t  earth_calendar(el_val_t z);
+el_val_t  earth_calendar_default(void);
+el_val_t  mars_calendar(void);
+el_val_t  cycle_calendar(el_val_t period_dur);
+el_val_t  no_cycle_calendar(void);
+el_val_t  relative_calendar(el_val_t epoch_inst);
+
+/* CalendarTime constructors and methods. Returns a heap-allocated struct
+ * whose pointer fits in el_val_t. */
+el_val_t  now_in(el_val_t cal);
+el_val_t  in_calendar(el_val_t inst, el_val_t cal);
+el_val_t  cal_format(el_val_t ct, el_val_t pattern);
+el_val_t  cal_to_instant(el_val_t ct);
+el_val_t  cal_cycle_phase(el_val_t ct);
+el_val_t  cal_in(el_val_t ct, el_val_t cal);
+
+/* LocalDate / LocalTime / LocalDateTime — calendar-agnostic value types.
+ * LocalTime carries nanoseconds since midnight as a signed int64 directly
+ * in the el_val_t slot (no allocation). LocalDate / LocalDateTime are
+ * heap-allocated structs with magic headers. */
+el_val_t  local_date(el_val_t y, el_val_t m, el_val_t d);
+el_val_t  local_time(el_val_t h, el_val_t m, el_val_t s, el_val_t ns);
+el_val_t  local_datetime(el_val_t date, el_val_t time);
+el_val_t  zoned(el_val_t date, el_val_t time, el_val_t cal);
+
+el_val_t  local_date_year(el_val_t ld);
+el_val_t  local_date_month(el_val_t ld);
+el_val_t  local_date_day(el_val_t ld);
+el_val_t  local_time_hour(el_val_t lt);
+el_val_t  local_time_minute(el_val_t lt);
+el_val_t  local_time_second(el_val_t lt);
+el_val_t  local_time_nanos(el_val_t lt);
+
+el_val_t  el_local_date_add_dur(el_val_t ld, el_val_t dur);
+el_val_t  el_local_time_add_dur(el_val_t lt, el_val_t dur);
+el_val_t  el_local_date_lt(el_val_t a, el_val_t b);
+el_val_t  el_local_date_eq(el_val_t a, el_val_t b);
+
+/* Rhythm — pluggable recurrence AST. Returns a heap-allocated struct
+ * pointer in el_val_t; rhythms are immutable so callers may share them. */
+el_val_t  rhythm_cycle_start(void);
+el_val_t  rhythm_cycle_phase(el_val_t phase);
+el_val_t  rhythm_duration(el_val_t d);
+el_val_t  rhythm_session_start(void);
+el_val_t  rhythm_event(el_val_t name);
+el_val_t  rhythm_and(el_val_t a, el_val_t b);
+el_val_t  rhythm_or(el_val_t a, el_val_t b);
+el_val_t  rhythm_weekday(el_val_t day);
+el_val_t  rhythm_weekly_at(el_val_t day, el_val_t hour, el_val_t minute);
+el_val_t  rhythm_next_after(el_val_t r, el_val_t after, el_val_t cal);
+el_val_t  rhythm_matches(el_val_t r, el_val_t ct);
+
+/* ── UUID ────────────────────────────────────────────────────────────────── */
+
+el_val_t  uuid_new(void);
+el_val_t  uuid_v4(void);
+
+/* ── Environment ─────────────────────────────────────────────────────────── */
+
+el_val_t  env(el_val_t key);
+
+/* ── In-process state K/V ────────────────────────────────────────────────── */
+
+el_val_t  state_set(el_val_t key, el_val_t value);
+el_val_t  state_get(el_val_t key);
+el_val_t  state_del(el_val_t key);
+el_val_t  state_keys(void);
+
+/* ── Float formatting ────────────────────────────────────────────────────── */
+
+el_val_t  float_to_str(el_val_t f);
+el_val_t  int_to_float(el_val_t n);
+el_val_t  float_to_int(el_val_t f);
+el_val_t  format_float(el_val_t f, el_val_t decimals);
+el_val_t  decimal_round(el_val_t f, el_val_t decimals);
+el_val_t  str_to_float(el_val_t s);
+
+/* ── Math (Float-aware) ──────────────────────────────────────────────────── */
+
+el_val_t  math_sqrt(el_val_t f);
+el_val_t  math_log(el_val_t f);
+el_val_t  math_ln(el_val_t f);
+el_val_t  math_sin(el_val_t f);
+el_val_t  math_cos(el_val_t f);
+el_val_t  math_pi(void);
+
+/* ── String additions ────────────────────────────────────────────────────── */
+
+el_val_t  str_index_of(el_val_t s, el_val_t sub);
+el_val_t  str_split(el_val_t s, el_val_t sep);
+el_val_t  str_char_at(el_val_t s, el_val_t i);
+el_val_t  str_char_code(el_val_t s, el_val_t i);
+el_val_t  str_pad_left(el_val_t s, el_val_t width, el_val_t pad);
+el_val_t  str_pad_right(el_val_t s, el_val_t width, el_val_t pad);
+el_val_t  str_format(el_val_t fmt, el_val_t data);
+el_val_t  str_lower(el_val_t s);
+el_val_t  str_upper(el_val_t s);
+
+/* ── Text-processing primitives (Phase 1: byte/codepoint, ASCII char classes)
+ * Phase 2 (filed): Unicode-grapheme awareness, NFC/NFD normalization, regex.
+ * is_* predicates: empty input returns false; multi-char requires ALL bytes
+ * to match. ASCII ranges only in Phase 1. */
+
+/* Counting */
+el_val_t  str_count(el_val_t s, el_val_t sub);              /* non-overlapping */
+el_val_t  str_count_chars(el_val_t s);                      /* codepoint count */
+el_val_t  str_count_bytes(el_val_t s);                      /* alias of str_len */
+el_val_t  str_count_lines(el_val_t s);
+el_val_t  str_count_words(el_val_t s);
+el_val_t  str_count_letters(el_val_t s);                    /* ASCII [A-Za-z] */
+el_val_t  str_count_digits(el_val_t s);                     /* ASCII [0-9] */
+
+/* Find / position */
+el_val_t  str_index_of_all(el_val_t s, el_val_t sub);       /* [Int] of byte offsets */
+el_val_t  str_last_index_of(el_val_t s, el_val_t sub);
+el_val_t  str_find_chars(el_val_t s, el_val_t any_of);      /* first idx of any ch */
+
+/* Transform */
+el_val_t  str_repeat(el_val_t s, el_val_t n);
+el_val_t  str_reverse(el_val_t s);                          /* by codepoint */
+el_val_t  str_strip_prefix(el_val_t s, el_val_t prefix);
+el_val_t  str_strip_suffix(el_val_t s, el_val_t suffix);
+el_val_t  str_strip_chars(el_val_t s, el_val_t chars);
+el_val_t  str_lstrip(el_val_t s);
+el_val_t  str_rstrip(el_val_t s);
+
+/* Char classification (Bool) */
+el_val_t  is_letter(el_val_t s);
+el_val_t  is_digit(el_val_t s);
+el_val_t  is_alphanumeric(el_val_t s);
+el_val_t  is_whitespace(el_val_t s);
+el_val_t  is_punctuation(el_val_t s);
+el_val_t  is_uppercase(el_val_t s);
+el_val_t  is_lowercase(el_val_t s);
+
+/* Split / join */
+el_val_t  str_split_lines(el_val_t s);
+el_val_t  str_split_chars(el_val_t s);                      /* alias of native_string_chars */
+el_val_t  str_split_n(el_val_t s, el_val_t sep, el_val_t n);
+el_val_t  str_join(el_val_t list, el_val_t sep);            /* alias of list_join */
+
+/* ── List additions ──────────────────────────────────────────────────────── */
+
+el_val_t  list_push(el_val_t list, el_val_t elem);
+el_val_t  list_push_front(el_val_t list, el_val_t elem);
+el_val_t  list_join(el_val_t list, el_val_t sep);
+el_val_t  list_range(el_val_t start, el_val_t end);
+
+/* ── Bool helpers ────────────────────────────────────────────────────────── */
+
+el_val_t  bool_to_str(el_val_t b);
+
+/* ── Numeric parsing ─────────────────────────────────────────────────────── */
+
+el_val_t  parse_int(el_val_t s, el_val_t default_val);
+
+/* ── Process ─────────────────────────────────────────────────────────────── */
+
+void      exit_program(el_val_t code);
+el_val_t  getpid_now(void);
+
+/* ── CGI identity ─────────────────────────────────────────────────────────────
+ * Called at the start of main() in CGI programs (those with a `cgi {}` block).
+ * Records the program's DHARMA identity before any other code executes.      */
+
+void      el_cgi_init(el_val_t name, el_val_t dharma_id, el_val_t principal,
+                      el_val_t network, el_val_t engram);
+
+/* ── DHARMA network builtins ─────────────────────────────────────────────────
+ * Available to CGI programs (declared with a `cgi {}` block).
+ *
+ * Peers are addressed by `dharma_id` of the form
+ *     "<registry-id>@<transport-url>"   e.g. "ntn-genesis@http://localhost:7770"
+ * If the @<url> portion is omitted, transport defaults to
+ * "http://localhost:7770" (the local CGI daemon assumption).
+ *
+ * Wire protocol (all peers expose):
+ *   POST <url>/dharma/recv      { channel, from, content } → response body
+ *   POST <url>/dharma/event     { type, payload, source, timestamp }
+ *   POST <url>/api/activate     { query }                 → list of nodes
+ *
+ * Hosting application's responsibility: an El program with a `cgi {}` block
+ * runs http_serve() with its own request handler; that handler should route
+ * "/dharma/event" requests by calling el_runtime_dharma_event_arrive() so
+ * incoming events feed dharma_field() queues. The runtime itself does not
+ * intercept any /dharma path.                                                */
+
+el_val_t  dharma_connect(el_val_t cgi_id);
+el_val_t  dharma_send(el_val_t channel, el_val_t content);
+el_val_t  dharma_activate(el_val_t query);
+void      dharma_emit(el_val_t event_type, el_val_t payload);
+el_val_t  dharma_field(el_val_t event_type);
+void      dharma_strengthen(el_val_t cgi_id, el_val_t weight);
+el_val_t  dharma_relationship(el_val_t cgi_id);
+el_val_t  dharma_peers(void);
+
+/* Public C API: called by an El program's HTTP handler when a /dharma/event
+ * request arrives. Pushes onto the per-event-type queue and signals any
+ * pending dharma_field() blockers. All three arguments must be NUL-terminated
+ * C strings (or NULL — then treated as empty).                               */
+void      el_runtime_dharma_event_arrive(const char* event_type,
+                                         const char* payload,
+                                         const char* source);
+
+/* ── Engram local graph primitives ───────────────────────────────────────────
+ * Operate on the CGI's local Engram knowledge graph.
+ * `engram_activate` queries the local graph only; `dharma_activate` is
+ * network-wide across all connected CGI graphs.                              */
+
+el_val_t  engram_node(el_val_t content, el_val_t node_type, el_val_t salience);
+el_val_t  engram_node_full(el_val_t content, el_val_t node_type, el_val_t label,
+                           el_val_t salience, el_val_t importance, el_val_t confidence,
+                           el_val_t tier, el_val_t tags);
+/* Layered consciousness — see el_runtime.c for the layered architecture
+ * design notes (search "Layered consciousness architecture"). The five
+ * canonical layers (safety / core-identity / domain-knowledge / imprint /
+ * suit) are seeded automatically; engram_add_layer extends the registry
+ * with imprint or suit overlays at runtime. Nodes default to layer 1
+ * (core-identity) when created via engram_node / engram_node_full. */
+el_val_t  engram_node_layered(el_val_t content, el_val_t node_type, el_val_t label,
+                              el_val_t salience, el_val_t certainty, el_val_t confidence,
+                              el_val_t status, el_val_t tags, el_val_t layer_id);
+el_val_t  engram_add_layer(el_val_t name, el_val_t priority, el_val_t suppressible,
+                           el_val_t transparent, el_val_t injectable);
+el_val_t  engram_remove_layer(el_val_t layer_id);
+el_val_t  engram_list_layers(void);
+el_val_t  engram_get_node(el_val_t id);
+void      engram_strengthen(el_val_t node_id);
+void      engram_forget(el_val_t node_id);
+el_val_t  engram_prune_telemetry(el_val_t older_than_ms);
+el_val_t  engram_node_count(void);
+el_val_t  engram_search(el_val_t query, el_val_t limit);
+el_val_t  engram_scan_nodes(el_val_t limit, el_val_t offset);
+void      engram_connect(el_val_t from_id, el_val_t to_id, el_val_t weight, el_val_t relation);
+el_val_t  engram_edge_between(el_val_t from_id, el_val_t to_id);
+el_val_t  engram_neighbors(el_val_t node_id);
+el_val_t  engram_neighbors_filtered(el_val_t node_id, el_val_t max_depth, el_val_t direction);
+el_val_t  engram_edge_count(void);
+/* Three-pass activation: background fan-out → working-memory promotion →
+ * Layer 0 override. See "Three-pass activation" in el_runtime.c. */
+el_val_t  engram_activate(el_val_t query, el_val_t depth);
+el_val_t  engram_save(el_val_t path);
+el_val_t  engram_load(el_val_t path);
+
+/* JSON-string accessors — return pre-serialized JSON so HTTP handlers
+ * can pass results straight through without round-tripping ElList/ElMap
+ * through json_stringify. */
+el_val_t  engram_get_node_json(el_val_t id);
+el_val_t  engram_get_node_by_label(el_val_t label);
+el_val_t  engram_search_json(el_val_t query, el_val_t limit);
+el_val_t  engram_scan_nodes_json(el_val_t limit, el_val_t offset);
+el_val_t  engram_scan_nodes_by_type_json(el_val_t node_type, el_val_t limit, el_val_t offset);
+el_val_t  engram_neighbors_json(el_val_t node_id, el_val_t max_depth, el_val_t direction);
+el_val_t  engram_activate_json(el_val_t query, el_val_t depth);
+el_val_t  engram_stats_json(void);
+el_val_t  engram_act_stats_json(void);
+el_val_t  engram_cosine_sim(el_val_t id_a, el_val_t id_b);
+/* Document frequency of a term across node labels — term-specificity signal
+ * for curiosity seed selection. (2026-08-03 self-review.) */
+el_val_t  engram_label_df(el_val_t term);
+el_val_t  engram_embed_backfill(el_val_t count);
+el_val_t  engram_list_layers_json(void);
+/* Working memory introspection — count, mean weight, and top-N snapshot.
+ * Ported from el-compiler/runtime on 2026-06-30 self-review. */
+el_val_t  engram_wm_count(void);
+el_val_t  engram_wm_avg_weight(void);
+el_val_t  engram_wm_top_json(el_val_t n);
+/* Merge-load: add nodes/edges from a snapshot without resetting the store. */
+el_val_t  engram_load_merge(el_val_t path);
+/* engram_compile_layered_json — produce a prompt-ready text block split
+ * into "[LAYER 0 — STRUCTURAL]" (non-suppressible layers, sacred fire)
+ * and "[ENGRAM CONTEXT]" (standard suppressible layers). Returns "" if
+ * no nodes promoted to working memory. */
+el_val_t  engram_compile_layered_json(el_val_t intent, el_val_t depth);
+
+/* ── LLM (Anthropic API client) ─────────────────────────────────────────────
+ * All functions call https://api.anthropic.com/v1/messages with the API key
+ * from env ANTHROPIC_API_KEY. Default model when empty: claude-sonnet-4-5. */
+
+el_val_t  llm_call(el_val_t model, el_val_t prompt);
+el_val_t  llm_call_system(el_val_t model, el_val_t system_prompt, el_val_t user_prompt);
+el_val_t  llm_call_agentic(el_val_t model, el_val_t system, el_val_t user, el_val_t tools);
+el_val_t  llm_vision(el_val_t model, el_val_t system, el_val_t prompt, el_val_t image_url_or_b64);
+el_val_t  llm_models(void);
+
+/* Register a tool handler by name. The handler is looked up via dlsym
+ * (mirroring http_set_handler), so any El `fn <name>(input)` compiles to
+ * a global C symbol that this function can locate at runtime.
+ * Handler signature: `el_val_t handler(el_val_t input_json)` — receives
+ * the tool input as a JSON-string el_val_t and returns a JSON-string
+ * el_val_t result. Used by llm_call_agentic.                                 */
+void      llm_register_tool(el_val_t name, el_val_t handler_fn_name);
+
+/* ── args() ─────────────────────────────────────────────────────────────────
+ * Provides access to command-line arguments passed to the program.
+ * Populated by el_runtime_init_args() before main() runs.           */
+
+el_val_t  args(void);
+void      el_runtime_init_args(int argc, char** argv);
+
+/* ── Crypto primitives ─────────────────────────────────────────────────────
+ * SHA-256, HMAC-SHA-256, and base64 (standard + URL-safe).
+ * Self-contained — no OpenSSL/libcrypto dependency. The implementations are
+ * adapted from public-domain reference code (Brad Conte / RFC 4648).
+ *
+ * Bytes-returning variants (sha256_bytes, hmac_sha256_bytes) return a string
+ * value whose contents are raw binary; callers usually feed these into
+ * base64_encode. Note that el_val_t strings are NUL-terminated by convention,
+ * so the binary payload may contain embedded NULs — pass it directly into
+ * base64_encode (which uses an explicit length) rather than treating it as
+ * a printable C string.
+ *
+ * The "base64" variants emit/accept RFC 4648 standard alphabet with padding.
+ * The "base64url" variants use URL-safe alphabet (`-`/`_`) with no padding,
+ * as used in JWTs.                                                           */
+
+el_val_t  sha256_hex(el_val_t input);
+el_val_t  sha256_bytes(el_val_t input);
+el_val_t  hmac_sha256_hex(el_val_t key, el_val_t message);
+el_val_t  hmac_sha256_bytes(el_val_t key, el_val_t message);
+el_val_t  base64_encode(el_val_t input);
+el_val_t  base64_decode(el_val_t input);
+el_val_t  base64url_encode(el_val_t input);
+el_val_t  base64url_decode(el_val_t input);
+
+/* Length-aware variants (internal — exposed for the rare caller that already
+ * has a known-length binary buffer and doesn't want to round-trip through
+ * a NUL-terminated el_val_t string). Sha256_bytes and hmac_sha256_bytes feed
+ * these implicitly. */
+el_val_t  el_sha256_bytes_n(const unsigned char* data, size_t len);
+el_val_t  el_base64_encode_n(const unsigned char* data, size_t len, int url_safe);
+
+/* ── Post-quantum primitives (liboqs-backed) ────────────────────────────────
+ * All inputs/outputs hex-encoded. Algorithm choices:
+ *   Signature: CRYSTALS-Dilithium-3   (NIST level 3, balanced)
+ *   KEM:       CRYSTALS-Kyber-768     (NIST level 3)
+ *   Hash:      SHA3-256 (Keccak)      (PQ-aware protocols favour SHA3 over SHA2)
+ *
+ * If liboqs is not linked (detected via __has_include(<oqs/oqs.h>) at compile
+ * time), the pq_* entry points return a JSON-shaped error string so callers
+ * fail loudly rather than silently fall back to classical schemes:
+ *   {"error":"liboqs not linked, post-quantum primitives unavailable"}
+ *
+ * The hybrid handshake pairs X25519 with Kyber-768 per NIST PQ guidance and
+ * CNSA 2.0. Combined shared secret is HKDF-SHA256(x25519_ss || kyber_ss).
+ * Even if Kyber falls, X25519 holds; if X25519 falls under quantum attack,
+ * Kyber holds. SHA3-256 also remains usable independent of liboqs (the
+ * Keccak permutation is PQ-OK as a primitive). */
+
+el_val_t  pq_keygen_signature(void);
+el_val_t  pq_sign(el_val_t secret_key_hex, el_val_t message);
+el_val_t  pq_verify(el_val_t public_key_hex, el_val_t message, el_val_t signature_hex);
+
+el_val_t  pq_kem_keygen(void);
+el_val_t  pq_kem_encaps(el_val_t public_key_hex);
+el_val_t  pq_kem_decaps(el_val_t secret_key_hex, el_val_t ciphertext_hex);
+
+el_val_t  pq_hybrid_keygen(void);
+el_val_t  pq_hybrid_handshake(el_val_t remote_pub_combined);
+
+el_val_t  sha3_256_hex(el_val_t input);
+
+/* ── AEAD: AES-256-GCM (libcrypto-backed) ───────────────────────────────────
+ * Symmetric authenticated encryption used to wrap envelopes after a KEM
+ * handshake. Caller MUST supply a 32-byte key (64 hex chars) — typically the
+ * Kyber-768 / hybrid shared_secret, optionally normalized via SHA3-256.
+ *
+ * aead_encrypt returns a JSON map {"nonce":"...","ciphertext":"..."} where
+ * ciphertext is the AES-256-GCM output with the 16-byte auth tag appended.
+ * Nonce is a fresh 12-byte CSPRNG draw — callers never pick the nonce, which
+ * structurally rules out the GCM nonce-reuse footgun.
+ *
+ * aead_decrypt returns the plaintext String, or "" on any failure (including
+ * auth-tag mismatch). Callers MUST check for "" before trusting the result. */
+el_val_t  aead_encrypt(el_val_t key_hex, el_val_t plaintext);
+el_val_t  aead_decrypt(el_val_t key_hex, el_val_t nonce_hex, el_val_t ciphertext_hex);
+
+/* ── Native VM builtin aliases (for compiled El source) ─────────────────────
+ * These match the El VM's native_* builtins so that El source compiled
+ * to C can call the same names without modification.                */
+
+el_val_t  native_list_get(el_val_t list, el_val_t index);
+el_val_t  native_list_len(el_val_t list);
+el_val_t  native_list_append(el_val_t list, el_val_t elem);
+el_val_t  native_list_empty(void);
+el_val_t  native_list_clone(el_val_t list);
+el_val_t  native_string_chars(el_val_t s);
+el_val_t  native_int_to_str(el_val_t n);
+
+/* ── Method-call shorthand aliases ──────────────────────────────────────────
+ * The El method-call convention `obj.method(args)` compiles to
+ * `method(obj, args)`.  These aliases expose the runtime functions under
+ * the short names that result from method calls in El source.
+ *
+ * Example: `myList.append(x)` → `append(myList, x)` (calls this alias)
+ *          `myList.len()`     → `len(myList)`         (calls this alias)  */
+
+el_val_t  append(el_val_t list, el_val_t elem);   /* el_list_append */
+el_val_t  len(el_val_t list);                      /* el_list_len    */
+el_val_t  get(el_val_t list, el_val_t index);      /* el_list_get    */
+el_val_t  map_get(el_val_t map, el_val_t key);     /* el_map_get     */
+el_val_t  map_set(el_val_t map, el_val_t key, el_val_t value); /* el_map_set */
+
+/* ── OTLP/HTTP Observability ─────────────────────────────────────────────── */
+/* See bottom of el_runtime.c for the implementation.
+ * Configured by env vars OTLP_ENDPOINT, OTEL_SERVICE_NAME, OTEL_SERVICE_VERSION.
+ * No-op when OTLP_ENDPOINT is unset. Drop-on-failure semantics. */
+/* ── Subprocess execution ────────────────────────────────────────────────── */
+el_val_t exec_command(el_val_t cmd);   /* run shell command, return exit code */
+el_val_t exec_capture(el_val_t cmd);   /* run shell command, capture stdout   */
+el_val_t exec(el_val_t cmd);           /* exec(cmd) → stdout String (30s timeout) */
+el_val_t exec_bg(el_val_t cmd);        /* exec_bg(cmd) → PID String (non-blocking) */
+
+el_val_t emit_log(el_val_t level, el_val_t msg, el_val_t fields_json);
+el_val_t emit_metric(el_val_t name, el_val_t value, el_val_t tags_json);
+el_val_t trace_span_start(el_val_t name);
+el_val_t trace_span_end(el_val_t span_handle);
+el_val_t emit_event(el_val_t name, el_val_t duration_ms);
+
+#ifdef __cplusplus
+}
+#endif