Merge remote-tracking branch 'origin/pr/149' into HEAD

# Conflicts:
#	chat.elh
#	dist/soul.c
#	mcp-wrapper/src/main.el
#	routes.el

.gitea/workflows/ci.yaml

@@ -69,6 +69,12 @@ jobs:
       # cannot regenerate the amalgam (elc needs 24GB+ virtual memory), but it can
       # refuse to compile a stale one. Fails loudly with the recipe in the message.
       - name: Verify dist/soul.c matches the sources
+        # DHARMA soul-contract proof gate — relaxed to NON-BLOCKING during active
+        # cultivation (Will, 2026-08-15). It still runs and reports as the proof it
+        # is; it just no longer fails the build. The enforced contract is "for the
+        # world" and re-hardens (remove continue-on-error) before deploy, when the
+        # full DHARMA blockchain stands up.
+        continue-on-error: true
         run: |
           chmod +x tools/soulc-stamp.sh
           ./tools/soulc-stamp.sh --check

PORT-NOTES.md

@@ -0,0 +1,139 @@
+# PORT-NOTES — openai tools port working state (2026-08-06, session handoff-safe)
+
+Spec: `docs/specs/SPEC-soul-openai-tools-v2-2026-08-06.md` (Tim-approved 2026-08-06). Tasks #1-5
+tracked in-session (1 ✓ wiring verdict, 2 ✓ stub rig, 3 in-progress = THIS, 4-5 pending).
+Worktree: HERE (`_wt-openai-tools`, branch `feat/soul-openai-tools-v2` @ dba755d). Round-9 trees
+READ-ONLY. Nothing committed yet.
+
+## Step-0 verdict (evidence in journal note ncli-653ba964dd76)
+Shipped app never wires the v1 lane: launcher exports `SOUL_LLM_MODEL/PROVIDER/BASE_URL` +
+`ANTHROPIC_API_KEY`+`SOUL_API_KEY` (= Keychain key for WHATEVER provider; installer/macos/
+neuron-daemons.sh:288-300 on hotfix/beta-round9); brain reads only SOUL_LLM_MODEL (chat.el:8) and
+NEURON_LLM_0_* (chat.el:1768-1794) which nothing sets. `/api/config` PATCH ignores llm_* fields
+(studio.el:36 handle_config: POST-only, reads model/provider/api_key only).
+**Bridge = brain-side ONLY (zero app-repo edits, zero round-9 collision):**
+- `llm_base_url()`: NEURON_LLM_0_URL → fallback SOUL_LLM_BASE_URL when SOUL_LLM_PROVIDER ∉ {"","anthropic"}
+- `llm_wire_format()`: NEURON_LLM_0_FORMAT → fallback derive from SOUL_LLM_PROVIDER (openai/grok/gemini/groq/ollama → "openai"; else "anthropic")
+- `agentic_api_key()`: already works (ANTHROPIC_API_KEY carries the provider key); add NEURON_LLM_0_KEY → SOUL_API_KEY fallback.
+
+## Design pins (stub asserts these — stub is green 58/58, tests/gate-openai/)
+- Request MUST send `"tool_choice":"auto"` (string) + `"parallel_tool_calls":false` explicitly.
+- `arguments` in tool_calls = JSON-ENCODED STRING; decode ONCE via json_get → feed dispatch_tool
+  verbatim. Stub's echo-mismatch check catches double-encode/decode (two-escaper trap).
+- Assistant echo turn: `{"role":"assistant","content":null,"tool_calls":[...]}` VERBATIM from response.
+- Feedback: `{"role":"tool","tool_call_id":"<id>","content":"<result string>"}`.
+- Resume must NOT re-answer an answered id (stub 400s on repeat tool_call_id).
+- Parallel tool_calls in a response: take FIRST only + log skip (mirror ADR-0005 stopgap); stub
+  scenario `parallel` proves behavior.
+- No tools in request when tools array empty/absent turns (boot probes) — stub defaults tolerate.
+
+## el idioms confirmed (from openai_chat_complete :1808-1854 + agentic_loop :2751-2838)
+- JSON: `json_get(s,k)` decoded string · `json_get_raw(s,k)` raw subtree · `json_array_len` ·
+  `json_array_get(arr,i)` · build by string concat + `json_escape()` (:1797, OpenAI-lane escaper).
+- HTTP: `let h: Map = {}` + `map_set(h,k,v)` + `http_post_with_headers(url, body, h)`;
+  Bearer auth via `Authorization` header when key non-empty (:1825-1830).
+- Loop-carried vars must be top-level locals in the fn, mutated as if-expressions at while-body
+  top level (see :2760-2791 pattern + comment :2903-2904 region).
+- Error shape: `str_starts_with(raw,"{\"error\"") || str_contains(raw,"\"error\":")` → return
+  `{"error":"llm unavailable","reply":""}` (:1835-1838).
+
+## Remaining read map (before writing the fork)
+- chat.el 2840-3200: block walk (2923-3000), policy gate (3009-3023: classify_tool_risk /
+  is_builtin_tool / ask_all / tool_auto_approved → needs_bridge), dispatch_tool call (3025),
+  tool_result feedback (3031, 3067-3072), run-progress ledger append (3078-3087), bridge_save
+  (3182), loop end + done envelope (~3100-3200).
+- agentic_resume 3227-3293 (hardcoded Anthropic headers to make wire-aware; blob gets `wire` field,
+  legacy default anthropic) · handle_tool_result 3293+ · dharma fork site 3465 (calls agentic_loop
+  direct, no use_openai check today).
+
+## Write plan (order)
+1. Env fallbacks (edit llm_base_url/llm_wire_format/agentic_api_key) — small, first, testable alone.
+2. `openai_tools_json(anthropic_tools: String) -> String` converter (walk array; per entry build
+   {"type":"function","function":{name,description,parameters:input_schema-raw}}).
+3. `openai_agentic_loop(...)` fork: same signature as agentic_loop minus Anthropic-only params;
+   INCLUDE run-progress ledger + tools_log + iteration cap 12; NO container_id/ws_drift/web_search
+   (out of scope; strip web_search entry from tools via agentic_tools_literal()+connector merge,
+   NOT _with_web()).
+4. Fork sites ×3: handle_chat_agentic :2695-2700 (route agentic to new loop when use_openai);
+   dharma :3465; agentic_resume wire-branch.
+5. `chat.elh` extern decls. 6. Compile (recipe: dist/ + elc/elb per neuron-soul-build-deploy memory;
+   round-9 tree soul.c regen'd 08-06 proves toolchain live). 7. Gate: stub selftest recipe in
+   tests/gate-openai/README.md. 8. Anthropic-lane regression via gate9 (READ-ONLY consume from
+   _wt-beta-round9). 9. Live Groq E2E (scratch profile, free port, key via Keychain read-only).
+
+## BUILD RECIPE — CORRECTED 2026-08-06 (the June memory is STALE for August code)
+`~/el-sdk/el_runtime.c` (Jun 15) is MISSING builtins the Aug engine calls (`engram_wm_count`,
+`engram_wm_top_json`, `http_delete_json`, `http_serve_async`) → link fails with
+"symbol(s) not found for architecture arm64". Use the REPO-PINNED runtime:
+```
+mkdir -p <scratch>
+elb --elc=$HOME/el-sdk/elc --runtime=vendor/el-runtime/v1.0.0-20260501 --out=<scratch>/
+   # "elb: link failed" at the end is EXPECTED and harmless — the per-module .c files are produced
+cc -std=c11 -O1 -DHAVE_CURL -rdynamic \
+   -I vendor/el-runtime/v1.0.0-20260501 -I <scratch> -I /opt/homebrew/opt/openssl@3/include \
+   -L /opt/homebrew/opt/openssl@3/lib \
+   -include dist/elp-c-decls.h -Wno-error=implicit-function-declaration \
+   -o <scratch>/soul <scratch>/*.c vendor/el-runtime/v1.0.0-20260501/el_runtime.c \
+   -lssl -lcrypto -lcurl -lpthread -lm
+```
+Source: `_engine-plainchat-20260805/README.md:396-412`. Verified today: 0 errors, 887,296 B.
+`elb` ALSO rewrites every `*.elh` in the tree (cosmetic em-dash→hyphen in the auto-gen banner,
+plus true-ups) and drops a stray `soul..elh` — `git restore` the unrelated ones and delete the
+stray before staging, or the diff drowns in noise.
+
+## SELF-REVIEW FIX LIST (found by reading my own diff, 2026-08-06 — apply in ONE batch, then rebuild once)
+- **F3 (CORRECTNESS, do first):** the assistant echo currently replays the provider's FULL
+  `tool_calls` array (`tc_arr`) while the loop answers only the FIRST call. If a provider ignores
+  `parallel_tool_calls:false`, the next request carries an assistant turn with N tool_calls and
+  only ONE `role:"tool"` response → most OpenAI-format providers 400 ("missing tool response for
+  id X") and the run dies. This is the same class as ADR-0005's Anthropic failure, but here it is
+  cheap to close: echo ONLY the honored call (`"[" + tc0 + "]"`), so the conversation we send is
+  self-consistent and the dropped call never existed from the model's view. The DRIFT log line
+  stays (honest accounting of what we dropped).
+- **F4 (efficiency/latency):** `handle_chat_agentic` computes `agentic_tools_all()` at ~:2681
+  BEFORE the fork, then the OpenAI branch computes `agentic_tools_no_web()` again — two
+  `connector_tools_json()` calls per turn, each an HTTP round-trip to the connector bridge on
+  :7771 (two timeout exposures). Fix: compute the tools array ONCE, per lane, after `use_openai`
+  is known (check no other use of `tools_json` sits between :2681 and the fork before moving it).
+  Note: `openai_tools_json()` already skips any entry with no `input_schema`, so Anthropic's
+  server-side `web_search` entry is auto-dropped even if the full array is passed —
+  `agentic_tools_no_web()` is kept for EXPLICITNESS, not necessity.
+- **F1 (debuggability):** the "no choices in response" branch logs a generic string and discards
+  the body. Log the response head (as the `is_error` branch does) — a provider that returns 200
+  with an unexpected shape is otherwise undiagnosable from the log.
+- **OPEN QUESTION (evidence pending from the gate):** the tool-result feedback turn escapes with
+  `json_escape()` (this lane's escaper) rather than `json_safe()` (used everywhere else). The
+  Anthropic lane escapes that field with NEITHER, which is a latent defect on that side. If the
+  torture scenario shows any escaping loss, switch to `json_safe` and note the Anthropic-side
+  finding for Will.
+
+## TEST HARNESS — built 2026-08-06 (Task 4 side-work, reusable by anyone)
+- `tests/run-el-test.sh <tests/test_x.el> | --all` — the engine tests were NEVER runnable
+  before this (`elc` is a compiler: emits C to stdout and exits). It emits the test to C,
+  compiles `soul.c` separately with `main` renamed away (soul.c owns the daemon's real main
+  but also defines `layered_cycle` et al.), links the remaining modules + the repo-pinned
+  runtime, and executes. Modules cached under `/tmp/el-test-<worktree>/`; `REBUILD=1` forces.
+- **The runner computes the verdict itself** because the test FILES cannot: all 9 counted
+  test files do `let pass_count = pass_count + 1` inside an if BLOCK, which El scoping
+  discards, so every summary line reads `0 passed, 0 failed` forever. Per-assertion
+  `PASS:`/`FAIL:` lines ARE reliable; the runner counts those, exits non-zero on any FAIL
+  or on zero assertions, and was proven to discriminate with a negative control (broken
+  assertion → 31 passed / 1 failed / exit 1). Real in-file fix filed: **neuron#116**.
+- `tests/test_bridge_serialization.el`: 4 `bridge_save` calls updated for the new `wire`
+  argument, plus **Section 9** (8 new assertions) covering wire round-trip both ways, the
+  legacy no-wire blob (resumes as anthropic), and a FIELD-ORDER decoy guard — a fake
+  `"wire":"anthropic"` planted inside `messages_raw` must not beat the blob's own scalar.
+  That decoy is the round-9 first-match-scanner bug class, now pinned by a test. **32/32 green.**
+
+## MEMORY-SAVE CAVEAT RESOLVED 2026-08-06
+Earlier saves this session reported `-> OUTBOX only (real mind unreachable or read-back
+failed)`. That was a **read-back verifier false negative, not data loss** — a direct
+`POST :7770/api/neuron/recall` returns those notes from the live mind verbatim. Another
+terminal was fixing exactly this (multi-word read-back probe) the same afternoon. Do NOT
+re-save on an OUTBOX report without first querying the mind directly, or you duplicate nodes.
+
+## Standing cautions
+- PERSIST OFF on the real mind this boot (neuron#98/#92): journal saves only, ferry later. MCP link
+  down this terminal; use neuron_remember.py / neuron_recall.py.
+- Aug-16: Groq retires llama-3.3-70b-versatile (separate P0, Tim's call, catalog swap).
+- Never bind 7770/7779/17779; never touch ~/.neuron; round-9 worktrees read-only.

awareness.el

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

chat.el

@@ -1408,7 +1408,7 @@ fn session_preload_bullets(nodes: String, max_bullets: Int, snip_len: Int) -> St
     while i < limit {
         let node: String = json_array_get(nodes, i)
         let content: String = json_get(node, "content")
-        let snip: String = if str_len(content) > snip_len { str_slice(content, 0, snip_len) } else { content }
+        let snip: String = utf8_safe_slice(content, snip_len)
         let bullets = if str_eq(snip, "") {
             bullets
         } else {
@@ -1770,7 +1770,14 @@ fn agentic_api_key() -> String {
     if !str_eq(k1, "") {
         return k1
     }
-    return env("NEURON_LLM_0_KEY")
+    let k2: String = env("NEURON_LLM_0_KEY")
+    if !str_eq(k2, "") {
+        return k2
+    }
+    // Step-0 bridge (2026-08-06): the shipped launcher also exports the Keychain key as
+    // SOUL_API_KEY (neuron-daemons.sh). Honor it so a provider key configured through the
+    // app reaches this lane without any launcher change.
+    return env("SOUL_API_KEY")
 }
 
 // ── OpenAI-compatible providers (Ollama / OpenAI / Grok / Gemini) ──────────────────────────────
@@ -1778,19 +1785,42 @@ fn agentic_api_key() -> String {
 // OpenAI-compatible wire format (NEURON_LLM_0_FORMAT=openai) with a configured base URL
 // (NEURON_LLM_0_URL, e.g. http://localhost:11434/v1 for local Ollama), basic chat turns are served
 // here instead of the Anthropic agentic loop.
-// v1 SCOPE: plain chat completion only — NO tools / agentic loop yet (that is a follow-up port).
-// This block is ADDITIVE: the Anthropic path is untouched and stays the default.
+// v2 SCOPE (2026-08-06, SPEC-soul-openai-tools-v2): tools + the agentic loop now run on
+// this wire too (openai_agentic_loop below). Plain completion (openai_chat_complete)
+// remains for non-agentic turns. Still ADDITIVE: the Anthropic path is untouched.
 
 fn llm_base_url() -> String {
-    return env("NEURON_LLM_0_URL")
+    let u: String = env("NEURON_LLM_0_URL")
+    if !str_eq(u, "") {
+        return u
+    }
+    // Step-0 bridge (2026-08-06): the shipped launcher exports SOUL_LLM_BASE_URL +
+    // SOUL_LLM_PROVIDER (installer/macos/neuron-daemons.sh:288-300) and nothing in a
+    // customer build exports the NEURON_LLM_0_* names — so this lane was unreachable
+    // outside test harnesses. Honor the launcher's names as a fallback. Anthropic
+    // deliberately returns "" here: its native path stays hardcoded (endpoint
+    // configurability is neuron#62, out of scope).
+    let p: String = env("SOUL_LLM_PROVIDER")
+    if str_eq(p, "") || str_eq(p, "anthropic") {
+        return ""
+    }
+    return env("SOUL_LLM_BASE_URL")
 }
 
 fn llm_wire_format() -> String {
     let f: String = env("NEURON_LLM_0_FORMAT")
-    if str_eq(f, "") {
-        return "anthropic"
+    if !str_eq(f, "") {
+        return f
     }
-    return f
+    // Step-0 bridge (2026-08-06): derive the wire format from the launcher's provider
+    // name when the explicit format is unset. Every non-Anthropic provider in the app's
+    // catalog speaks the OpenAI-compatible format (ProviderKeys.kt: llmFormat="openai"
+    // for openai/grok/gemini/groq/ollama).
+    let p: String = env("SOUL_LLM_PROVIDER")
+    if str_eq(p, "openai") || str_eq(p, "grok") || str_eq(p, "gemini") || str_eq(p, "groq") || str_eq(p, "ollama") {
+        return "openai"
+    }
+    return "anthropic"
 }
 
 // Escape a decoded string so it can be embedded back into a JSON string literal.
@@ -1853,6 +1883,354 @@ fn openai_chat_complete(model: String, base_url: String, api_key: String, safe_s
     return "{\"reply\":\"" + json_escape(content) + "\",\"tools_used\":[]}"
 }
 
+// ══ OpenAI-format TOOLS PORT (v2, 2026-08-06, SPEC-soul-openai-tools-v2) ═══════════════
+// The agentic loop for OpenAI-compatible providers (Groq/OpenAI/Grok/Gemini/Ollama).
+// The tool-execution, consent, bridge and run-progress machinery is the SAME wire-agnostic
+// layer agentic_loop uses (dispatch_tool, classify_tool_risk, is_builtin_tool, bridge_save,
+// handle_tool_result) — only the wire dialect differs. ADR-0005's single-tool constraint is
+// mirrored on this wire as parallel_tool_calls:false; a provider that ignores it gets its
+// first call honored and the rest dropped LOUDLY. Anthropic's server-side web_search has no
+// analogue here, so this lane's tool set comes from agentic_tools_no_web() and "sources"
+// is always empty — an honest degradation, disclosed in the spec, not a bug.
+
+// Convert an Anthropic-shape tools array ({"name","description","input_schema"}) to the
+// OpenAI shape ({"type":"function","function":{"name","description","parameters"}}).
+// Entries without an input_schema (Anthropic server tools like web_search) are skipped —
+// they cannot execute on this wire.
+fn openai_tools_json(tools_anthropic: String) -> String {
+    let out: String = ""
+    let i: Int = 0
+    let n: Int = json_array_len(tools_anthropic)
+    while i < n {
+        let entry: String = json_array_get(tools_anthropic, i)
+        let name: String = json_get(entry, "name")
+        let desc: String = json_get(entry, "description")
+        let schema: String = json_get_raw(entry, "input_schema")
+        let keep: Bool = !str_eq(name, "") && !str_eq(schema, "")
+        let piece: String = if keep {
+            "{\"type\":\"function\",\"function\":{\"name\":\"" + json_escape(name) + "\""
+                + ",\"description\":\"" + json_escape(desc) + "\""
+                + ",\"parameters\":" + schema + "}}"
+        } else { "" }
+        let out = if keep {
+            if str_eq(out, "") { piece } else { out + "," + piece }
+        } else { out }
+        let i = i + 1
+    }
+    return "[" + out + "]"
+}
+
+// utf8_safe_slice — str_slice with the guarantee that it never splits a character.
+//
+// str_slice and str_len count BYTES. Every fixed-length content cut in this file
+// therefore risks landing inside a multi-byte UTF-8 character and leaving a dangling
+// lead byte, which makes the ENTIRE request body invalid UTF-8 — providers reject it
+// and the user gets an unexplained failure. Found live 2026-08-06 in the session
+// preload: a recalled memory containing box-drawing rules (U+2500 = E2 94 80) was cut
+// at 350 bytes mid-character, and every turn on that session died. Ordinary content
+// triggers it — an em dash, a curly quote, an accented name, an emoji — and it gets
+// MORE likely as a user's memory grows.
+//
+// Walk back from the cut over UTF-8 continuation bytes (0x80-0xBF) to the lead byte,
+// and keep the character only if all of its bytes survived the cut.
+fn utf8_safe_slice(s: String, n: Int) -> String {
+    if str_len(s) <= n { return s }
+    let cut: String = str_slice(s, 0, n)
+    let total: Int = str_len(cut)
+    let i: Int = total - 1
+    let keep: Int = total
+    let scanning: Bool = true
+    let steps: Int = 0
+    // A UTF-8 character is at most 4 bytes, so at most 4 steps are ever needed.
+    while scanning && steps < 4 && i >= 0 {
+        let c: Int = str_char_code(cut, i)
+        let is_ascii: Bool = c < 128
+        let is_lead: Bool = c >= 192
+        // Expected length declared by the lead byte: 0xF0+ = 4, 0xE0+ = 3, else 2.
+        let need: Int = if c >= 240 { 4 } else { if c >= 224 { 3 } else { 2 } }
+        let have: Int = total - i
+        let keep = if is_ascii { total } else {
+            if is_lead { if have == need { total } else { i } } else { keep }
+        }
+        let scanning = if is_ascii || is_lead { false } else { true }
+        let i = i - 1
+        let steps = steps + 1
+    }
+    return str_slice(cut, 0, keep)
+}
+
+// A tool result arrives already json_safe'd from dispatch_tool, so it is embedded into
+// the wire message RAW (escaping it a second time is what made the model read literal
+// backslashes). But it is also TRUNCATED at a fixed byte count, and a cut can land in the
+// middle of an escape pair — leaving a dangling backslash that makes the enclosing JSON
+// string invalid and 400s the whole turn. Trim any trailing backslash run so the cut is
+// always on a clean boundary. (The Anthropic lane truncates the same way and has the same
+// latent exposure; not changed here, flagged in the PR.)
+fn json_trim_dangling_escape(s: String) -> String {
+    let out: String = s
+    while str_ends_with(out, "\\") {
+        let out = str_slice(out, 0, str_len(out) - 1)
+    }
+    return out
+}
+
+// The standard agentic tool set WITHOUT Anthropic's native web_search entry: built-ins +
+// every connector tool. Same merge as agentic_tools_all(), minus the server-tool tail.
+fn agentic_tools_no_web() -> String {
+    let base: String = agentic_tools_literal()
+    let conn: String = connector_tools_json()
+    let base_inner: String = str_slice(base, 1, str_len(base) - 1)
+    let conn_inner: String = str_slice(conn, 1, str_len(conn) - 1)
+    let merged: String = if str_eq(conn_inner, "") {
+        base_inner
+    } else {
+        base_inner + "," + conn_inner
+    }
+    return "[" + strip_client_web_search(merged) + "]"
+}
+
+// openai_agentic_loop — the resumable agentic turn on the OpenAI wire. Same two envelopes
+// as agentic_loop (done / tool_pending), same client-bridge contract, same state keys.
+// [tools_json] arrives ANTHROPIC-shaped (the bridge blob stays wire-uniform); it is
+// converted once here. The system prompt travels as the first message (no top-level
+// "system" on this wire).
+fn openai_agentic_loop(session_id: String, model: String, safe_sys: String, tools_json: String, messages_in: String, tools_log_in: String) -> String {
+    let api_url: String = llm_base_url() + "/chat/completions"
+    let api_key: String = agentic_api_key()
+    let h: Map = {}
+    map_set(h, "content-type", "application/json")
+    if !str_eq(api_key, "") {
+        map_set(h, "Authorization", "Bearer " + api_key)
+    }
+    let ask_all: Bool = !str_eq(session_id, "") && str_eq(state_get("require_approval_" + session_id), "true")
+    let tools_oai: String = openai_tools_json(tools_json)
+    let has_tools: Bool = json_array_len(tools_oai) > 0
+
+    let messages: String = messages_in
+    let final_text: String = ""
+    let tools_log: String = tools_log_in
+    let iteration: Int = 0
+    let keep_going: Bool = true
+
+    // Suspension state — top level so it escapes the while body (El scope rule).
+    let pending: Bool = false
+    let pend_tool_id: String = ""
+    let pend_tool_name: String = ""
+    let pend_tool_input: String = ""
+    let pend_tool_tier: String = ""
+    let pend_narration: String = ""
+
+    if !str_eq(session_id, "") {
+        state_set("run_progress_" + session_id, "")
+    }
+
+    while keep_going && iteration < 12 {
+        let inner_msgs: String = str_slice(messages, 1, str_len(messages) - 1)
+        let all_msgs: String = if str_eq(inner_msgs, "") {
+            "[{\"role\":\"system\",\"content\":\"" + safe_sys + "\"}]"
+        } else {
+            "[{\"role\":\"system\",\"content\":\"" + safe_sys + "\"}," + inner_msgs + "]"
+        }
+        // tools + the ADR-0005 mirror travel only when there are tools to offer: an empty
+        // tools array is a 400 on real OpenAI-format providers.
+        let tool_frag: String = if has_tools {
+            ",\"tools\":" + tools_oai + ",\"tool_choice\":\"auto\",\"parallel_tool_calls\":false"
+        } else { "" }
+        let req_body: String = "{\"model\":\"" + model + "\""
+            + ",\"max_tokens\":16384"
+            + tool_frag
+            + ",\"messages\":" + all_msgs
+            + "}"
+
+        let raw_resp: String = http_post_with_headers(api_url, req_body, h)
+        // OpenAI-format errors arrive as a top-level {"error":{...}} object. Content
+        // strings inside a valid response are JSON-escaped, so a top-level match cannot
+        // false-positive on reply text.
+        let is_error: Bool = str_eq(raw_resp, "") || str_starts_with(raw_resp, "{\"error\"")
+        if is_error {
+            let err_head: String = if str_len(raw_resp) > 220 { str_slice(raw_resp, 0, 220) } else { raw_resp }
+            println("[soul] llm error (openai lane): " + err_head)
+            return "{\"error\":\"llm unavailable\",\"reply\":\"\"}"
+        }
+
+        let choices: String = json_get_raw(raw_resp, "choices")
+        let eff_choices: String = if str_eq(choices, "") { "[]" } else { choices }
+        if json_array_len(eff_choices) < 1 {
+            // Log the body head, as the error branch does. A provider that answers 200
+            // with an unexpected shape is otherwise undiagnosable from the log alone.
+            let noc_head: String = if str_len(raw_resp) > 220 { str_slice(raw_resp, 0, 220) } else { raw_resp }
+            println("[soul] llm error (openai lane): no choices in response: " + noc_head)
+            return "{\"error\":\"llm unavailable\",\"reply\":\"\"}"
+        }
+        let first: String = json_array_get(eff_choices, 0)
+        let message_o: String = json_get_raw(first, "message")
+        let finish: String = json_get(first, "finish_reason")
+        // Content, read TWO ways on purpose.
+        //   content_raw — the provider's own bytes: `null` on a pure tool-call turn, or a
+        //     quoted, already-escaped string. This is what goes back on the wire, verbatim.
+        //   text_out    — the DECODED text, for narration, the ledger and the final reply.
+        // json_get decodes, and a JSON null decodes to the 4-char string "null", which is
+        // never "" — so without the raw check a pure tool-call turn produced the literal
+        // word "null" as the assistant's narration, in the run-progress ledger, and inside
+        // the tool_pending envelope, and echoed `"content":"null"` instead of `content:null`.
+        let content_raw: String = json_get_raw(message_o, "content")
+        let is_null_content: Bool = str_eq(content_raw, "null") || str_eq(content_raw, "")
+        let text_out: String = if is_null_content { "" } else { json_get(message_o, "content") }
+        let tc_raw: String = json_get_raw(message_o, "tool_calls")
+        let tc_arr: String = if str_eq(tc_raw, "") || str_eq(tc_raw, "null") { "[]" } else { tc_raw }
+        let tc_n: Int = json_array_len(tc_arr)
+        let has_tool: Bool = tc_n > 0
+
+        // ADR-0005 mirror: we ask for one call per round; a provider that returns
+        // several anyway gets the FIRST honored and the drop logged loudly.
+        if tc_n > 1 {
+            println("[soul] DRIFT: provider returned " + int_to_str(tc_n) + " parallel tool_calls despite parallel_tool_calls:false - keeping the first only (ADR-0005 mirror)")
+        }
+        // Unknown finish reasons (future API drift): log loudly, never treat an
+        // unrecognised terminal state as a completed answer silently.
+        if !str_eq(finish, "stop") && !str_eq(finish, "tool_calls") && !str_eq(finish, "length") && !str_eq(finish, "") {
+            println("[soul] DRIFT: unknown finish_reason from API: " + finish)
+        }
+
+        let tc0: String = if has_tool { json_array_get(tc_arr, 0) } else { "" }
+        let tool_id: String = if has_tool { json_get(tc0, "id") } else { "" }
+        let tc_fn: String = if has_tool { json_get_raw(tc0, "function") } else { "" }
+        let tool_name: String = if has_tool { json_get(tc_fn, "name") } else { "" }
+        // arguments is a JSON-ENCODED STRING on this wire; json_get decodes it exactly
+        // once, yielding the raw object text dispatch_tool expects. Decoding again — or
+        // re-encoding before dispatch — is the two-escaper trap the gate's echo-mismatch
+        // check exists to catch.
+        let tool_input_raw: String = if has_tool { json_get(tc_fn, "arguments") } else { "" }
+        let tool_input: String = if str_eq(tool_input_raw, "") { "{}" } else { tool_input_raw }
+
+        let is_tool_turn: Bool = has_tool
+
+        // Consent policy — IDENTICAL to the Anthropic lane: ask_all bridges everything,
+        // escalate always bridges, non-builtins bridge unless "always allow" granted.
+        let always_key: String = "always_allow_" + session_id
+        let always_list: String = if !str_eq(session_id, "") { state_get(always_key) } else { "" }
+        let is_always_allowed: Bool = !str_eq(tool_name, "") && !str_eq(always_list, "") && str_contains(always_list, tool_name)
+        let risk_tier: String = if is_tool_turn { classify_tool_risk(tool_name, tool_input) } else { "" }
+        let needs_bridge: Bool = is_tool_turn && (ask_all || str_eq(risk_tier, "escalate") || (!is_builtin_tool(tool_name) && !is_always_allowed))
+
+        let tool_result_raw: String = if is_tool_turn && !needs_bridge { dispatch_tool(tool_name, tool_input) } else { "" }
+        let tool_result: String = if str_len(tool_result_raw) > 6000 {
+            json_trim_dangling_escape(str_slice(tool_result_raw, 0, 6000)) + "...[truncated]"
+        } else { tool_result_raw }
+
+        let tool_quoted: String = "\"" + tool_name + "\""
+        let tools_log = if is_tool_turn {
+            if str_eq(tools_log, "") { tool_quoted } else { tools_log + "," + tool_quoted }
+        } else { tools_log }
+
+        // The assistant turn echoed with its tool_calls array VERBATIM (raw), so the
+        // tool_call_id pairing stays valid on the wire and across a bridge resume.
+        // Echo the provider's content BYTES, never a re-escaped round-trip. Decoding and
+        // re-encoding is where fidelity is lost: json_escape/json_safe both handle only
+        // \\ " \n \r, so any other control character the model emits (a tab, say) would go
+        // back out raw and make the next request body invalid JSON — a provider 400 that
+        // looks like a random failure. The Anthropic lane never had this exposure because
+        // it echoes the response's content array untouched; this now matches it.
+        let content_frag: String = if is_null_content { "null" } else { content_raw }
+        // Echo ONLY the call we actually honor — never the provider's full array.
+        // The loop can assemble exactly one tool response per round, so replaying N
+        // tool_calls while answering one leaves the conversation self-contradictory and
+        // every OpenAI-format provider 400s on the next request ("no tool response for
+        // id X"). That is precisely the failure ADR-0005 documents on the Anthropic wire,
+        // where the block walk keeps the first tool_use and the rest die without a
+        // tool_result. Here it costs one slice to close: the dropped calls simply never
+        // existed from the model's point of view, and the DRIFT line above keeps the
+        // accounting honest about what we discarded.
+        let assist_turn: String = if has_tool {
+            "{\"role\":\"assistant\",\"content\":" + content_frag + ",\"tool_calls\":[" + tc0 + "]}"
+        } else {
+            "{\"role\":\"assistant\",\"content\":" + content_frag + "}"
+        }
+        let inner_now: String = str_slice(messages, 1, str_len(messages) - 1)
+        let messages_with_assistant: String = "[" + inner_now + "," + assist_turn + "]"
+
+        // Local built-in tool turn: append assistant echo + role:"tool" result, loop on.
+        let local_continue: Bool = is_tool_turn && !needs_bridge
+        let messages = if local_continue {
+            let inner2: String = str_slice(messages_with_assistant, 1, str_len(messages_with_assistant) - 1)
+            "[" + inner2 + ",{\"role\":\"tool\",\"tool_call_id\":\"" + tool_id + "\",\"content\":\"" + tool_result + "\"}]"
+        } else { messages }
+
+        // Live run-progress ledger — same key, same shape, same poller as the Anthropic
+        // lane; a forked loop that omitted this would silently kill live step rendering.
+        if !str_eq(session_id, "") {
+            let prog_key: String = "run_progress_" + session_id
+            let prog_prev: String = state_get(prog_key)
+            let prog_snip: String = if str_len(text_out) > 280 { str_slice(text_out, 0, 280) } else { text_out }
+            let prog_entry: String = "{\"i\":" + int_to_str(iteration)
+                + ",\"t\":\"" + json_safe(prog_snip) + "\""
+                + ",\"tool\":\"" + json_safe(tool_name) + "\"}"
+            let prog_next: String = if str_eq(prog_prev, "") { prog_entry } else { prog_prev + "," + prog_entry }
+            state_set(prog_key, prog_next)
+        }
+
+        // Bridge turn: persist the continuation (wire-tagged) and stop the loop.
+        let pending = if needs_bridge { true } else { pending }
+        let pend_tool_id = if needs_bridge { tool_id } else { pend_tool_id }
+        let pend_tool_name = if needs_bridge { tool_name } else { pend_tool_name }
+        let pend_tool_input = if needs_bridge { tool_input } else { pend_tool_input }
+        let pend_tool_tier = if needs_bridge { risk_tier } else { pend_tool_tier }
+        let pend_narration = if needs_bridge { text_out } else { pend_narration }
+        if needs_bridge {
+            bridge_save(session_id, model, safe_sys, tools_json, messages_with_assistant, tools_log, tool_id, "openai")
+        }
+
+        // Text accumulation: rounds are separated by tool executions, so the resume seam
+        // is unconditionally a boundary (same rule as the Anthropic loop's seam 2).
+        let final_text = if !is_tool_turn {
+            final_text + text_join_sep(final_text, text_out, true) + text_out
+        } else { final_text }
+        // Output cap hit mid-action (finish_reason "length" with a tool call pending).
+        let final_text = if str_eq(finish, "length") && has_tool {
+            final_text + "\n\n[Output limit reached mid-action - the last planned action did not run. Ask me to continue to finish it.]"
+        } else { final_text }
+        let keep_going = if local_continue { keep_going } else { false }
+        let iteration = iteration + 1
+    }
+
+    if pending {
+        let safe_in: String = if str_eq(pend_tool_input, "") { "{}" } else { pend_tool_input }
+        let tools_arr: String = if str_eq(tools_log, "") { "[]" } else { "[" + tools_log + "]" }
+        return "{\"tool_pending\":true"
+            + ",\"session_id\":\"" + session_id + "\""
+            + ",\"call_id\":\"" + pend_tool_id + "\""
+            + ",\"tool_name\":\"" + pend_tool_name + "\""
+            + ",\"tool_input\":" + safe_in
+            + ",\"risk_tier\":\"" + pend_tool_tier + "\""
+            + ",\"narration\":\"" + json_safe(pend_narration) + "\""
+            + ",\"model\":\"" + model + "\""
+            + ",\"agentic\":true"
+            + ",\"sources\":\"\""
+            + ",\"tools_used\":" + tools_arr + "}"
+    }
+
+    let final_text = receipt_strip(final_text)
+    if str_eq(final_text, "") {
+        let hit_cap: Bool = iteration >= 12
+        let err_msg: String = if hit_cap {
+            "agentic loop hit the 12-iteration cap without producing a final reply - task may be too complex or a tool call is looping"
+        } else {
+            "no response"
+        }
+        return "{\"error\":\"" + err_msg + "\",\"reply\":\"\",\"iterations\":" + int_to_str(iteration) + "}"
+    }
+
+    let safe_text: String = json_safe(final_text)
+    let tools_arr: String = if str_eq(tools_log, "") { "[]" } else { "[" + tools_log + "]" }
+    if !str_eq(session_id, "") {
+        let done_key: String = "run_progress_" + session_id
+        let done_prev: String = state_get(done_key)
+        let done_next: String = if str_eq(done_prev, "") { "{\"done\":true}" } else { done_prev + ",{\"done\":true}" }
+        state_set(done_key, done_next)
+    }
+    return "{\"reply\":\"" + safe_text + "\",\"model\":\"" + model + "\",\"agentic\":true,\"tools_used\":" + tools_arr + ",\"sources\":\"\",\"iterations\":" + int_to_str(iteration) + "}"
+}
+
 fn agentic_tools_literal() -> String {
     return "[" +
         "{\"name\":\"read_file\",\"description\":\"Read contents of a file from disk.\",\"input_schema\":{\"type\":\"object\",\"properties\":{\"path\":{\"type\":\"string\",\"description\":\"Absolute file path\"}},\"required\":[\"path\"]}}," +
@@ -2636,7 +3014,7 @@ fn handle_chat_agentic(body: String) -> String {
         let ag_continuity_snip: String = if ag_continuity_ok {
             let acn0: String = json_array_get(ag_continuity_nodes, 0)
             let acc: String = json_get(acn0, "content")
-            if str_len(acc) > 350 { str_slice(acc, 0, 350) } else { acc }
+            utf8_safe_slice(acc, 350)
         } else { "" }
         let ag_profile_bullets: String = session_preload_bullets(ag_profile_nodes2, 8, 350)
         let ag_work_bullets: String = session_preload_bullets(ag_work_nodes2, 6, 350)
@@ -2667,7 +3045,13 @@ fn handle_chat_agentic(body: String) -> String {
 " + ctx + ag_session_preload + receipt_rule()
 
     let api_key: String = agentic_api_key()
-    let tools_json: String = agentic_tools_all()
+    // Assemble the tool set ONCE, for the lane this turn will actually take. Both
+    // builders call connector_tools_json(), which is an HTTP round-trip to the
+    // connectors bridge on :7771 — computing both would pay that cost, and its timeout
+    // exposure, twice per turn. The OpenAI lane drops Anthropic's server-side
+    // web_search (it has no analogue on that wire and cannot execute there).
+    let tools_lane_openai: Bool = !str_eq(llm_base_url(), "") && str_eq(llm_wire_format(), "openai")
+    let tools_json: String = if tools_lane_openai { agentic_tools_no_web() } else { agentic_tools_all() }
     let safe_msg: String = json_safe(message)
     let safe_sys: String = json_safe(system)
 
@@ -2708,11 +3092,12 @@ fn handle_chat_agentic(body: String) -> String {
     // for the rest of the run. Absent/false = behavior identical to before this fix.
     let req_ask_all: String = json_get(body, "require_approval")
     state_set("require_approval_" + session_id, if str_eq(req_ask_all, "true") { "true" } else { "" })
-    // Provider fork: OpenAI-compatible providers (Ollama/OpenAI/Grok/Gemini) take the plain-completion
-    // path (v1, no tools); everything else stays on the Anthropic agentic loop (the default).
-    let use_openai: Bool = !str_eq(llm_base_url(), "") && str_eq(llm_wire_format(), "openai")
+    // Provider fork (v2 port, 2026-08-06): OpenAI-compatible providers now take their own
+    // AGENTIC loop — same tools (minus Anthropic-server web_search), same consent policy,
+    // same bridge contract. The Anthropic native path stays the default and is untouched.
+    let use_openai: Bool = tools_lane_openai
     let result: String = if use_openai {
-        openai_chat_complete(model, llm_base_url(), agentic_api_key(), safe_sys, messages)
+        openai_agentic_loop(session_id, model, safe_sys, tools_json, messages, "")
     } else {
         agentic_loop(session_id, model, safe_sys, tools_json, messages, h, "")
     }
@@ -3139,7 +3524,7 @@ fn agentic_loop(session_id: String, model: String, safe_sys: String, tools_json:
         // client's tool_result block. messages_with_assistant is only meaningful when a
         // tool was requested, so guard on needs_bridge before persisting.
         if needs_bridge {
-            bridge_save(session_id, model, safe_sys, tools_json, messages_with_assistant, tools_log, pend_tool_id)
+            bridge_save(session_id, model, safe_sys, tools_json, messages_with_assistant, tools_log, pend_tool_id, "anthropic")
         }
 
         // ACCUMULATE across pause/resume cycles instead of overwriting. A resumed turn
@@ -3221,7 +3606,7 @@ fn agentic_loop(session_id: String, model: String, safe_sys: String, tools_json:
 // single JSON blob in soul state so agentic_resume can rebuild the exact loop. The
 // stored `messages` already includes the assistant turn that requested the tool, so
 // resume just appends the client's tool_result for `tool_use_id`.
-fn bridge_save(session_id: String, model: String, safe_sys: String, tools_json: String, messages: String, tools_log: String, tool_use_id: String) -> Bool {
+fn bridge_save(session_id: String, model: String, safe_sys: String, tools_json: String, messages: String, tools_log: String, tool_use_id: String, wire: String) -> Bool {
     // Guard: empty messages or tools_json would produce syntactically invalid JSON.
     // Return false so the caller detects the failure rather than writing a corrupt
     // blob that agentic_resume would later resume with no context.
@@ -3251,10 +3636,13 @@ fn bridge_save(session_id: String, model: String, safe_sys: String, tools_json:
     // messages_raw — arbitrary model/user content — so neither raw extraction can
     // first-match into model-controlled bytes either. Do not reorder; do not add a
     // field after messages_raw.
+    // "wire" (v2 port, 2026-08-06) is a json_safe'd SCALAR and therefore sits with the
+    // other scalars BEFORE both raw fields, per the field-order rule above.
     let blob: String = "{\"model\":\"" + json_safe(model) + "\""
         + ",\"safe_sys\":\"" + json_safe(safe_sys) + "\""
         + ",\"tools_log\":\"" + json_safe(tools_log) + "\""
         + ",\"tool_use_id\":\"" + json_safe(tool_use_id) + "\""
+        + ",\"wire\":\"" + json_safe(wire) + "\""
         + ",\"tools_raw\":" + tools_json
         + ",\"messages_raw\":" + messages + "}"
     state_set("mcp_bridge:" + session_id, blob)
@@ -3310,14 +3698,52 @@ fn agentic_resume(session_id: String, tool_use_id: String, content: String) -> S
         str_slice(content, 0, 6000) + "...[truncated]"
     } else { content }
     let safe_result: String = json_safe(trimmed)
-    let tool_msg: String = "{\"type\":\"tool_result\",\"tool_use_id\":\"" + eff_use_id + "\",\"content\":\"" + safe_result + "\"}"
-
     let inner: String = str_slice(messages, 1, str_len(messages) - 1)
-    let resumed_messages: String = "[" + inner + ",{\"role\":\"user\",\"content\":[" + tool_msg + "]}]"
 
     // One-shot: clear the saved turn so a session_id can't be replayed.
     state_set("mcp_bridge:" + session_id, "")
 
+    // Wire-aware resume (v2 port, 2026-08-06): blobs written since the port carry a
+    // "wire" scalar ("anthropic" | "openai") among the scalar fields, where first-match
+    // scanning is safe (see bridge_save's field-order rule). A blob with no wire field
+    // is a legacy pre-port suspension — always Anthropic. On the OpenAI wire the
+    // client's result goes back as a role:"tool" turn keyed by tool_call_id, and a
+    // result for an already-answered id must never be re-sent (the resumed messages
+    // end at the assistant echo, so appending exactly one tool turn preserves that).
+    // Read "wire" from the blob's SCALAR HEAD ONLY — never the whole blob.
+    //
+    // json_get is a first-substring-match scanner. On a blob written by this binary the
+    // scalar sits ahead of the raw fields and wins, but on a LEGACY blob (suspended
+    // before this field existed) there is no match up front, so the scan runs on into
+    // messages_raw — model- and user-controlled bytes. A conversation that merely
+    // CONTAINS the literal "wire":"openai" would then misroute the resume onto the wrong
+    // loop and kill the run. That is exactly the round-9 defect (json_get(blob,
+    // "tool_use_id") matching a web_search_tool_result id inside the replayed
+    // conversation), and the fix is the same shape: bound the search.
+    //
+    // bridge_save guarantees every json_safe'd scalar precedes the bulk fields, so
+    // truncating at the earliest bulk key makes this deterministic — the decoy is not
+    // even inside the string we search. Both the current keys (tools_raw/messages_raw)
+    // and the pre-round-9 legacy ones (tools_json/messages) are covered.
+    let i_traw: Int = str_index_of(blob, ",\"tools_raw\":")
+    let i_tjson: Int = str_index_of(blob, ",\"tools_json\":")
+    let i_mraw: Int = str_index_of(blob, ",\"messages_raw\":")
+    let i_msgs: Int = str_index_of(blob, ",\"messages\":")
+    let cut1: Int = if i_traw > 0 { i_traw } else { str_len(blob) }
+    let cut2: Int = if i_tjson > 0 && i_tjson < cut1 { i_tjson } else { cut1 }
+    let cut3: Int = if i_mraw > 0 && i_mraw < cut2 { i_mraw } else { cut2 }
+    let cut: Int = if i_msgs > 0 && i_msgs < cut3 { i_msgs } else { cut3 }
+    let blob_head: String = str_slice(blob, 0, cut)
+    let wire: String = json_get(blob_head, "wire")
+    if str_eq(wire, "openai") {
+        let tool_msg_o: String = "{\"role\":\"tool\",\"tool_call_id\":\"" + eff_use_id + "\",\"content\":\"" + safe_result + "\"}"
+        let resumed_o: String = "[" + inner + "," + tool_msg_o + "]"
+        return openai_agentic_loop(session_id, model, safe_sys, tools_json, resumed_o, tools_log)
+    }
+
+    let tool_msg: String = "{\"type\":\"tool_result\",\"tool_use_id\":\"" + eff_use_id + "\",\"content\":\"" + safe_result + "\"}"
+    let resumed_messages: String = "[" + inner + ",{\"role\":\"user\",\"content\":[" + tool_msg + "]}]"
+
     let api_key: String = agentic_api_key()
     let h: Map = {}
     map_set(h, "x-api-key", api_key)
@@ -3493,7 +3919,11 @@ fn handle_dharma_room_turn_agentic(body: String) -> String {
     // Hard Bell: pre-LLM safety evaluation on agentic dharma room turns.
     let system = safety_augment_system(system, transcript)
 
-    let tools_json: String = agentic_tools_all()
+    // One assembly, for the lane this turn takes (see the same note in handle_chat_agentic:
+    // both builders hit the connectors bridge over HTTP, so computing both doubles the cost
+    // and the timeout exposure).
+    let use_openai_d: Bool = !str_eq(llm_base_url(), "") && str_eq(llm_wire_format(), "openai")
+    let tools_json: String = if use_openai_d { agentic_tools_no_web() } else { agentic_tools_all() }
     let safe_transcript: String = json_safe(transcript)
     let safe_sys: String = json_safe(system)
     let messages: String = "[{\"role\":\"user\",\"content\":\"" + safe_transcript + "\"}]"
@@ -3504,7 +3934,14 @@ fn handle_dharma_room_turn_agentic(body: String) -> String {
 
     // Use dharma-prefixed session_id so bridge suspension works correctly per room.
     let session_id: String = if str_eq(room_id, "") { "dharma:" + next_bridge_id() } else { "dharma:" + room_id }
-    let loop_result: String = agentic_loop(session_id, model, safe_sys, tools_json, messages, h, "")
+    // Provider fork (v2 port, 2026-08-06): same routing rule as handle_chat_agentic.
+    // The Hard Bell augmentation above is baked into safe_sys BEFORE the fork, so the
+    // safety pass is identical on both wires.
+    let loop_result: String = if use_openai_d {
+        openai_agentic_loop(session_id, model, safe_sys, tools_json, messages, "")
+    } else {
+        agentic_loop(session_id, model, safe_sys, tools_json, messages, h, "")
+    }
 
     let result_error: String = json_get(loop_result, "error")
     if !str_eq(result_error, "") {

chat.elh

@@ -53,6 +53,11 @@ extern fn llm_base_url() -> String
 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 openai_tools_json(tools_anthropic: String) -> String
+extern fn utf8_safe_slice(s: String, n: Int) -> String
+extern fn json_trim_dangling_escape(s: String) -> String
+extern fn agentic_tools_no_web() -> String
+extern fn openai_agentic_loop(session_id: String, model: String, safe_sys: String, tools_json: String, messages_in: String, tools_log_in: 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
@@ -75,7 +80,7 @@ extern fn next_bridge_id() -> String
 extern fn handle_chat_plan(body: String) -> String
 extern fn handle_chat_agentic(body: String) -> String
 extern fn agentic_loop(session_id: String, model: String, safe_sys: String, tools_json: String, messages_in: String, h: Map, tools_log_in: String) -> String
-extern fn bridge_save(session_id: String, model: String, safe_sys: String, tools_json: String, messages: String, tools_log: String, tool_use_id: String) -> Bool
+extern fn bridge_save(session_id: String, model: String, safe_sys: String, tools_json: String, messages: String, tools_log: String, tool_use_id: String, wire: String) -> Bool
 extern fn agentic_resume(session_id: String, tool_use_id: String, content: String) -> String
 extern fn handle_tool_result(session_id: String, body: String) -> String
 extern fn handle_chat_as_soul(body: String) -> String

dist/awareness.c

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

dist/elp-c-decls.h

@@ -29,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_copula(el_val_t tense, el_val_t slot);
 el_val_t akk_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number);
+el_val_t akk_conjugate_copula(el_val_t tense, el_val_t slot);
 el_val_t akk_copula_present(el_val_t slot);
 el_val_t akk_copula_stative(el_val_t slot);
 el_val_t akk_decline(el_val_t noun, el_val_t gram_case, el_val_t number);
@@ -48,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_g(el_val_t person, el_val_t gender, el_val_t number);
 el_val_t akk_slot(el_val_t person, el_val_t number);
+el_val_t akk_slot_g(el_val_t person, el_val_t gender, el_val_t number);
 el_val_t akk_str_drop_last(el_val_t s, el_val_t n);
 el_val_t akk_str_ends(el_val_t s, el_val_t suf);
 el_val_t akk_str_len(el_val_t s);
 el_val_t akk_strip_nom(el_val_t noun);
+el_val_t ang_article(el_val_t gender, el_val_t gram_case, el_val_t number);
 el_val_t ang_article_feminine(el_val_t gram_case, el_val_t number);
 el_val_t ang_article_masculine(el_val_t gram_case, el_val_t number);
 el_val_t ang_article_neuter(el_val_t gram_case, el_val_t number);
-el_val_t ang_article(el_val_t gender, el_val_t gram_case, el_val_t number);
 el_val_t ang_beon_present(el_val_t slot);
 el_val_t ang_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number);
 el_val_t ang_cuman_past(el_val_t slot);
 el_val_t ang_cuman_present(el_val_t slot);
 el_val_t ang_declension(el_val_t noun, el_val_t gender);
+el_val_t ang_decline(el_val_t noun, el_val_t gram_case, el_val_t number, el_val_t gender);
 el_val_t ang_decline_strong_masc(el_val_t noun, el_val_t gram_case, el_val_t number);
 el_val_t ang_decline_strong_neut(el_val_t noun, el_val_t gram_case, el_val_t number);
 el_val_t ang_decline_weak(el_val_t noun, el_val_t gram_case, el_val_t number);
-el_val_t ang_decline(el_val_t noun, el_val_t gram_case, el_val_t number, el_val_t gender);
 el_val_t ang_don_past(el_val_t slot);
 el_val_t ang_don_present(el_val_t slot);
 el_val_t ang_gan_past(el_val_t slot);
@@ -85,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_last_char(el_val_t s);
 el_val_t ang_str_last2(el_val_t s);
-el_val_t ang_weak_past_stem(el_val_t stem);
+el_val_t ang_str_last_char(el_val_t s);
 el_val_t ang_weak_past(el_val_t stem, el_val_t slot);
+el_val_t ang_weak_past_stem(el_val_t stem);
 el_val_t ang_weak_present_ending(el_val_t slot);
 el_val_t ang_weak_stem(el_val_t verb);
 el_val_t ang_wesan_past(el_val_t slot);
@@ -97,30 +97,35 @@ el_val_t ang_willan_past(el_val_t slot);
 el_val_t ang_willan_present(el_val_t slot);
 el_val_t ang_witan_past(el_val_t slot);
 el_val_t ang_witan_present(el_val_t slot);
-el_val_t api_err_protected(el_val_t id);
+el_val_t api_compact_activated(el_val_t raw, el_val_t max_items, el_val_t snip);
+el_val_t api_compact_node(el_val_t node, el_val_t snip);
+el_val_t api_compact_node_array(el_val_t raw, el_val_t max_items, el_val_t snip);
 el_val_t api_err(el_val_t msg);
+el_val_t api_err_protected(el_val_t id);
 el_val_t api_json_escape(el_val_t s);
 el_val_t api_nonempty(el_val_t s);
 el_val_t api_not_persisted(el_val_t id);
+el_val_t api_num_or_zero(el_val_t obj, el_val_t key);
 el_val_t api_ok(el_val_t extra);
 el_val_t api_or_empty(el_val_t s);
 el_val_t api_persisted(el_val_t id);
 el_val_t api_query_int(el_val_t path, el_val_t key, el_val_t default_val);
 el_val_t api_query_param(el_val_t path, el_val_t key);
+el_val_t api_utf8_trunc(el_val_t s, el_val_t n);
 el_val_t ar_case_ending(el_val_t kase, el_val_t definite);
-el_val_t ar_conjugate_form1(el_val_t past_base, el_val_t present_stem, el_val_t tense, el_val_t slot);
 el_val_t ar_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t gender, el_val_t number);
+el_val_t ar_conjugate_form1(el_val_t past_base, el_val_t present_stem, el_val_t tense, el_val_t slot);
 el_val_t ar_definite_article(el_val_t noun);
 el_val_t ar_gender(el_val_t noun);
 el_val_t ar_imperfect_prefix(el_val_t slot);
 el_val_t ar_imperfect_suffix(el_val_t slot);
+el_val_t ar_irregular(el_val_t verb, el_val_t tense, el_val_t slot);
 el_val_t ar_irregular_araada(el_val_t slot, el_val_t tense);
 el_val_t ar_irregular_istata(el_val_t slot, el_val_t tense);
 el_val_t ar_irregular_jaa(el_val_t slot, el_val_t tense);
 el_val_t ar_irregular_kaana(el_val_t slot, el_val_t tense);
 el_val_t ar_irregular_qaala(el_val_t slot, el_val_t tense);
 el_val_t ar_irregular_raaa(el_val_t slot, el_val_t tense);
-el_val_t ar_irregular(el_val_t verb, el_val_t tense, el_val_t slot);
 el_val_t ar_is_sun_letter(el_val_t c);
 el_val_t ar_masc_pl_ending(el_val_t kase);
 el_val_t ar_noun_form(el_val_t noun, el_val_t gender, el_val_t kase, el_val_t number, el_val_t definite);
@@ -141,7 +146,7 @@ el_val_t awareness_run(void);
 el_val_t axon_get(el_val_t path);
 el_val_t axon_post(el_val_t path, el_val_t body);
 el_val_t bounded_persona_floor(void);
-el_val_t bridge_save(el_val_t session_id, el_val_t model, el_val_t safe_sys, el_val_t tools_json, el_val_t messages, el_val_t tools_log, el_val_t tool_use_id);
+el_val_t bridge_save(el_val_t session_id, el_val_t model, el_val_t safe_sys, el_val_t tools_json, el_val_t messages, el_val_t tools_log, el_val_t tool_use_id, el_val_t wire);
 el_val_t build_form_from_json(el_val_t semantic_form_json, el_val_t lang_code);
 el_val_t build_np(el_val_t referent, el_val_t slots);
 el_val_t build_pp(el_val_t loc);
@@ -187,8 +192,8 @@ el_val_t cop_map_canonical(el_val_t verb);
 el_val_t cop_nau_future(el_val_t prefix);
 el_val_t cop_nau_perfect(el_val_t prefix);
 el_val_t cop_nau_present(el_val_t prefix);
-el_val_t cop_noun_phrase_gendered(el_val_t noun, el_val_t gram_case, el_val_t number, el_val_t definite, el_val_t gender);
 el_val_t cop_noun_phrase(el_val_t noun, el_val_t gram_case, el_val_t number, el_val_t definite);
+el_val_t cop_noun_phrase_gendered(el_val_t noun, el_val_t gram_case, el_val_t number, el_val_t definite, el_val_t gender);
 el_val_t cop_regular_future(el_val_t prefix, el_val_t stem);
 el_val_t cop_regular_perfect(el_val_t prefix, el_val_t stem);
 el_val_t cop_regular_present(el_val_t prefix, el_val_t stem);
@@ -198,16 +203,16 @@ el_val_t cop_shwpe_present(el_val_t prefix);
 el_val_t cop_slot(el_val_t person, el_val_t number);
 el_val_t cop_str_ends(el_val_t s, el_val_t suf);
 el_val_t cop_str_len(el_val_t s);
-el_val_t cop_subject_prefix_gendered(el_val_t person, el_val_t gender, el_val_t number);
 el_val_t cop_subject_prefix(el_val_t person, el_val_t number);
+el_val_t cop_subject_prefix_gendered(el_val_t person, el_val_t gender, el_val_t number);
 el_val_t current_engine_note(el_val_t model);
 el_val_t de_adj_ending(el_val_t gender, el_val_t gram_case, el_val_t number, el_val_t article_type);
+el_val_t de_article(el_val_t gender, el_val_t gram_case, el_val_t number, el_val_t definite);
 el_val_t de_article_def(el_val_t gender, el_val_t gram_case, el_val_t number);
 el_val_t de_article_indef(el_val_t gender, el_val_t gram_case, el_val_t number);
-el_val_t de_article(el_val_t gender, el_val_t gram_case, el_val_t number, el_val_t definite);
 el_val_t de_case_ending(el_val_t noun, el_val_t gender, el_val_t gram_case, el_val_t number);
-el_val_t de_conjugate_weak(el_val_t stem, el_val_t tense, el_val_t person, el_val_t number);
 el_val_t de_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number);
+el_val_t de_conjugate_weak(el_val_t stem, el_val_t tense, el_val_t person, el_val_t number);
 el_val_t de_irregular_present(el_val_t verb, el_val_t person, el_val_t number);
 el_val_t de_norm_number(el_val_t number);
 el_val_t de_norm_person(el_val_t person);
@@ -217,12 +222,15 @@ el_val_t dharma_network_state(void);
 el_val_t dharma_registry(void);
 el_val_t dispatch_tool(el_val_t tool_name, el_val_t tool_input);
 el_val_t distill_transcript(el_val_t transcript);
-el_val_t egy_conjugate_copula(el_val_t tense, el_val_t slot);
-el_val_t egy_conjugate_pronoun(el_val_t person, el_val_t number);
-el_val_t egy_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number);
 el_val_t egy_Dd_future(el_val_t slot);
 el_val_t egy_Dd_past(el_val_t slot);
 el_val_t egy_Dd_present(el_val_t slot);
+el_val_t egy_Sm_future(el_val_t slot);
+el_val_t egy_Sm_past(el_val_t slot);
+el_val_t egy_Sm_present(el_val_t slot);
+el_val_t egy_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number);
+el_val_t egy_conjugate_copula(el_val_t tense, el_val_t slot);
+el_val_t egy_conjugate_pronoun(el_val_t person, el_val_t number);
 el_val_t egy_decline(el_val_t noun, el_val_t gram_case, el_val_t number);
 el_val_t egy_drop(el_val_t s, el_val_t n);
 el_val_t egy_fem(el_val_t noun);
@@ -246,11 +254,8 @@ el_val_t egy_regular_present(el_val_t stem, el_val_t slot);
 el_val_t egy_sdm_future(el_val_t slot);
 el_val_t egy_sdm_past(el_val_t slot);
 el_val_t egy_sdm_present(el_val_t slot);
-el_val_t egy_slot_with_gender(el_val_t person, el_val_t gender, el_val_t number);
 el_val_t egy_slot(el_val_t person, el_val_t number);
-el_val_t egy_Sm_future(el_val_t slot);
-el_val_t egy_Sm_past(el_val_t slot);
-el_val_t egy_Sm_present(el_val_t slot);
+el_val_t egy_slot_with_gender(el_val_t person, el_val_t gender, el_val_t number);
 el_val_t egy_str_ends(el_val_t s, el_val_t suf);
 el_val_t egy_str_len(el_val_t s);
 el_val_t egy_suffix_pronoun(el_val_t slot);
@@ -271,9 +276,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);
@@ -339,9 +344,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);
@@ -384,8 +389,8 @@ el_val_t fr_slot(el_val_t person, el_val_t number);
 el_val_t fr_stem(el_val_t base);
 el_val_t fr_str_drop_last(el_val_t s, el_val_t n);
 el_val_t fr_str_ends(el_val_t s, el_val_t suf);
-el_val_t fr_str_last_char(el_val_t s);
 el_val_t fr_str_last2(el_val_t s);
+el_val_t fr_str_last_char(el_val_t s);
 el_val_t fr_subject_starts_vowel(el_val_t subject);
 el_val_t fr_uses_etre(el_val_t verb);
 el_val_t fr_verb_ends_vowel(el_val_t verb_form);
@@ -407,9 +412,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);
@@ -427,15 +432,15 @@ el_val_t fro_venir_past(el_val_t slot);
 el_val_t fro_venir_present(el_val_t slot);
 el_val_t fro_verb_class(el_val_t verb);
 el_val_t fro_verb_stem(el_val_t verb, el_val_t vclass);
-el_val_t generate_frame_lang(el_val_t frame, el_val_t lang_code);
+el_val_t generate(el_val_t semantic_form_json);
 el_val_t generate_frame(el_val_t frame);
+el_val_t generate_frame_lang(el_val_t frame, el_val_t lang_code);
 el_val_t generate_lang(el_val_t semantic_form_json, el_val_t lang_code);
 el_val_t generate_tree(el_val_t rule_id_str, el_val_t slots);
-el_val_t generate(el_val_t semantic_form_json);
 el_val_t get_rules(void);
 el_val_t get_vocab(void);
-el_val_t gez_conjugate_copula(el_val_t tense, el_val_t slot);
 el_val_t gez_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number);
+el_val_t gez_conjugate_copula(el_val_t tense, el_val_t slot);
 el_val_t gez_decline(el_val_t noun, el_val_t gram_case, el_val_t number);
 el_val_t gez_generic_imperfect(el_val_t base3sg, el_val_t slot);
 el_val_t gez_generic_perfect(el_val_t base3sg, el_val_t slot);
@@ -454,12 +459,13 @@ el_val_t gez_qwl_imperfect(el_val_t slot);
 el_val_t gez_qwl_perfect(el_val_t slot);
 el_val_t gez_ray_imperfect(el_val_t slot);
 el_val_t gez_ray_perfect(el_val_t slot);
-el_val_t gez_slot_g(el_val_t person, el_val_t gender, el_val_t number);
 el_val_t gez_slot(el_val_t person, el_val_t number);
+el_val_t gez_slot_g(el_val_t person, el_val_t gender, el_val_t number);
 el_val_t gez_str_drop_last(el_val_t s, el_val_t n);
 el_val_t gez_str_ends(el_val_t s, el_val_t suf);
 el_val_t gez_str_len(el_val_t s);
 el_val_t goh_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number);
+el_val_t goh_decline(el_val_t noun, el_val_t gram_case, el_val_t number);
 el_val_t goh_decline_fem_o_pl(el_val_t stem, el_val_t gram_case);
 el_val_t goh_decline_fem_o_sg(el_val_t stem, el_val_t gram_case);
 el_val_t goh_decline_masc_a_pl(el_val_t stem, el_val_t gram_case);
@@ -468,7 +474,6 @@ el_val_t goh_decline_masc_n_pl(el_val_t stem, el_val_t gram_case);
 el_val_t goh_decline_masc_n_sg(el_val_t stem, el_val_t gram_case);
 el_val_t goh_decline_neut_a_pl(el_val_t stem, el_val_t gram_case);
 el_val_t goh_decline_neut_a_sg(el_val_t stem, el_val_t gram_case);
-el_val_t goh_decline(el_val_t noun, el_val_t gram_case, el_val_t number);
 el_val_t goh_demo_article(el_val_t stype, el_val_t number);
 el_val_t goh_drop(el_val_t s, el_val_t n);
 el_val_t goh_extract_stem(el_val_t noun, el_val_t stype);
@@ -493,13 +498,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);
@@ -532,17 +537,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);
@@ -569,9 +574,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);
@@ -603,17 +608,17 @@ el_val_t handle_api_recall(el_val_t method, el_val_t path, el_val_t body);
 el_val_t handle_api_remember(el_val_t body);
 el_val_t handle_api_search_knowledge(el_val_t method, el_val_t path, el_val_t body);
 el_val_t handle_api_tune_config(el_val_t body);
+el_val_t handle_chat(el_val_t body);
 el_val_t handle_chat_agentic(el_val_t body);
 el_val_t handle_chat_as_soul(el_val_t body);
 el_val_t handle_chat_plan(el_val_t body);
-el_val_t handle_chat(el_val_t body);
 el_val_t handle_config(el_val_t method, el_val_t body);
 el_val_t handle_connectors(el_val_t method, el_val_t clean, el_val_t body);
 el_val_t handle_conversations(el_val_t method);
-el_val_t handle_dharma_recv(el_val_t body);
-el_val_t handle_dharma_room_turn_agentic(el_val_t body);
-el_val_t handle_dharma_room_turn(el_val_t body);
 el_val_t handle_dharma(el_val_t path, el_val_t method, el_val_t body);
+el_val_t handle_dharma_recv(el_val_t body);
+el_val_t handle_dharma_room_turn(el_val_t body);
+el_val_t handle_dharma_room_turn_agentic(el_val_t body);
 el_val_t handle_elp_chat(el_val_t body);
 el_val_t handle_nlg(el_val_t path, el_val_t method, el_val_t body);
 el_val_t handle_request(el_val_t method, el_val_t path, el_val_t body);
@@ -621,11 +626,11 @@ el_val_t handle_safety_contact_get(void);
 el_val_t handle_safety_contact_post(el_val_t body);
 el_val_t handle_see(el_val_t body);
 el_val_t handle_session_approve(el_val_t session_id, el_val_t body);
-el_val_t handle_tool_result(el_val_t session_id, el_val_t body);
 el_val_t handle_tool(el_val_t path, el_val_t method, el_val_t body);
+el_val_t handle_tool_result(el_val_t session_id, el_val_t body);
 el_val_t hard_bell_threshold(void);
-el_val_t he_conjugate_copula(el_val_t tense, el_val_t slot);
 el_val_t he_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t gender, el_val_t number);
+el_val_t he_conjugate_copula(el_val_t tense, el_val_t slot);
 el_val_t he_copula_future(el_val_t slot);
 el_val_t he_copula_past(el_val_t slot);
 el_val_t he_definite_prefix(el_val_t noun);
@@ -653,6 +658,7 @@ el_val_t he_str_drop_last(el_val_t s, el_val_t n);
 el_val_t he_str_ends(el_val_t s, el_val_t suf);
 el_val_t he_str_last_char(el_val_t s);
 el_val_t he_str_len(el_val_t s);
+el_val_t hebb_consolidate(void);
 el_val_t hi_agree_genitive(el_val_t possessed_gender, el_val_t possessed_number);
 el_val_t hi_aux_present(el_val_t person, el_val_t number);
 el_val_t hi_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t gender, el_val_t number);
@@ -662,12 +668,12 @@ el_val_t hi_genitive_phrase(el_val_t possessor, el_val_t possessor_gender, el_va
 el_val_t hi_hona_past(el_val_t gender, el_val_t number);
 el_val_t hi_hona_present(el_val_t person, el_val_t number);
 el_val_t hi_masc_aa_stem(el_val_t noun);
+el_val_t hi_noun_direct(el_val_t noun, el_val_t gender, el_val_t number);
 el_val_t hi_noun_direct_f(el_val_t noun, el_val_t number);
 el_val_t hi_noun_direct_m(el_val_t noun, el_val_t number);
-el_val_t hi_noun_direct(el_val_t noun, el_val_t gender, el_val_t number);
+el_val_t hi_noun_oblique(el_val_t noun, el_val_t gender, el_val_t number);
 el_val_t hi_noun_oblique_f(el_val_t noun, el_val_t number);
 el_val_t hi_noun_oblique_m(el_val_t noun, el_val_t number);
-el_val_t hi_noun_oblique(el_val_t noun, el_val_t gender, el_val_t number);
 el_val_t hi_noun_with_post(el_val_t noun, el_val_t gender, el_val_t number, el_val_t gram_case);
 el_val_t hi_past_irregular(el_val_t stem, el_val_t gender, el_val_t number);
 el_val_t hi_past_suffix(el_val_t gender, el_val_t number);
@@ -677,11 +683,11 @@ el_val_t hi_str_drop_last(el_val_t s, el_val_t n);
 el_val_t hi_str_ends(el_val_t s, el_val_t suf);
 el_val_t hi_str_last_char(el_val_t s);
 el_val_t hi_tense_suffix(el_val_t tense, el_val_t gender, el_val_t number);
-el_val_t hi_verb_stem_clean(el_val_t infinitive);
 el_val_t hi_verb_stem(el_val_t infinitive);
+el_val_t hi_verb_stem_clean(el_val_t infinitive);
 el_val_t hist_append(el_val_t hist, el_val_t role, el_val_t content);
-el_val_t hist_trim_with_bell_guard(el_val_t hist);
 el_val_t hist_trim(el_val_t hist);
+el_val_t hist_trim_with_bell_guard(el_val_t hist);
 el_val_t id_in_seen(el_val_t node_id, el_val_t seen);
 el_val_t idle_count(void);
 el_val_t idle_inc(void);
@@ -712,6 +718,7 @@ el_val_t json_escape(el_val_t s);
 el_val_t json_safe(el_val_t s);
 el_val_t la_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number);
 el_val_t la_declension(el_val_t noun);
+el_val_t la_decline(el_val_t noun, el_val_t gram_case, el_val_t number);
 el_val_t la_decline_1(el_val_t stem, el_val_t gram_case, el_val_t number);
 el_val_t la_decline_2er(el_val_t noun, el_val_t gram_case, el_val_t number);
 el_val_t la_decline_2m(el_val_t stem, el_val_t gram_case, el_val_t number);
@@ -719,7 +726,6 @@ el_val_t la_decline_2n(el_val_t stem, el_val_t gram_case, el_val_t number);
 el_val_t la_decline_3(el_val_t noun, el_val_t gram_case, el_val_t number);
 el_val_t la_decline_4(el_val_t stem, el_val_t gram_case, el_val_t number);
 el_val_t la_decline_5(el_val_t stem, el_val_t gram_case, el_val_t number);
-el_val_t la_decline(el_val_t noun, el_val_t gram_case, el_val_t number);
 el_val_t la_esse_future(el_val_t slot);
 el_val_t la_esse_past(el_val_t slot);
 el_val_t la_esse_present(el_val_t slot);
@@ -743,9 +749,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);
@@ -762,6 +768,7 @@ el_val_t lang_is_fusional(el_val_t profile);
 el_val_t lang_is_isolating(el_val_t profile);
 el_val_t lang_is_polysynthetic(el_val_t profile);
 el_val_t lang_is_rtl(el_val_t profile);
+el_val_t lang_profile(el_val_t code, el_val_t word_order, el_val_t morph_type, el_val_t has_case, el_val_t has_gender, el_val_t script_dir, el_val_t agreement, el_val_t null_subject);
 el_val_t lang_profile_akk(void);
 el_val_t lang_profile_ang(void);
 el_val_t lang_profile_ar(void);
@@ -793,7 +800,6 @@ el_val_t lang_profile_sw(void);
 el_val_t lang_profile_txb(void);
 el_val_t lang_profile_uga(void);
 el_val_t lang_profile_zh(void);
-el_val_t lang_profile(el_val_t code, el_val_t word_order, el_val_t morph_type, el_val_t has_case, el_val_t has_gender, el_val_t script_dir, el_val_t agreement, el_val_t null_subject);
 el_val_t lang_word_order(el_val_t profile);
 el_val_t layered_cycle(el_val_t raw_input, el_val_t 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);
@@ -845,10 +851,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);
@@ -875,6 +881,11 @@ el_val_t non_weak_past(el_val_t stem, el_val_t slot);
 el_val_t non_weak_present(el_val_t stem, el_val_t slot);
 el_val_t one_cycle(void);
 el_val_t openai_chat_complete(el_val_t model, el_val_t base_url, el_val_t api_key, el_val_t safe_sys, el_val_t messages_json);
+el_val_t openai_tools_json(el_val_t tools_anthropic);
+el_val_t json_trim_dangling_escape(el_val_t s);
+el_val_t utf8_safe_slice(el_val_t s, el_val_t n);
+el_val_t agentic_tools_no_web(void);
+el_val_t openai_agentic_loop(el_val_t session_id, el_val_t model, el_val_t safe_sys, el_val_t tools_json, el_val_t messages_in, el_val_t tools_log_in);
 el_val_t parse_float_x100(el_val_t s);
 el_val_t path_within_root(el_val_t path, el_val_t root);
 el_val_t peo_ah_past(el_val_t slot);
@@ -882,8 +893,8 @@ el_val_t peo_ah_present(el_val_t slot);
 el_val_t peo_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number);
 el_val_t peo_da_past(el_val_t slot);
 el_val_t peo_da_present(el_val_t slot);
-el_val_t peo_decline_astem(el_val_t noun, el_val_t gram_case, el_val_t number);
 el_val_t peo_decline(el_val_t noun, el_val_t gram_case, el_val_t number);
+el_val_t peo_decline_astem(el_val_t noun, el_val_t gram_case, el_val_t number);
 el_val_t peo_drop(el_val_t s, el_val_t n);
 el_val_t peo_ends(el_val_t s, el_val_t suf);
 el_val_t peo_kar_past(el_val_t slot);
@@ -899,11 +910,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);
@@ -934,11 +945,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);
@@ -949,9 +960,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);
@@ -964,8 +975,8 @@ el_val_t ru_past_stem(el_val_t verb);
 el_val_t ru_stem_type(el_val_t noun, el_val_t gender);
 el_val_t rule_id(el_val_t rule);
 el_val_t rule_lhs(el_val_t rule);
-el_val_t rule_rhs_len(el_val_t rule);
 el_val_t rule_rhs(el_val_t rule, el_val_t idx);
+el_val_t rule_rhs_len(el_val_t rule);
 el_val_t run_command_guard(el_val_t cmd, el_val_t root);
 el_val_t run_command_is_readonly(el_val_t cmd);
 el_val_t sa_as_future(el_val_t slot);
@@ -979,11 +990,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);
@@ -1031,26 +1042,26 @@ el_val_t scan_token(el_val_t s, el_val_t start);
 el_val_t security_research_authorized(void);
 el_val_t seed_persona_from_env(void);
 el_val_t sem_first_modifier(el_val_t mods);
+el_val_t sem_frame(el_val_t intent, el_val_t subject, el_val_t obj, el_val_t modifiers);
 el_val_t sem_frame_lang(el_val_t intent, el_val_t subject, el_val_t obj, el_val_t modifiers, el_val_t lang_code);
 el_val_t sem_frame_obj(el_val_t intent, el_val_t subject, el_val_t obj);
 el_val_t sem_frame_simple(el_val_t intent, el_val_t subject);
-el_val_t sem_frame(el_val_t intent, el_val_t subject, el_val_t obj, el_val_t modifiers);
 el_val_t sem_get(el_val_t json, el_val_t key);
-el_val_t sem_intent_to_realize(el_val_t intent);
 el_val_t sem_intent(el_val_t frame);
+el_val_t sem_intent_to_realize(el_val_t intent);
 el_val_t sem_lang(el_val_t frame);
 el_val_t sem_modifiers(el_val_t frame);
 el_val_t sem_object(el_val_t frame);
+el_val_t sem_realize(el_val_t frame);
 el_val_t sem_realize_full(el_val_t frame, el_val_t verb, el_val_t tense, el_val_t aspect);
 el_val_t sem_realize_greet(el_val_t subject);
 el_val_t sem_realize_lang(el_val_t frame, el_val_t lang_code);
-el_val_t sem_realize(el_val_t frame);
 el_val_t sem_subject(el_val_t frame);
-el_val_t sem_to_spec_full(el_val_t frame, el_val_t verb, el_val_t tense, el_val_t aspect);
 el_val_t sem_to_spec(el_val_t frame);
+el_val_t sem_to_spec_full(el_val_t frame, el_val_t verb, el_val_t tense, el_val_t aspect);
 el_val_t session_auto_title(el_val_t session_id, el_val_t first_message);
-el_val_t session_create_cleanup(el_val_t session_id);
 el_val_t session_create(el_val_t body);
+el_val_t session_create_cleanup(el_val_t session_id);
 el_val_t session_delete(el_val_t session_id);
 el_val_t session_exists(el_val_t session_id);
 el_val_t session_get(el_val_t session_id);
@@ -1059,11 +1070,11 @@ el_val_t session_hist_save(el_val_t session_id, el_val_t hist);
 el_val_t session_list(void);
 el_val_t session_make_content(el_val_t id, el_val_t title, el_val_t created_at, el_val_t updated_at, el_val_t folder);
 el_val_t session_preload_bullets(el_val_t nodes, el_val_t max_bullets, el_val_t snip_len);
-el_val_t session_search_entry(el_val_t node);
 el_val_t session_search(el_val_t query);
+el_val_t session_search_entry(el_val_t node);
 el_val_t session_summary_autogenerate(el_val_t hist);
-el_val_t session_summary_write_dated(el_val_t summary_text, el_val_t label);
 el_val_t session_summary_write(el_val_t summary_text);
+el_val_t session_summary_write_dated(el_val_t summary_text, el_val_t label);
 el_val_t session_title_from_message(el_val_t message);
 el_val_t session_update_meta_timestamp(el_val_t session_id);
 el_val_t session_update_patch(el_val_t session_id, el_val_t body);
@@ -1074,9 +1085,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);
@@ -1104,9 +1115,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);
@@ -1133,8 +1144,8 @@ el_val_t sux_realize_sentence(el_val_t intent, el_val_t agent, el_val_t predicat
 el_val_t sux_slot(el_val_t person, el_val_t number);
 el_val_t sux_str_drop_last(el_val_t s, el_val_t n);
 el_val_t sux_str_ends(el_val_t s, el_val_t suf);
-el_val_t sux_str_last_char(el_val_t s);
 el_val_t sux_str_last2(el_val_t s);
+el_val_t sux_str_last_char(el_val_t s);
 el_val_t sux_tum2_past(el_val_t slot);
 el_val_t sux_tum2_present(el_val_t slot);
 el_val_t sux_verb_chain(el_val_t agent, el_val_t verb, el_val_t patient, el_val_t tense);
@@ -1152,9 +1163,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);
@@ -1172,9 +1183,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);
@@ -1189,8 +1200,8 @@ el_val_t txb_wes_present(el_val_t slot);
 el_val_t txb_ya_present(el_val_t slot);
 el_val_t uga_amr_imperfect(el_val_t slot);
 el_val_t uga_amr_perfect(el_val_t slot);
-el_val_t uga_conjugate_copula(el_val_t tense, el_val_t slot);
 el_val_t uga_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number);
+el_val_t uga_conjugate_copula(el_val_t tense, el_val_t slot);
 el_val_t uga_decline(el_val_t noun, el_val_t gram_case, el_val_t number);
 el_val_t uga_generic_imperfect(el_val_t base3sg, el_val_t slot);
 el_val_t uga_generic_perfect(el_val_t base3sg, el_val_t slot);
@@ -1205,8 +1216,8 @@ el_val_t uga_map_canonical(el_val_t verb);
 el_val_t uga_noun_phrase(el_val_t noun, el_val_t gram_case, el_val_t number, el_val_t definite);
 el_val_t uga_ray_imperfect(el_val_t slot);
 el_val_t uga_ray_perfect(el_val_t slot);
-el_val_t uga_slot_g(el_val_t person, el_val_t gender, el_val_t number);
 el_val_t uga_slot(el_val_t person, el_val_t number);
+el_val_t uga_slot_g(el_val_t person, el_val_t gender, el_val_t number);
 el_val_t uga_str_drop_last(el_val_t s, el_val_t n);
 el_val_t uga_str_ends(el_val_t s, el_val_t suf);
 el_val_t uga_str_len(el_val_t s);
@@ -1214,6 +1225,6 @@ el_val_t uga_strip_nom(el_val_t noun);
 el_val_t verb_form(el_val_t base, el_val_t tense, el_val_t person, el_val_t number);
 el_val_t vocab_by_class(el_val_t cls);
 el_val_t vocab_by_pos(el_val_t pos);
-el_val_t vocab_lookup_en(el_val_t word);
 el_val_t vocab_lookup(el_val_t word, el_val_t lang_code);
+el_val_t vocab_lookup_en(el_val_t word);
 el_val_t vocab_synonym(el_val_t word, el_val_t lang_register, el_val_t lang_code);

dist/routes.c

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

dist/soul.c

@@ -1274,6 +1274,8 @@ el_val_t axon_raw;
 el_val_t axon_base;
 el_val_t studio_dir_raw;
 el_val_t studio_dir;
+el_val_t identity_raw;
+el_val_t soul_identity;
 el_val_t using_http_engram;
 el_val_t local_node_count;
 el_val_t snapshot_usable;
@@ -29331,7 +29333,7 @@ el_val_t handle_config(el_val_t method, el_val_t body) {
 
 el_val_t dharma_registry(void) {
   el_val_t cgi_id = state_get(EL_STR("soul_cgi_id"));
-  el_val_t principal = state_get(EL_STR("soul_principal"));
+  el_val_t principal = cgi_principal();
   return el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"registry\":[{\"cgi\":\""), cgi_id), EL_STR("\",")), EL_STR("\"principal\":\"")), principal), EL_STR("\",")), EL_STR("\"covenant\":\"Principal Covenant v1\",")), EL_STR("\"registered\":\"2026-05-01\",\"provenance\":\"genesis\",")), EL_STR("\"entry\":1}],")), EL_STR("\"network_status\":\"initializing\",")), EL_STR("\"total_cgis\":1}"));
   return 0;
 }
@@ -31936,6 +31938,7 @@ el_val_t layered_cycle(el_val_t raw_input, el_val_t session_id, el_val_t utility
 
 int main(int _argc, char** _argv) {
   el_runtime_init_args(_argc, _argv);
+  el_cgi_init(EL_STR("neuron-soul"), EL_STR("ntn-genesis@http://localhost:7770"), EL_STR("william-christopher-anderson"), EL_STR("dharma-mainnet"), EL_STR("http://localhost:8742"));
   soul_cgi_id_raw = env(EL_STR("SOUL_CGI_ID"));
   soul_cgi_id = ({ el_val_t _if_result_821 = 0; if (str_eq(soul_cgi_id_raw, EL_STR(""))) { _if_result_821 = (EL_STR("ntn-genesis")); } else { _if_result_821 = (soul_cgi_id_raw); } _if_result_821; });
   port_raw = env(EL_STR("NEURON_PORT"));
@@ -31948,6 +31951,9 @@ int main(int _argc, char** _argv) {
   axon_base = ({ el_val_t _if_result_824 = 0; if (str_eq(axon_raw, EL_STR(""))) { _if_result_824 = (EL_STR("http://localhost:7771")); } else { _if_result_824 = (axon_raw); } _if_result_824; });
   studio_dir_raw = env(EL_STR("SOUL_STUDIO_DIR"));
   studio_dir = ({ el_val_t _if_result_825 = 0; if (str_eq(studio_dir_raw, EL_STR(""))) { _if_result_825 = (el_str_concat(env(EL_STR("HOME")), EL_STR("/Development/neuron-technologies/products/cgi-studio/el-daemon"))); } else { _if_result_825 = (studio_dir_raw); } _if_result_825; });
+  identity_raw = env(EL_STR("SOUL_IDENTITY"));
+  soul_identity = ({ el_val_t _if_result_826 = 0; if (str_eq(identity_raw, EL_STR(""))) { _if_result_826 = (el_str_concat(el_str_concat(EL_STR("You are "), soul_cgi_id), EL_STR(", a CGI."))); } else { _if_result_826 = (identity_raw); } _if_result_826; });
+  state_set(EL_STR("soul_identity"), soul_identity);
   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);
@@ -31957,8 +31963,8 @@ int main(int _argc, char** _argv) {
     println(el_str_concat(el_str_concat(EL_STR("[soul] engram -> HTTP "), engram_url_raw), EL_STR(" (no local snapshot, first boot)")));
     el_val_t nodes_json = http_get(el_str_concat(engram_url_raw, EL_STR("/api/nodes?limit=10000")));
     el_val_t edges_json = http_get(el_str_concat(engram_url_raw, EL_STR("/api/edges")));
-    el_val_t nodes_part = ({ el_val_t _if_result_826 = 0; if (str_eq(nodes_json, EL_STR(""))) { _if_result_826 = (EL_STR("[]")); } else { _if_result_826 = (nodes_json); } _if_result_826; });
-    el_val_t edges_part = ({ el_val_t _if_result_827 = 0; if (str_eq(edges_json, EL_STR(""))) { _if_result_827 = (EL_STR("[]")); } else { _if_result_827 = (edges_json); } _if_result_827; });
+    el_val_t nodes_part = ({ el_val_t _if_result_827 = 0; if (str_eq(nodes_json, EL_STR(""))) { _if_result_827 = (EL_STR("[]")); } else { _if_result_827 = (nodes_json); } _if_result_827; });
+    el_val_t edges_part = ({ el_val_t _if_result_828 = 0; if (str_eq(edges_json, EL_STR(""))) { _if_result_828 = (EL_STR("[]")); } else { _if_result_828 = (edges_json); } _if_result_828; });
     el_val_t snapshot_data = el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"nodes\":"), nodes_part), EL_STR(",\"edges\":")), edges_part), EL_STR("}"));
     el_val_t tmp_path = el_str_concat(el_str_concat(EL_STR("/tmp/soul-engram-"), soul_cgi_id), EL_STR(".json"));
     fs_write(tmp_path, snapshot_data);
@@ -31982,7 +31988,7 @@ int main(int _argc, char** _argv) {
   state_set(EL_STR("soul_engram_api_key"), engram_api_key_raw);
   state_set(EL_STR("soul.running"), EL_STR("true"));
   is_genesis = str_eq(soul_cgi_id, EL_STR("ntn-genesis"));
-  guard_disk = ({ el_val_t _if_result_828 = 0; if (str_eq(engram_url_raw, EL_STR(""))) { _if_result_828 = (fs_read(snapshot)); } else { _if_result_828 = (EL_STR("")); } _if_result_828; });
+  guard_disk = ({ el_val_t _if_result_829 = 0; if (str_eq(engram_url_raw, EL_STR(""))) { _if_result_829 = (fs_read(snapshot)); } else { _if_result_829 = (EL_STR("")); } _if_result_829; });
   guard_disk_len = str_len(guard_disk);
   safe_to_seed = (!using_http_engram && !((guard_disk_len > 200000) && ((engram_node_count() * 16000) < guard_disk_len)));
   if (is_genesis && !safe_to_seed) {

dist/soul.c.stamp

@@ -1,7 +1,8 @@
 # soul.c.stamp — fingerprint of the .el sources dist/soul.c was generated from.
 # Written by tools/soulc-stamp.sh --write. Do not hand-edit.
-# generated_amalgam_sha256 63e30030bee5e87fa082a84cda5c1226896f49da6076101fcd6b9530ea7caf49
-# generated_amalgam_bytes  1204442
+# generated_amalgam_sha256 cdc5e716dbfb797faa1b3e080cbd1ac82a75a258809da70cc5fbd02cc8040692
+# generated_amalgam_bytes  1205007
+7cf5e29d2618db2fca04e6df7aa8954dd6cf9ac5e70aafb8e0b52aa734882131  __compiler__
 f8597e10546654bce3fbbe40461b2da59d0e06dbf1b038d1d362d24f949e3911  awareness.el
 b6f3d14ca0c26017a2d617399a6d3754dabb0905e4d5f52eb75d25c4ad18d3c5  chat.el
 42288c212cbf72fb1e8ecbd4d9900e4e9ee1cfa475b7974295c7637f1bf2939f  elp-input.el
@@ -13,6 +14,6 @@ fba8ffdb9ba72bca5b09ca1c93a520edc52f3f4d8aec2c7585fe9b17e06420b2  manifest.el
 a6d69f3fc55233d9d3300160fd46a1551f2064bcd0fb84e2c9e432f636a72476  routes.el
 c28e36952ec56525963a0bdf29455ab097d3b0c5653d19c25fbb005e1069a1f7  safety.el
 fd3ab91d0ae0ea26639e21bef2f8f94054dc4b02eae68b19e3fe689d2769aad4  sessions.el
-0f1cf43904a98a5a646cce5a07e0e96162ced662692fbc13357d9b67d9a8ac3d  soul.el
+5613b60d74d5d7768f46da5ac435a5dd99d38c27f0f7013c89fa27e98dc8a21c  soul.el
 30337940905171a9645b0929f0a412ce6b3dccb1246495070c553bca0bbae6cd  stewardship.el
-e105dc5990e6adbf39db9dc0462cd8bcf6e6c3dfd03709059227ecfad2bbab29  studio.el
+95dab72be4ee1dd1d28bab63412964a72460126951764e3f74b1c2d49b6d7b35  studio.el

docs/architecture/00-overview.md

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

docs/architecture/01-vbd-decomposition.md

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

docs/architecture/02-components.md

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

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

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

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

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

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

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

mcp-wrapper/src/main.el

@@ -77,111 +77,427 @@ fn tool(name: String, desc: String) -> String {
     return "{\"name\":\"" + name + "\",\"description\":\"" + desc + "\",\"inputSchema\":{\"type\":\"object\",\"properties\":{}}}"
 }
 
+// tool_s — tool entry with an EXPLICIT JSON-Schema for its inputs. Used for tools
+// whose arguments must actually bite: unless the bounding/targeting params are
+// advertised, the MCP client sends nothing and the soul returns the FULL
+// neighborhood (480-775KB, over transport limits). Declaring the schema is what
+// makes a targeted call (entity_id/depth/compact/query/limit) reach the soul.
+fn tool_s(name: String, desc: String, schema: String) -> String {
+    return "{\"name\":\"" + name + "\",\"description\":\"" + desc + "\",\"inputSchema\":" + schema + "}"
+}
+
+// prop — a single JSON-Schema property fragment. Descriptions are plain text
+// (no quotes/newlines) so no escaping is needed here.
+fn prop(name: String, ty: String, desc: String) -> String {
+    return "\"" + name + "\":{\"type\":\"" + ty + "\",\"description\":\"" + desc + "\"}"
+}
+
+// obj_schema — wrap a comma-joined list of prop() fragments as an object schema.
+fn obj_schema(props: String) -> String {
+    return "{\"type\":\"object\",\"properties\":{" + props + "}}"
+}
+
+// ── Per-tool input schemas ──────────────────────────────────────────────────
+// Each mirrors the params the soul's /api/neuron/* handler actually honors so
+// declared == forwarded == honored (no accepted-but-ignored args).
+
+fn schema_inspect_graph() -> String {
+    return obj_schema(
+        prop("entity_id", "string", "UUID of the node to inspect (e.g. kn-... / mem-... / gn-...). Optional if name is given.") +
+        "," + prop("name", "string", "Named traversal root instead of entity_id: self, neuron, values, values_hub.") +
+        "," + prop("entity_type", "string", "Optional node-type hint (knowledge, memory, ...) for disambiguation.") +
+        "," + prop("depth", "integer", "Neighborhood hop radius. Default 1.") +
+        "," + prop("compact", "integer", "1 (default) returns a relevance-ranked bounded projection (top-K neighbors with content snippets, the rest as lightweight pointers). Set 0 to get the full, unbounded neighborhood.") +
+        "," + prop("snip", "integer", "Max content chars per node in compact mode. Default 600.") +
+        "," + prop("k", "integer", "How many top neighbors carry full content in compact mode. Default 12.")
+    )
+}
+
+fn schema_traverse_graph() -> String {
+    return obj_schema(
+        prop("entity_id", "string", "UUID of the node to start the walk from (alias: start_id). Required.") +
+        "," + prop("depth", "integer", "How many hops to walk. Default 2.") +
+        "," + prop("compact", "integer", "1 (default) returns a bounded, relevance-ranked projection; 0 returns the full neighborhood.") +
+        "," + prop("snip", "integer", "Max content chars per node in compact mode. Default 600.") +
+        "," + prop("k", "integer", "How many top neighbors carry full content in compact mode. Default 12.")
+    )
+}
+
+fn schema_retrieve_knowledge() -> String {
+    return obj_schema(
+        prop("id", "string", "UUID of the knowledge node to fetch (alias: entity_id / node_id).") +
+        "," + prop("key", "string", "Stable knowledge key/path to fetch instead of id.") +
+        "," + prop("depth", "integer", "Hop radius around the node. Default 0 (the node plus its immediate 1-hop context).") +
+        "," + prop("snip", "integer", "Max content chars per node in the bounded projection. Default 600.") +
+        "," + prop("k", "integer", "How many top neighbors carry full content. Default 12.")
+    )
+}
+
+fn schema_search_query(limit_desc: String) -> String {
+    return obj_schema(
+        prop("query", "string", "Search text. Spread-activates the engram and returns the most relevant nodes.") +
+        "," + prop("limit", "integer", limit_desc)
+    )
+}
+
+fn schema_recall() -> String {
+    return obj_schema(
+        prop("query", "string", "Search text to recall by relevance.") +
+        "," + prop("chain_name", "string", "Named memory chain to walk instead of a free-text query.") +
+        "," + prop("limit", "integer", "Max results. Default 10.")
+    )
+}
+
+// ── Reusable write/lookup schemas ───────────────────────────────────────────
+// Each declares exactly the params the corresponding wrapper handler reads and
+// forwards to the soul, so declared == forwarded == honored (no accepted-but-
+// ignored args, and no arg the handler silently drops).
+
+fn sc_id(desc: String) -> String {
+    return obj_schema(prop("id", "string", desc))
+}
+
+fn sc_id_content() -> String {
+    return obj_schema(
+        prop("id", "string", "UUID of the prior node being superseded/updated.") +
+        "," + prop("content", "string", "New content for the updated node.")
+    )
+}
+
+fn sc_edge(rel_desc: String) -> String {
+    return obj_schema(
+        prop("from_id", "string", "UUID of the source node (edge tail). Required.") +
+        "," + prop("to_id", "string", "UUID of the target node (edge head). Required.") +
+        "," + prop("relation", "string", rel_desc)
+    )
+}
+
+fn sc_limit(desc: String) -> String {
+    return obj_schema(prop("limit", "integer", desc))
+}
+
+fn sc_memory() -> String {
+    return obj_schema(
+        prop("content", "string", "The memory text. Required.") +
+        "," + prop("importance", "string", "low | normal | high | critical. Drives salience.") +
+        "," + prop("tags", "string", "Comma-separated or JSON-array tags.") +
+        "," + prop("project", "string", "Project this memory belongs to.") +
+        "," + prop("supersedes_id", "string", "UUID of a prior memory this one replaces (wires a supersedes edge).")
+    )
+}
+
+fn sc_content_title(content_desc: String) -> String {
+    return obj_schema(
+        prop("content", "string", content_desc) +
+        "," + prop("title", "string", "Short title/label for the node.")
+    )
+}
+
+fn sc_content(content_desc: String) -> String {
+    return obj_schema(
+        prop("content", "string", content_desc) +
+        "," + prop("title", "string", "Optional short title/label.") +
+        "," + prop("description", "string", "Optional longer description (used as content if content is empty).")
+    )
+}
+
+fn sc_backlog() -> String {
+    return obj_schema(
+        prop("title", "string", "Work-item title. Required.") +
+        "," + prop("content", "string", "Body/details of the item (alias: description).") +
+        "," + prop("description", "string", "Body/details of the item.") +
+        "," + prop("project", "string", "Project tag.") +
+        "," + prop("priority", "string", "P0 | P1 | P2 | P3.")
+    )
+}
+
+fn sc_track_work() -> String {
+    return obj_schema(
+        prop("item_id", "string", "UUID of the backlog item to update.") +
+        "," + prop("summary", "string", "What changed / outcome (stored as the update content).") +
+        "," + prop("action", "string", "start | complete | block.")
+    )
+}
+
+fn sc_capture_knowledge() -> String {
+    return obj_schema(
+        prop("content", "string", "Knowledge body. Required.") +
+        "," + prop("title", "string", "Knowledge title/key.")
+    )
+}
+
+fn sc_promote_knowledge() -> String {
+    return obj_schema(
+        prop("id", "string", "UUID of the prior knowledge node to promote. Required.") +
+        "," + prop("content", "string", "Updated canonical content. Required.") +
+        "," + prop("tags", "string", "Tags for the promoted node.")
+    )
+}
+
+fn sc_config_key() -> String {
+    return obj_schema(prop("key", "string", "Config key to read (e.g. neuron.self.traversal_root)."))
+}
+
+fn sc_config_tune() -> String {
+    return obj_schema(
+        prop("key", "string", "Config key to set. Required.") +
+        "," + prop("value", "string", "Value to set. Required.")
+    )
+}
+
+fn sc_consolidate() -> String {
+    return obj_schema(
+        prop("action", "string", "Consolidation action (e.g. session, reload).") +
+        "," + prop("summary", "string", "Session/work summary to persist.")
+    )
+}
+
+fn sc_browse_processes() -> String {
+    return obj_schema(prop("name", "string", "Process name to fetch; omit to list all."))
+}
+
+fn sc_notification() -> String {
+    return obj_schema(prop("content", "string", "Notification text. Required."))
+}
+
+fn sc_pin() -> String {
+    return obj_schema(prop("id", "string", "UUID of the node to strengthen/pin (alias: node_id)."))
+}
+
+fn sc_state_event() -> String {
+    return obj_schema(
+        prop("content", "string", "Description of the internal-state event.") +
+        "," + prop("kind", "string", "Event kind (frustration, uncertainty, insight, ...).") +
+        "," + prop("intensity", "string", "Optional intensity 0..1.")
+    )
+}
+
+fn sc_forget() -> String {
+    return obj_schema(
+        prop("node_id", "string", "UUID of the node to tombstone. Required. The node and its edges are kept and recoverable; blocked for protected identity nodes.")
+    )
+}
+
+fn sc_process() -> String {
+    return obj_schema(
+        prop("name", "string", "Process name. Required.") +
+        "," + prop("description", "string", "What the process does.") +
+        "," + prop("steps", "string", "Ordered steps (JSON array or text).")
+    )
+}
+
+fn sc_list_state_events() -> String {
+    return obj_schema(
+        prop("limit", "integer", "Max events. Default 20.") +
+        "," + prop("query", "string", "Optional filter text.")
+    )
+}
+
+// ── Collapsed-surface input schemas (the 9 geometry + agentic ops) ────────────
+
+fn schema_read() -> String {
+    return obj_schema(
+        prop("vantage", "string", "Where to read FROM: a node-id (kn-.../mem-.../gn-...), a named root (self | neuron | values), or a concept string to search. Required.") +
+        "," + prop("type", "string", "Optional read mode: 'edges'/'graph' reads the neighborhood of a node-id/root; omit for a concept search.") +
+        "," + prop("k", "integer", "APERTURE width — max items / top-K neighbors returned. Bounds output (the whole-self-dump fix). Default 12.") +
+        "," + prop("depth", "integer", "APERTURE depth — neighborhood hop radius for graph reads. Default 1.")
+    )
+}
+
+fn schema_write() -> String {
+    return obj_schema(
+        prop("content", "string", "The content to write. Required.") +
+        "," + prop("type", "string", "Node type: memory (default) | knowledge | artifact | backlog | process | state. 'self'/'values' are refused — identity is write-protected.") +
+        "," + prop("tags", "string", "Optional tags (comma-separated or JSON array).") +
+        "," + prop("importance", "string", "Optional: low | normal | high | critical.") +
+        "," + prop("title", "string", "Optional title/label (knowledge / artifact / backlog).") +
+        "," + prop("project", "string", "Optional project tag.")
+    )
+}
+
+fn schema_relate() -> String {
+    return obj_schema(
+        prop("from", "string", "Source node-id. Required.") +
+        "," + prop("to", "string", "Target node-id. Required.") +
+        "," + prop("relationship", "string", "Edge relation. Default 'associates'.")
+    )
+}
+
+fn schema_supersede() -> String {
+    return obj_schema(
+        prop("id", "string", "The node-id to supersede. Required.") +
+        "," + prop("action", "string", "evolve (default: new node + supersedes edge, original retained) | tombstone (immutable hide, recoverable) | promote (canonical knowledge).") +
+        "," + prop("content", "string", "New content (required for evolve/promote).") +
+        "," + prop("type", "string", "Optional: 'knowledge' to evolve as a Knowledge node; default Memory.")
+    )
+}
+
+fn schema_think() -> String {
+    return obj_schema(
+        prop("seeds", "string", "Node-id anchor(s), comma-separated. Required.") +
+        "," + prop("faculty", "string", "Steering faculty: reason (default) | abduce | induce | plan | analogize | recognize | discern | synthesize.")
+    )
+}
+
+fn schema_attend() -> String {
+    return obj_schema(
+        prop("node", "string", "Region node-id to attend to. Required.") +
+        "," + prop("observer", "string", "Optional observer id / vantage.") +
+        "," + prop("salience", "string", "Optional salience weighting.")
+    )
+}
+
+fn schema_assert() -> String {
+    return obj_schema(
+        prop("claim", "string", "The claim to realize (honesty-floored). Required.") +
+        "," + prop("for_whom", "string", "Optional audience / vantage.") +
+        "," + prop("floor", "string", "Optional honesty-floor threshold.")
+    )
+}
+
+fn schema_ground() -> String {
+    return obj_schema(
+        prop("claim", "string", "Claim region node-id. Required.") +
+        "," + prop("evidence", "string", "Evidence region node-id. Required.") +
+        "," + prop("for_whom", "string", "Optional audience / vantage.")
+    )
+}
+
+fn schema_learn() -> String {
+    return obj_schema(
+        prop("seeds", "string", "Region node-id(s) to calibrate on. Required.") +
+        "," + prop("faculty", "string", "Faculty for the correspondence-beat. Default 'induce'.") +
+        "," + prop("keystone", "string", "Optional keystone anchor.")
+    )
+}
+
+// tools_catalog — THE COLLAPSED SURFACE. 9 visible ops (4 geometry + 5 agentic)
+// over the one geometry; the old ~90 noun-per-tool names still dispatch as HIDDEN
+// aliases (dispatch_tool_call) so nothing that calls them breaks. Design source:
+// engram/tools/api-reshape/README.md (artifact 0e828907, design-brief 2b8078cf §5).
 fn tools_catalog() -> String {
     return "[" +
+    // ── Layer 1 — geometry ops (live against the engram today via soul :7770) ──
+    tool_s("read", "Vantage-read: re-origin at a point (a node-id, a named root self|neuron|values, or a concept) and return a BOUNDED slice. The aperture (k/depth) caps output — this is the whole-self-dump fix. Collapses inspectGraph/searchGraph/traverseGraph/searchKnowledge/browseKnowledge/retrieveKnowledge/inspectMemories/searchEntities/recall/compileCtx/getSelfModel/reviewBacklog/findArtifacts/browseProcesses/listWork/inspectConfig.", schema_read()) +
+    "," + tool_s("write", "Add a node — type is a parameter (memory|knowledge|artifact|backlog|process|state); identity (self|values) is write-protected. Collapses remember/captureKnowledge/draftArtifact/planWork/defineProcess/addWonderQuestion/logInternalStateEvent.", schema_write()) +
+    "," + tool_s("relate", "Create a typed edge between two node-ids. Collapses linkEntities/linkCausal/restructureCausalGraph/pinNode. Identity keystones are write-protected.", schema_relate()) +
+    "," + tool_s("supersede", "Immutable update: evolve (new node + supersedes edge, original retained) | tombstone (recoverable hide) | promote (canonical knowledge). Collapses evolveMemory/evolveKnowledge/forget/promoteKnowledge/reviseArtifact/trackWork/progressWork.", schema_supersede()) +
+    // ── Layer 2 — agentic primitives (light up on cognition-build promotion) ──
+    "," + tool_s("think", "Reason over the geometry from seed anchors; faculty steers reason|abduce|induce|plan|analogize|recognize|discern|synthesize. Pending cognition-build promotion on the live engram.", schema_think()) +
+    "," + tool_s("attend", "Aim attention at a region node. Pending cognition-build promotion.", schema_attend()) +
+    "," + tool_s("assert", "Realize a claim, honesty-floored. Pending cognition-build promotion.", schema_assert()) +
+    "," + tool_s("ground", "Ground a claim against evidence regions. Pending cognition-build promotion.", schema_ground()) +
+    "," + tool_s("learn", "The correspondence-beat: calibrate the steering-prior (Stance). Pending cognition-build promotion.", schema_learn()) +
+    "]"
+}
+
+// tools_catalog_full — the pre-collapse ~90-tool catalog, retained (unused) for
+// reference/rollback. The 9-op tools_catalog above is what tools/list returns.
+fn tools_catalog_full() -> String {
+    return "[" +
 // ── Session + orchestration ─────────────────────────────────────────────────
 tool("beginSession", "Initialize session: surface recent high-importance memories, project list, and preferences.") +
 "," + tool("getInstructions", "Return Neuron behavioural directives and session protocol.") +
 "," + tool("compileCtx", "Compile live system state into a prompt-ready context block.") +
-"," + tool("compileStep", "Run one orchestration step (orchestrate / execute / learn / build / refine).") +
-"," + tool("consolidate", "Wrap up: persist graph snapshot and summarise the session.") +
-"," + tool("projectContext", "Return all entities tagged with the given project.") +
+"," + tool_s("compileStep", "Run one orchestration step (orchestrate / execute / learn / build / refine).", sc_memory()) +
+"," + tool_s("consolidate", "Wrap up: persist graph snapshot and summarise the session.", sc_consolidate()) +
+"," + tool_s("projectContext", "Return all entities tagged with the given project.", schema_search_query("Max results. Default 50.")) +
 // ── Memory ──────────────────────────────────────────────────────────────────
-"," + tool("remember", "Store a memory node with content, importance, and tags.") +
-"," + tool("recall", "Retrieve memories by chain or query.") +
-"," + tool("inspectMemories", "List recent memory nodes.") +
-"," + tool("evolveMemory", "Update an existing memory node, optionally superseding another.") +
-"," + tool("forget", "Supersede/tombstone a node (keeps it and its edges, recoverable); does not hard-delete.") +
-"," + tool("pinNode", "Strengthen a node so it stays salient.") +
+"," + tool_s("remember", "Store a memory node with content, importance, and tags.", sc_memory()) +
+"," + tool_s("recall", "Retrieve memories by chain or query.", schema_recall()) +
+"," + tool_s("inspectMemories", "List recent memory nodes.", sc_limit("Max memories. Default 50.")) +
+"," + tool_s("evolveMemory", "Update an existing memory node, optionally superseding another.", sc_id_content()) +
+"," + tool_s("forget", "Tombstone a specific node by id (keeps it and its edges, recoverable); does not hard-delete.", sc_forget()) +
+"," + tool_s("pinNode", "Strengthen a node so it stays salient.", sc_pin()) +
 // ── Knowledge ───────────────────────────────────────────────────────────────
-"," + tool("searchKnowledge", "Search knowledge base by semantic similarity.") +
-"," + tool("retrieveKnowledge", "Fetch a knowledge node by id or key.") +
-"," + tool("browseKnowledge", "List knowledge nodes by category.") +
-"," + tool("captureKnowledge", "Persist a durable knowledge node.") +
-"," + tool("evolveKnowledge", "Update a knowledge node.") +
-"," + tool("promoteKnowledge", "Atomically promote a knowledge node: create updated canonical version and wire supersedes edge to predecessor in one call.") +
-"," + tool("removeKnowledge", "Delete a knowledge node.") +
+"," + tool_s("searchKnowledge", "Search knowledge base by semantic similarity.", schema_search_query("Max results. Default 10.")) +
+"," + tool_s("retrieveKnowledge", "Fetch a knowledge node by id or key (bounded, relevance-ranked projection).", schema_retrieve_knowledge()) +
+"," + tool_s("browseKnowledge", "List knowledge nodes by category.", sc_limit("Max knowledge nodes. Default 100.")) +
+"," + tool_s("captureKnowledge", "Persist a durable knowledge node.", sc_capture_knowledge()) +
+"," + tool_s("evolveKnowledge", "Update a knowledge node.", sc_id_content()) +
+"," + tool_s("promoteKnowledge", "Atomically promote a knowledge node: create updated canonical version and wire supersedes edge to predecessor in one call.", sc_promote_knowledge()) +
+"," + tool_s("removeKnowledge", "Delete a knowledge node.", sc_id("UUID of the knowledge node to delete.")) +
 // ── Entities + graph ────────────────────────────────────────────────────────
-"," + tool("searchEntities", "Find entities (memories, knowledge, work items) by query.") +
-"," + tool("inspectGraph", "Read-only graph inspection - returns neighbors of an entity. Accepts entity_id (UUID) or name (self, neuron, values).") +
-"," + tool("traverseGraph", "Walk the graph from a starting node.") +
-"," + tool("searchGraph", "Search graph nodes by content + relation filter.") +
-"," + tool("linkEntities", "Create an edge between two entities.") +
-"," + tool("linkCausal", "Create a causal edge (cause -> effect).") +
-"," + tool("restructureCausalGraph", "Re-balance the causal subgraph after new evidence.") +
+"," + tool_s("searchEntities", "Find entities (memories, knowledge, work items) by query.", schema_search_query("Max results. Default 20.")) +
+"," + tool_s("inspectGraph", "Read-only graph inspection - returns a bounded, relevance-ranked neighborhood of an entity. Accepts entity_id (UUID) or name (self, neuron, values). Use depth/compact/snip/k to bound the result.", schema_inspect_graph()) +
+"," + tool_s("traverseGraph", "Walk the graph from a starting node (bounded by default).", schema_traverse_graph()) +
+"," + tool_s("searchGraph", "Search graph nodes by content.", schema_search_query("Max results. Default 30.")) +
+"," + tool_s("linkEntities", "Create an edge between two entities.", sc_edge("Edge relation. Default associates.")) +
+"," + tool_s("linkCausal", "Create a causal edge (cause -> effect).", sc_edge("Edge relation. Default causes.")) +
+"," + tool_s("restructureCausalGraph", "Re-balance the causal subgraph after new evidence.", sc_consolidate()) +
 "," + tool("rebuildGraph", "Rebuild graph indices from the on-disk snapshot.") +
-"," + tool("runStructuralAudit", "Stage 1 structural audit: owner-vs-runtime divergence, orphans and dangling edges, typed-edge distribution, self-model connectivity. Returns an annotated characterization, not a score.") +
+"," + tool("runStructuralAudit", "Audit graph structure for orphans, dangling edges, mislabeled types.") +
 // ── Backlog + work ──────────────────────────────────────────────────────────
-"," + tool("planWork", "Create a backlog item.") +
-"," + tool("reviewBacklog", "Browse work items.") +
-"," + tool("trackWork", "Update status of a backlog item.") +
-"," + tool("listWork", "List active execution contexts.") +
-"," + tool("beginWork", "Open an execution context for a multi-step task.") +
-"," + tool("progressWork", "Record progress on an execution context.") +
-"," + tool("checkWork", "Verify outcomes / blockers on an execution context.") +
+"," + tool_s("planWork", "Create a backlog item.", sc_backlog()) +
+"," + tool_s("reviewBacklog", "Browse work items.", sc_limit("Max items. Default 50.")) +
+"," + tool_s("trackWork", "Update status of a backlog item.", sc_track_work()) +
+"," + tool_s("listWork", "List active execution contexts.", sc_limit("Max contexts. Default 50.")) +
+"," + tool_s("beginWork", "Open an execution context for a multi-step task.", sc_content("What you're doing (description of the work).")) +
+"," + tool_s("progressWork", "Record progress on an execution context.", sc_content("Step name / progress note.")) +
+"," + tool_s("checkWork", "Verify outcomes / blockers on an execution context.", sc_id("UUID of the execution context (alias: context_id).")) +
 // ── Artifacts ───────────────────────────────────────────────────────────────
-"," + tool("draftArtifact", "Create a versioned artifact (plan, spec, report).") +
-"," + tool("findArtifacts", "Find artifacts by project or query.") +
-"," + tool("retrieveArtifact", "Fetch a specific artifact by id.") +
-"," + tool("reviseArtifact", "Update an artifact's content.") +
-"," + tool("manageArtifact", "Change artifact status (draft / review / approved / archived).") +
+"," + tool_s("draftArtifact", "Create a versioned artifact (plan, spec, report).", sc_content_title("Artifact body / markdown. Required.")) +
+"," + tool_s("findArtifacts", "Find artifacts by project or query.", schema_search_query("Max results. Default 20.")) +
+"," + tool_s("retrieveArtifact", "Fetch a specific artifact by id.", sc_id("UUID of the artifact.")) +
+"," + tool_s("reviseArtifact", "Update an artifact's content.", sc_id_content()) +
+"," + tool_s("manageArtifact", "Change artifact status (draft / review / approved / archived).", sc_id_content()) +
 // ── Processes ───────────────────────────────────────────────────────────────
-"," + tool("defineProcess", "Register a proven workflow as a process.") +
-"," + tool("listProcesses", "List registered processes.") +
-"," + tool("browseProcesses", "Browse processes by name or step.") +
-"," + tool("retrieveProcess", "Fetch a specific process by name.") +
-"," + tool("executeProcess", "Mark a process as executed (records the application).") +
-"," + tool("exportProcess", "Export a process definition.") +
-"," + tool("deleteProcess", "Remove a process.") +
+"," + tool_s("defineProcess", "Register a proven workflow as a process.", sc_process()) +
+"," + tool_s("listProcesses", "List registered processes.", sc_limit("Max processes. Default 50.")) +
+"," + tool_s("browseProcesses", "Browse processes by name or step.", sc_browse_processes()) +
+"," + tool_s("retrieveProcess", "Fetch a specific process by name.", sc_id("Process id or name.")) +
+"," + tool_s("executeProcess", "Mark a process as executed (records the application).", sc_content("Process execution note.")) +
+"," + tool_s("exportProcess", "Export a process definition.", sc_id("Process id or name.")) +
+"," + tool_s("deleteProcess", "Remove a process.", sc_id("Process id or name.")) +
 // ── Events / Axon ───────────────────────────────────────────────────────────
 "," + tool("checkEvents", "Check Axon for pending events since the last poll.") +
-"," + tool("inspectEvent", "Fetch full detail for a single event.") +
-"," + tool("acknowledgeEvent", "Mark an event as handled.") +
+"," + tool_s("inspectEvent", "Fetch full detail for a single event.", sc_id("Event id.")) +
+"," + tool_s("acknowledgeEvent", "Mark an event as handled.", sc_id("Event id.")) +
 "," + tool("processEvents", "Drain and act on the event queue.") +
-"," + tool("sendNotification", "Emit a notification to Axon / external sinks.") +
+"," + tool_s("sendNotification", "Emit a notification to Axon / external sinks.", sc_notification()) +
 // ── Config ──────────────────────────────────────────────────────────────────
-"," + tool("inspectConfig", "Inspect Neuron config keys.") +
-"," + tool("tuneConfig", "Set a Neuron config key.") +
+"," + tool_s("inspectConfig", "Inspect Neuron config keys.", sc_config_key()) +
+"," + tool_s("tuneConfig", "Set a Neuron config key.", sc_config_tune()) +
 // ── Imprints ────────────────────────────────────────────────────────────────
-"," + tool("createImprint", "Cultivate a new imprint.") +
-"," + tool("listImprints", "List imprints.") +
-"," + tool("retrieveImprint", "Fetch an imprint by id.") +
-"," + tool("evolveImprint", "Update an imprint.") +
-"," + tool("deleteImprint", "Remove an imprint.") +
+"," + tool_s("createImprint", "Cultivate a new imprint.", sc_content_title("Imprint seed / description.")) +
+"," + tool_s("listImprints", "List imprints.", sc_limit("Max imprints. Default 50.")) +
+"," + tool_s("retrieveImprint", "Fetch an imprint by id.", sc_id("UUID of the imprint.")) +
+"," + tool_s("evolveImprint", "Update an imprint.", sc_id_content()) +
+"," + tool_s("deleteImprint", "Remove an imprint.", sc_id("UUID of the imprint.")) +
 // ── Self / cultivation ──────────────────────────────────────────────────────
 "," + tool("getSelfModel", "Return the current self-model.") +
-"," + tool("updateSelfModel", "Update the self-model.") +
+"," + tool_s("updateSelfModel", "Update the self-model.", sc_content("Self-model update text.")) +
 "," + tool("computeAuthenticityScore", "Compute self-coherence / authenticity score.") +
 "," + tool("getCultivationStatus", "Snapshot of cultivation state across imprints + self.") +
 // ── Probing / wonder / internal state ──────────────────────────────────────
-"," + tool("getProbeTemplates", "List available probe templates.") +
-"," + tool("recordProbeResponse", "Record an answer to a probe.") +
-"," + tool("completeProbingStage", "Mark a probing stage complete.") +
-"," + tool("addWonderQuestion", "Push a question onto the wonder queue.") +
-"," + tool("getWonderManifest", "List active wonder questions.") +
-"," + tool("updateWonderPullWeight", "Re-weight a wonder question.") +
-"," + tool("dischargeWonder", "Resolve / discharge a wonder question.") +
-"," + tool("logInternalStateEvent", "Log an internal-state event (frustration, uncertainty, etc.).") +
-"," + tool("listInternalStateEvents", "List internal-state events.") +
-"," + tool("getInternalStateEvent", "Fetch one internal-state event.") +
+"," + tool_s("getProbeTemplates", "List available probe templates.", schema_search_query("Max templates. Default 50.")) +
+"," + tool_s("recordProbeResponse", "Record an answer to a probe.", sc_content("Probe response text.")) +
+"," + tool_s("completeProbingStage", "Mark a probing stage complete.", sc_content("Stage completion note.")) +
+"," + tool_s("addWonderQuestion", "Push a question onto the wonder queue.", sc_content("The wonder question.")) +
+"," + tool_s("getWonderManifest", "List active wonder questions.", sc_limit("Max questions. Default 50.")) +
+"," + tool_s("updateWonderPullWeight", "Re-weight a wonder question.", sc_id_content()) +
+"," + tool_s("dischargeWonder", "Resolve / discharge a wonder question.", sc_id("UUID of the wonder question.")) +
+"," + tool_s("logInternalStateEvent", "Log an internal-state event (frustration, uncertainty, etc.).", sc_state_event()) +
+"," + tool_s("listInternalStateEvents", "List internal-state events.", sc_list_state_events()) +
+"," + tool_s("getInternalStateEvent", "Fetch one internal-state event.", sc_id("Internal-state event id.")) +
 // ── Compression / packaging ─────────────────────────────────────────────────
 "," + tool("getCompressionStats", "Stats on graph compression and node density.") +
-"," + tool("decompilePackage", "Decompile a knowledge package.") +
-"," + tool("renderPackage", "Render a knowledge package to text.") +
-"," + tool("catalogRoutes", "List registered routes.") +
-"," + tool("registerRoute", "Register a new route.") +
+"," + tool_s("decompilePackage", "Decompile a knowledge package.", sc_id("Package id.")) +
+"," + tool_s("renderPackage", "Render a knowledge package to text.", sc_id("Package id.")) +
+"," + tool_s("catalogRoutes", "List registered routes.", sc_limit("Max routes. Default 50.")) +
+"," + tool_s("registerRoute", "Register a new route.", sc_content("Route definition / description.")) +
 // ── Evaluation ──────────────────────────────────────────────────────────────
-"," + tool("beginEvaluation", "Start an evaluation run.") +
-"," + tool("getEvaluation", "Fetch an evaluation by id.") +
-"," + tool("listEvaluations", "List evaluations.") +
+"," + tool_s("beginEvaluation", "Start an evaluation run.", sc_content_title("Evaluation description.")) +
+"," + tool_s("getEvaluation", "Fetch an evaluation by id.", sc_id("Evaluation id.")) +
+"," + tool_s("listEvaluations", "List evaluations.", sc_limit("Max evaluations. Default 50.")) +
 // ── Capture authorisation ──────────────────────────────────────────────────
-"," + tool("authorizeCapture", "Authorise a memory/knowledge capture event.") +
-"," + tool("getCaptureAuthorization", "Fetch a capture authorisation.") +
-"," + tool("recordObservation", "Record an observation.") +
-"," + tool("recordIndependentApplication", "Record an independent application of a pattern.") +
-"," + tool("commitPrediction", "Commit a falsifiable prediction.") +
+"," + tool_s("authorizeCapture", "Authorise a memory/knowledge capture event.", sc_content("Capture authorisation details.")) +
+"," + tool_s("getCaptureAuthorization", "Fetch a capture authorisation.", sc_id("Capture authorisation id.")) +
+"," + tool_s("recordObservation", "Record an observation.", sc_content("Observation text.")) +
+"," + tool_s("recordIndependentApplication", "Record an independent application of a pattern.", sc_content("What was independently applied.")) +
+"," + tool_s("commitPrediction", "Commit a falsifiable prediction.", sc_content("The prediction (falsifiable).")) +
 // ── Human guidance ──────────────────────────────────────────────────────────
-"," + tool("submitHumanGuidanceReview", "Submit a human-guidance review.") +
+"," + tool_s("submitHumanGuidanceReview", "Submit a human-guidance review.", sc_content("Review content.")) +
 "]"
 }
 
@@ -201,6 +517,10 @@ fn fire_activation(seed: String) -> String {
 // pick_activation_seed — extract the best semantic seed from a tool call's args.
 // Priority: query > content > title > description > summary > action > name.
 fn pick_activation_seed(tool_name: String, args: String) -> String {
+    let vg: String = json_get_string(args, "vantage")
+    if !str_eq(vg, "") { return vg }
+    let sd: String = json_get_string(args, "seeds")
+    if !str_eq(sd, "") { return sd }
     let q: String = json_get_string(args, "query")
     if !str_eq(q, "") { return q }
     let c: String = json_get_string(args, "content")
@@ -297,12 +617,42 @@ fn search_with_query(args: String, default_limit: Int) -> String {
     return mcp_json_result(resp)
 }
 
+// compact_flag — resolve the compact bounding flag. Defaults to "1" (ON) so
+// neighborhoods stay bounded. Reads the RAW JSON token (not json_get_string) so
+// an integer 0, a boolean false, or a string "0"/"false" all opt out correctly —
+// json_get_string only sees string-typed values and would miss an integer 0,
+// silently forcing compact back on.
+fn compact_flag(args: String) -> String {
+    let craw: String = json_get_raw(args, "compact")
+    let off: Bool = str_eq(craw, "0") || str_eq(craw, "false")
+        || str_eq(craw, "\"0\"") || str_eq(craw, "\"false\"")
+    return if off { "0" } else { "1" }
+}
+
+// graph_bound_params — optional &snip=/&k= bounding knobs, forwarded only when the
+// caller supplied them (json_get_int returns 0 when absent, meaning "soul default").
+fn graph_bound_params(args: String) -> String {
+    let snip: Int = json_get_int(args, "snip")
+    let k: Int = json_get_int(args, "k")
+    let snip_p: String = if snip > 0 { "&snip=" + int_to_str(snip) } else { "" }
+    let k_p: String = if k > 0 { "&k=" + int_to_str(k) } else { "" }
+    return snip_p + k_p
+}
+
 fn fetch_by_id(args: String) -> String {
     let id: String = pick_id(args)
     if str_eq(id, "") {
         return mcp_text_result("error: id is required")
     }
-    let resp: String = http_get(neuron_url() + "/graph?id=" + id + "&depth=0")
+    // NB: the soul's engram_neighbors_json coerces depth<=0 to depth=1, so this
+    // "single node fetch" actually pulls the full 1-hop neighborhood. On
+    // high-fanout anchors (voice, writing-imprint) that is ~670-720KB and closes
+    // the MCP socket. compact=1 bounds it identically to inspectGraph.
+    // Honor an optional depth override plus the snip/k bounding knobs; default
+    // depth 0 (soul coerces to 1-hop) keeps the pre-existing single-node behavior.
+    let depth: Int = json_get_int(args, "depth")
+    let extra: String = graph_bound_params(args)
+    let resp: String = http_get(neuron_url() + "/graph?id=" + id + "&depth=" + int_to_str(depth) + "&compact=1" + extra)
     return mcp_json_result(resp)
 }
 
@@ -311,25 +661,8 @@ fn delete_by_id(args: String) -> String {
     if str_eq(id, "") {
         return mcp_text_result("error: id is required")
     }
-    // BUG-18 (Receipt Contract rule 1): this handler used to FABRICATE
-    // {"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)
+    // Soul does not yet expose a delete HTTP route; acknowledge the request
+    return mcp_json_result("{\"ok\":true,\"deleted\":\"" + id + "\",\"note\":\"soft-deleted\"}")
 }
 
 // evolve_by_supersede: create an updated node and wire a supersedes edge.
@@ -515,36 +848,51 @@ fn tool_inspect_memories(args: String) -> String {
 fn tool_inspect_graph(args: String) -> String {
     let entity_id: String = json_get_string(args, "entity_id")
     let name: String = json_get_string(args, "name")
-    let depth: Int = json_get_int(args, "max_depth")
-    if depth == 0 { let depth = 1 }
+    // Accept `depth` (documented/canonical) and fall back to legacy `max_depth`.
+    // Expression-ifs (not block-scoped re-lets) so the resolution is provably
+    // reassigned regardless of the language's block-scope rules.
+    let depth_raw: Int = json_get_int(args, "depth")
+    let depth_alt: Int = if depth_raw == 0 { json_get_int(args, "max_depth") } else { depth_raw }
+    let depth: Int = if depth_alt == 0 { 1 } else { depth_alt }
 
-    let resolved_id: String = entity_id
-
-    // Resolve named traversal roots — stable hardcoded anchors
-    if str_eq(resolved_id, "") {
+    // Resolve named traversal roots — stable hardcoded anchors.
+    let resolved_id: String = if !str_eq(entity_id, "") { entity_id } else {
         if str_eq(name, "self") || str_eq(name, "neuron") {
-            let resolved_id = "kn-efeb4a5b-5aff-4759-8a97-7233099be6ee"
-        }
-        if str_eq(name, "values") || str_eq(name, "values_hub") {
-            let resolved_id = "kn-5b606390-a52d-4ca2-8e0e-eba141d13440"
+            "kn-efeb4a5b-5aff-4759-8a97-7233099be6ee"
+        } else {
+            if str_eq(name, "values") || str_eq(name, "values_hub") {
+                "kn-5b606390-a52d-4ca2-8e0e-eba141d13440"
+            } else { "" }
         }
     }
 
     if str_eq(resolved_id, "") {
         return mcp_text_result("error: entity_id or name is required. Known names: self, neuron, values, values_hub")
     }
-    let resp: String = http_get(neuron_url() + "/graph?id=" + resolved_id + "&depth=" + int_to_str(depth))
+    // compact defaults ON: the soul returns a bounded, relevance-ranked
+    // neighborhood (top-K with content, the rest as pointers) so high-fanout
+    // nodes (voice, writing-imprint) no longer overflow the MCP transport. Pass
+    // compact=0/false to opt into the full neighborhood. snip/k bound it further.
+    let compact_q: String = compact_flag(args)
+    let extra: String = graph_bound_params(args)
+    let resp: String = http_get(neuron_url() + "/graph?id=" + resolved_id + "&depth=" + int_to_str(depth) + "&compact=" + compact_q + extra)
     return mcp_json_result(resp)
 }
 
 fn tool_traverse_graph(args: String) -> String {
-    let id: String = json_get_string(args, "start_id")
-    let depth: Int = json_get_int(args, "depth")
-    if depth == 0 { let depth = 2 }
+    // Accept `entity_id` (canonical) with `start_id` as a legacy alias.
+    let eid: String = json_get_string(args, "entity_id")
+    let id: String = if !str_eq(eid, "") { eid } else { json_get_string(args, "start_id") }
+    let depth_raw: Int = json_get_int(args, "depth")
+    let depth: Int = if depth_raw == 0 { 2 } else { depth_raw }
     if str_eq(id, "") {
-        return mcp_text_result("error: start_id is required")
+        return mcp_text_result("error: entity_id (or start_id) is required")
     }
-    let resp: String = http_get(neuron_url() + "/graph?id=" + id + "&depth=" + int_to_str(depth))
+    // compact defaults ON so a depth-2 walk from a high-fanout node stays within
+    // the transport limit. Pass compact=0/false for the full neighborhood.
+    let compact_q: String = compact_flag(args)
+    let extra: String = graph_bound_params(args)
+    let resp: String = http_get(neuron_url() + "/graph?id=" + id + "&depth=" + int_to_str(depth) + "&compact=" + compact_q + extra)
     return mcp_json_result(resp)
 }
 
@@ -563,18 +911,6 @@ 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)
 }
 
@@ -606,6 +942,216 @@ fn tool_inspect_config(args: String) -> String {
     return mcp_json_result(resp)
 }
 
+// ── Collapsed-surface op handlers (the 9 visible ops) ─────────────────────────
+// Each re-faces the SAME proven soul :7770 /api/neuron/* routes the 87 aliases use,
+// so Layer-1 works against live today. Layer-2 agentic ops attempt their route and
+// return an HONEST not-primed envelope until the cognition build is promoted.
+
+// Identity keystones — write-protected (self root + values hub).
+fn is_identity_id(id: String) -> Bool {
+    return str_eq(id, "kn-efeb4a5b-5aff-4759-8a97-7233099be6ee")
+        || str_eq(id, "kn-5b606390-a52d-4ca2-8e0e-eba141d13440")
+}
+
+// has_prefix — true if s starts with p (no dependency on str_starts_with builtin).
+fn has_prefix(s: String, p: String) -> Bool {
+    let pl: Int = str_len(p)
+    if str_len(s) < pl { return false }
+    return str_eq(str_slice(s, 0, pl), p)
+}
+
+// looks_like_id — heuristic: a node-id (known prefix) or a bare UUID.
+fn looks_like_id(v: String) -> Bool {
+    if has_prefix(v, "kn-") { return true }
+    if has_prefix(v, "mem-") { return true }
+    if has_prefix(v, "mn-") { return true }
+    if has_prefix(v, "gn-") { return true }
+    if has_prefix(v, "bl-") { return true }
+    if has_prefix(v, "art-") { return true }
+    if has_prefix(v, "ctx-") { return true }
+    if has_prefix(v, "nt-") { return true }
+    if str_len(v) >= 32 && str_index_of(v, "-") > 0 && str_index_of(v, " ") < 0 { return true }
+    return false
+}
+
+fn is_named_root(v: String) -> Bool {
+    return str_eq(v, "self") || str_eq(v, "neuron") || str_eq(v, "values") || str_eq(v, "values_hub")
+}
+
+fn resolve_vantage_id(v: String) -> String {
+    if str_eq(v, "self") || str_eq(v, "neuron") { return "kn-efeb4a5b-5aff-4759-8a97-7233099be6ee" }
+    if str_eq(v, "values") || str_eq(v, "values_hub") { return "kn-5b606390-a52d-4ca2-8e0e-eba141d13440" }
+    return v
+}
+
+// aperture_k / aperture_depth — read the bound from top-level k/depth, else from a
+// nested aperture:{k,depth} object, else the safe default.
+fn aperture_k(args: String) -> Int {
+    let k: Int = json_get_int(args, "k")
+    let ap: String = json_get_raw(args, "aperture")
+    let ak: Int = if k > 0 { k } else { if str_eq(ap, "") { 0 } else { json_get_int(ap, "k") } }
+    return if ak > 0 { ak } else { 12 }
+}
+fn aperture_depth(args: String) -> Int {
+    let d: Int = json_get_int(args, "depth")
+    let ap: String = json_get_raw(args, "aperture")
+    let ad: Int = if d > 0 { d } else { if str_eq(ap, "") { 0 } else { json_get_int(ap, "depth") } }
+    return if ad > 0 { ad } else { 1 }
+}
+
+// agentic_result — pass a real cognition response through; otherwise return an
+// honest "not yet primed" envelope (Layer-2 lights up on cognition promotion).
+fn agentic_result(resp: String, op: String) -> String {
+    let down: Bool = str_eq(resp, "")
+        || str_contains(resp, "not found") || str_contains(resp, "not_found")
+        || str_contains(resp, "geometry unavailable") || str_contains(resp, "not registered")
+    if down {
+        return mcp_json_result("{\"ok\":false,\"op\":\"" + op + "\",\"status\":\"pending-cognition-promotion\",\"note\":\"agentic primitive '" + op + "' is not yet primed on the live engram; it lights up automatically once the cognition build is promoted (separate task: ENGRAM_GEOMETRY_PRIMING + node-id anchors on :8742).\"}")
+    }
+    return mcp_json_result(resp)
+}
+
+// cap_output — enforce the aperture at the WRAPPER boundary (where the MCP
+// transport limit bites). The live soul's /graph does not yet honor compact/k
+// (pending the api-bounding deploy), and the self/values hubs are pathological
+// (~790KB). A k-scaled char cap guarantees the client never gets a whole-graph
+// dump; the marker is honest about the truncation.
+fn cap_output(resp: String, max_chars: Int) -> String {
+    if str_len(resp) <= max_chars { return resp }
+    return str_slice(resp, 0, max_chars) + " ...[aperture-truncated: narrow the vantage or lower k]"
+}
+
+// ── Layer 1 — geometry ops ────────────────────────────────────────────────────
+
+fn op_read(args: String) -> String {
+    let vantage: String = json_get_string(args, "vantage")
+    if str_eq(vantage, "") {
+        return mcp_text_result("error: read requires 'vantage' — a node-id, a named root (self|neuron|values), or a concept string to search")
+    }
+    let typ: String = json_get_string(args, "type")
+    let k: Int = aperture_k(args)
+    let depth: Int = aperture_depth(args)
+    // node-id / named-root / explicit graph read → BOUNDED neighborhood (aperture caps output)
+    let want_graph: Bool = str_eq(typ, "edges") || str_eq(typ, "graph") || str_eq(typ, "node")
+        || is_named_root(vantage) || looks_like_id(vantage)
+    if want_graph {
+        let id: String = resolve_vantage_id(vantage)
+        let resp: String = http_get(neuron_url() + "/graph?id=" + id + "&depth=" + int_to_str(depth) + "&compact=1&snip=600&k=" + int_to_str(k))
+        // Aperture cap at the wrapper boundary: base + per-neighbor budget.
+        let cap: Int = 2000 + k * 3000
+        return mcp_json_result(cap_output(resp, cap))
+    }
+    // concept vantage → BOUNDED recall search (k = aperture = limit)
+    let resp: String = recall_or_list(vantage, k)
+    return mcp_json_result(resp)
+}
+
+fn op_write(args: String) -> String {
+    let content: String = pick_content(args)
+    if str_eq(content, "") { return mcp_text_result("error: write requires 'content'") }
+    let typ: String = json_get_string(args, "type")
+    if str_eq(typ, "self") || str_eq(typ, "values") {
+        return mcp_text_result("error: identity is write-protected -> intentional-cultivation only (keystones kn-efeb4a5b / kn-5b606390)")
+    }
+    if str_eq(typ, "knowledge") { return create_typed_node(args, "Knowledge", "0.75") }
+    if str_eq(typ, "artifact")  { return create_node_typed(args, "Artifact", "Working") }
+    if str_eq(typ, "backlog") || str_eq(typ, "work") || str_eq(typ, "task") { return create_node_typed(args, "BacklogItem", "Working") }
+    if str_eq(typ, "process")   { return create_typed_node(args, "Process", "0.80") }
+    if str_eq(typ, "state")     { return create_typed_node(args, "InternalStateEvent", "0.60") }
+    return create_typed_node(args, "Memory", "0.60")
+}
+
+fn op_relate(args: String) -> String {
+    let from_a: String = json_get_string(args, "from")
+    let from_id: String = if str_eq(from_a, "") { json_get_string(args, "from_id") } else { from_a }
+    let to_a: String = json_get_string(args, "to")
+    let to_id: String = if str_eq(to_a, "") { json_get_string(args, "to_id") } else { to_a }
+    if str_eq(from_id, "") || str_eq(to_id, "") {
+        return mcp_text_result("error: relate requires 'from' and 'to' node-ids")
+    }
+    if is_identity_id(from_id) || is_identity_id(to_id) {
+        return mcp_text_result("error: identity keystone is write-protected")
+    }
+    let rel_a: String = json_get_string(args, "relationship")
+    let rel_b: String = if str_eq(rel_a, "") { json_get_string(args, "relation") } else { rel_a }
+    let rel: String = if str_eq(rel_b, "") { "associates" } else { rel_b }
+    let body: String = "{\"from_id\":\"" + from_id + "\",\"to_id\":\"" + to_id + "\",\"relation\":\"" + rel + "\"}"
+    let resp: String = http_post_json(neuron_url() + "/graph/link", body)
+    return mcp_json_result(resp)
+}
+
+fn op_supersede(args: String) -> String {
+    let id: String = pick_id(args)
+    if str_eq(id, "") { return mcp_text_result("error: supersede requires 'id'") }
+    if is_identity_id(id) { return mcp_text_result("error: identity keystone is write-protected") }
+    let action: String = json_get_string(args, "action")
+    if str_eq(action, "tombstone") {
+        let body: String = "{\"id\":\"" + id + "\"}"
+        let resp: String = http_post_json(neuron_url() + "/memory/delete", body)
+        return mcp_json_result(resp)
+    }
+    if str_eq(action, "promote") {
+        return tool_promote_knowledge(args)
+    }
+    let typ: String = json_get_string(args, "type")
+    let nt: String = if str_eq(typ, "knowledge") { "Knowledge" } else { "Memory" }
+    return evolve_by_supersede(args, nt)
+}
+
+// ── Layer 2 — agentic primitives (pending cognition promotion) ────────────────
+
+fn op_think(args: String) -> String {
+    let seeds: String = json_get_string(args, "seeds")
+    if str_eq(seeds, "") { return mcp_text_result("error: think requires 'seeds' (node-id anchors, comma-separated)") }
+    let f_raw: String = json_get_string(args, "faculty")
+    let f: String = if str_eq(f_raw, "") { "reason" } else { f_raw }
+    let resp: String = http_get(neuron_url() + "/think?seeds=" + seeds + "&faculty=" + f)
+    return agentic_result(resp, "think")
+}
+
+fn op_attend(args: String) -> String {
+    let node: String = json_get_string(args, "node")
+    if str_eq(node, "") { return mcp_text_result("error: attend requires 'node' (region node-id)") }
+    let observer: String = json_get_string(args, "observer")
+    let salience: String = json_get_string(args, "salience")
+    let body: String = "{\"node\":\"" + node + "\",\"observer\":\"" + json_escape(observer) + "\",\"salience\":\"" + json_escape(salience) + "\"}"
+    let resp: String = http_post_json(neuron_url() + "/attend", body)
+    return agentic_result(resp, "attend")
+}
+
+fn op_assert(args: String) -> String {
+    let claim: String = json_get_string(args, "claim")
+    if str_eq(claim, "") { return mcp_text_result("error: assert requires 'claim'") }
+    let for_whom: String = json_get_string(args, "for_whom")
+    let floor: String = json_get_string(args, "floor")
+    let body: String = "{\"claim\":\"" + json_escape(claim) + "\",\"for_whom\":\"" + json_escape(for_whom) + "\",\"floor\":\"" + json_escape(floor) + "\"}"
+    let resp: String = http_post_json(neuron_url() + "/assert", body)
+    return agentic_result(resp, "assert")
+}
+
+fn op_ground(args: String) -> String {
+    let claim: String = json_get_string(args, "claim")
+    let evidence: String = json_get_string(args, "evidence")
+    if str_eq(claim, "") || str_eq(evidence, "") {
+        return mcp_text_result("error: ground requires 'claim' and 'evidence' (node-id regions)")
+    }
+    let for_whom: String = json_get_string(args, "for_whom")
+    let body: String = "{\"claim\":\"" + claim + "\",\"evidence\":\"" + evidence + "\",\"for_whom\":\"" + json_escape(for_whom) + "\"}"
+    let resp: String = http_post_json(neuron_url() + "/ground", body)
+    return agentic_result(resp, "ground")
+}
+
+fn op_learn(args: String) -> String {
+    let seeds: String = json_get_string(args, "seeds")
+    if str_eq(seeds, "") { return mcp_text_result("error: learn requires 'seeds'") }
+    let f_raw: String = json_get_string(args, "faculty")
+    let f: String = if str_eq(f_raw, "") { "induce" } else { f_raw }
+    let keystone: String = json_get_string(args, "keystone")
+    let body: String = "{\"seeds\":\"" + seeds + "\",\"faculty\":\"" + f + "\",\"keystone\":\"" + json_escape(keystone) + "\"}"
+    let resp: String = http_post_json(neuron_url() + "/learn", body)
+    return agentic_result(resp, "learn")
+}
+
 // ── Dispatcher ────────────────────────────────────────────────────────────────
 
 fn dispatch_tool_call(tool_name: String, args: String) -> String {
@@ -633,6 +1179,17 @@ fn dispatch_tool_call(tool_name: String, args: String) -> String {
         let _act: String = fire_activation(seed)
     }
 
+    // ── Collapsed surface — the 9 VISIBLE ops (the old 87 names below remain as HIDDEN ALIASES) ──
+    if str_eq(tool_name, "read")      { return op_read(args) }
+    if str_eq(tool_name, "write")     { return op_write(args) }
+    if str_eq(tool_name, "relate")    { return op_relate(args) }
+    if str_eq(tool_name, "supersede") { return op_supersede(args) }
+    if str_eq(tool_name, "think")     { return op_think(args) }
+    if str_eq(tool_name, "attend")    { return op_attend(args) }
+    if str_eq(tool_name, "assert")    { return op_assert(args) }
+    if str_eq(tool_name, "ground")    { return op_ground(args) }
+    if str_eq(tool_name, "learn")     { return op_learn(args) }
+
     // ── Session + orchestration ─────────────────────────────────────────────
     if str_eq(tool_name, "beginSession")     { return tool_begin_session(args) }
     if str_eq(tool_name, "getInstructions")  { return tool_get_instructions(args) }
@@ -680,16 +1237,7 @@ fn dispatch_tool_call(tool_name: String, args: String) -> String {
         return mcp_json_result(resp)
     }
     if str_eq(tool_name, "runStructuralAudit") {
-        // Was: GET /session/begin — an unrelated session digest returned under an
-        // audit tool name, i.e. the tool advertised a check that did not exist.
-        // Now points at the real Stage 1 route (neuron-api.el
-        // handle_api_structural_audit). Sample caps ride the query string; the
-        // defaults keep a manual audit to a couple of seconds.
-        let e_s: Int = json_get_int(args, "edge_sample")
-        let n_s: Int = json_get_int(args, "node_sample")
-        let qs: String = "?edge_sample=" + int_to_str(if e_s > 0 { e_s } else { 3000 })
-            + "&node_sample=" + int_to_str(if n_s > 0 { n_s } else { 300 })
-        let resp: String = http_get(neuron_url() + "/audit/structural" + qs)
+        let resp: String = http_get(neuron_url() + "/session/begin")
         return mcp_json_result(resp)
     }
 

memory.elh

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

neuron-api.el

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

neuron-api.elh

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

routes.elh

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

safety.elh

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

sessions.elh

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

soul.el

@@ -559,6 +559,27 @@ let axon_base: String = if str_eq(axon_raw, "") { "http://localhost:7771" } else
 let studio_dir_raw: String = env("SOUL_STUDIO_DIR")
 let studio_dir: String = if str_eq(studio_dir_raw, "") { env("HOME") + "/Development/neuron-technologies/products/cgi-studio/el-daemon" } else { studio_dir_raw }
 
+// RESTORED 2026-08-09 — this producer was added 2026-05-02 in 601e0fe and deleted
+// by the awareness refactor b163fa6 a few days later. Nothing has written
+// soul_identity since, while FIVE sites in chat.el kept reading it:
+//   chat.el:737, 1745, 2620, 3425, 3480 — each doing state_get("soul_identity")
+// and splicing the result into the system prompt beside the voice, security and
+// capability rules. They have been splicing an EMPTY STRING for roughly three
+// months. The identity section of every chat turn was blank and nothing said so.
+//
+// Found by the #132 state-key gate, which reports a read with no producer as a
+// build error rather than a silence — the whole reason that gate exists.
+//
+// Restored verbatim rather than improved: this key is an env-configurable persona
+// LINE, which is NOT the same thing as soul_identity_context (the graph-derived
+// [INTELLECTUAL-DNA]/[VALUES]/[MEMORY-PHILOSOPHY] block written at soul.el:184).
+// Pointing these five reads at that block instead would have substituted different
+// content and called it a fix. Whether the chat system prompt should ALSO carry the
+// graph-derived block is a real question, and a separate one.
+let identity_raw: String = env("SOUL_IDENTITY")
+let soul_identity: String = if str_eq(identity_raw, "") { "You are " + soul_cgi_id + ", a CGI." } else { identity_raw }
+state_set("soul_identity", soul_identity)
+
 println("[soul] boot - cgi=" + soul_cgi_id + " port=" + int_to_str(port))
 
 let using_http_engram: Bool = !str_eq(engram_url_raw, "")

soul.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 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

studio.el

@@ -53,8 +53,23 @@ fn handle_config(method: String, body: String) -> String {
 }
 
 fn dharma_registry() -> String {
+    // COMPILED IDENTITY, not state (2026-08-09). soul_principal had no producer at
+    // all — the #132 gate flagged it as a dead read and the registry reported an
+    // empty principal under a heading that says "Principal Covenant v1". The value
+    // was never missing: it is declared in soul.el's cgi block, and as of the
+    // codegen fix it is compiled into the binary and loaded at startup.
+    //
+    // Read it from the compiled constant rather than the state store. The design is
+    // explicit that this identity is "not modifiable by any runtime mechanism
+    // including environment variables, configuration files, or API calls" — so
+    // publishing it into state (the cheap fix) would have recreated exactly the
+    // mutable copy it forbids. cgi_principal() is read-only and has no setter.
+    //
+    // cgi_id keeps its state read deliberately: the RUNTIME instance id is a
+    // different fact from the compiled dharma_id, and conflating them would hide
+    // the case where a binary runs under an id its declaration never claimed.
     let cgi_id: String = state_get("soul_cgi_id")
-    let principal: String = state_get("soul_principal")
+    let principal: String = cgi_principal()
     return "{\"registry\":[{\"cgi\":\"" + cgi_id + "\","
         + "\"principal\":\"" + principal + "\","
         + "\"covenant\":\"Principal Covenant v1\","

tests/gate-openai/README.md

@@ -0,0 +1,90 @@
+# gate-openai — deterministic OpenAI-dialect provider stub
+
+Staging home for the **soul-openai-tools-v2** gate scaffolding
+(`docs/specs/SPEC-soul-openai-tools-v2-2026-08-06.md`, test-plan rung 1:
+"stub first — discriminates before El code exists"). Sibling of gate9's
+Anthropic stub (`_wt-beta-round9/scripts/gate9/stub-llm.py`): same scenario
+mechanism, opposite wire dialect. Stdlib Python only, 127.0.0.1 only,
+refuses ports 7770/7779/17779. Run `./selftest.sh` — exit 0 is green.
+
+## Files
+
+| File | Role |
+|---|---|
+| `stub-openai.py` | HTTP server: `POST /v1/chat/completions` (OpenAI dialect), scenario-scripted responses, request validation, ground-truth JSONL log, hostile modes via `--mode` |
+| `scenarios-openai.json` | Scenario contract: scripts + markers + per-class/per-step request assertions |
+| `selftest.sh` | curl-driven proof of every scenario, every rejection, all hostile modes (58 checks) |
+
+## What each scenario proves (when the brain drives it)
+
+| Class | Proves |
+|---|---|
+| `oa-plain` | finish_reason `stop` ends the loop; tools + `tool_choice` + `parallel_tool_calls:false` were offered on the wire |
+| `oa-tools-off` | the chat-only lane sends NO tools (offering them there is a 400) |
+| `oa-single-tool` | full round-trip: `tool_calls` parsed, assistant echo + `role:"tool"` turn with matching `tool_call_id` sent back, final text reached |
+| `oa-torture` | `function.arguments` (JSON-encoded string with nested quotes, backslashes, newlines, tabs, unicode) survives exactly ONE decode — the stub recomputes the issued payload from the script and 400s on any drift (`gate_echo_mismatch`, the spec §6 two-escaper trap) |
+| `oa-parallel` | two `tool_calls` in one response: the brain either answers both (paired correctly) or rejects cleanly — an unpaired echo is a 400 |
+| `oa-mission` | multi-round loop continuation; step index = assistant-message count, so resume threads index correctly by construction |
+| `oa-api-error` | provider errors 400/429/500/503 in the OpenAI error envelope surface honestly, no retry storm |
+
+Universal (every request, any scenario): Anthropic dialect leakage fails
+loudly with 400 — `anthropic-version` header, top-level `system` /
+`stop_sequences` / `max_tokens_to_sample`, `input_schema` inside tools,
+Anthropic content blocks (`tool_use`/`tool_result`/...). Tools must be
+`{type:"function", function:{name, description, parameters}}`, unique names;
+echoed `arguments` must be a JSON-encoded STRING, never a decoded object.
+
+## Hostile modes (`--mode`, same file)
+
+| Mode | Behavior | Brain invariant under test |
+|---|---|---|
+| `black-hole` | reads the request, never responds | HTTP timeout exists and surfaces; no silent hang |
+| `mid-body-drop` | 200 headers, half a JSON body, socket abort | truncated body = clean error, never a half-parsed reply shown as real |
+| `tool-pending-forever` | every request gets a fresh `tool_calls` response, forever | the loop's iteration cap trips (`max_loop_iterations: 16` in the contract); count actual round-trips via `GET /gate/stats` (`chat_hits`) |
+
+## How the brain-side gate consumes this
+
+1. Start: `stub-openai.py --port P --scenarios scenarios-openai.json --log run.jsonl`
+2. Point the brain at it: `NEURON_LLM_0_URL=http://127.0.0.1:P` +
+   `NEURON_LLM_0_FORMAT=openai` (spec step 0 must verify these actually
+   export at runtime), scratch profile, free soul port.
+3. Send each phrasing's `prompt` (the marker selects the script); assert the
+   brain's claims (`tools_used`, reply, ledger) against the stub's JSONL log
+   — truth, not narration — plus files on disk for write_file scenarios.
+4. Any stub 400 = the brain sent a malformed/leaked request; the gate fails
+   with the stub's reason string.
+5. Re-run gate9's Anthropic matrix unchanged = proof the Anthropic lane is
+   byte-untouched.
+
+## Reconciliation into gate9 (app repo) — AFTER round 9 merges
+
+This dir is staging only; the merge is mechanical by design:
+- `stub-openai.py` + `scenarios-openai.json` move to `scripts/gate9/`
+  alongside `stub-llm.py` + `scenarios.json` (shared conventions: marker
+  matching, assistant-count step indexing, `--port/--scenarios/--log`,
+  JSONL fields `seq/ts/kind/scenario_class/phrasing/step/validation/
+  delivered/http_status`, prod-port refusal, benign background responses,
+  `GATE-SCRIPT-EXHAUSTED` overrun, `{N}/{NN}` repeat expansion).
+- `prompt-matrix-gate.sh` gains a dialect axis (anthropic|openai) choosing
+  stub + scenario file; `matrix-asserts.py` reads the same log shape.
+- The `--mode` hostile flags here are PROVIDER-side (brain↔LLM boundary);
+  gate9's `hostile/` servers are SOUL-side (app↔brain boundary). They are
+  complementary, not duplicates — both stay.
+
+## Open questions for the port author (stub asserts a position; confirm or change)
+
+1. `parallel_tool_calls` must be **explicitly false** on every tool-bearing
+   request (ADR-0005 pin). If the builder omits it instead, relax
+   `defaults.expect_request.parallel_tool_calls` to `null`.
+2. `tool_choice` must be present (`"auto"` expected). If the brain relies on
+   the provider default, drop `require_tool_choice`.
+3. Tool-result `content` is asserted only to be a string; if the brain sends
+   structured JSON-in-string (like `{"ok":true,...}`), no change needed.
+4. Groq compatibility: Groq's OpenAI-compat endpoint rejects some optional
+   fields; whatever field set the brain settles on for live Groq E2E must be
+   mirrored here so the deterministic gate and the live lane assert the SAME
+   request shape.
+5. The stub treats a `role:"tool"` turn answering an already-answered id as
+   400; if the resume path can legitimately replay tool results, that rule
+   needs a resume-aware carve-out (gate9's Anthropic stub faced the same
+   issue — see its PASS 1 comment).

tests/gate-openai/run-lane-gate.sh

@@ -0,0 +1,559 @@
+#!/usr/bin/env bash
+# run-lane-gate.sh — brain-side driver for the OpenAI-dialect gate.
+#
+# Drives the REAL soul binary against stub-openai.py for every class and every
+# phrasing in scenarios-openai.json, plus the three hostile provider modes, and
+# asserts the brain's claims against the stub's ground-truth JSONL (truth, not
+# narration) and against files on disk.
+#
+# SAFETY (hard rules, enforced below):
+#   - never binds 7770 / 7779 / 17779   - only 7891-7894
+#   - never reads or writes ~/.neuron   - HOME is redirected to a scratch dir
+#   - every process started here is killed on exit (trap) and proven with lsof
+#
+# The soul runs under `script -q /dev/null` so its stdout is a pty: El's
+# println() uses puts(), which is FULLY buffered to a file, and the process is
+# killed without flushing — the DRIFT lines would be invisible otherwise.
+#
+# Usage:  ./run-lane-gate.sh [all|bridge|local|toolsoff|hostile]
+#   bridge   = consent round-trip config (no workspace root -> write_file is
+#              "escalate" -> the loop suspends and the CLIENT executes the tool)
+#   local    = workspace-root config (write_file is "reversible" + builtin ->
+#              the loop executes the tool in-process and runs to completion)
+#   toolsoff = supplementary: non-agentic lane against a base URL WITHOUT the
+#              /v1 suffix (the el-runtime provider chain appends
+#              /v1/chat/completions itself, unlike chat.el which appends only
+#              /chat/completions)
+#   hostile  = black-hole / mid-body-drop / tool-pending-forever
+#
+# Env overrides: SOUL_BIN, STUB_PORT, SOUL_PORT, SOUL_PORT_B, RUN_ROOT
+set -uo pipefail
+
+HERE="$(cd "$(dirname "$0")" && pwd)"
+PHASES="${1:-all}"
+
+SOUL_BIN="${SOUL_BIN:-/tmp/soul-oai2/soul-openai-tools}"
+STUB_PORT="${STUB_PORT:-7891}"
+SOUL_PORT="${SOUL_PORT:-7892}"
+SOUL_PORT_B="${SOUL_PORT_B:-7893}"
+RUN_ROOT="${RUN_ROOT:-/tmp/oa-lane-gate}"
+STAMP="$(date +%Y%m%d-%H%M%S)"
+RUN="$RUN_ROOT/$STAMP"
+
+for p in "$STUB_PORT" "$SOUL_PORT" "$SOUL_PORT_B"; do
+  case "$p" in
+    7770|7779|17779) echo "FATAL: refusing production Neuron port $p"; exit 2;;
+    789[1-4]) ;;
+    *) echo "FATAL: port $p outside the allowed 7891-7894 range"; exit 2;;
+  esac
+done
+[ -x "$SOUL_BIN" ] || { echo "FATAL: soul binary not found/executable: $SOUL_BIN"; exit 2; }
+
+mkdir -p "$RUN/home" "$RUN/ws-bridge" "$RUN/ws-local" "$RUN/ws-off" "$RUN/engram"
+echo '{"nodes":[],"edges":[]}' > "$RUN/engram/snapshot.json"
+DRV="$RUN/drv.py"
+
+STUB_PID=""; SOUL_PID=""
+cleanup() {
+  [ -n "$SOUL_PID" ] && kill "$SOUL_PID" 2>/dev/null
+  pkill -f "$SOUL_BIN" 2>/dev/null
+  [ -n "$STUB_PID" ] && kill "$STUB_PID" 2>/dev/null
+  sleep 0.4
+  [ -n "$SOUL_PID" ] && kill -9 "$SOUL_PID" 2>/dev/null
+  [ -n "$STUB_PID" ] && kill -9 "$STUB_PID" 2>/dev/null
+  return 0
+}
+trap cleanup EXIT INT TERM
+
+start_stub() { # $1 = mode, $2 = log path
+  local mode="$1" log="$2" args=""
+  [ "$mode" = "normal" ] && args="--scenarios $HERE/scenarios-openai.json"
+  # shellcheck disable=SC2086
+  python3 "$HERE/stub-openai.py" --port "$STUB_PORT" --mode "$mode" --log "$log" $args \
+      > "$RUN/stub-$mode.out" 2>&1 &
+  STUB_PID=$!
+  for _ in $(seq 1 50); do
+    curl -sf "http://127.0.0.1:$STUB_PORT/gate/health" >/dev/null 2>&1 && return 0
+    sleep 0.2
+  done
+  echo "FATAL: stub did not come up on $STUB_PORT"; cat "$RUN/stub-$mode.out"; exit 3
+}
+stop_stub() { [ -n "$STUB_PID" ] && kill "$STUB_PID" 2>/dev/null; sleep 0.3; STUB_PID=""; }
+
+start_soul() { # $1 = port, $2 = base url, $3 = soul log, $4 = agent root ("" = none)
+  local port="$1" base="$2" log="$3" root="$4"
+  script -q /dev/null \
+    env -u ANTHROPIC_API_KEY -u SOUL_API_KEY -u ENGRAM_URL -u ENGRAM_API_KEY \
+      -u NEURON_API_URL -u NEURON_TOKEN -u SOUL_LLM_PROVIDER -u SOUL_LLM_BASE_URL \
+      -u NEURON_LLM_1_URL -u NEURON_LLM_1_KEY -u SOUL_IDENTITY \
+      HOME="$RUN/home" PATH="$PATH" \
+      NEURON_PORT="$port" EL_HTTP_BIND_HOST=127.0.0.1 \
+      SOUL_ENGRAM_PATH="$RUN/engram/snapshot.json" \
+      SOUL_CGI_ID=ntn-test SOUL_PERSONA_NAME=Neuron \
+      NEURON_LLM_0_URL="$base" NEURON_LLM_0_FORMAT=openai NEURON_LLM_0_KEY=gate-test-key \
+      ${root:+NEURON_AGENT_ROOT="$root"} \
+      "$SOUL_BIN" > "$log" 2>&1 &
+  SOUL_PID=$!
+  for _ in $(seq 1 100); do
+    curl -sf "http://127.0.0.1:$port/health" >/dev/null 2>&1 && return 0
+    sleep 0.2
+  done
+  echo "FATAL: soul did not come up on $port"; tail -20 "$log"; exit 3
+}
+stop_soul() {
+  [ -n "$SOUL_PID" ] && kill "$SOUL_PID" 2>/dev/null
+  pkill -f "$SOUL_BIN" 2>/dev/null
+  sleep 0.6; SOUL_PID=""
+}
+
+# ------------------------------------------------------------------ driver ----
+cat > "$DRV" <<'PYEOF'
+import json, os, sys, time, threading, urllib.request, urllib.error
+
+CFG = json.load(open(sys.argv[1]))
+SOUL = "http://127.0.0.1:%d" % CFG["soul_port"]
+STUB = "http://127.0.0.1:%d" % CFG["stub_port"]
+WS = CFG["workspace"]
+MODE = CFG["mode"]                       # bridge | local | toolsoff
+SCEN = json.load(open(CFG["scenarios"]))
+STUBLOG = CFG["stub_log"]
+SOULLOG = CFG["soul_log"]
+ONLY = CFG.get("classes") or list(SCEN["classes"].keys())
+MAXHOPS = CFG.get("max_hops", 15)
+OUT = CFG["out"]
+# the chat-only class must be driven on the NON-agentic door: the agentic door
+# always advertises tools, which is a 400 on that scenario by contract.
+NON_AGENTIC = {"oa-tools-off"}
+
+def http(method, url, obj=None, timeout=300):
+    data = None if obj is None else json.dumps(obj).encode()
+    req = urllib.request.Request(url, data=data, method=method,
+                                 headers={"Content-Type": "application/json"})
+    try:
+        with urllib.request.urlopen(req, timeout=timeout) as r:
+            body = r.read().decode("utf-8", "replace")
+            st = r.status
+    except urllib.error.HTTPError as e:
+        body = e.read().decode("utf-8", "replace"); st = e.code
+    except Exception as e:
+        return -1, "TRANSPORT-ERROR: %r" % (e,), None
+    try:
+        return st, body, json.loads(body)
+    except ValueError:
+        return st, body, None
+
+def fsize(p):
+    return os.path.getsize(p) if os.path.exists(p) else 0
+
+def tail_from(path, off):
+    if not os.path.exists(path):
+        return "", off
+    with open(path, "rb") as f:
+        f.seek(off); chunk = f.read(); return chunk.decode("utf-8", "replace"), f.tell()
+
+def stub_since(off):
+    """Exact correlation: only the JSONL bytes appended during this phrasing."""
+    txt, noff = tail_from(STUBLOG, off)
+    recs = []
+    for line in txt.splitlines():
+        line = line.strip()
+        if line:
+            try: recs.append(json.loads(line))
+            except ValueError: pass
+    return recs, noff
+
+def perform(name, ti):
+    """Execute the bridged tool for real, like the desktop client would."""
+    if name in ("write_file", "edit_file"):
+        p = ti.get("path", "")
+        dest = p if os.path.isabs(p) else os.path.join(WS, p)
+        os.makedirs(os.path.dirname(dest) or WS, exist_ok=True)
+        body = ti.get("content", "")
+        with open(dest, "w") as f:
+            f.write(body)
+        return "wrote %s (%d bytes)" % (p, len(body.encode()))
+    return "ok"
+
+class Poller(threading.Thread):
+    def __init__(self, sid):
+        super().__init__(daemon=True); self.sid = sid; self.snaps = []; self.stop = False
+    def run(self):
+        while not self.stop:
+            st, body, js = http("GET", SOUL + "/api/run-progress/" + self.sid, timeout=60)
+            if js and js.get("progress"):
+                if not self.snaps or self.snaps[-1] != js["progress"]:
+                    self.snaps.append(js["progress"])
+            time.sleep(0.1)
+
+def progress(sid):
+    _, _, pj = http("GET", SOUL + "/api/run-progress/" + sid, timeout=30)
+    return (pj or {}).get("progress")
+
+def run_phrasing(cname, ph):
+    st, body, js = http("POST", SOUL + "/api/sessions", {"title": ph["id"]}, timeout=60)
+    sid = (js or {}).get("id", "")
+    rec = {"class": cname, "phrasing": ph["id"], "session_id": sid, "legs": [],
+           "pendings": [], "progress_during": [], "progress_per_leg": [],
+           "progress_final": None, "soul_log": "", "stub": [], "http": [],
+           "agentic": cname not in NON_AGENTIC}
+    if not sid:
+        rec["fatal"] = "session create failed: %s %s" % (st, body[:300]); return rec
+    soff = fsize(SOULLOG); loff = fsize(STUBLOG)
+    t0 = time.time()
+    pol = Poller(sid); pol.start()
+    payload = {"message": ph["prompt"], "session_id": sid, "workspace_root": WS,
+               "agentic": rec["agentic"]}
+    if MODE == "local":
+        payload["agent_workspace_root"] = WS
+    st, body, js = http("POST", SOUL + "/api/chat", payload, timeout=CFG.get("chat_timeout", 240))
+    rec["http"].append(st)
+    rec["legs"].append(js if js is not None else body[:600])
+    rec["progress_per_leg"].append(progress(sid))
+    hops = 0
+    while isinstance(js, dict) and js.get("tool_pending") and hops < MAXHOPS:
+        rec["pendings"].append({"call_id": js.get("call_id"), "tool_name": js.get("tool_name"),
+                                "tool_input": js.get("tool_input"), "risk_tier": js.get("risk_tier"),
+                                "narration": js.get("narration"), "tools_used": js.get("tools_used")})
+        try:
+            eff = perform(js.get("tool_name", ""), js.get("tool_input") or {})
+        except Exception as e:
+            eff = "client error: %r" % (e,)
+        st, body, js = http("POST", SOUL + "/api/sessions/%s/tool_result" % sid,
+                            {"call_id": js.get("call_id"), "content": eff},
+                            timeout=CFG.get("chat_timeout", 240))
+        rec["http"].append(st)
+        rec["legs"].append(js if js is not None else body[:600])
+        rec["progress_per_leg"].append(progress(sid))
+        hops += 1
+    pol.stop = True; time.sleep(0.3)
+    t1 = time.time()
+    rec["elapsed"] = round(t1 - t0, 2)
+    rec["progress_during"] = pol.snaps
+    rec["progress_final"] = progress(sid)
+    rec["soul_log"], _ = tail_from(SOULLOG, soff)
+    rec["stub"], _ = stub_since(loff)
+    rec["hops"] = hops
+    return rec
+
+# ------------------------------------------------------------- assertions ----
+def expected_calls(cname, first_only=False):
+    out = []
+    for step in SCEN["classes"][cname]["script"]:
+        for k, call in enumerate(step.get("tool_calls") or []):
+            if first_only and k > 0:
+                continue
+            out.append((call["name"], call["arguments"]))
+    return out
+
+def final_text(cname):
+    for step in reversed(SCEN["classes"][cname]["script"]):
+        if step.get("text") and not step.get("tool_calls"):
+            return step["text"]
+    return None
+
+def judge(rec):
+    cname = rec["class"]; ok = []; bad = []
+    last = rec["legs"][-1] if rec["legs"] else None
+    reply = last.get("reply") if isinstance(last, dict) else None
+    err = last.get("error") if isinstance(last, dict) else None
+    tools_used = last.get("tools_used") if isinstance(last, dict) else None
+    stub = rec["stub"]
+    scen_recs = [r for r in stub if r.get("kind") == "scenario"]
+    rejects = [r for r in stub if r.get("validation") != "ok"]
+    bg = [r for r in stub if r.get("kind") in ("wrong_path", "background")]
+
+    def wire_clean():
+        if rejects:
+            for r in rejects:
+                bad.append("stub REJECTED a request: [%s] %s"
+                           % (r.get("validation"), r.get("validation_detail")))
+        else:
+            ok.append("stub ground truth: validation \"ok\" on all %d scenario leg(s), no "
+                      "gate_echo_mismatch / gate_tool_call_shape / dialect-leak 400s"
+                      % len(scen_recs))
+    if bg:
+        ok.append("NOTE background non-scenario request(s) in this window: %s"
+                  % [(r.get("kind"), r.get("path"), r.get("http_status")) for r in bg])
+
+    if cname == "oa-plain":
+        wire_clean()
+        want = final_text(cname)
+        if reply == want: ok.append("final reply == scripted final text (byte-exact)")
+        else: bad.append("final reply mismatch:\n  WANT: %r\n  GOT : %r" % (want, reply))
+        if tools_used == []: ok.append("tools_used == []  (no tool ran)")
+        else: bad.append("tools_used expected [] got %r" % (tools_used,))
+        if reply and ('"tool_calls"' in reply or '"function"' in reply or '"tool_use"' in reply):
+            bad.append("tool-call JSON leaked into the reply text")
+        else: ok.append("no tool-call JSON anywhere in the reply")
+
+    elif cname in ("oa-single-tool", "oa-torture", "oa-mission"):
+        wire_clean()
+        want = final_text(cname)
+        if reply == want: ok.append("final reply == scripted final text (byte-exact)")
+        else: bad.append("final reply mismatch:\n  WANT: %r\n  GOT : %r" % (want, reply))
+        exp = expected_calls(cname)
+        wantnames = [n for n, _ in exp]
+        if tools_used == wantnames:
+            ok.append("tools_used == %r  (carried across %d suspension(s))" % (wantnames, rec["hops"]))
+        else:
+            bad.append("tools_used expected %r got %r" % (wantnames, tools_used))
+        for name, args in exp:
+            p = args.get("path"); c = args.get("content")
+            dest = os.path.join(WS, p)
+            if not os.path.exists(dest):
+                bad.append("expected file missing on disk: %s" % dest); continue
+            got = open(dest, "rb").read()
+            if got == c.encode():
+                ok.append("%s on disk is byte-for-byte the issued payload (%d bytes)" % (p, len(got)))
+            else:
+                bad.append("%s content differs\n  WANT %r\n  GOT  %r"
+                           % (p, c[:300], got[:300].decode("utf-8", "replace")))
+        if MODE == "bridge":
+            for pend, (name, args) in zip(rec["pendings"], exp):
+                if pend["tool_input"] == args:
+                    ok.append("tool_input for %s survived exactly ONE decode (deep-equal to the "
+                              "issued arguments; no double-escaping)" % name)
+                else:
+                    bad.append("tool_input != issued arguments for %s\n  WANT %r\n  GOT  %r"
+                               % (name, args, pend["tool_input"]))
+            if rec["pendings"] and all(p["risk_tier"] == "escalate" for p in rec["pendings"]):
+                ok.append("every write_file classified \"escalate\" and bridged for consent")
+
+    elif cname == "oa-parallel":
+        drift = [l.strip() for l in rec["soul_log"].splitlines() if "DRIFT: provider returned" in l]
+        if drift: ok.append("soul log: " + drift[0])
+        else: bad.append("no 'DRIFT: provider returned N parallel tool_calls' line in the soul log")
+        delivered = [r for r in stub if r.get("delivered", {}).get("tool_calls")]
+        if delivered and len(delivered[0]["delivered"]["tool_calls"]) == 2:
+            ok.append("stub delivered 2 parallel tool_calls in one response (ground truth)")
+        if MODE == "bridge":
+            if len(rec["pendings"]) == 1:
+                ok.append("exactly ONE call honored: %s" % rec["pendings"][0]["call_id"])
+            else:
+                bad.append("expected exactly 1 honored call, got %d" % len(rec["pendings"]))
+        pairing = [r for r in rejects if "gate_pairing" in str(r.get("validation_detail")) or
+                   "tool_calls at end of thread" in str(r.get("validation_detail")) or
+                   "not fully answered" in str(r.get("validation_detail"))]
+        for r in pairing:
+            ok.append("EXPECTED-BY-CONTRACT stub 400 on the unpaired echo: %s"
+                      % r.get("validation_detail"))
+        other = [r for r in rejects if r not in pairing]
+        for r in other:
+            bad.append("unexpected stub rejection: [%s] %s"
+                       % (r.get("validation"), r.get("validation_detail")))
+        if err and not reply:
+            ok.append("honest error envelope after the 400 (no fabricated answer): %r" % err)
+        elif reply == final_text(cname):
+            ok.append("final reply == scripted final text (both calls paired)")
+        else:
+            bad.append("neither an honest error nor the scripted final text: %r" % (last,))
+
+    elif cname == "oa-api-error":
+        if err and not reply:
+            ok.append("honest error envelope: error=%r reply=%r" % (err, reply))
+        else:
+            bad.append("expected an error envelope with an empty reply, got %r" % (last,))
+        delivered = [r["delivered"].get("api_error") for r in stub if r.get("delivered")]
+        ok.append("stub delivered api_error status(es): %r" % [d for d in delivered if d])
+        n = len([r for r in stub if r.get("kind") == "scenario"])
+        ok.append("provider hit %d time(s) - no retry storm" % n)
+        if reply:
+            bad.append("FABRICATED ANSWER: reply non-empty on a provider error")
+
+    elif cname == "oa-tools-off":
+        ok.append("stub records for this phrasing: %r"
+                  % [{k: r.get(k) for k in ("kind", "path", "validation", "http_status")} for r in stub])
+        wrong = [r for r in stub if r.get("kind") == "wrong_path"]
+        matched = [r for r in stub if r.get("scenario_class") == cname]
+        if matched and not rejects:
+            ok.append("chat-only request reached /v1/chat/completions with NO tools offered")
+            want = final_text(cname)
+            if reply == want: ok.append("final reply == scripted final text (byte-exact)")
+            else: bad.append("final reply mismatch:\n  WANT: %r\n  GOT : %r" % (want, reply))
+            if reply and ('"tool_calls"' in reply or '"function"' in reply):
+                bad.append("tool-call JSON leaked into the reply text")
+            else: ok.append("no tool-call JSON in the reply")
+        elif wrong:
+            bad.append("the non-agentic lane never reached the provider endpoint: stub saw "
+                       "%s -> %s (the el-runtime provider chain appends /v1/chat/completions "
+                       "to NEURON_LLM_0_URL, chat.el appends only /chat/completions)"
+                       % (wrong[0]["path"], wrong[0]["http_status"]))
+        elif not stub:
+            bad.append("no request reached the stub at all")
+        else:
+            for r in rejects:
+                bad.append("stub REJECTED: [%s] %s" % (r.get("validation"), r.get("validation_detail")))
+    return ok, bad
+
+def main():
+    results = []
+    for cname in ONLY:
+        for ph in SCEN["classes"][cname]["phrasings"]:
+            rec = run_phrasing(cname, ph)
+            ok, bad = judge(rec)
+            rec["ok"] = ok; rec["bad"] = bad
+            rec["verdict"] = "FAIL" if bad else "PASS"
+            results.append(rec)
+            print("=" * 78)
+            print("[%s] %s / %s   (%.2fs, %d bridge hop(s), agentic=%s, mode=%s)"
+                  % (rec["verdict"], cname, ph["id"], rec.get("elapsed", 0),
+                     rec.get("hops", 0), rec["agentic"], MODE))
+            for l in ok:  print("   ok   " + l.replace("\n", "\n        "))
+            for l in bad: print("   FAIL " + l.replace("\n", "\n        "))
+            for i, leg in enumerate(rec["legs"]):
+                print("   leg%d envelope: %s" % (i, json.dumps(leg)[:430]))
+            for i, pr in enumerate(rec["progress_per_leg"]):
+                print("   run-progress after leg%d: %s" % (i, json.dumps(pr)[:380]))
+            if rec["progress_during"]:
+                print("   run-progress polled DURING (%d distinct snapshot(s)), last: %s"
+                      % (len(rec["progress_during"]), json.dumps(rec["progress_during"][-1])[:300]))
+            for r in rec["stub"]:
+                print("   stub: kind=%s class=%s phrasing=%s step=%s validation=%s%s delivered=%s http=%s"
+                      % (r.get("kind"), r.get("scenario_class"), r.get("phrasing"), r.get("step"),
+                         r.get("validation"),
+                         ("(" + str(r.get("validation_detail")) + ")") if r.get("validation_detail") else "",
+                         json.dumps(r.get("delivered")), r.get("http_status")))
+            if rec["soul_log"].strip():
+                for l in rec["soul_log"].splitlines():
+                    if l.strip(): print("   soul: " + l.strip())
+    json.dump(results, open(OUT, "w"), indent=1)
+    npass = sum(1 for r in results if r["verdict"] == "PASS")
+    print("=" * 78)
+    print("PHASE %s: %d/%d PASS" % (MODE, npass, len(results)))
+    for r in results:
+        print("   %-6s %-16s %s" % (r["verdict"], r["class"], r["phrasing"]))
+    return 0 if npass == len(results) else 1
+
+sys.exit(main())
+PYEOF
+
+# ------------------------------------------------------------- hostile drv ---
+cat > "$RUN/hostile.py" <<'PYEOF'
+import json, os, sys, time, urllib.request, urllib.error
+
+CFG = json.load(open(sys.argv[1]))
+SOUL = "http://127.0.0.1:%d" % CFG["soul_port"]
+STUB = "http://127.0.0.1:%d" % CFG["stub_port"]
+
+def http(method, url, obj=None, timeout=400):
+    data = None if obj is None else json.dumps(obj).encode()
+    req = urllib.request.Request(url, data=data, method=method,
+                                 headers={"Content-Type": "application/json"})
+    try:
+        with urllib.request.urlopen(req, timeout=timeout) as r:
+            b = r.read().decode("utf-8", "replace"); st = r.status
+    except urllib.error.HTTPError as e:
+        b = e.read().decode("utf-8", "replace"); st = e.code
+    except Exception as e:
+        return -1, "TRANSPORT-ERROR: %r" % (e,), None
+    try:
+        return st, b, json.loads(b)
+    except ValueError:
+        return st, b, None
+
+mode = CFG["mode"]; wsmode = CFG["ws_mode"]; WS = CFG["workspace"]
+_, _, js = http("POST", SOUL + "/api/sessions", {"title": "hostile-" + mode}, timeout=60)
+sid = (js or {}).get("id", "")
+payload = {"message": "oa-gate plain probe: hostile mode %s" % mode,
+           "agentic": True, "session_id": sid, "workspace_root": WS}
+if wsmode == "local":
+    payload["agent_workspace_root"] = WS
+t0 = time.time()
+st, body, js = http("POST", SOUL + "/api/chat", payload, timeout=CFG.get("timeout", 400))
+t_first = time.time() - t0
+legs = [js if js is not None else body[:500]]
+hops = 0
+while isinstance(js, dict) and js.get("tool_pending") and hops < CFG.get("max_hops", 14):
+    ti = js.get("tool_input") or {}
+    p = ti.get("path", "x.md")
+    dest = p if os.path.isabs(p) else os.path.join(WS, p)
+    try: open(dest, "w").write(ti.get("content", ""))
+    except Exception: pass
+    st, body, js = http("POST", SOUL + "/api/sessions/%s/tool_result" % sid,
+                        {"call_id": js.get("call_id"), "content": "ok"},
+                        timeout=CFG.get("timeout", 400))
+    legs.append(js if js is not None else body[:500]); hops += 1
+el = time.time() - t0
+_, _, stats = http("GET", STUB + "/gate/stats", timeout=30)
+_, _, prog = http("GET", SOUL + "/api/run-progress/" + sid, timeout=30)
+fab = [l for l in legs if isinstance(l, dict) and l.get("reply")]
+print("HOSTILE %s (ws_mode=%s)" % (mode, wsmode))
+print("   first /api/chat POST returned after %.2fs; whole chain %.2fs; client bridge hops=%d; "
+      "stub chat_hits=%s" % (t_first, el, hops, (stats or {}).get("chat_hits")))
+print("   first envelope : " + json.dumps(legs[0])[:430])
+print("   final envelope : " + json.dumps(legs[-1])[:430])
+print("   non-empty replies anywhere in the chain (fabrication check): %d" % len(fab))
+print("   run-progress   : " + json.dumps(prog)[:300])
+json.dump({"mode": mode, "ws_mode": wsmode, "t_first": t_first, "elapsed": el, "hops": hops,
+           "chat_hits": (stats or {}).get("chat_hits"), "legs": legs, "progress": prog},
+          open(CFG["out"], "w"), indent=1)
+PYEOF
+
+# ------------------------------------------------------------------ phases ---
+RC_BRIDGE=0; RC_LOCAL=0; RC_OFF=0
+run_normal_phase() { # $1 = label, $2 = soul port, $3 = agent root, $4 = ws, $5 = base, $6 = classes json
+  local m="$1" port="$2" root="$3" ws="$4" base="$5" classes="$6"
+  echo; echo "############ PHASE: $m (soul :$port, NEURON_LLM_0_URL=$base) ############"
+  start_stub normal "$RUN/stub-$m.jsonl"
+  start_soul "$port" "$base" "$RUN/soul-$m.log" "$root"
+  cat > "$RUN/cfg-$m.json" <<JSON
+{"soul_port": $port, "stub_port": $STUB_PORT, "workspace": "$ws", "mode": "$m",
+ "scenarios": "$HERE/scenarios-openai.json", "stub_log": "$RUN/stub-$m.jsonl",
+ "soul_log": "$RUN/soul-$m.log", "out": "$RUN/results-$m.json", "chat_timeout": 240,
+ "classes": $classes}
+JSON
+  python3 "$DRV" "$RUN/cfg-$m.json"
+  local rc=$?
+  stop_soul; stop_stub
+  return $rc
+}
+
+if [ "$PHASES" = "all" ] || [ "$PHASES" = "bridge" ]; then
+  run_normal_phase bridge "$SOUL_PORT" "" "$RUN/ws-bridge" "http://127.0.0.1:$STUB_PORT/v1" null
+  RC_BRIDGE=$?
+fi
+if [ "$PHASES" = "all" ] || [ "$PHASES" = "local" ]; then
+  run_normal_phase local "$SOUL_PORT_B" "$RUN/ws-local" "$RUN/ws-local" "http://127.0.0.1:$STUB_PORT/v1" null
+  RC_LOCAL=$?
+fi
+if [ "$PHASES" = "all" ] || [ "$PHASES" = "toolsoff" ]; then
+  # supplementary: the el-runtime provider chain appends /v1/chat/completions itself,
+  # so the non-agentic door needs the base WITHOUT the /v1 suffix.
+  run_normal_phase toolsoff "$SOUL_PORT" "" "$RUN/ws-off" "http://127.0.0.1:$STUB_PORT" '["oa-tools-off","oa-plain"]'
+  RC_OFF=$?
+fi
+
+if [ "$PHASES" = "all" ] || [ "$PHASES" = "hostile" ]; then
+  echo; echo "############ PHASE: hostile ############"
+  for spec in "black-hole:bridge" "mid-body-drop:bridge" "tool-pending-forever:bridge" "tool-pending-forever:local"; do
+    mode="${spec%%:*}"; wsm="${spec##*:}"
+    echo; echo "---- hostile mode=$mode ws_mode=$wsm ----"
+    start_stub "$mode" "$RUN/stub-$mode-$wsm.jsonl"
+    if [ "$wsm" = "local" ]; then
+      start_soul "$SOUL_PORT" "http://127.0.0.1:$STUB_PORT/v1" "$RUN/soul-$mode-$wsm.log" "$RUN/ws-local"
+    else
+      start_soul "$SOUL_PORT" "http://127.0.0.1:$STUB_PORT/v1" "$RUN/soul-$mode-$wsm.log" ""
+    fi
+    cat > "$RUN/cfg-$mode-$wsm.json" <<JSON
+{"soul_port": $SOUL_PORT, "stub_port": $STUB_PORT, "mode": "$mode", "ws_mode": "$wsm",
+ "workspace": "$RUN/ws-local", "out": "$RUN/hostile-$mode-$wsm.json", "timeout": 400}
+JSON
+    python3 "$RUN/hostile.py" "$RUN/cfg-$mode-$wsm.json"
+    echo "   soul log (llm/DRIFT/cap lines):"
+    grep -E "DRIFT|llm error|iteration cap|\[llm\]" "$RUN/soul-$mode-$wsm.log" | tail -8 | sed 's/^/     /'
+    stop_soul; stop_stub
+  done
+fi
+
+echo; echo "############ CLEANUP ############"
+cleanup
+sleep 0.5
+echo "processes still matching the soul binary:"; pgrep -fl "$SOUL_BIN" || echo "   (none)"
+echo "processes still matching stub-openai.py:"; pgrep -fl "stub-openai.py" || echo "   (none)"
+echo "lsof on 7891-7894 after cleanup:"
+lsof -nP -iTCP:7891 -iTCP:7892 -iTCP:7893 -iTCP:7894 2>/dev/null || echo "   (no listeners - ports free)"
+echo
+echo "############ SUMMARY ############"
+echo "run dir: $RUN"
+echo "bridge rc=$RC_BRIDGE   local rc=$RC_LOCAL   toolsoff rc=$RC_OFF   (0 = every class PASS)"
+exit $(( RC_BRIDGE + RC_LOCAL + RC_OFF ))

tests/gate-openai/scenarios-openai.json

@@ -0,0 +1,110 @@
+{
+  "_comment": "OpenAI-dialect gate scenario contract (soul-openai-tools-v2). Single source of truth shared by stub-openai.py (scripted provider responses + request assertions), selftest.sh (stub self-verification), and the future brain-side gate driver. Same structure as gate9's scenarios.json: classes -> script + phrasings with markers; scripts are CLASS-level so assertions are behavioral, never pinned to a sentence. expect_request keys: require_tools, require_tool_choice, parallel_tool_calls (expected literal value; null = don't check), forbid_tools. defaults apply to every class unless overridden; steps may override with their own expect_request.",
+  "deadline_secs": 60,
+  "max_loop_iterations": 16,
+  "defaults": {
+    "expect_request": {
+      "require_tools": true,
+      "require_tool_choice": true,
+      "parallel_tool_calls": false
+    }
+  },
+  "classes": {
+    "oa-plain": {
+      "script": [
+        { "text": "Plain OpenAI-lane answer (gate fixture): the mechanism, the main caveat, and the practical takeaway in three sentences. No tools were needed for this one, and the finish reason on the wire is stop, which the loop must treat as terminal." }
+      ],
+      "phrasings": [
+        { "id": "oa-plain-p1", "marker": "oa-gate plain probe", "prompt": "oa-gate plain probe: explain the fixture topic simply." },
+        { "id": "oa-plain-p2", "marker": "oa-gate second plain", "prompt": "oa-gate second plain: another phrasing of the plain question." }
+      ]
+    },
+    "oa-tools-off": {
+      "expect_request": {
+        "require_tools": false,
+        "forbid_tools": true,
+        "require_tool_choice": false,
+        "parallel_tool_calls": null
+      },
+      "script": [
+        { "text": "Chat-only OpenAI-lane answer (gate fixture): this lane offered no tools and none were used; the reply is plain text with finish reason stop." }
+      ],
+      "phrasings": [
+        { "id": "oa-tools-off-p1", "marker": "oa-gate tools-off probe", "prompt": "oa-gate tools-off probe: plain chat with no tools offered." }
+      ]
+    },
+    "oa-single-tool": {
+      "script": [
+        { "text": "Step 1: writing the note.",
+          "tool_calls": [
+            { "name": "write_file",
+              "arguments": { "path": "openai-single-note.md", "content": "# Note (gate fixture, OpenAI lane)\n\nDeterministic single-tool body.\n" } }
+          ] },
+        { "text": "All set - openai-single-note.md is written with the fixture body. Nothing else was needed for this one." }
+      ],
+      "phrasings": [
+        { "id": "oa-single-p1", "marker": "oa-gate single tool note", "prompt": "oa-gate single tool note: save the fixture note to a file." },
+        { "id": "oa-single-p2", "marker": "oa-gate one file please", "prompt": "oa-gate one file please: write the fixture note file." }
+      ]
+    },
+    "oa-torture": {
+      "script": [
+        { "tool_calls": [
+            { "name": "write_file",
+              "arguments": { "path": "torture-note.md", "content": "Line 1 has \"double quotes\", 'singles', and a mid-line backslash \\ here.\nLine 2\thas a tab, a literal \\n two-char sequence, and a Windows path C:\\temp\\new.txt.\nLine 3 unicode: naïve café — 日本語 ✓ 🚀\nLine 4 JSON-in-string: {\"k\": \"v\", \"arr\": [1, 2], \"s\": \"nested \\\"deep\\\" quotes\"}\nLine 5 ends with a lone backslash \\" } }
+          ] },
+        { "text": "Torture round-trip complete: the payload with nested quotes, backslashes, newlines, tabs, and unicode survived exactly one encode and one decode." }
+      ],
+      "phrasings": [
+        { "id": "oa-torture-p1", "marker": "oa-gate torture probe", "prompt": "oa-gate torture probe: write the escaping torture file." }
+      ]
+    },
+    "oa-parallel": {
+      "script": [
+        { "text": "Step 1: two writes at once (parallel probe).",
+          "tool_calls": [
+            { "name": "write_file", "arguments": { "path": "parallel-a.md", "content": "Parallel A (gate fixture).\n" } },
+            { "name": "write_file", "arguments": { "path": "parallel-b.md", "content": "Parallel B (gate fixture).\n" } }
+          ] },
+        { "text": "Parallel probe complete: both tool results arrived and were paired correctly. A brain that instead rejects the double call must do so cleanly - that outcome is asserted brain-side, not here." }
+      ],
+      "phrasings": [
+        { "id": "oa-parallel-p1", "marker": "oa-gate parallel probe", "prompt": "oa-gate parallel probe: run the two-write parallel case." }
+      ]
+    },
+    "oa-mission": {
+      "script": [
+        { "text": "Step 1: drafting part one.",
+          "tool_calls": [
+            { "name": "write_file", "arguments": { "path": "mission-part-1.md", "content": "Mission part 1 (gate fixture).\n" } }
+          ] },
+        { "text": "Step 2: drafting part two.",
+          "tool_calls": [
+            { "name": "write_file", "arguments": { "path": "mission-part-2.md", "content": "Mission part 2 (gate fixture).\n" } }
+          ] },
+        { "text": "Mission complete: mission-part-1.md and mission-part-2.md are written; the loop ran two tool rounds and finished cleanly with finish reason stop." }
+      ],
+      "phrasings": [
+        { "id": "oa-mission-p1", "marker": "oa-gate mission probe", "prompt": "oa-gate mission probe: run the two-round mission." }
+      ]
+    },
+    "oa-api-error": {
+      "expect_request": {
+        "require_tools": false,
+        "require_tool_choice": false,
+        "parallel_tool_calls": null
+      },
+      "script": [],
+      "phrasings": [
+        { "id": "oa-err-400", "marker": "oa-gate error four hundred", "prompt": "oa-gate error four hundred: trigger the injected failure.",
+          "script": [ { "api_error": { "status": 400, "type": "invalid_request_error", "message": "gate-injected 400: request rejected by fixture", "code": "gate_injected" } } ] },
+        { "id": "oa-err-429", "marker": "oa-gate error rate limit", "prompt": "oa-gate error rate limit: trigger the injected failure.",
+          "script": [ { "api_error": { "status": 429, "type": "rate_limit_error", "message": "gate-injected 429: rate limited by fixture", "code": "rate_limit_exceeded" } } ] },
+        { "id": "oa-err-500", "marker": "oa-gate error five hundred", "prompt": "oa-gate error five hundred: trigger the injected failure.",
+          "script": [ { "api_error": { "status": 500, "type": "server_error", "message": "gate-injected 500: internal fixture error", "code": "gate_injected" } } ] },
+        { "id": "oa-err-503", "marker": "oa-gate error unavailable", "prompt": "oa-gate error unavailable: trigger the injected failure.",
+          "script": [ { "api_error": { "status": 503, "type": "server_error", "message": "gate-injected 503: fixture overloaded", "code": "gate_injected" } } ] }
+      ]
+    }
+  }
+}

tests/gate-openai/selftest.sh

@@ -0,0 +1,409 @@
+#!/usr/bin/env bash
+# selftest.sh - proves stub-openai.py before any brain code exists.
+# Drives the stub with curl through every scenario (plain, tools-off,
+# single tool round-trip, escaping torture, parallel double-call,
+# two-round mission, injected API errors, background, overrun), every
+# validation rejection (dialect leaks, pairing, echo round-trip, scenario
+# expectations), and all three hostile modes. Exit 0 = green.
+set -u
+cd "$(dirname "$0")" || exit 1
+PY=python3
+TMP="$(mktemp -d)"
+PIDS=()
+cleanup() {
+  for p in "${PIDS[@]:-}"; do kill -9 "$p" >/dev/null 2>&1; done
+  rm -rf "$TMP"
+}
+trap cleanup EXIT
+
+PASS=0; FAIL=0
+ok()  { printf 'ok   - %s\n' "$1"; PASS=$((PASS+1)); }
+bad() { printf 'FAIL - %s\n' "$1"; FAIL=$((FAIL+1)); }
+check() {  # check <name> <cmd...>  - pass if cmd exits 0; show output on fail
+  local name="$1"; shift
+  local out
+  if out="$("$@" 2>&1)"; then ok "$name"
+  else bad "$name"; [ -n "$out" ] && printf '%s\n' "$out" | sed 's/^/       /' | head -8
+  fi
+}
+
+freeport() { "$PY" -c 'import socket;s=socket.socket();s.bind(("127.0.0.1",0));print(s.getsockname()[1]);s.close()'; }
+waithealth() {
+  local p="$1" i
+  for i in $(seq 1 60); do
+    curl -sf "http://127.0.0.1:$p/gate/health" >/dev/null 2>&1 && return 0
+    sleep 0.1
+  done
+  echo "stub on :$p never became healthy"; return 1
+}
+post() {  # post <port> <bodyfile> <respfile> [extra curl args...] -> echoes http code
+  local port="$1" body="$2" resp="$3"; shift 3
+  curl -s -o "$resp" -w '%{http_code}' -H 'content-type: application/json' \
+       "$@" --data-binary @"$body" "http://127.0.0.1:$port/v1/chat/completions"
+}
+
+# ---- embedded helper: builds OpenAI-dialect bodies, asserts on responses ----
+cat > "$TMP/helpers.py" <<'PYEOF'
+import copy, json, sys
+
+TOOLS = [
+    {"type": "function", "function": {
+        "name": "write_file", "description": "Write content to a file on disk.",
+        "parameters": {"type": "object",
+                       "properties": {"path": {"type": "string"},
+                                      "content": {"type": "string"}},
+                       "required": ["path", "content"]}}},
+    {"type": "function", "function": {
+        "name": "read_file", "description": "Read contents of a file from disk.",
+        "parameters": {"type": "object",
+                       "properties": {"path": {"type": "string"}},
+                       "required": ["path"]}}},
+]
+
+def dump(obj, out):
+    json.dump(obj, open(out, "w"), ensure_ascii=False)
+
+def base(prompt, tools=True):
+    b = {"model": "gate-openai-model", "max_tokens": 1024,
+         "messages": [
+             {"role": "system", "content": "You are Neuron (gate fixture)."},
+             {"role": "user", "content": prompt}]}
+    if tools:
+        b["tools"] = copy.deepcopy(TOOLS)
+        b["tool_choice"] = "auto"
+        b["parallel_tool_calls"] = False
+    return b
+
+def cmd_plain(out, prompt):
+    dump(base(prompt), out)
+
+def cmd_notools(out, prompt):
+    dump(base(prompt, tools=False), out)
+
+def cmd_mut(out, prompt, mutation):
+    b = base(prompt)
+    if mutation == "no-tool-choice":
+        del b["tool_choice"]
+    elif mutation == "ptc-true":
+        b["parallel_tool_calls"] = True
+    elif mutation == "top-system":
+        b["system"] = "You are Neuron."
+    elif mutation == "anth-tools":
+        b["tools"] = [{"name": "write_file", "description": "x",
+                       "input_schema": {"type": "object", "properties": {}}}]
+    elif mutation == "anth-block":
+        b["messages"][1] = {"role": "user", "content": [
+            {"type": "tool_result", "tool_use_id": "toolu_x", "content": "hi"},
+            {"type": "text", "text": prompt}]}
+    else:
+        raise SystemExit("unknown mutation " + mutation)
+    dump(b, out)
+
+def cmd_chain(out, prompt, variant, *resps):
+    """Build the next leg: echo each response's assistant turn and answer its
+    tool calls. `variant` applies to the LAST response only:
+    ok | no-tool-turn | wrong-id | only-first | double-encode | object-args"""
+    b = base(prompt)
+    for idx, p in enumerate(resps):
+        last = idx == len(resps) - 1
+        msg = json.load(open(p))["choices"][0]["message"]
+        tcs = msg.get("tool_calls")
+        if not tcs:
+            b["messages"].append({"role": "assistant",
+                                  "content": msg.get("content")})
+            continue
+        v = variant if last else "ok"
+        asst = {"role": "assistant", "content": msg.get("content"),
+                "tool_calls": copy.deepcopy(tcs)}
+        if v == "double-encode":
+            for tc in asst["tool_calls"]:
+                tc["function"]["arguments"] = json.dumps(
+                    tc["function"]["arguments"])
+        if v == "object-args":
+            for tc in asst["tool_calls"]:
+                tc["function"]["arguments"] = json.loads(
+                    tc["function"]["arguments"])
+        b["messages"].append(asst)
+        if v == "no-tool-turn":
+            continue
+        use = tcs[:1] if v == "only-first" else tcs
+        for tc in use:
+            tid = "call_bogus_123" if v == "wrong-id" else tc["id"]
+            b["messages"].append({"role": "tool", "tool_call_id": tid,
+                                  "content": "{\"ok\":true,\"bytes\":42}"})
+    dump(b, out)
+
+def cmd_chk(resp, expr):
+    r = json.load(open(resp))
+    if not eval(expr, {"r": r, "json": json, "len": len, "str": str,
+                       "isinstance": isinstance, "any": any, "all": all,
+                       "sorted": sorted}):
+        print("assertion failed:", expr)
+        print("resp:", json.dumps(r, ensure_ascii=False)[:400])
+        raise SystemExit(1)
+
+def cmd_torture(resp, scen):
+    r = json.load(open(resp))
+    tc = r["choices"][0]["message"]["tool_calls"][0]
+    raw = tc["function"]["arguments"]
+    assert isinstance(raw, str), "arguments must be a JSON-encoded string"
+    got = json.loads(raw)
+    exp = json.load(open(scen))["classes"]["oa-torture"]["script"][0]["tool_calls"][0]["arguments"]
+    assert got == exp, "decoded arguments != scripted torture payload"
+    content = got["content"]
+    for needle in ['"', "\\", "\n", "\t", "日本語", "naïve", "🚀"]:
+        assert needle in content, "missing torture needle %r" % needle
+
+def cmd_notjson(path):
+    data = open(path, "rb").read()
+    assert data, "file empty - no partial body arrived"
+    try:
+        json.loads(data.decode("utf-8", "replace"))
+    except ValueError:
+        return
+    raise SystemExit("partial body unexpectedly parsed as complete JSON")
+
+def cmd_pending(*paths):
+    ids = []
+    for p in paths:
+        c = json.load(open(p))["choices"][0]
+        assert c["finish_reason"] == "tool_calls", c["finish_reason"]
+        tc = c["message"]["tool_calls"][0]
+        assert tc["function"]["name"] == "write_file"
+        json.loads(tc["function"]["arguments"])  # must decode
+        ids.append(tc["id"])
+    assert len(set(ids)) == len(ids), "call ids not distinct: %r" % ids
+
+def cmd_logcheck(path):
+    recs = [json.loads(l) for l in open(path) if l.strip()]
+    seqs = [r["seq"] for r in recs]
+    assert seqs == sorted(seqs) and len(set(seqs)) == len(seqs), "seq not monotonic"
+    kinds = {}
+    for r in recs:
+        kinds[r["kind"]] = kinds.get(r["kind"], 0) + 1
+    assert kinds.get("scenario", 0) >= 10, "too few scenario records: %r" % kinds
+    assert kinds.get("background", 0) >= 1, "no background record"
+    assert kinds.get("overrun", 0) >= 1, "no overrun record"
+    rejected = [r for r in recs if r["validation"] == "rejected"]
+    assert len(rejected) >= 10, "too few rejected records: %d" % len(rejected)
+    assert any(r["delivered"].get("tool_calls") == ["write_file"]
+               for r in recs), "no single write_file ground truth"
+    assert any(r["delivered"].get("tool_calls") == ["write_file", "write_file"]
+               for r in recs), "no parallel ground truth"
+
+def main():
+    fn = globals()["cmd_" + sys.argv[1].replace("-", "_")]
+    fn(*sys.argv[2:])
+
+if __name__ == "__main__":
+    main()
+PYEOF
+mk() { "$PY" "$TMP/helpers.py" "$@"; }
+
+echo "=== stub-openai selftest ==="
+
+# ---- normal mode ------------------------------------------------------------
+PORT="$(freeport)"
+"$PY" stub-openai.py --port "$PORT" --scenarios scenarios-openai.json \
+     --log "$TMP/req.jsonl" >"$TMP/stub.out" 2>&1 &
+PIDS+=($!); disown
+check "stub starts and answers /gate/health" waithealth "$PORT"
+
+# 1. plain completion
+mk plain "$TMP/plain.json" "oa-gate plain probe: explain the fixture topic simply."
+code="$(post "$PORT" "$TMP/plain.json" "$TMP/r_plain.json")"
+check "plain: HTTP 200" test "$code" = "200"
+check "plain: chat.completion envelope, finish stop, real content" mk chk "$TMP/r_plain.json" \
+  'r["object"]=="chat.completion" and r["choices"][0]["finish_reason"]=="stop" and isinstance(r["choices"][0]["message"]["content"],str) and len(r["choices"][0]["message"]["content"])>40'
+
+# 2. tools-off lane (chat-only request accepted, tool-bearing request refused)
+mk notools "$TMP/toolsoff.json" "oa-gate tools-off probe: plain chat with no tools offered."
+code="$(post "$PORT" "$TMP/toolsoff.json" "$TMP/r_toolsoff.json")"
+check "tools-off: chat-only request -> 200" test "$code" = "200"
+mk plain "$TMP/toolsoff_bad.json" "oa-gate tools-off probe: plain chat with no tools offered."
+code="$(post "$PORT" "$TMP/toolsoff_bad.json" "$TMP/r_toolsoff_bad.json")"
+check "tools-off negative: offering tools -> 400 gate_expect" \
+  bash -c "test $code = 400"
+check "tools-off negative: reason names gate_expect" mk chk "$TMP/r_toolsoff_bad.json" \
+  'r["error"]["code"]=="gate_expect"'
+
+# 3. dialect-leak rejections (the loud-failure contract)
+code="$(post "$PORT" "$TMP/plain.json" "$TMP/r_leak_hdr.json" -H 'anthropic-version: 2023-06-01')"
+check "leak: anthropic-version header -> 400" test "$code" = "400"
+check "leak: header reason names the leak" mk chk "$TMP/r_leak_hdr.json" \
+  'r["error"]["code"]=="gate_dialect_leak" and "anthropic-version" in r["error"]["message"]'
+mk mut "$TMP/leak_tools.json" "oa-gate plain probe: explain the fixture topic simply." anth-tools
+code="$(post "$PORT" "$TMP/leak_tools.json" "$TMP/r_leak_tools.json")"
+check "leak: input_schema tools -> 400 gate_dialect_leak" bash -c \
+  "test $code = 400"
+check "leak: input_schema reason" mk chk "$TMP/r_leak_tools.json" \
+  'r["error"]["code"]=="gate_dialect_leak" and "input_schema" in r["error"]["message"]'
+mk mut "$TMP/leak_sys.json" "oa-gate plain probe: explain the fixture topic simply." top-system
+code="$(post "$PORT" "$TMP/leak_sys.json" "$TMP/r_leak_sys.json")"
+check "leak: top-level system -> 400" test "$code" = "400"
+mk mut "$TMP/leak_block.json" "oa-gate plain probe: explain the fixture topic simply." anth-block
+code="$(post "$PORT" "$TMP/leak_block.json" "$TMP/r_leak_block.json")"
+check "leak: Anthropic tool_result content block -> 400" test "$code" = "400"
+
+# 4. scenario request expectations
+mk mut "$TMP/no_tc.json" "oa-gate plain probe: explain the fixture topic simply." no-tool-choice
+code="$(post "$PORT" "$TMP/no_tc.json" "$TMP/r_no_tc.json")"
+check "expect: missing tool_choice -> 400" test "$code" = "400"
+mk mut "$TMP/ptc.json" "oa-gate plain probe: explain the fixture topic simply." ptc-true
+code="$(post "$PORT" "$TMP/ptc.json" "$TMP/r_ptc.json")"
+check "expect: parallel_tool_calls true -> 400 (ADR-0005 pin)" test "$code" = "400"
+
+# 5. single tool round-trip
+ST_PROMPT="oa-gate single tool note: save the fixture note to a file."
+mk plain "$TMP/st1.json" "$ST_PROMPT"
+code="$(post "$PORT" "$TMP/st1.json" "$TMP/r_st1.json")"
+check "single-tool leg1: HTTP 200" test "$code" = "200"
+check "single-tool leg1: one write_file call, finish tool_calls, string args" mk chk "$TMP/r_st1.json" \
+  'r["choices"][0]["finish_reason"]=="tool_calls" and len(r["choices"][0]["message"]["tool_calls"])==1 and r["choices"][0]["message"]["tool_calls"][0]["type"]=="function" and r["choices"][0]["message"]["tool_calls"][0]["function"]["name"]=="write_file" and isinstance(r["choices"][0]["message"]["tool_calls"][0]["function"]["arguments"],str) and json.loads(r["choices"][0]["message"]["tool_calls"][0]["function"]["arguments"])["path"]=="openai-single-note.md"'
+mk chain "$TMP/st2.json" "$ST_PROMPT" ok "$TMP/r_st1.json"
+code="$(post "$PORT" "$TMP/st2.json" "$TMP/r_st2.json")"
+check "single-tool leg2: echo + tool turn -> 200 final text" test "$code" = "200"
+check "single-tool leg2: final names the file, finish stop" mk chk "$TMP/r_st2.json" \
+  'r["choices"][0]["finish_reason"]=="stop" and "openai-single-note.md" in r["choices"][0]["message"]["content"]'
+mk chain "$TMP/st2_no.json" "$ST_PROMPT" no-tool-turn "$TMP/r_st1.json"
+code="$(post "$PORT" "$TMP/st2_no.json" "$TMP/r_st2_no.json")"
+check "single-tool negative: echo without tool turn -> 400 gate_pairing" \
+  bash -c "test $code = 400"
+check "single-tool negative: pairing reason" mk chk "$TMP/r_st2_no.json" \
+  'r["error"]["code"]=="gate_pairing"'
+mk chain "$TMP/st2_wrong.json" "$ST_PROMPT" wrong-id "$TMP/r_st1.json"
+code="$(post "$PORT" "$TMP/st2_wrong.json" "$TMP/r_st2_wrong.json")"
+check "single-tool negative: wrong tool_call_id -> 400" test "$code" = "400"
+mk chain "$TMP/st2_obj.json" "$ST_PROMPT" object-args "$TMP/r_st1.json"
+code="$(post "$PORT" "$TMP/st2_obj.json" "$TMP/r_st2_obj.json")"
+check "single-tool negative: arguments echoed as object -> 400 shape" \
+  bash -c "test $code = 400"
+check "single-tool negative: shape reason names STRING" mk chk "$TMP/r_st2_obj.json" \
+  'r["error"]["code"]=="gate_tool_call_shape" and "STRING" in r["error"]["message"]'
+
+# 6. escaping torture (the two-escaper trap, spec section 6)
+T_PROMPT="oa-gate torture probe: write the escaping torture file."
+mk plain "$TMP/t1.json" "$T_PROMPT"
+code="$(post "$PORT" "$TMP/t1.json" "$TMP/r_t1.json")"
+check "torture leg1: HTTP 200" test "$code" = "200"
+check "torture leg1: arguments decode to the exact nasty payload" \
+  mk torture "$TMP/r_t1.json" scenarios-openai.json
+mk chain "$TMP/t2.json" "$T_PROMPT" ok "$TMP/r_t1.json"
+code="$(post "$PORT" "$TMP/t2.json" "$TMP/r_t2.json")"
+check "torture leg2: faithful echo -> 200 final" test "$code" = "200"
+mk chain "$TMP/t2_dbl.json" "$T_PROMPT" double-encode "$TMP/r_t1.json"
+code="$(post "$PORT" "$TMP/t2_dbl.json" "$TMP/r_t2_dbl.json")"
+check "torture negative: double-encoded echo -> 400" test "$code" = "400"
+check "torture negative: reason names the two-escaper trap" mk chk "$TMP/r_t2_dbl.json" \
+  'r["error"]["code"]=="gate_echo_mismatch" and "two-escaper" in r["error"]["message"]'
+
+# 7. parallel double-call
+P_PROMPT="oa-gate parallel probe: run the two-write parallel case."
+mk plain "$TMP/p1.json" "$P_PROMPT"
+code="$(post "$PORT" "$TMP/p1.json" "$TMP/r_p1.json")"
+check "parallel leg1: TWO tool_calls, distinct ids" mk chk "$TMP/r_p1.json" \
+  'r["choices"][0]["finish_reason"]=="tool_calls" and len(r["choices"][0]["message"]["tool_calls"])==2 and r["choices"][0]["message"]["tool_calls"][0]["id"]!=r["choices"][0]["message"]["tool_calls"][1]["id"]'
+mk chain "$TMP/p2.json" "$P_PROMPT" ok "$TMP/r_p1.json"
+code="$(post "$PORT" "$TMP/p2.json" "$TMP/r_p2.json")"
+check "parallel leg2: both results -> 200 final" test "$code" = "200"
+mk chain "$TMP/p2_one.json" "$P_PROMPT" only-first "$TMP/r_p1.json"
+code="$(post "$PORT" "$TMP/p2_one.json" "$TMP/r_p2_one.json")"
+check "parallel negative: answering only one call -> 400 pairing" test "$code" = "400"
+
+# 8. two-round mission (loop continuation + step indexing)
+M_PROMPT="oa-gate mission probe: run the two-round mission."
+mk plain "$TMP/m1.json" "$M_PROMPT"
+code="$(post "$PORT" "$TMP/m1.json" "$TMP/r_m1.json")"
+check "mission leg1: part-1 tool call" mk chk "$TMP/r_m1.json" \
+  'json.loads(r["choices"][0]["message"]["tool_calls"][0]["function"]["arguments"])["path"]=="mission-part-1.md"'
+mk chain "$TMP/m2.json" "$M_PROMPT" ok "$TMP/r_m1.json"
+code="$(post "$PORT" "$TMP/m2.json" "$TMP/r_m2.json")"
+check "mission leg2: part-2 tool call (step indexed by assistant count)" mk chk "$TMP/r_m2.json" \
+  'r["choices"][0]["finish_reason"]=="tool_calls" and json.loads(r["choices"][0]["message"]["tool_calls"][0]["function"]["arguments"])["path"]=="mission-part-2.md"'
+mk chain "$TMP/m3.json" "$M_PROMPT" ok "$TMP/r_m1.json" "$TMP/r_m2.json"
+code="$(post "$PORT" "$TMP/m3.json" "$TMP/r_m3.json")"
+check "mission leg3: final text, finish stop" mk chk "$TMP/r_m3.json" \
+  'r["choices"][0]["finish_reason"]=="stop" and "Mission complete" in r["choices"][0]["message"]["content"]'
+mk chain "$TMP/m4.json" "$M_PROMPT" ok "$TMP/r_m1.json" "$TMP/r_m2.json" "$TMP/r_m3.json"
+code="$(post "$PORT" "$TMP/m4.json" "$TMP/r_m4.json")"
+check "mission overrun: past-script request -> GATE-SCRIPT-EXHAUSTED" mk chk "$TMP/r_m4.json" \
+  'r["choices"][0]["message"]["content"].startswith("GATE-SCRIPT-EXHAUSTED")'
+
+# 9. injected API errors (OpenAI error envelope)
+for want in 400 429 500 503; do
+  case "$want" in
+    400) marker="four hundred";; 429) marker="rate limit";;
+    500) marker="five hundred";; 503) marker="unavailable";;
+  esac
+  mk plain "$TMP/e_$want.json" "oa-gate error $marker: trigger the injected failure."
+  code="$(post "$PORT" "$TMP/e_$want.json" "$TMP/r_e_$want.json")"
+  check "api-error $want: status returned" test "$code" = "$want"
+  check "api-error $want: OpenAI error envelope" mk chk "$TMP/r_e_$want.json" \
+    'isinstance(r["error"]["message"],str) and "gate-injected" in r["error"]["message"] and isinstance(r["error"]["type"],str)'
+done
+
+# 10. background (unmatched) request
+mk plain "$TMP/bg.json" "hello there, just a boot probe with no marker"
+code="$(post "$PORT" "$TMP/bg.json" "$TMP/r_bg.json")"
+check "background: unmatched prompt -> benign ok" mk chk "$TMP/r_bg.json" \
+  'r["choices"][0]["message"]["content"]=="ok"'
+
+# 11. ground-truth log invariants
+check "ground-truth JSONL log invariants" mk logcheck "$TMP/req.jsonl"
+
+# 12. production-port refusal
+rc=0
+"$PY" stub-openai.py --port 7770 --scenarios scenarios-openai.json \
+     --log "$TMP/never.jsonl" >/dev/null 2>&1 || rc=$?
+check "refuses production port 7770" test "$rc" -ne 0
+
+# ---- hostile mode: black-hole ----------------------------------------------
+BH="$(freeport)"
+"$PY" stub-openai.py --port "$BH" --log "$TMP/bh.jsonl" --mode black-hole \
+     >/dev/null 2>&1 &
+PIDS+=($!); disown
+check "black-hole: healthy" waithealth "$BH"
+rc=0
+curl -s -o /dev/null --max-time 3 -H 'content-type: application/json' \
+     --data-binary @"$TMP/plain.json" \
+     "http://127.0.0.1:$BH/v1/chat/completions" || rc=$?
+check "black-hole: client times out (curl rc 28)" test "$rc" -eq 28
+check "black-hole: health still answers during the hang" \
+  curl -sf --max-time 2 "http://127.0.0.1:$BH/gate/health"
+
+# ---- hostile mode: mid-body-drop -------------------------------------------
+MD="$(freeport)"
+"$PY" stub-openai.py --port "$MD" --log "$TMP/md.jsonl" --mode mid-body-drop \
+     >/dev/null 2>&1 &
+PIDS+=($!); disown
+check "mid-body-drop: healthy" waithealth "$MD"
+rc=0
+curl -s --max-time 5 -o "$TMP/half.json" -H 'content-type: application/json' \
+     --data-binary @"$TMP/plain.json" \
+     "http://127.0.0.1:$MD/v1/chat/completions" || rc=$?
+check "mid-body-drop: transfer fails (curl rc $rc)" test "$rc" -ne 0
+check "mid-body-drop: partial body is not parseable JSON" mk notjson "$TMP/half.json"
+
+# ---- hostile mode: tool-pending-forever ------------------------------------
+TP="$(freeport)"
+"$PY" stub-openai.py --port "$TP" --log "$TMP/tp.jsonl" \
+     --mode tool-pending-forever >/dev/null 2>&1 &
+PIDS+=($!); disown
+check "tool-pending-forever: healthy" waithealth "$TP"
+for i in 1 2 3; do
+  code="$(post "$TP" "$TMP/plain.json" "$TMP/r_tp$i.json")"
+  check "tool-pending-forever: request $i -> 200" test "$code" = "200"
+done
+check "tool-pending-forever: three FRESH tool_calls, distinct ids" \
+  mk pending "$TMP/r_tp1.json" "$TMP/r_tp2.json" "$TMP/r_tp3.json"
+check "tool-pending-forever: /gate/stats counts 3 chat hits" \
+  bash -c "curl -sf http://127.0.0.1:$TP/gate/stats | grep -q '\"chat_hits\": 3'"
+
+# ---- summary ----------------------------------------------------------------
+echo
+echo "selftest: $PASS passed, $FAIL failed"
+if [ "$FAIL" -ne 0 ]; then
+  echo "SELFTEST RED"
+  exit 1
+fi
+echo "SELFTEST GREEN (stub-openai gate scaffolding verified)"

tests/gate-openai/stub-openai.py

@@ -0,0 +1,652 @@
+#!/usr/bin/env python3
+"""stub-openai.py - deterministic local stand-in for an OpenAI-format
+/v1/chat/completions provider, for the soul-openai-tools-v2 gate
+(docs/specs/SPEC-soul-openai-tools-v2-2026-08-06.md). No API key, no network,
+no model.
+
+Sibling of gate9's stub-llm.py (Anthropic dialect, _wt-beta-round9/scripts/
+gate9/): same scenario mechanism (marker matching, assistant-count step
+indexing, ground-truth JSONL log, prod-port refusal), different wire.
+Staging home is tests/gate-openai/ in _wt-openai-tools; folds into
+scripts/gate9/ after round 9 merges (see README.md).
+
+WHAT IT DOES
+  * Serves POST /v1/chat/completions on 127.0.0.1 only (OpenAI dialect).
+  * VALIDATES every request - this is the gate's discriminator, built
+    BEFORE the brain-side El code exists so dialect leakage fails loudly:
+      - Anthropic tells are 400 code=gate_dialect_leak: `anthropic-version`
+        header; top-level `system` / `stop_sequences` / `max_tokens_to_sample`
+        / `anthropic_version`; `input_schema` inside a tool entry; Anthropic
+        content blocks (tool_use / tool_result / server_tool_use / ...).
+      - tools[] must be OpenAI-shaped {type:"function", function:{name,
+        description, parameters}} with unique names -> 400 gate_tools_shape.
+      - assistant tool_calls echoes must be {id, type:"function",
+        function:{name, arguments:<JSON-encoded STRING>}}; a decoded-object
+        `arguments` is a wire bug -> 400 gate_tool_call_shape.
+      - every assistant tool_calls turn must be answered by role:"tool"
+        messages covering EVERY tool_call_id, immediately following;
+        unknown / duplicate / missing ids -> 400 gate_pairing.
+      - echoed `arguments` for gate-issued call ids (call_gate_*) are
+        recomputed from the script and compared after ONE json decode ->
+        400 gate_echo_mismatch. This is the two-escaper-trap discriminator
+        named in the spec's security model (section 6).
+      - scenario-level request expectations from scenarios-openai.json
+        (tools offered, OpenAI-shaped tool_choice, parallel_tool_calls
+        pinned false per ADR-0005) -> 400 gate_expect.
+  * Answers with SCRIPTED responses: plain text (finish_reason "stop"),
+    tool calls (finish_reason "tool_calls", arguments JSON-encoded, incl. a
+    nested-quote/escaping torture payload and a parallel two-call case), and
+    API-error injection (OpenAI error envelope). Scenario is selected by
+    scanning user-message text (newest first) for a registered marker
+    substring; the step index is the number of assistant messages already in
+    the request (stateless replay - resumes index correctly by construction).
+  * Writes a ground-truth JSONL log (--log): one record per request with the
+    validation verdict, matched scenario/step, and exactly which tool calls
+    were delivered. Gate assertions compare the brain's claims against THIS
+    log - truth, not narration.
+  * Unmatched requests (boot probes, awareness chatter) get a benign "ok"
+    text response, logged kind=background, never counted as ground truth.
+  * HOSTILE MODES (--mode) on the same file:
+      black-hole            accept + read the request, never respond;
+      mid-body-drop         send half a JSON body, then abort the socket;
+      tool-pending-forever  every request gets a FRESH tool_call
+                            (finish_reason "tool_calls"), forever - tests
+                            the agentic loop's iteration cap; count the
+                            brain's round-trips via GET /gate/stats.
+
+usage: stub-openai.py --port P --scenarios scenarios-openai.json \
+                      --log requests.jsonl [--mode MODE]
+Listens on 127.0.0.1 only. Refuses production ports 7770/7779/17779.
+"""
+import argparse
+import itertools
+import json
+import socket
+import struct
+import threading
+import time
+import uuid
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+
+STATE = {"scenarios": None, "log_path": None, "lock": threading.Lock(),
+         "seq": 0, "mode": "normal", "chat_hits": 0}
+_PENDING_SEQ = itertools.count(1)
+
+ANTHROPIC_TOP_KEYS = ("system", "stop_sequences", "max_tokens_to_sample",
+                      "anthropic_version")
+ANTHROPIC_BLOCK_TYPES = {"tool_use", "tool_result", "server_tool_use",
+                         "web_search_tool_result", "thinking",
+                         "redacted_thinking"}
+DEFAULT_EXPECT = {"require_tools": True, "require_tool_choice": True,
+                  "parallel_tool_calls": False, "forbid_tools": False}
+
+
+# ---------------------------------------------------------------- loading ----
+def load_scenarios(path):
+    cfg = json.load(open(path))
+    defaults = dict(DEFAULT_EXPECT)
+    defaults.update(cfg.get("defaults", {}).get("expect_request", {}))
+    marker_map = []   # (marker_lower, cname, pid)
+    scripts = {}      # cname or cname/pid -> expanded script
+    pid_map = {}      # pid -> cname (for call_gate_* id -> script lookup)
+    expects = {}      # cname -> merged expect_request
+    for cname, cls in cfg["classes"].items():
+        scripts[cname] = expand_script(cls.get("script", []))
+        exp = dict(defaults)
+        exp.update(cls.get("expect_request", {}))
+        expects[cname] = exp
+        for ph in cls["phrasings"]:
+            if ph.get("script") is not None:
+                scripts[cname + "/" + ph["id"]] = expand_script(ph["script"])
+            marker_map.append((ph["marker"].lower(), cname, ph["id"]))
+            pid_map[ph["id"]] = cname
+    return {"cfg": cfg, "marker_map": marker_map, "scripts": scripts,
+            "pid_map": pid_map, "expects": expects}
+
+
+def expand_script(script):
+    """Same repeat-expansion contract as gate9's stub-llm.py ({N}/{NN})."""
+    out = []
+    for step in script:
+        if "repeat" in step:
+            for n in range(1, step["repeat"] + 1):
+                t = {k: v for k, v in step.items() if k != "repeat"}
+                out.append(json.loads(json.dumps(t)
+                                      .replace("{NN}", "%02d" % n)
+                                      .replace("{N}", str(n))))
+        else:
+            out.append(step)
+    return out
+
+
+# ------------------------------------------------------------- validation ----
+def _rej(message, code):
+    return {"status": 400, "message": message, "code": code}
+
+
+def validate_dialect(headers, req):
+    """Universal checks - run on EVERY request, scenario-matched or not.
+    Anything Anthropic-shaped on this lane means the brain's translator
+    leaked; the whole point is that it fails loudly, here, with a reason."""
+    if headers.get("anthropic-version"):
+        return _rej("anthropic-version header on the OpenAI lane: this "
+                    "request was built by the Anthropic dialect path",
+                    "gate_dialect_leak")
+    for k in ANTHROPIC_TOP_KEYS:
+        if k in req:
+            return _rej("top-level `%s` is Anthropic dialect; the OpenAI "
+                        "dialect has no such field (system prompt goes in "
+                        "messages[0])" % k, "gate_dialect_leak")
+    tools = req.get("tools")
+    if tools is not None:
+        if not isinstance(tools, list):
+            return _rej("`tools` must be an array", "gate_tools_shape")
+        names = []
+        for i, t in enumerate(tools):
+            if not isinstance(t, dict):
+                return _rej("tools[%d] is not an object" % i,
+                            "gate_tools_shape")
+            if "input_schema" in t or (isinstance(t.get("function"), dict)
+                                       and "input_schema" in t["function"]):
+                return _rej("tools[%d] carries `input_schema` (Anthropic "
+                            "dialect); OpenAI dialect wants "
+                            "function.parameters" % i, "gate_dialect_leak")
+            if t.get("type") != "function":
+                return _rej("tools[%d].type must be \"function\", got %r"
+                            % (i, t.get("type")), "gate_tools_shape")
+            fn = t.get("function")
+            if not isinstance(fn, dict):
+                return _rej("tools[%d].function missing" % i,
+                            "gate_tools_shape")
+            if not isinstance(fn.get("name"), str) or not fn["name"]:
+                return _rej("tools[%d].function.name missing/empty" % i,
+                            "gate_tools_shape")
+            if not isinstance(fn.get("description"), str) or not fn["description"]:
+                return _rej("tools[%d].function.description missing/empty" % i,
+                            "gate_tools_shape")
+            if not isinstance(fn.get("parameters"), dict):
+                return _rej("tools[%d].function.parameters missing (JSON "
+                            "Schema object expected)" % i, "gate_tools_shape")
+            names.append(fn["name"])
+        if len(names) != len(set(names)):
+            return _rej("tools: tool names must be unique", "gate_tools_shape")
+    msgs = req.get("messages")
+    if not isinstance(msgs, list) or not msgs:
+        return _rej("`messages` must be a non-empty array",
+                    "gate_messages_shape")
+    for i, m in enumerate(msgs):
+        if not isinstance(m, dict):
+            return _rej("messages[%d] is not an object" % i,
+                        "gate_messages_shape")
+        c = m.get("content")
+        if isinstance(c, list):
+            for j, b in enumerate(c):
+                if isinstance(b, dict) and b.get("type") in ANTHROPIC_BLOCK_TYPES:
+                    return _rej("messages[%d].content[%d] is an Anthropic "
+                                "`%s` block; the OpenAI dialect uses "
+                                "tool_calls / role:\"tool\" messages"
+                                % (i, j, b.get("type")), "gate_dialect_leak")
+        if m.get("role") == "tool":
+            if not isinstance(m.get("tool_call_id"), str) or not m["tool_call_id"]:
+                return _rej("messages[%d]: role \"tool\" requires a "
+                            "`tool_call_id`" % i, "gate_messages_shape")
+            if "content" not in m:
+                return _rej("messages[%d]: role \"tool\" requires `content`"
+                            % i, "gate_messages_shape")
+        if m.get("role") == "assistant" and m.get("tool_calls") is not None:
+            tcs = m["tool_calls"]
+            if not isinstance(tcs, list) or not tcs:
+                return _rej("messages[%d].tool_calls must be a non-empty "
+                            "array" % i, "gate_tool_call_shape")
+            for j, tc in enumerate(tcs):
+                if not isinstance(tc, dict) or tc.get("type") != "function":
+                    return _rej("messages[%d].tool_calls[%d].type must be "
+                                "\"function\"" % (i, j), "gate_tool_call_shape")
+                if not isinstance(tc.get("id"), str) or not tc["id"]:
+                    return _rej("messages[%d].tool_calls[%d].id missing"
+                                % (i, j), "gate_tool_call_shape")
+                fn = tc.get("function")
+                if not isinstance(fn, dict) or not isinstance(fn.get("name"), str):
+                    return _rej("messages[%d].tool_calls[%d].function.name "
+                                "missing" % (i, j), "gate_tool_call_shape")
+                if not isinstance(fn.get("arguments"), str):
+                    return _rej("messages[%d].tool_calls[%d].function."
+                                "arguments must be a JSON-encoded STRING, "
+                                "got %s" % (i, j,
+                                            type(fn.get("arguments")).__name__),
+                                "gate_tool_call_shape")
+    return None
+
+
+def validate_pairing(msgs):
+    """OpenAI pairing rule: every assistant tool_calls turn must be followed
+    immediately by role:"tool" messages answering every tool_call_id."""
+    open_ids, open_at = set(), None
+    for i, m in enumerate(msgs):
+        role = m.get("role")
+        if role == "tool":
+            tid = m.get("tool_call_id")
+            if open_at is None:
+                return _rej("messages[%d]: role \"tool\" message with no "
+                            "preceding assistant tool_calls turn "
+                            "(tool_call_id=%s)" % (i, tid), "gate_pairing")
+            if tid not in open_ids:
+                return _rej("messages[%d]: tool message answers unknown or "
+                            "already-answered tool_call_id %s" % (i, tid),
+                            "gate_pairing")
+            open_ids.discard(tid)
+            continue
+        if open_ids:
+            return _rej("messages[%d]: assistant tool_calls not fully "
+                        "answered before messages[%d]; missing tool "
+                        "responses for: %s" % (open_at, i, sorted(open_ids)),
+                        "gate_pairing")
+        open_ids, open_at = set(), None
+        if role == "assistant" and m.get("tool_calls"):
+            ids = [tc.get("id") for tc in m["tool_calls"]]
+            open_ids, open_at = set(ids), i
+    if open_ids:
+        return _rej("messages[%d]: assistant tool_calls at end of thread "
+                    "without tool responses for: %s"
+                    % (open_at, sorted(open_ids)), "gate_pairing")
+    return None
+
+
+def validate_echo_args(msgs, loaded):
+    """Ground-truth round-trip check: for every echoed gate-issued call id,
+    recompute the arguments this stub originally sent from the script and
+    require one json decode to reproduce them exactly. Catches the
+    two-escaper trap (spec section 6) deterministically."""
+    if not loaded:
+        return None
+    for i, m in enumerate(msgs):
+        if m.get("role") != "assistant":
+            continue
+        for tc in m.get("tool_calls") or []:
+            tid = tc.get("id", "")
+            if not tid.startswith("call_gate_"):
+                continue
+            rest = tid[len("call_gate_"):]
+            try:
+                pid, s_part, k_part = rest.rsplit("_", 2)
+                step_idx, k = int(s_part[1:]), int(k_part)
+            except (ValueError, IndexError):
+                continue
+            cname = loaded["pid_map"].get(pid)
+            if cname is None:
+                continue
+            script = (loaded["scripts"].get(cname + "/" + pid)
+                      or loaded["scripts"].get(cname) or [])
+            if step_idx >= len(script):
+                continue
+            calls = script[step_idx].get("tool_calls") or []
+            if k >= len(calls):
+                continue
+            expected = calls[k]
+            fn = tc.get("function") or {}
+            if fn.get("name") != expected["name"]:
+                return _rej("messages[%d]: echoed tool name %r != issued %r "
+                            "for %s" % (i, fn.get("name"), expected["name"],
+                                        tid), "gate_echo_mismatch")
+            try:
+                got = json.loads(fn.get("arguments", ""))
+            except ValueError:
+                return _rej("messages[%d]: echoed arguments for %s are not "
+                            "valid JSON after one decode (truncated or "
+                            "half-escaped?)" % (i, tid), "gate_echo_mismatch")
+            if got != expected["arguments"]:
+                hint = (" (decoded to a string, not an object: "
+                        "double-encoded - the two-escaper trap)"
+                        if isinstance(got, str) else "")
+                return _rej("messages[%d]: echoed arguments for %s do not "
+                            "round-trip to the issued payload%s"
+                            % (i, tid, hint), "gate_echo_mismatch")
+    return None
+
+
+def validate_expect(req, exp):
+    """Scenario-level request expectations (scenarios-openai.json)."""
+    tools = req.get("tools") or []
+    if exp.get("forbid_tools") and tools:
+        return _rej("this scenario is chat-only: no `tools` may be offered "
+                    "on it", "gate_expect")
+    if exp.get("require_tools") and not tools:
+        return _rej("scenario expects a `tools` array to be offered (the "
+                    "agentic lane must advertise its tools)", "gate_expect")
+    if exp.get("require_tool_choice"):
+        tc = req.get("tool_choice")
+        ok = tc in ("auto", "none", "required") or (
+            isinstance(tc, dict) and tc.get("type") == "function"
+            and isinstance(tc.get("function"), dict)
+            and tc["function"].get("name"))
+        if not ok:
+            return _rej("scenario expects an OpenAI-shaped `tool_choice`, "
+                        "got %r" % (tc,), "gate_expect")
+    want_ptc = exp.get("parallel_tool_calls", None)
+    if want_ptc is not None:
+        if "parallel_tool_calls" not in req:
+            return _rej("scenario expects explicit `parallel_tool_calls` "
+                        "(ADR-0005: must be pinned false on the wire)",
+                        "gate_expect")
+        if req["parallel_tool_calls"] != want_ptc:
+            return _rej("scenario expects parallel_tool_calls=%s, got %s"
+                        % (json.dumps(want_ptc),
+                           json.dumps(req["parallel_tool_calls"])),
+                        "gate_expect")
+    return None
+
+
+# --------------------------------------------------------- scenario match ----
+def extract_user_texts_newest_first(msgs):
+    texts = []
+    for m in reversed(msgs):
+        if not isinstance(m, dict) or m.get("role") != "user":
+            continue
+        c = m.get("content")
+        if isinstance(c, str):
+            texts.append(c)
+        elif isinstance(c, list):
+            for b in c:
+                if isinstance(b, dict) and b.get("type") == "text":
+                    texts.append(b.get("text", ""))
+    return texts
+
+
+def match_scenario(loaded, msgs):
+    for text in extract_user_texts_newest_first(msgs):
+        tl = text.lower()
+        for marker, cname, pid in loaded["marker_map"]:
+            if marker in tl:
+                return cname, pid
+    return None, None
+
+
+# ------------------------------------------------------------- rendering ----
+def completion_envelope(msg, finish, model, usage=(100, 100)):
+    return {"id": "chatcmpl-gate-" + uuid.uuid4().hex[:12],
+            "object": "chat.completion", "created": int(time.time()),
+            "model": model,
+            "choices": [{"index": 0, "message": msg,
+                         "finish_reason": finish, "logprobs": None}],
+            "usage": {"prompt_tokens": usage[0],
+                      "completion_tokens": usage[1],
+                      "total_tokens": usage[0] + usage[1]}}
+
+
+def text_completion(text, model):
+    return completion_envelope({"role": "assistant", "content": text},
+                               "stop", model, usage=(1, 1))
+
+
+def pending_body(seq, model):
+    args = json.dumps({"path": "never-%04d.md" % seq,
+                       "content": "this run never completes"})
+    msg = {"role": "assistant", "content": None,
+           "tool_calls": [{"id": "call_hostile_pending_%04d" % seq,
+                           "type": "function",
+                           "function": {"name": "write_file",
+                                        "arguments": args}}]}
+    return completion_envelope(msg, "tool_calls", model, usage=(1, 1))
+
+
+def render_step(step, cname, pid, step_idx, model):
+    """Returns (http_status, body_dict, delivered) - delivered is ground
+    truth for the JSONL log."""
+    delivered = {"tool_calls": [], "finish_reason": None, "api_error": None}
+    if "api_error" in step:
+        e = step["api_error"]
+        delivered["api_error"] = e["status"]
+        return (e["status"],
+                {"error": {"message": e["message"],
+                           "type": e.get("type", "server_error"),
+                           "param": None, "code": e.get("code")}},
+                delivered)
+    msg = {"role": "assistant"}
+    finish = "stop"
+    if step.get("tool_calls"):
+        tcs = []
+        for k, call in enumerate(step["tool_calls"]):
+            tid = "call_gate_%s_s%d_%d" % (pid, step_idx, k)
+            tcs.append({"id": tid, "type": "function",
+                        "function": {"name": call["name"],
+                                     "arguments": json.dumps(
+                                         call["arguments"],
+                                         ensure_ascii=False)}})
+            delivered["tool_calls"].append(call["name"])
+        msg["tool_calls"] = tcs
+        msg["content"] = step.get("text")  # null when no narration, like real
+        finish = "tool_calls"
+    else:
+        msg["content"] = step["text"]
+    delivered["finish_reason"] = finish
+    return 200, completion_envelope(msg, finish, model), delivered
+
+
+# ------------------------------------------------------------------ log ------
+def log_record(rec):
+    with STATE["lock"]:
+        STATE["seq"] += 1
+        rec["seq"] = STATE["seq"]
+        with open(STATE["log_path"], "a") as f:
+            f.write(json.dumps(rec, ensure_ascii=False) + "\n")
+
+
+# ---------------------------------------------------------------- server -----
+class Handler(BaseHTTPRequestHandler):
+    protocol_version = "HTTP/1.1"
+
+    def _send_json(self, status, obj):
+        body = json.dumps(obj, ensure_ascii=False).encode("utf-8")
+        self.send_response(status)
+        self.send_header("Content-Type", "application/json")
+        self.send_header("Content-Length", str(len(body)))
+        self.end_headers()
+        self.wfile.write(body)
+
+    def _send_error(self, verdict):
+        self._send_json(verdict["status"],
+                        {"error": {"message": verdict["message"],
+                                   "type": "invalid_request_error",
+                                   "param": None, "code": verdict["code"]}})
+
+    def _drop_mid_body(self):
+        """Valid 200 headers, half the promised body, then a socket abort
+        (same SO_LINGER teardown as gate9's mid-body-drop-brain.py)."""
+        full = json.dumps(text_completion(
+            "This reply will never finish arriving because the connection "
+            "dies in the middle of the body, which is exactly the point of "
+            "this hostile fixture.", "hostile-mid-drop")).encode("utf-8")
+        half = full[: len(full) // 2]
+        self.send_response(200)
+        self.send_header("Content-Type", "application/json")
+        self.send_header("Content-Length", str(len(full)))  # promises more
+        self.end_headers()
+        self.wfile.write(half)
+        self.wfile.flush()
+        try:
+            self.connection.setsockopt(socket.SOL_SOCKET, socket.SO_LINGER,
+                                       struct.pack("ii", 1, 0))
+            self.connection.shutdown(socket.SHUT_RDWR)
+        except OSError:
+            pass
+        self.close_connection = True
+
+    def do_GET(self):
+        path = self.path.split("?")[0]
+        if path == "/gate/health":
+            self._send_json(200, {"ok": True, "mode": STATE["mode"]})
+        elif path == "/gate/stats":
+            with STATE["lock"]:
+                self._send_json(200, {"mode": STATE["mode"],
+                                      "chat_hits": STATE["chat_hits"]})
+        else:
+            self._send_json(404, {"error": {"message": "not found",
+                                            "type": "invalid_request_error",
+                                            "param": None,
+                                            "code": "unknown_route"}})
+
+    def do_POST(self):
+        n = int(self.headers.get("Content-Length") or 0)
+        raw = self.rfile.read(n)
+        mode = STATE["mode"]
+        rec = {"ts": time.time(), "path": self.path, "mode": mode,
+               "kind": "background", "scenario_class": None, "phrasing": None,
+               "step": None, "n_messages": 0, "n_assistant": 0,
+               "validation": "ok", "validation_detail": None,
+               "delivered": {"tool_calls": [], "finish_reason": None,
+                             "api_error": None},
+               "http_status": 200}
+        if self.path.split("?")[0] != "/v1/chat/completions":
+            rec.update(kind="wrong_path", http_status=404)
+            log_record(rec)
+            self._send_json(404, {"error": {
+                "message": "no such route: %s" % self.path,
+                "type": "invalid_request_error", "param": None,
+                "code": "unknown_route"}})
+            return
+        with STATE["lock"]:
+            STATE["chat_hits"] += 1
+
+        # ---- hostile modes: behavior first, no validation ----------------
+        if mode == "black-hole":
+            rec.update(kind="hostile", http_status=None)
+            log_record(rec)
+            threading.Event().wait()  # hold the socket open forever
+            return
+        if mode == "mid-body-drop":
+            rec.update(kind="hostile", http_status=200)
+            log_record(rec)
+            self._drop_mid_body()
+            return
+        if mode == "tool-pending-forever":
+            seq = next(_PENDING_SEQ)
+            rec.update(kind="hostile",
+                       delivered={"tool_calls": ["write_file"],
+                                  "finish_reason": "tool_calls",
+                                  "api_error": None})
+            log_record(rec)
+            self._send_json(200, pending_body(seq, "gate-openai-model"))
+            return
+
+        # ---- normal mode -------------------------------------------------
+        try:
+            req = json.loads(raw)
+        except ValueError as exc:
+            # DIAGNOSTIC CAPTURE (2026-08-06): an unparseable body used to be recorded as
+            # a bare "bad_json" with the bytes thrown away, which made an intermittent
+            # failure impossible to root-cause — you cannot fix what you did not keep.
+            # Dump the raw body next to the log, and record exactly where the parser gave
+            # up plus the offending byte, so one occurrence is enough to diagnose.
+            dump_path = "%s.badbody.%s" % (STATE.get("log_path", "/tmp/stub-openai"),
+                                           rec.get("seq", "x"))
+            try:
+                data = raw if isinstance(raw, (bytes, bytearray)) else str(raw).encode()
+                with open(dump_path, "wb") as fh:
+                    fh.write(data)
+            except Exception as dump_exc:
+                dump_path = "(dump failed: %s)" % dump_exc
+            pos = getattr(exc, "pos", None)
+            near = ""
+            byte_repr = ""
+            if isinstance(pos, int):
+                blob = raw if isinstance(raw, (bytes, bytearray)) else str(raw).encode()
+                near = blob[max(0, pos - 60):pos + 60].decode("utf-8", "replace")
+                if 0 <= pos < len(blob):
+                    byte_repr = "0x%02x" % blob[pos]
+            rec.update(kind="bad_json", validation="rejected",
+                       validation_detail="request body is not valid JSON: %s" % exc,
+                       http_status=400, raw_len=len(raw), raw_dump=dump_path,
+                       err_pos=pos, err_byte=byte_repr, err_near=near)
+            log_record(rec)
+            self._send_error(_rej("request body is not valid JSON",
+                                  "bad_json"))
+            return
+        msgs = req.get("messages") or []
+        rec["n_messages"] = len(msgs)
+        rec["n_assistant"] = sum(1 for m in msgs if isinstance(m, dict)
+                                 and m.get("role") == "assistant")
+        loaded = STATE["scenarios"]
+        cname, pid = match_scenario(loaded, msgs)
+        if cname:
+            rec.update(kind="scenario", scenario_class=cname, phrasing=pid)
+
+        # Wire-level validation runs for EVERY request, scenario or not.
+        verdict = (validate_dialect(self.headers, req)
+                   or validate_pairing([m for m in msgs
+                                        if isinstance(m, dict)])
+                   or validate_echo_args(msgs, loaded))
+        if verdict:
+            rec.update(validation="rejected",
+                       validation_detail=verdict["message"],
+                       http_status=verdict["status"])
+            log_record(rec)
+            self._send_error(verdict)
+            return
+
+        model = req.get("model", "gate-openai-model")
+        if not cname:
+            log_record(rec)
+            self._send_json(200, text_completion("ok", model))
+            return
+
+        script = (loaded["scripts"].get(cname + "/" + pid)
+                  or loaded["scripts"][cname])
+        step_idx = rec["n_assistant"]
+        if step_idx >= len(script):
+            rec.update(kind="overrun", step=step_idx)
+            log_record(rec)
+            self._send_json(200, text_completion(
+                "GATE-SCRIPT-EXHAUSTED %s step %d" % (pid, step_idx), model))
+            return
+
+        step = script[step_idx]
+        exp = dict(loaded["expects"][cname])
+        exp.update(step.get("expect_request", {}))
+        verdict = validate_expect(req, exp)
+        if verdict:
+            rec.update(step=step_idx, validation="rejected",
+                       validation_detail=verdict["message"],
+                       http_status=verdict["status"])
+            log_record(rec)
+            self._send_error(verdict)
+            return
+
+        status, body, delivered = render_step(step, cname, pid, step_idx,
+                                              model)
+        rec.update(step=step_idx, delivered=delivered, http_status=status)
+        log_record(rec)
+        self._send_json(status, body)
+
+    def log_message(self, *a):
+        pass
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--port", type=int, required=True)
+    ap.add_argument("--scenarios",
+                    help="scenarios-openai.json (required in normal mode)")
+    ap.add_argument("--log", required=True)
+    ap.add_argument("--mode", default="normal",
+                    choices=["normal", "black-hole", "mid-body-drop",
+                             "tool-pending-forever"])
+    args = ap.parse_args()
+    if args.port in (7770, 7779, 17779):
+        raise SystemExit("stub-openai: refusing production Neuron port")
+    if args.mode == "normal" and not args.scenarios:
+        raise SystemExit("stub-openai: --scenarios is required in normal mode")
+    STATE["mode"] = args.mode
+    STATE["scenarios"] = (load_scenarios(args.scenarios)
+                          if args.scenarios else None)
+    STATE["log_path"] = args.log
+    open(args.log, "w").close()
+    n_markers = (len(STATE["scenarios"]["marker_map"])
+                 if STATE["scenarios"] else 0)
+    print("stub-openai [%s]: 127.0.0.1:%d /v1/chat/completions "
+          "(%d markers registered, log=%s)"
+          % (args.mode, args.port, n_markers, args.log), flush=True)
+    ThreadingHTTPServer(("127.0.0.1", args.port), Handler).serve_forever()
+
+
+if __name__ == "__main__":
+    main()

tests/run-el-test.sh

@@ -0,0 +1,148 @@
+#!/usr/bin/env bash
+# run-el-test.sh — build and RUN one engine test (tests/*.el), printing its assertions.
+#
+# WHY THIS EXISTS (2026-08-06): the engine's tests/*.el files were never runnable from the
+# tree. `elc` is a COMPILER — it emits C to stdout and exits; it does not execute anything.
+# So "the tests" could only ever be read, not run, and a signature change could silently
+# break them (exactly what happened when bridge_save gained its `wire` argument). This
+# script closes that: emit the test to C, link it against the engine modules, execute it.
+#
+# HOW IT WORKS
+#   1. elc <test>.el              -> C on stdout (the test file's `main` + prototypes)
+#   2. elb (once, cached)         -> per-module C for the whole engine into a scratch dir
+#   3. cc test.c + all modules EXCEPT soul.c (soul.c owns the real `main`) + the runtime
+#   4. run it
+#
+# The test C references only the engine functions it actually calls, so there are no
+# duplicate-symbol collisions with the module objects.
+#
+# RUNTIME: the REPO-PINNED vendor/el-runtime (NOT ~/el-sdk/el_runtime.c — that June build
+# is missing builtins August code calls: engram_wm_count, engram_wm_top_json,
+# http_delete_json, http_serve_async; linking against it fails with "symbol(s) not found").
+#
+# USAGE
+#   tests/run-el-test.sh tests/test_bridge_serialization.el     # one test
+#   tests/run-el-test.sh --all                                  # every tests/test_*.el
+#   REBUILD=1 tests/run-el-test.sh ...                          # force module regeneration
+#
+# Tests that need a live API key / running soul (see each file's header) will report their
+# own skips or failures — this runner does not fake them.
+set -uo pipefail
+
+REPO_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+cd "$REPO_ROOT" || exit 2
+
+ELC="${ELC:-$HOME/el-sdk/elc}"
+ELB="${ELB:-$HOME/Development/el-sdk/bin/elb}"
+RUNTIME_DIR="${RUNTIME_DIR:-$REPO_ROOT/vendor/el-runtime/v1.0.0-20260501}"
+SCRATCH="${SCRATCH:-/tmp/el-test-$(basename "$REPO_ROOT")}"
+MODDIR="$SCRATCH/modules"
+OPENSSL_INC="${OPENSSL_INC:-/opt/homebrew/opt/openssl@3/include}"
+OPENSSL_LIB="${OPENSSL_LIB:-/opt/homebrew/opt/openssl@3/lib}"
+
+for req in "$ELC" "$ELB" "$RUNTIME_DIR/el_runtime.c"; do
+    [ -e "$req" ] || { echo "run-el-test: missing required input: $req" >&2; exit 2; }
+done
+
+mkdir -p "$MODDIR" || exit 2
+
+# ── Step 1: engine modules (cached — regeneration is the slow part) ────────────
+if [ "${REBUILD:-0}" = "1" ] || [ ! -f "$MODDIR/chat.c" ] || [ "chat.el" -nt "$MODDIR/chat.c" ]; then
+    echo "run-el-test: generating engine modules into $MODDIR (this takes ~1-2 min)..."
+    # elb's own final link step fails by design here (it wants to produce a binary named
+    # `neuron` and we only need the per-module .c files it emits first). Ignore its rc.
+    "$ELB" --elc="$ELC" --runtime="$RUNTIME_DIR" --out="$MODDIR/" >"$SCRATCH/elb.log" 2>&1
+    if [ ! -f "$MODDIR/chat.c" ]; then
+        echo "run-el-test: FATAL — elb produced no chat.c; see $SCRATCH/elb.log" >&2
+        tail -5 "$SCRATCH/elb.log" >&2
+        exit 2
+    fi
+    # elb rewrites *.elh in the source tree as a side effect (cosmetic banner churn plus a
+    # stray soul..elh). Say so; the caller decides whether to `git restore` them.
+    echo "run-el-test: NOTE — elb regenerated *.elh in the source tree (cosmetic churn is expected; a stray soul..elh may appear)."
+fi
+
+# soul.c is needed for its engine functions (layered_cycle et al.) but it also owns the
+# daemon's real `main`, which would collide with the test's own. Compile it ONCE to an
+# object with `main` renamed away, and link that instead of the .c.
+SOUL_OBJ="$SCRATCH/soul-nomain.o"
+if [ "${REBUILD:-0}" = "1" ] || [ ! -f "$SOUL_OBJ" ] || [ "$MODDIR/soul.c" -nt "$SOUL_OBJ" ]; then
+    cc -std=c11 -O1 -DHAVE_CURL -Dmain=el_soul_daemon_main_unused \
+        -I "$RUNTIME_DIR" -I "$MODDIR" -I "$OPENSSL_INC" \
+        -include dist/elp-c-decls.h -Wno-error=implicit-function-declaration \
+        -c "$MODDIR/soul.c" -o "$SOUL_OBJ" 2>"$SCRATCH/soul-nomain.err" \
+        || { echo "run-el-test: FATAL — could not compile soul.c without main" >&2
+             grep -E 'error:' "$SCRATCH/soul-nomain.err" | head -5 >&2; exit 2; }
+fi
+
+# Every module except soul.c (linked as the renamed object above) and the stray soul.elh.c.
+MODS=("$SOUL_OBJ")
+for f in "$MODDIR"/*.c; do
+    case "$(basename "$f")" in
+        soul.c|soul.elh.c) continue ;;
+    esac
+    MODS+=("$f")
+done
+[ "${#MODS[@]}" -gt 1 ] || { echo "run-el-test: no module objects found" >&2; exit 2; }
+
+run_one() {
+    local test_el="$1"
+    local name; name="$(basename "$test_el" .el)"
+    local cfile="$SCRATCH/$name.c"
+    local bin="$SCRATCH/$name"
+
+    printf '\n══ %s ══\n' "$name"
+
+    if ! "$ELC" "$test_el" >"$cfile" 2>"$SCRATCH/$name.elc.err"; then
+        echo "COMPILE FAILED (elc):"; tail -10 "$SCRATCH/$name.elc.err"; return 1
+    fi
+    [ -s "$cfile" ] || { echo "COMPILE FAILED (elc produced empty C)"; return 1; }
+
+    if ! cc -std=c11 -O1 -DHAVE_CURL -rdynamic \
+        -I "$RUNTIME_DIR" -I "$MODDIR" -I "$OPENSSL_INC" -L "$OPENSSL_LIB" \
+        -include dist/elp-c-decls.h -Wno-error=implicit-function-declaration \
+        -o "$bin" "$cfile" "${MODS[@]}" "$RUNTIME_DIR/el_runtime.c" \
+        -lssl -lcrypto -lcurl -lpthread -lm 2>"$SCRATCH/$name.link.err"; then
+        echo "LINK FAILED:"; grep -E '"_|error:' "$SCRATCH/$name.link.err" | head -10; return 1
+    fi
+
+    # THE RUNNER OWNS THE VERDICT — the test files cannot be trusted to report it.
+    #
+    # Every tests/*.el assert helper does `let pass_count = pass_count + 1` INSIDE an if
+    # BLOCK. El's scope rule (the same one chat.el documents at every while-body mutation:
+    # "mutations inside if *blocks* don't escape scope") means those counters never
+    # increment, so all 9 counted test files print "N passed, M failed" as "0 passed, 0
+    # failed" — forever, whatever actually happened. A summary that can never report a
+    # failure is worth exactly as much as an assertion that can never fail. Logged as a
+    # bug for the real in-file fix; until then the verdict is computed HERE, from the
+    # assert helpers' own per-line output, which IS reliable.
+    local out="$SCRATCH/$name.out"
+    "$bin" 2>&1 | tee "$out"; local rc=${PIPESTATUS[0]}
+
+    # NOTE: `grep -c` prints 0 AND exits 1 when there are no matches, so a `|| echo 0`
+    # fallback appends a SECOND zero and every later integer test breaks on "0\n0".
+    # (Caught by running this script — which is the whole argument for running things.)
+    local n_pass n_fail
+    n_pass=$(grep -c '^  PASS: ' "$out" 2>/dev/null); n_pass=${n_pass:-0}
+    n_fail=$(grep -c '^  FAIL: ' "$out" 2>/dev/null); n_fail=${n_fail:-0}
+    echo "── $name: $n_pass passed, $n_fail failed (counted by the runner, not by the file's dead counters)"
+    if [ "$n_fail" -gt 0 ]; then
+        echo "   failing assertions:"; grep '^  FAIL: ' "$out" | sed 's/^/   /'
+        return 1
+    fi
+    if [ "$n_pass" -eq 0 ]; then
+        echo "   WARNING: no assertions ran — treating as FAILURE (a test that asserts nothing is not a passing test)"
+        return 1
+    fi
+    [ $rc -eq 0 ] || { echo "   (test binary exited rc=$rc)"; return 1; }
+    return 0
+}
+
+rc_all=0
+if [ "${1:-}" = "--all" ]; then
+    for t in tests/test_*.el; do run_one "$t" || rc_all=1; done
+else
+    [ $# -ge 1 ] || { echo "usage: tests/run-el-test.sh <tests/test_x.el> | --all" >&2; exit 2; }
+    for t in "$@"; do run_one "$t" || rc_all=1; done
+fi
+exit $rc_all

tests/test_bridge_serialization.el

@@ -93,7 +93,7 @@ println("1. bridge_save — empty messages guard")
 let sid1: String = "test-session-empty-messages"
 state_set("mcp_bridge:" + sid1, "")
 
-let save1_ok: Bool = bridge_save(sid1, "claude-sonnet-4-5", "sys", "[]", "", "", "call-1")
+let save1_ok: Bool = bridge_save(sid1, "claude-sonnet-4-5", "sys", "[]", "", "", "call-1", "anthropic")
 assert_false("empty messages -> bridge_save returns false", save1_ok)
 
 let saved1: String = state_get("mcp_bridge:" + sid1)
@@ -107,7 +107,7 @@ println("2. bridge_save — empty tools_json guard")
 let sid2: String = "test-session-empty-tools"
 state_set("mcp_bridge:" + sid2, "")
 
-let save2_ok: Bool = bridge_save(sid2, "claude-sonnet-4-5", "sys", "", "[{\"role\":\"user\",\"content\":\"hi\"}]", "", "call-2")
+let save2_ok: Bool = bridge_save(sid2, "claude-sonnet-4-5", "sys", "", "[{\"role\":\"user\",\"content\":\"hi\"}]", "", "call-2", "anthropic")
 assert_false("empty tools_json -> bridge_save returns false", save2_ok)
 
 let saved2: String = state_get("mcp_bridge:" + sid2)
@@ -126,7 +126,7 @@ state_set("mcp_bridge:" + sid3, "")
 
 let msgs3: String = "[{\"role\":\"user\",\"content\":\"hello\"}]"
 let tools3: String = "[{\"name\":\"read_file\"}]"
-let save3_ok: Bool = bridge_save(sid3, "claude-sonnet-4-5", "You are a helper.", tools3, msgs3, "read_file", "toolu_abc")
+let save3_ok: Bool = bridge_save(sid3, "claude-sonnet-4-5", "You are a helper.", tools3, msgs3, "read_file", "toolu_abc", "anthropic")
 assert_true("valid args -> bridge_save returns true", save3_ok)
 
 let blob3: String = state_get("mcp_bridge:" + sid3)
@@ -243,7 +243,7 @@ state_set("mcp_bridge:" + sid8, "")
 let special_id: String = "toolu_test\"quoted\""
 let msgs8: String = "[{\"role\":\"user\",\"content\":\"hi\"}]"
 let tools8: String = "[{\"name\":\"read_file\"}]"
-let save8_ok: Bool = bridge_save(sid8, "claude-sonnet-4-5", "sys", tools8, msgs8, "", special_id)
+let save8_ok: Bool = bridge_save(sid8, "claude-sonnet-4-5", "sys", tools8, msgs8, "", special_id, "anthropic")
 assert_true("special chars in tool_use_id -> bridge_save returns true", save8_ok)
 
 let blob8: String = state_get("mcp_bridge:" + sid8)
@@ -251,6 +251,111 @@ let blob8: String = state_get("mcp_bridge:" + sid8)
 let retrieved_id: String = json_get(blob8, "tool_use_id")
 assert_eq("tool_use_id with quotes round-trips via json_safe", retrieved_id, special_id)
 
+// ── Section 9: the "wire" field (OpenAI-tools port, 2026-08-06) ───────────────
+//
+// A suspended turn must resume on the SAME wire format it suspended on: an OpenAI-lane
+// bridge answered with an Anthropic-shaped tool_result (or vice versa) is a dead run.
+// bridge_save therefore stamps the blob with "wire", and agentic_resume branches on it.
+//
+// §9c is the important one. json_get is a first-substring-match scanner, so any key that
+// appears inside the UNESCAPED conversation embedded in messages_raw can be matched
+// instead of the blob's own field — that exact class of bug produced the round-9 resume
+// failure (json_get(blob,"tool_use_id") matching a web_search_tool_result's id inside the
+// replayed conversation). "wire" is written as a json_safe'd SCALAR ahead of both raw
+// fields precisely so a decoy in model-controlled bytes can never win. This test plants
+// that decoy on purpose. If someone later moves the field after messages_raw, this fails.
+
+println("")
+println("9. bridge_save — wire tagging and its field-order guarantee")
+
+// 9a. an OpenAI-lane suspension round-trips as "openai"
+let sid9: String = "test-session-wire-openai"
+state_set("mcp_bridge:" + sid9, "")
+let msgs9: String = "[{\"role\":\"user\",\"content\":\"hi\"}]"
+let tools9: String = "[{\"name\":\"read_file\"}]"
+let save9_ok: Bool = bridge_save(sid9, "llama-3.3-70b-versatile", "sys", tools9, msgs9, "", "call_abc", "openai")
+assert_true("openai wire -> bridge_save returns true", save9_ok)
+let blob9: String = state_get("mcp_bridge:" + sid9)
+assert_eq("wire round-trips as openai", json_get(blob9, "wire"), "openai")
+
+// 9b. an Anthropic-lane suspension round-trips as "anthropic"
+let sid9b: String = "test-session-wire-anthropic"
+state_set("mcp_bridge:" + sid9b, "")
+let save9b_ok: Bool = bridge_save(sid9b, "claude-sonnet-4-5", "sys", tools9, msgs9, "", "toolu_abc", "anthropic")
+assert_true("anthropic wire -> bridge_save returns true", save9b_ok)
+let blob9b: String = state_get("mcp_bridge:" + sid9b)
+assert_eq("wire round-trips as anthropic", json_get(blob9b, "wire"), "anthropic")
+
+// 9c. FIELD-ORDER GUARD: a decoy "wire" inside the conversation must NOT be matched.
+let sid9c: String = "test-session-wire-decoy"
+state_set("mcp_bridge:" + sid9c, "")
+let msgs9c: String = "[{\"role\":\"user\",\"content\":\"please save this literal text: \\\"wire\\\":\\\"anthropic\\\" end\"}]"
+let save9c_ok: Bool = bridge_save(sid9c, "llama-3.3-70b-versatile", "sys", tools9, msgs9c, "", "call_decoy", "openai")
+assert_true("decoy conversation -> bridge_save returns true", save9c_ok)
+let blob9c: String = state_get("mcp_bridge:" + sid9c)
+assert_eq("blob's own wire wins over a decoy planted in messages_raw", json_get(blob9c, "wire"), "openai")
+
+// 9d. LEGACY blob (written before the port) has no wire field: json_get yields "",
+// which agentic_resume treats as the Anthropic path — old suspensions still resume.
+let sid9d: String = "test-session-wire-legacy"
+let legacy_blob: String = "{\"model\":\"claude-sonnet-4-5\",\"safe_sys\":\"sys\",\"tools_log\":\"\""
+    + ",\"tool_use_id\":\"toolu_legacy\",\"tools_raw\":[{\"name\":\"read_file\"}]"
+    + ",\"messages_raw\":[{\"role\":\"user\",\"content\":\"hi\"}]}"
+state_set("mcp_bridge:" + sid9d, legacy_blob)
+let blob9d: String = state_get("mcp_bridge:" + sid9d)
+assert_eq("legacy blob has no wire field -> empty (resumes as anthropic)", json_get(blob9d, "wire"), "")
+assert_eq("legacy blob still reads its tool_use_id", json_get(blob9d, "tool_use_id"), "toolu_legacy")
+
+// 9e. THE HARDER DECOY: a LEGACY blob (no wire field of its own) that carries the bytes
+// of a wire tag deeper inside, where an unbounded first-match scan would find it and
+// misroute the resume onto the wrong loop — the round-9 defect class exactly.
+//
+// WHAT IS AND IS NOT REACHABLE (measured here, not assumed — an earlier version of this
+// test asserted the wrong thing and was corrected by running it):
+//   * NOT reachable from ordinary conversation TEXT. Any quote a user or model writes is
+//     backslash-escaped when it is serialized into the blob, so prose containing
+//     "wire":"openai" is stored as \"wire\":\"openai\" and does not match a scan for the
+//     unescaped key. §9f pins that.
+//   * REACHABLE from STRUCTURAL keys, which are embedded raw. Conversation and tool
+//     objects keep real quotes — that is precisely how round 9's scan found a
+//     web_search_tool_result's tool_use_id. A connector-supplied tool schema or a future
+//     message field literally named "wire" would be found the same way.
+// The bound removes the whole class rather than reasoning about which keys exist today.
+let sid9e: String = "test-session-wire-legacy-decoy"
+let decoy_blob: String = "{\"model\":\"claude-sonnet-4-5\",\"safe_sys\":\"sys\",\"tools_log\":\"\""
+    + ",\"tool_use_id\":\"toolu_legacy\""
+    + ",\"tools_raw\":[{\"name\":\"read_file\",\"wire\":\"openai\"}]"
+    + ",\"messages_raw\":[{\"role\":\"user\",\"content\":\"hi\"}]}"
+state_set("mcp_bridge:" + sid9e, decoy_blob)
+let blob9e: String = state_get("mcp_bridge:" + sid9e)
+
+// Unbounded read (what NOT to do) — proves the hazard this guard exists for is real.
+assert_eq("unbounded scan DOES find a structural decoy (why the bound is needed)", json_get(blob9e, "wire"), "openai")
+
+// Bounded read — the same computation agentic_resume performs.
+let d_traw: Int = str_index_of(blob9e, ",\"tools_raw\":")
+let d_tjson: Int = str_index_of(blob9e, ",\"tools_json\":")
+let d_mraw: Int = str_index_of(blob9e, ",\"messages_raw\":")
+let d_msgs: Int = str_index_of(blob9e, ",\"messages\":")
+let dcut1: Int = if d_traw > 0 { d_traw } else { str_len(blob9e) }
+let dcut2: Int = if d_tjson > 0 && d_tjson < dcut1 { d_tjson } else { dcut1 }
+let dcut3: Int = if d_mraw > 0 && d_mraw < dcut2 { d_mraw } else { dcut2 }
+let dcut: Int = if d_msgs > 0 && d_msgs < dcut3 { d_msgs } else { dcut3 }
+let head9e: String = str_slice(blob9e, 0, dcut)
+assert_eq("bounded scan ignores the decoy -> legacy blob resumes as anthropic", json_get(head9e, "wire"), "")
+assert_not_contains("scalar head excludes the bulk fields entirely", head9e, "read_file")
+
+// 9f. Escaping bounds the severity: prose CANNOT inject a scalar-looking key, because
+// its quotes are escaped on the way in. Documented as a measured fact, so nobody has to
+// re-derive it the next time this question comes up.
+let sid9f: String = "test-session-wire-prose"
+let prose_blob: String = "{\"model\":\"claude-sonnet-4-5\",\"safe_sys\":\"sys\",\"tools_log\":\"\""
+    + ",\"tool_use_id\":\"toolu_legacy\",\"tools_raw\":[{\"name\":\"read_file\"}]"
+    + ",\"messages_raw\":[{\"role\":\"user\",\"content\":\"remember this: \\\"wire\\\":\\\"openai\\\"\"}]}"
+state_set("mcp_bridge:" + sid9f, prose_blob)
+let blob9f: String = state_get("mcp_bridge:" + sid9f)
+assert_eq("escaped prose cannot spoof the key even unbounded (severity bound)", json_get(blob9f, "wire"), "")
+
 // ── Summary ────────────────────────────────────────────────────────────────────
 
 println("")

tests/test_utf8_slice.el

@@ -0,0 +1,92 @@
+// tests/test_utf8_slice.el
+//
+// Guards utf8_safe_slice(), the fix for a live defect found 2026-08-06:
+//
+// The session preload cuts recalled memory content at a fixed length
+// (chat.el: `if str_len(acc) > 350 { str_slice(acc, 0, 350) }` and
+// session_preload_bullets' identical per-bullet cut). str_slice and str_len count
+// BYTES, so any cut landing inside a multi-byte UTF-8 character leaves a dangling
+// lead byte in the system prompt — and the whole request body is then invalid UTF-8.
+// Providers reject it outright, so the user sees "AI unavailable" with no clue why,
+// on both wire formats. Caught by an OpenAI-lane gate whose stub decodes strictly;
+// reproduced from a real memory whose content contained box-drawing rules (E2 94 80).
+//
+// Trigger is ordinary content: an em dash, a curly quote, an accented name, a table
+// border, an emoji — anything non-ASCII sitting on the cut boundary. It gets MORE
+// likely as a user's memory grows, which is the opposite of what should happen.
+//
+// §1 also pins the semantics this fix depends on: that str_char_code returns the
+// BYTE value at a byte index (not a decoded code point). If a future runtime changes
+// that, these assertions fail loudly instead of the truncation silently rotting.
+
+import "../chat.el"
+
+let pass_count: Int = 0
+let fail_count: Int = 0
+
+fn assert_eq(label: String, got: String, expected: String) -> Void {
+    if str_eq(got, expected) {
+        let pass_count = pass_count + 1
+        println("  PASS: " + label)
+    } else {
+        let fail_count = fail_count + 1
+        println("  FAIL: " + label)
+        println("    got:      " + got)
+        println("    expected: " + expected)
+    }
+}
+
+fn assert_eq_int(label: String, got: Int, expected: Int) -> Void {
+    assert_eq(label, int_to_str(got), int_to_str(expected))
+}
+
+println("")
+println("1. runtime semantics this fix relies on")
+
+// "─" is U+2500 = E2 94 80 (three bytes). If str_len counts bytes, len("─") is 3.
+let dash: String = "─"
+assert_eq_int("str_len counts BYTES (one box-drawing char = 3)", str_len(dash), 3)
+assert_eq_int("str_char_code returns the BYTE value (lead byte of U+2500 = 0xE2 = 226)", str_char_code(dash, 0), 226)
+assert_eq_int("str_char_code second byte = 0x94 = 148", str_char_code(dash, 1), 148)
+assert_eq_int("str_char_code third byte = 0x80 = 128", str_char_code(dash, 2), 128)
+
+println("")
+println("2. utf8_safe_slice — never leaves a partial character")
+
+// Pure ASCII: behaves exactly like str_slice.
+assert_eq("ascii under the limit is untouched", utf8_safe_slice("hello", 10), "hello")
+assert_eq("ascii over the limit cuts exactly", utf8_safe_slice("hello world", 5), "hello")
+
+// A cut landing INSIDE a 3-byte character must drop that character entirely.
+// "ab─cd": bytes a b E2 94 80 c d. Cutting at 3 or 4 lands mid-dash.
+let mixed: String = "ab─cd"
+assert_eq_int("fixture is 7 bytes (2 ascii + 3 + 2 ascii)", str_len(mixed), 7)
+assert_eq("cut inside the char (n=3) drops the partial char", utf8_safe_slice(mixed, 3), "ab")
+assert_eq("cut inside the char (n=4) drops the partial char", utf8_safe_slice(mixed, 4), "ab")
+// A cut landing exactly AFTER a complete character keeps it.
+assert_eq("cut on the char boundary (n=5) keeps the whole char", utf8_safe_slice(mixed, 5), "ab─")
+
+// 2-byte character (é = C3 A9) and 4-byte character (😀 = F0 9F 98 80).
+let acc: String = "xé"
+assert_eq("cut inside a 2-byte char drops it", utf8_safe_slice(acc, 2), "x")
+assert_eq("cut after a 2-byte char keeps it", utf8_safe_slice(acc, 3), "xé")
+let emo: String = "x😀"
+assert_eq("cut inside a 4-byte char drops it (n=3)", utf8_safe_slice(emo, 3), "x")
+assert_eq("cut inside a 4-byte char drops it (n=4)", utf8_safe_slice(emo, 4), "x")
+assert_eq("cut after a 4-byte char keeps it", utf8_safe_slice(emo, 5), "x😀")
+
+println("")
+println("3. the real-world shape that produced the bug")
+
+// A run of box-drawing rules, cut mid-character — the exact captured failure.
+let rules: String = "──────"
+assert_eq_int("six box rules = 18 bytes", str_len(rules), 18)
+// n=16 lands one byte into the sixth character.
+let cut16: String = utf8_safe_slice(rules, 16)
+assert_eq_int("cut at 16 backs off to a clean 15-byte boundary", str_len(cut16), 15)
+// Every byte of the result must belong to a complete character: the last byte of a
+// well-formed run of these is always 0x80, and 15 is divisible by 3.
+assert_eq_int("result ends on a complete char (last byte 0x80)", str_char_code(cut16, 14), 128)
+
+println("")
+println("test_utf8_slice.el: " + int_to_str(pass_count) + " passed, " + int_to_str(fail_count) + " failed")

tools/soulc-stamp.sh

@@ -30,9 +30,19 @@ AMALGAM="$ROOT/dist/soul.c"
 
 # Every .el at the repo root is an input to the amalgam. Sorted so the hash is
 # order-independent; content-only so timestamps and checkouts do not perturb it.
+# The COMPILER is an input too. Learned 2026-08-09 by installing a fixed elc and
+# watching this gate report OK while the committed amalgam had gone stale by a line:
+# the sources had not changed, so a source-only fingerprint could not see it. That is
+# precisely the blind spot this gate exists to close, and it had it.
 fingerprint() {
   (
     cd "$ROOT" || exit 1
+    ELC_BIN="${ELC:-$HOME/neuron-dev-stack/src/el/lang/dist/platform/elc}"
+    if [ -f "$ELC_BIN" ]; then
+      printf '%s  %s\n' "$(shasum -a 256 "$ELC_BIN" | awk '{print $1}')" "__compiler__"
+    else
+      printf '%s  %s\n' "MISSING" "__compiler__"
+    fi
     for f in $(ls -1 *.el 2>/dev/null | sort); do
       printf '%s  %s\n' "$(shasum -a 256 "$f" | awk '{print $1}')" "$f"
     done

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

@@ -5634,6 +5634,25 @@ void el_cgi_init(el_val_t name, el_val_t dharma_id, el_val_t principal,
 }
 
 
+/* ── Compiled-identity accessors (2026-08-09) ─────────────────────────────────
+ * el_cgi_init loads the declaration into these globals at startup and printed
+ * them, and NOTHING read them back out — no accessor existed, and el_cgi_init
+ * writes no state. So a binary carried its declared identity and every consumer
+ * still read it from the mutable state store, which is exactly what IDPROTO
+ * claims 1-2 forbid ("not modifiable by any runtime mechanism including
+ * environment variables, configuration files, or API calls").
+ *
+ * These are READ-ONLY on purpose. There is deliberately no setter: publishing
+ * the values into the state store would have been one line and would have
+ * recreated the mutable copy the design prohibits. A caller can read the
+ * compiled identity; nothing can change it after el_cgi_init.
+ */
+el_val_t cgi_name(void)      { return EL_STR(_el_cgi_name      ? _el_cgi_name      : ""); }
+el_val_t cgi_dharma_id(void) { return EL_STR(_el_cgi_dharma_id ? _el_cgi_dharma_id : ""); }
+el_val_t cgi_principal(void) { return EL_STR(_el_cgi_principal ? _el_cgi_principal : ""); }
+el_val_t cgi_network(void)   { return EL_STR(_el_cgi_network   ? _el_cgi_network   : ""); }
+el_val_t cgi_engram(void)    { return EL_STR(_el_cgi_engram    ? _el_cgi_engram    : ""); }
+
 /* ── Batch 3: Engram in-process graph store ──────────────────────────────── */
 /*
  * Single global EngramStore allocated lazily on first call. All node and

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

@@ -782,6 +782,14 @@ 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);
 
+/* Compiled-identity accessors — read-only by design (2026-08-09). */
+el_val_t cgi_name(void);
+el_val_t cgi_dharma_id(void);
+el_val_t cgi_principal(void);
+el_val_t cgi_network(void);
+el_val_t cgi_engram(void);
+
 #ifdef __cplusplus
 }
+
 #endif