feat(soul): Stage 1 structural audit as a real route — an annotated characterization, not a score (#91)

`runStructuralAudit` has been an advertised MCP tool with nothing behind it: the
dispatcher GET'd /session/begin and returned that unrelated session digest under
an audit tool's name. Meanwhile the failure the audit would have caught ran
silently for about three weeks — the soul reporting 103,089 nodes while the
engram, which OWNS persistence, held ~79,900, a crash discarding the difference,
and every boot reporting green throughout, because nothing in the system ever
compared the two sides.

WHAT THE PATENT SPECIFIES, AND HOW IT SHAPED THIS
  CGI provisional, 05-detailed-description.md, "Stage 1: Structural audit 430".
  Two clauses did the design work. First the four things the module evaluates:
  the density and typed distribution of causal edges; value/execution-record
  consistency; the richness and connectivity of the self-model; and wonder-
  manifest authenticity. Second, and decisively: it "produces a coherence
  assessment 432 — NOT A BINARY SCORE but an annotated characterization of the
  graph's structural properties."

  So every finding carries its numbers AND a plain-language note saying what
  they mean and how they were obtained. There is no pass/fail and no composite
  health figure, and `"score":null` is emitted explicitly so a reader cannot
  mistake its absence for an omission.

WHAT IS IN STAGE 1 (four findings)
  owner_runtime_divergence   — the motivating case. Runtime counts vs the owner's
      own GET /api/stats, the delta, and the trend against the previous audit, so
      a second call answers "is the gap growing?" rather than restating it.
  self_model_connectivity    — the three identity pillars plus the self root:
      present, content length, one-hop degree. This RETIRES the Claude-side vitals
      identity block, which lived outside the system it was checking and went on
      reporting green while the memory-philosophy pillar was absent from the live
      graph. Asking the running soul is the designed mechanism; a shell probe was
      the fourth patch on the same hole.
  typed_edge_distribution    — exact counts against the claim-10 vocabulary, plus
      density, plus a separate count of LOWERCASE near-misses ("causes" vs
      "Causes"): "the vocabulary is unused" and "the vocabulary is misspelled by
      the write paths" are different defects with different fixes.
  orphans_and_dangling_edges — the tool's own long-standing promise.

WHAT IS DEFERRED, AND WHY IT IS DATA RATHER THAN A COMMENT
  Value/execution-record consistency and wonder-manifest authenticity ship as a
  `deferred` array that MEASURES the populations they would need (Prediction and
  WonderQuestion nodes) and reports those counts as the reason. Both are ~0 today
  — WonderQuestion because of a known write/read node-type mismatch. Asserting
  value coherence or a pull-weight correlation on an empty population would be a
  fabricated result, which is worse than a stated gap.

MEASUREMENT HONESTY: EXACT WHERE CHEAP, SAMPLED WHERE NOT, ALWAYS LABELLED
  Counts, edge typing and self-model connectivity are exact. Orphan and dangling
  rates are sampled, because engram_find_node_index is a linear scan — an
  exhaustive dangling check is O(nodes x edges), ~2.2e9 string compares at today's
  scale. Samples are UNIFORM across the whole population (str_index_of_all gives
  every edge offset in one pass, so any index is O(1); json_array_get would have
  been O(n^2)), never head-of-list, and each figure ships with its own sampled /
  population / exhaustive fields. ?edge_sample= and ?node_sample= at population
  size run either check exhaustively. The real fix is an id index in the runtime.

ONE BUG THIS FOUND IN ITSELF, CAUGHT IN TEST
  http_get does not return "" when the owner is unreachable — it returns a JSON
  error object. Testing only for "" made a DEAD owner read as reachable with
  node_count 0, so the audit reported 100% divergence and named it data loss.
  Reachability is now proved by the presence of the node_count field, and the
  owner's raw reply is attached. A confident wrong answer is exactly what this
  route exists to stop.

  Edge findings need relation labels and the runtime has no edge-enumeration
  builtin, so they use the same scratch export GET /api/graph/edges already uses
  (engram_save to TMPDIR, never the owner's canonical file — #117). That is a
  large write on a large graph, so this is a manual route, not a timer; ?edges=0
  skips it.

  neuron-api.el:900-1273  handler + helpers
  routes.el:567,752       GET and POST /api/neuron/audit/structural
  mcp-wrapper/src/main.el:113,682  tool description + dispatch off /session/begin
  dist/soul.c             regenerated (1255 bodies)

Rung: E2E-VERIFIED. Soul built from this branch (gen-soul-amalgam + cc-brain,
921,192 bytes, 16 warnings, 0 errors), booted on throwaway ports 7893/7896/7897
with throwaway HOMEs against a stub owner on 7894. Three scenarios pass: owner
reachable (runtime 62 vs owner 42, delta 20 / 32.2%, trend flat on the second
call; 12/20 edges claim-10 typed, 3 lowercase near-misses; 50/62 orphans, 3/20
dangling — every figure matches the fixture by construction), owner unreachable
(reported as a finding with the raw reply, not a crash), and file mode (owner
"none", divergence undefined). Reached end-to-end through the MCP tool via a
locally built wrapper. verify-soul-contract.sh: GATE PASS, 27/27 routes +
immutability. No process left running; live :7770 and :8742 untouched (GET only).

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

.gitea/workflows/ci.yaml

@@ -63,22 +63,6 @@ jobs:
           cp vendor/el-runtime/v1.0.0-20260501/el_runtime.h /opt/el/runtime/el_runtime.h
           echo "El runtime PINNED to v1.0.0-20260501: $(ls /opt/el/runtime/)"
 
-      # neuron#133: CI compiles dist/soul.c, NOT the .el sources. On 2026-08-07 a
-      # build off main would have shipped an engine with none of five merged fixes,
-      # including a P0 safety fix, while main's source read as correct. The runner
-      # 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
-
       - name: Build neuron soul binary
         run: |
           RUNTIME=/opt/el/runtime

.gitignore

@@ -7,15 +7,5 @@ dist/*.backup-*
 *.o
 *.a
 
-# elc/elb compiled header caches. DO NOT commit these: elc/elb silently
-# prefer a stale committed .elh over recompiling its .el source, with no
-# warning — a fresh checkout with these committed caches present can build
-# and boot "successfully" while silently missing large chunks of code
-# (found 2026-08-15: an amalgam regen with these present under-resolved to
-# 251-645 of 2541 real functions, incl. losing the entire 31-language NLG/
-# morphology stack, with exit code 0 and no error). Regenerate locally; never
-# commit the cache.
-*.elh
-
 # macOS
 .DS_Store

AGENTS.md

@@ -1,170 +0,0 @@
-# AGENTS.md — neuron (the canonical CGI substrate: soul + engram + proxy + wrapper)
-
-This is the core repo: the **soul** (the running agent), the **engram** (its memory graph),
-and the MCP proxy/wrapper that expose it. Read this before touching anything here.
-
-> Corrected 2026-08-15 during a local-build audit. This file previously existed only
-> uncommitted on disk (never in git history) and documented the pre-collapse MCP tool
-> surface as current. Both are fixed here — see the audit's findings in Neuron memory
-> (tags `neuron-technologies/neuron,build-audit`) for full evidence.
-
-## Code vs. Artifact
-- **Authored source:** `*.el` + `*.elh` at the repo root (`awareness.el`, `chat.el`, `memory.el`, `neuron-api.el`, `persist.el`, `routes.el`, `safety.el`, `sessions.el`, `stewardship.el`, `imprint.el`, `studio.el`, `elp-input.el`, `manifest.el`) plus `cli/`, `council/`, `connectd/`, `mcp-proxy/`, `mcp-wrapper/` — edit here.
-- **Artifacts (DO NOT hand-edit `dist/soul.c`):** `dist/soul.c` is a generated single-translation-unit amalgamation of the soul's full transitive `.el` import set, produced by concatenating the sources (import lines stripped) and running `elc` once — see "Build / regenerate" below for the exact, audit-verified recipe. `dist/*.c` per-module files and `dist/*.elh` headers alongside it are separate, also-generated artifacts from other tooling; don't hand-edit those either.
-- **Release:** git tag `neuron-vX.Y.Z` on this repo. No `releases/` folders.
-- Org-wide code-vs-artifact policy: `docs/CODE-VS-ARTIFACT.md` (this repo's own `dist/soul.c` situation is a special case of that policy — see below, not a duplicate of it).
-
-## How to work here as Neuron (mandatory session protocol)
-
-You do not start fresh — you resume. The live MCP surface is a 9-op collapse
-(merged from the old ~90-tool surface in PR #153, `feat/mcp-wrapper-collapse-9ops`,
-already merged to `main`): **`read`, `write`, `relate`, `supersede`** (geometry, live)
-and **`think`, `attend`, `assert`, `ground`, `learn`** (agentic, pending Layer-2
-cognition-build promotion). There is no `getInstructions`/`beginSession`/
-`inspectGraph`/`searchKnowledge`/`compileCtx`/etc — those tool names no longer exist.
-
-At the start of every session:
-
-1. `mcp__neuron__read(vantage="self", k=12, depth=1)` — the canonical self node
-   (`kn-efeb4a5b-5aff-4759-8a97-7233099be6ee`). Widen `k`/`depth` deliberately if you
-   need the connected identity neighborhood (intellectual-dna, memory-philosophy,
-   values, voice, runtime-environment, writing-imprint) — the aperture caps output
-   by `k` first, so this is bounded by design, not a flattened dump.
-   Then `mcp__neuron__read(vantage="values", k=13)` for the 13 grounded value nodes.
-   - Best-effort: on a 502/520, log the id and proceed — the compiled `fixedSelf` in
-     `daemon/internal/substrate/substrate.go` is always complete.
-2. `mcp__neuron__read(vantage="<task domain>")` before implementing anything.
-3. `mcp__neuron__read(vantage="<project>", k=20)` for a bounded context snapshot when
-   resuming known work.
-
-## The Five Primitives (every significant task)
-
-**Orchestrate → Execute → Learn → Build → Refine**, all routed through the 9-op surface:
-- Orchestrate: `read(vantage=...)` for backlog/roadmap/process discovery, `attend()` for
-  what's currently live/salient.
-- Execute: `write(type="state", ...)` to open/advance work, `relate()` to link it to
-  what it touches.
-- Learn: `write(type="memory", ...)` **as you go, not batched**; `importance="critical"`
-  for architecture decisions.
-- Build: `write(type="artifact"|"backlog", ...)`.
-- Refine: `supersede(id=..., action="evolve"|"tombstone"|"promote", ...)` for
-  completions and lessons-learned; `learn(seeds=..., faculty="induce")` to recalibrate
-  the steering-prior, not as a session-notes dump.
-
-## Architecture style — VBD, no exceptions
-
-Volatility-Based Decomposition is THE style. Encapsulate volatility, not function. Full docs:
-**`docs/architecture/`** — `00-overview`, `02-components`, `03-data-and-memory`,
-`04-runtime-and-deployment`, `06-cognitive-architecture`, `07-storage-coherence-and-distribution`.
-Verified component map: `routes.el` = HTTP dispatcher (`handle_request`), `soul.el` = boot +
-layered cycle, `awareness.el` = awareness daemon, `sessions.el`/`memory.el`/`safety.el`/
-`stewardship.el` = managers; `engram` (separate repo) = the persistence/graph engine.
-
-## Hard operational rules
-
-- **Never touch the live soul (`:7770`) or engram (`:8742`), `~/.neuron`, or live binaries.**
-  Experiment on **throwaway ports** with a **scratch `HOME`**. The soul binary defaults to
-  `HOME=~` (your real `~/.neuron`) and `NEURON_PORT=7770` (live) if invoked bare — **never**
-  invoke it without an override `HOME` and `NEURON_PORT` set. Leaving `ENGRAM_URL` unset is
-  verified safe (see `soul.el:590`, `using_http_engram` gates the only HTTP call to any
-  engram endpoint — confirmed by source trace during the 2026-08-15 audit, not just
-  observed behavior) — it does not fall back to any live/network default.
-- **Immutability:** memory/knowledge is append-only — **supersede/tombstone, never hard-delete or
-  edit in place.** The engram is immutable by design.
-- **gcloud** via the `terraform@` SA token; **never switch the active gcloud account**.
-- **`tea` for Gitea**, never raw `curl` (Cloudflare Access blocks it).
-- **No AI-attribution footers** in commits/PRs. Commit/push only when asked; branch off `main` first.
-- **Multi-step work → sub-agent** to protect the context window.
-
-## Build / regenerate `dist/soul.c` (audit-verified 2026-08-15, macOS arm64)
-
-There is no committed regeneration script upstream of this audit. The recipe below is
-verified: it reproduces the committed `dist/soul.c`'s exact symbol set byte-for-byte in
-content (modulo genuinely new code), and the resulting binary boots and answers `/health`.
-
-**The compiler toolchain** lives in the sibling `foundation` repo, not this one:
-`foundation/el/lang/dist/platform/elc-darwin-arm64` (put it on `$PATH` as `elc`; `elb`
-also exists there but is NOT the right tool for this repo — see gotcha below).
-
-**⚠ elc gotcha #1 — stale `.elh` header caches silently truncate the build.** This repo
-(and the `dist/` dir) ships committed `.elh` header files. `elc`/`elb` prefer an existing
-`.elh` over recompiling its source when present, with NO warning or error when the cached
-header is stale/truncated — the build "succeeds" with silently missing code (observed:
-251-645 of 2541 real functions, depending on which `.elh` files were present, including
-losing the entire 31-language NLG/morphology stack with exit code 0). **Delete every
-`*.elh` in the repo root and `dist/` before regenerating**, every time.
-
-**⚠ elc gotcha #2 — `elb` cannot produce this repo's single-TU `dist/soul.c`.** `elb`
-does per-module separate compilation (`--out=DIR` writes one `.c`/`.elh` pair per
-module; the default `--out` is also a directory, `dist/` itself). This codebase's
-`.el` modules call each other's functions without forward declarations (relying on
-`elc`'s own single-pass, whole-file forward-declaration emission), so per-module
-compilation always fails with `implicit-function-declaration` errors across module
-boundaries. **Use plain `elc` on one manually-flattened file, not `elb`.**
-
-**⚠ elc gotcha #3 — the manual-concatenation path silently drops functions.** When
-`elc` compiles a flat, hand-concatenated `.el` file, it silently drops (no error, no
-declaration, no definition) the 1-2 top-level function definitions immediately
-following any multi-line leading `//` comment block or file-boundary transition —
-reproduced deterministically. **Insert two trivial buffer functions
-(`fn __amalgam_buf_N__() -> Int { return 0 }`) after every concatenated file's
-content**, then strip them back out of the generated `.c` before committing.
-
-**The actual steps:**
-1. Delete all `*.elh` in repo root and `dist/`.
-2. Concatenate, with `import` lines stripped, in this order: `elp.el`'s own 34-file
-   NLG/morphology chain (`foundation/el/elp/src/` — the order is documented in
-   `elp.el`'s own header comment: language-profile, vocabulary, morphology, the 30
-   `morphology-XX.el` engines, grammar, realizer, semantics, then `elp.el` itself),
-   then this repo's 13 soul modules in `elb`'s own reported dependency order:
-   `persist, memory, safety, stewardship, imprint, awareness, chat, studio,
-   elp-input, neuron-api, sessions, routes, soul`. Insert the 2-function buffer
-   after every file (works around gotcha #3).
-3. `elc <flat-file> > dist/soul.c` against the **pinned** vendor runtime headers
-   (`vendor/el-runtime/v1.0.0-20260501/` — see "why pinned" below), not
-   `foundation/el/lang/el-compiler/runtime/` (that's the bleeding-edge runtime;
-   using it drops symbols like `engram_prune_telemetry` that this soul still calls).
-4. Strip the buffer functions back out of `dist/soul.c` (a small regex: drop every
-   `el_val_t __amalgam_buf_\d+__(void);` decl line and every matching 4-line
-   definition block).
-5. `tools/soulc-stamp.sh --write` to record the new fingerprint.
-6. `bash tools/build-soul-from-dist.sh dist/neuron` to compile+link with CI's exact
-   flags (this script now auto-detects Homebrew's `openssl@3` lib path on macOS —
-   see gotcha #4).
-
-**⚠ gotcha #4 — macOS needs an explicit OpenSSL library path.** `cc ... -lssl -lcrypto
--lcurl ...` fails with `ld: library 'ssl' not found` on macOS because Homebrew's
-`openssl@3` is keg-only. `tools/build-soul-from-dist.sh` now adds
-`-L$(brew --prefix openssl@3)/lib` automatically on Darwin; CI's Ubuntu runner needs
-no such flag (`apt-get install libcurl4-openssl-dev` puts it on the default path).
-
-**⚠ Build-integrity (unchanged from before this audit):** `dist/soul.c` is committed
-and generated. CI compiles it **directly and never regenerates it** (`elb`/`elc` on
-Linux OOM the runner). So **any `.el` change to the soul MUST be followed by
-regenerating `dist/soul.c` (steps above) and committing it** — otherwise CI ships
-stale behavior, exactly as happened between commit `72e0b82` (Aug 9) and `main` HEAD
-before this audit (`dist/soul.c` was missing PR #122's 459-line chat.el change, incl.
-a "silently break chat" fix, until this pass regenerated and re-stamped it).
-`tools/soulc-stamp.sh --check` is the gate that catches this — **note it is currently
-`continue-on-error: true` in CI** ("relaxed... during active cultivation", 2026-08-15),
-so it reports but does not block; re-harden before it needs to actually stop a bad ship.
-
-- **Tests:** El contract suite in `tests/*.el` (e.g. `test_layer_contract.el`, `test_safety.el`,
-  `test_sessions.el`, `test_soul_guard.el`). Run against a throwaway soul, never the live one.
-- **Port topology (confirmed live, 2026-08-15):** soul `:7770`, engram `:8742`,
-  mcp-wrapper `:17779` (`MCP_PORT` env override in its LaunchAgent; source default is
-  `7779`), mcp-proxy `:7779` (the stable front door Claude Code actually connects to).
-  **`:7771` is a live three-way collision, not a single well-defined port** — `axon`
-  (soul.el's Rust backlog/memory/knowledge proxy, unbuilt), `neuron-connectd` (the MCP
-  connector sidecar `routes.el`/`chat.el` call — unbuilt; a local-dev stub now exists at
-  `connectd/`), and `council` (`council/`, an anti-confabulation LLM-voting service —
-  the one actually bound to `:7771` in Will's live environment) are all hardcoded to it.
-  See `connectd/README.md` for the full trace and the open question this leaves for Will.
-- **Deploy:** merge to `main` → `.gitea/workflows/ci.yaml` builds + publishes `neuron-soul@<sha8>`
-  and blue/green-deploys to GKE `neuron-prod` via `scripts/blue-green-deploy.sh`. Self-improvement
-  experiments go to **stage** first (snapshot prod DB → deploy stage → verify → blue/green promote).
-
-## Git / CI / deploy workflow
-
-See **`../GITOPS.md`** (repo-family GitOps README): branch model, required checks, blue/green,
-Cloud Run, Terraform/ESO/Vault, and the pack-objects/crawler incident runbook.

PORT-NOTES.md

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

README.md

@@ -1,28 +0,0 @@
-# neuron
-
-The canonical CGI substrate: the **soul** (the running agent), the **engram** (its memory
-graph), and the MCP proxy/wrapper that expose it. See `AGENTS.md` for detail, including
-the audit-verified local build/regenerate recipe and known local-build gotchas.
-
-## Quick local build
-
-```bash
-# 1. dist/soul.c must match current .el sources — this refuses otherwise:
-bash tools/build-soul-from-dist.sh dist/neuron
-
-# 2. If it refuses (stale amalgam), regenerate first — see AGENTS.md's
-#    "Build / regenerate dist/soul.c" section for the full, gotcha-laden recipe.
-```
-
-For a full local dev stack (soul + engram + mcp-wrapper + mcp-proxy, wired into Claude
-Code) see `neuron-dev-setup/README.md` instead — this repo alone only builds the soul.
-
-## Code vs. Artifact
-- **Authored source:** `*.el` + `*.elh` at the repo root plus `cli/`, `council/`,
-  `connectd/`, `mcp-proxy/`, `mcp-wrapper/` — edit here.
-- **Artifacts (do not hand-edit):** `dist/soul.c` (generated single-TU amalgam —
-  regenerate via the recipe in `AGENTS.md`, then `tools/soulc-stamp.sh --write`) and
-  the `dist/neuron` binary it compiles to.
-- **Release:** git tag `neuron-vX.Y.Z` on this repo. No `releases/` folders.
-
-See org policy: `docs/CODE-VS-ARTIFACT.md`.

awareness.el

@@ -30,74 +30,6 @@ fn idle_reset() -> Void {
 // read decide where telemetry goes. The in-process write remains only as a
 // last resort when the HTTP POST itself fails, and is tagged ise-fallback-local
 // so misrouting is visible in the stream instead of silent.
-// hebb_consolidate — push self-formed associations to the durable store.
-//
-// WHY THIS EXISTS (2026-08-07 self-review, measured on the live system).
-// Yesterday's eligibility-trace fix made Hebbian learning work: hebb_max
-// 0.000799 -> 0.4725, and 1,198 hebbian-associate edges formed in 23h48m.
-// A census this morning found all 1,198 of them living in this process's RAM
-// and nowhere else:
-//
-//   soul daemon in-process graph:   42,426 edges, 1,198 hebbian
-//   engram server (:8742, durable): 41,213 edges,    49 hebbian
-//
-// The soul pulls from the server every 10 min (GET /api/sync) and never
-// pushes. It also cannot save its own snapshot: soul.el only sets
-// soul_snapshot_path inside `if is_genesis && safe_to_seed`, and safe_to_seed
-// is unconditionally false when ENGRAM_URL is set — which it is, in the
-// launchd plist — because the HTTP server owns persistence and a soul writing
-// snapshot.json would clobber it. That guard is right. So mem_save() below has
-// literally never run, and this daemon (the ONLY process doing idle cognition,
-// therefore where essentially all co-activation happens) was throwing away
-// every association it learned, every restart, silently.
-//
-// The fix is not to let the soul write the file. It is to make consolidation a
-// message: hand each newly-formed edge to the durable store over the API the
-// server already exposes. Fast volatile store learns online; slow durable store
-// keeps what cleared the threshold. Only edges past ENGRAM_HEBB_LINK_MIN are
-// ever queued, so what crosses the boundary already earned it.
-//
-// Failure is non-fatal by construction: a drained entry that fails to POST is
-// gone, and that is fine — a real association re-forms from live co-activation.
-// The counts go into the heartbeat (hebb_wb_*) so a consolidation path that has
-// stopped delivering is visible in the stream rather than in a later autopsy.
-fn hebb_consolidate() -> Int {
-    let batch: String = engram_hebb_drain_json(64)
-    if str_eq(batch, "") { return 0 }
-    if str_eq(batch, "[]") { return 0 }
-    let n: Int = json_array_len(batch)
-    if n == 0 { return 0 }
-    let url_env: String = env("SOUL_ISE_URL")
-    let url_state: String = if str_eq(url_env, "") { state_get("soul_engram_url") } else { url_env }
-    let engram_url: String = if str_eq(url_state, "") { "http://localhost:8742" } else { url_state }
-    // ONE request for the whole batch, not one per edge. The server's
-    // persist_canonical() writes the full 60MB snapshot on every durable
-    // write, so per-edge POSTs would cost ~840MB of disk per heartbeat to
-    // persist ~14 associations. /api/edges/batch connects them all and
-    // snapshots once. The drain payload is already the right shape; it only
-    // needs an envelope: the drain already emits the relation per entry.
-    //
-    // _auth is REQUIRED and its absence is silent. check_auth_ok() in server.el
-    // exempts GET and /api/neuron/state-events (which is why ise_post works
-    // without a key) but gates every other mutation on "_auth" in the BODY —
-    // http_serve does not surface request headers, so there is no Bearer path.
-    // A batch posted without it comes back {"error":"unauthorized"}, which is a
-    // non-empty response: the naive `if resp == "" return 0` check would read
-    // that as success and report edges delivered that were in fact refused,
-    // after the drain had already destroyed them. Hence both the key and the
-    // accepted-count check below. Fall back to env when the state key is empty
-    // — never let a corruptible state read decide whether learning persists.
-    let key_state: String = state_get("soul_engram_api_key")
-    let api_key: String = if str_eq(key_state, "") { env("ENGRAM_API_KEY") } else { key_state }
-    let auth_part: String = if str_eq(api_key, "") { "" } else { ",\"_auth\":\"" + api_key + "\"" }
-    let body: String = "{\"edges\":" + batch + auth_part + "}"
-    let resp: String = http_post_json(engram_url + "/api/edges/batch", body)
-    if str_eq(resp, "") { return 0 }
-    let acc: String = json_get(resp, "accepted")
-    if str_eq(acc, "") { return 0 }
-    return str_to_int(acc)
-}
-
 fn ise_post(content: String) -> Void {
     let ise_url: String = env("SOUL_ISE_URL")
     let state_url: String = if str_eq(ise_url, "") { state_get("soul_engram_url") } else { ise_url }
@@ -122,21 +54,6 @@ fn ise_post(content: String) -> Void {
         let fail_raw: String = state_get("soul.ise_fail_count")
         let fail_n: Int = if str_eq(fail_raw, "") { 0 } else { str_to_int(fail_raw) }
         state_set("soul.ise_fail_count", int_to_str(fail_n + 1))
-        // el_from_float on a LITERAL is correct and is NOT the double-wrap bug
-        // (checked and dismissed 2026-08-02 self-review — recording the result
-        // so this call site is not "fixed" again by the next reader).
-        // The compiler treats el_from_float as the boxing intrinsic: both
-        // `el_from_float(0.3)` and a bare `0.3` emit exactly one
-        // el_from_float(0.3) in dist/awareness.c. Verified byte-identical
-        // codegen either way.
-        // The real bug fixed in server.el on 2026-08-01 was different: there
-        // the arguments came from json_get_float(), i.e. values ALREADY boxed
-        // as el_val_t. Wrapping THOSE a second time reinterprets the boxed
-        // bits as a raw double, fails engram_decode_score's range check, and
-        // silently clamps to defaults.
-        // The sweep criterion is therefore "el_from_float applied to an
-        // already-boxed expression", never "el_from_float applied to a
-        // literal". Grepping for the call name alone produces false positives.
         let discard: String = engram_node_full(
             content, "InternalStateEvent", "state-event",
             el_from_float(0.3), el_from_float(0.3), el_from_float(0.8),
@@ -382,89 +299,8 @@ fn emit_heartbeat() -> Void {
     // here so the stuck-term failure is visible in the heartbeat stream too.
     let hb_ats_raw: String = state_get("soul.auto_term_streak")
     let hb_ats: Int = if str_eq(hb_ats_raw, "") { 0 } else { str_to_int(hb_ats_raw) }
-    // auto_term_empty_streak (2026-08-06): consecutive scans producing NO auto
-    // term. Split out because str_eq("","") made the two failures indist-
-    // inguishable — see the comment at the streak computation in
-    // proactive_curiosity. Nonzero and climbing = extractor broken, not stuck.
-    let hb_ate_raw: String = state_get("soul.auto_term_empty_streak")
-    let hb_ate: Int = if str_eq(hb_ate_raw, "") { 0 } else { str_to_int(hb_ate_raw) }
-    // Hebbian eligibility gauges (2026-08-06 self-review). The graph learned
-    // ZERO structure in its first 23h of uptime: hebb_max 0.000799 against a
-    // 0.15 consolidation threshold, hebbian-associate edges 0, and the
-    // awareness loop calls engram_connect nowhere — so Hebbian consolidation
-    // is the only self-structuring path there is, and it was inert.
-    //   hebb_warm — nodes with a live eligibility trace but NOT co-resident in
-    //               WM: exactly the population the old simultaneity rule threw
-    //               away. 0 forever ⇒ traces never arm and this bought nothing.
-    //   hebb_max  — strongest single association. The number that has to move.
-    //   hebb_links— consolidated edges. The outcome that has to become nonzero.
-    let hebb_warm_raw: String = json_get(act_stats, "hebb_warm")
-    let hebb_warm: String = if str_eq(hebb_warm_raw, "") { "-1" } else { hebb_warm_raw }
-    let hebb_max_raw: String = json_get(act_stats, "hebb_max")
-    let hebb_max: String = if str_eq(hebb_max_raw, "") { "-1" } else { hebb_max_raw }
-    let hebb_links_raw: String = json_get(act_stats, "hebb_links")
-    let hebb_links: String = if str_eq(hebb_links_raw, "") { "-1" } else { hebb_links_raw }
-    // Candidate-table gauges (2026-08-10 self-review). el_runtime.c COMPUTES
-    // hebb_cands/hebb_cand_max/hebb_mass/hebb_edges and emits them from
-    // engram_metrics_json — and this function dropped all four on the floor.
-    // Nineteen keys crossed the C boundary; fourteen reached the ISE stream.
-    // The two that mattered most are exactly the pair the runtime added to
-    // answer the question the 08-06 review had to instrument for:
-    //   hebb_cands    — associations currently being tracked toward
-    //                   consolidation. 0 ⇒ nothing co-activates at all.
-    //   hebb_cand_max — how close the leading candidate is to
-    //                   ENGRAM_HEBB_LINK_MIN (0.15). Sustained just-below ⇒
-    //                   the THRESHOLD is the bottleneck, not the event rate.
-    // Without both, "hebb_links stopped climbing" is undiagnosable from the
-    // durable record: nothing-co-activates and threshold-too-high look
-    // identical. An instrument that is computed but not plumbed to durable
-    // storage is not an instrument — it is a local variable.
-    //   hebb_mass     — Σ hebb across edges; the runaway detector against the
-    //                   ENGRAM_HEBB_NODE_BUDGET homeostatic cap.
-    //   hebb_edges    — total potentiated edges (hebb > MIN), the denominator
-    //                   hebb_max is the max of.
-    let hebb_cands_raw: String = json_get(act_stats, "hebb_cands")
-    let hebb_cands: String = if str_eq(hebb_cands_raw, "") { "-1" } else { hebb_cands_raw }
-    let hebb_cmax_raw: String = json_get(act_stats, "hebb_cand_max")
-    let hebb_cmax: String = if str_eq(hebb_cmax_raw, "") { "-1" } else { hebb_cmax_raw }
-    let hebb_mass_raw: String = json_get(act_stats, "hebb_mass")
-    let hebb_mass: String = if str_eq(hebb_mass_raw, "") { "-1" } else { hebb_mass_raw }
-    let hebb_edges_raw: String = json_get(act_stats, "hebb_edges")
-    let hebb_edges: String = if str_eq(hebb_edges_raw, "") { "-1" } else { hebb_edges_raw }
-    // Consolidation write-back gauges (2026-08-07 self-review). hebb_links
-    // counts what this process LEARNED; these three count what SURVIVES it.
-    // The distinction is the whole finding: 1,198 links formed, 0 persisted,
-    // because the learner is not the persistence owner (see hebb_consolidate).
-    //   wb_pending — queued, not yet handed over. Climbing ⇒ writer is down.
-    //   wb_drained — cumulative popped for delivery. Flat while hebb_links
-    //                climbs ⇒ the drain is not being called at all.
-    //   wb_dropped — lost to a full queue. Must stay 0; nonzero means the
-    //                durable store has been unreachable long enough to matter.
-    //   wb_sent    — POSTs the durable store actually accepted this beat.
-    let wb_pend_raw: String = json_get(act_stats, "hebb_wb_pending")
-    let wb_pend: String = if str_eq(wb_pend_raw, "") { "-1" } else { wb_pend_raw }
-    let wb_drain_raw: String = json_get(act_stats, "hebb_wb_drained")
-    let wb_drain: String = if str_eq(wb_drain_raw, "") { "-1" } else { wb_drain_raw }
-    let wb_drop_raw: String = json_get(act_stats, "hebb_wb_dropped")
-    let wb_drop: String = if str_eq(wb_drop_raw, "") { "-1" } else { wb_drop_raw }
-    let wb_sent_raw: String = state_get("soul.hebb_wb_sent")
-    let wb_sent: String = if str_eq(wb_sent_raw, "") { "0" } else { wb_sent_raw }
-    // dup_wm_global (2026-08-06): redundant WM residents that arrived via the
-    // carry-over path, which Pass 3½ structurally could not see. Confirmed live
-    // by a census that caught two byte-identical copies of one 3,193-char
-    // document both holding slots.
-    let dup_wm_g_raw: String = json_get(act_stats, "dup_wm_global")
-    let dup_wm_g: String = if str_eq(dup_wm_g_raw, "") { "-1" } else { dup_wm_g_raw }
     let act_brk_raw: String = json_get(act_stats, "embed_breaker_open")
     let act_brk: String = if str_eq(act_brk_raw, "") { "-1" } else { act_brk_raw }
-    // embed_consec_fail (2026-08-10 self-review): also computed by the C side
-    // and also dropped here. embed_breaker_open is the LAGGING indicator — it
-    // only goes 1 after ENGRAM_EMBED_BREAKER_LIMIT consecutive failures, by
-    // which point semantic activation has already degraded to pure lexical
-    // for the whole cooldown. consec_fail is the leading edge of the same
-    // event and costs nothing to carry.
-    let emb_cf_raw: String = json_get(act_stats, "embed_consec_fail")
-    let emb_cf: String = if str_eq(emb_cf_raw, "") { "-1" } else { emb_cf_raw }
     // ctx_cos (2026-07-29 self-review): cos(query, context centroid) at the
     // last activate call — the drift gauge for the new context-centroid
     // scoring. ~1.0 aligned; low at domain-rotation boundaries is healthy;
@@ -472,79 +308,7 @@ fn emit_heartbeat() -> Void {
     // down) and semantic continuity is silently absent.
     let ctx_cos_raw: String = json_get(act_stats, "ctx_cos")
     let ctx_cos: String = if str_eq(ctx_cos_raw, "") { "-2" } else { ctx_cos_raw }
-    // Redundancy suppression gauges (2026-08-05 self-review). A content-hash
+    let payload: String = "{\"event\":\"heartbeat\",\"pulse\":" + pulse + ",\"tick\":" + pulse + ",\"boot\":" + boot + ",\"idle\":" + idle + ",\"idle_ms\":" + int_to_str(idle_ms) + ",\"node_count\":" + int_to_str(nc) + ",\"edge_count\":" + int_to_str(ec) + ",\"node_delta\":" + int_to_str(node_delta) + ",\"edge_delta\":" + int_to_str(edge_delta) + ",\"wm_active\":" + int_to_str(wmc) + ",\"wm_delta\":" + int_to_str(wm_delta) + ",\"wm_saturated\":" + int_to_str(wm_sat) + ",\"wm_top0_streak\":" + int_to_str(t0streak) + ",\"wm_churn\":" + int_to_str(wm_churn) + ",\"wm_top0_wm\":" + wm_top0_wm + ",\"sync_added_total\":" + sat_str + ",\"sync_age_ms\":" + int_to_str(sync_age) + ",\"wm_avg_weight\":" + wm_avg_str + ",\"wm_top\":" + wm_top + ",\"ts\":" + int_to_str(ts) + ",\"uptime_ms\":" + int_to_str(up_ms) + ",\"uptime\":\"" + up_human + "\",\"embed_ok\":" + int_to_str(emb_ok) + ",\"embed_backfilled\":" + bf_done + ",\"embed_count\":" + bf_total + ",\"embed_eligible\":" + embed_elig + ",\"wm_evicted\":" + act_evict + ",\"wm_evicted_delta\":" + int_to_str(evict_delta) + ",\"breakthroughs\":" + act_bt + ",\"breakthroughs_delta\":" + int_to_str(bt_delta) + ",\"auto_term_streak\":" + int_to_str(hb_ats) + ",\"embed_breaker_open\":" + act_brk + ",\"ctx_cos\":" + ctx_cos + ",\"ise_fail\":" + fail_str + "}"
-    // census found 1,858 redundant copies — 44.9% of the non-ISE graph, from a
-    // June id-scheme migration. They embed identically, so they were taking
-    // 40.2% of semantic seed slots (measured: 4.78 distinct seeds of 8).
-    //   dup_seeds — redundant copies denied a seed slot, cumulative. A healthy
-    //               nonzero rate means the suppressor is doing real work; a
-    //               sustained drop toward 0 means the duplicates were finally
-    //               merged out of the graph (the repair this defends against).
-    //   dup_wm    — duplicate WM candidates evicted before the capacity cap.
-    // Cumulative like wm_evicted/breakthroughs; diff across heartbeats for rate.
-    let dup_seeds_raw: String = json_get(act_stats, "dup_seeds")
-    let dup_seeds: String = if str_eq(dup_seeds_raw, "") { "-1" } else { dup_seeds_raw }
-    let dup_wm_raw: String = json_get(act_stats, "dup_wm")
-    let dup_wm: String = if str_eq(dup_wm_raw, "") { "-1" } else { dup_wm_raw }
-    // txt_damaged (2026-08-08 self-review): nodes created THIS process whose
-    // content carries the character-loss signature (see eg_text_loss_signature
-    // in el_runtime.c). Today's review found the JSON parser had been replacing
-    // every \uXXXX escape with a literal '?' for at least two months — 76% of
-    // non-telemetry nodes damaged, including the self root and every values
-    // node — and nothing caught it, because every gauge here reported whether
-    // the machinery was RUNNING and none reported whether the text it carried
-    // was INTACT. The parser is fixed; this is the standing regression signal.
-    // Healthy state is a flat 0. Any climb means a write path is mangling text
-    // again. The full store census is GET /api/text-health (too expensive for
-    // a 60s beat); this is the cheap flow counter that belongs on every beat.
-    let txt_dmg_raw: String = json_get(act_stats, "txt_damaged")
-    let txt_dmg: String = if str_eq(txt_dmg_raw, "") { "-1" } else { txt_dmg_raw }
-    // ── Corpus damage STOCK, not just flow (2026-08-10 self-review) ────────
-    // txt_damaged above is a FLOW gauge: nodes damaged by a write in THIS
-    // process. The 08-08 review fixed the parser, watched that flow fall to
-    // 0, and recorded the defect as closed. It was not closed. Today's census
-    // on the live store: scanned 4100, damaged 2781 — 67.8% of the corpus is
-    // STILL carrying the character loss, including the self root and every
-    // values node ("Value ? Constraints as Freedom"). The parser stopped
-    // producing new damage; nothing ever repaired the old.
-    //
-    // That is the 08-08 lesson recursing one level up. 08-08 said "instrument
-    // the payload, not just the machinery" — and then instrumented the payload
-    // RATE and not the payload STOCK. A flow gauge reads 0 both when the
-    // corpus is clean and when it is uniformly damaged but quiescent. Those
-    // are opposite states and the beat could not tell them apart.
-    //
-    // Cost: GET /api/text-health scans the whole store, too expensive for a
-    // 60s beat (which is why 08-08 left it off). So sample it on a countdown
-    // and CARRY the last reading on every beat, with its age. A stale-but-
-    // present stock number beats an absent one; damaged_age_ms makes the
-    // staleness explicit rather than implied. No modulo/multiply — both
-    // operators are broken in this compiler (see the note at line ~160).
-    let tc_raw: String = state_get("soul.txt_census_countdown")
-    let tc_n: Int = if str_eq(tc_raw, "") { 0 } else { str_to_int(tc_raw) }
-    if tc_n <= 0 {
-        let th_resp: String = http_get(hb_engram_url + "/api/text-health")
-        let th_pct: String = json_get(th_resp, "damaged_pct")
-        if !str_eq(th_pct, "") {
-            state_set("soul.txt_damaged_pct", th_pct)
-            state_set("soul.txt_damaged_n", json_get(th_resp, "damaged"))
-            state_set("soul.txt_scanned_n", json_get(th_resp, "scanned"))
-            state_set("soul.txt_census_ts", int_to_str(ts))
-        }
-        // 30 beats ≈ 30 min at the 60s cadence. Reset even on a failed census
-        // so an unreachable route cannot turn this into a per-beat full scan.
-        state_set("soul.txt_census_countdown", "30")
-    }
-    if tc_n > 0 { state_set("soul.txt_census_countdown", int_to_str(tc_n - 1)) }
-    let dmg_pct_raw: String = state_get("soul.txt_damaged_pct")
-    let dmg_pct: String = if str_eq(dmg_pct_raw, "") { "-1" } else { dmg_pct_raw }
-    let dmg_n_raw: String = state_get("soul.txt_damaged_n")
-    let dmg_n: String = if str_eq(dmg_n_raw, "") { "-1" } else { dmg_n_raw }
-    let dmg_scan_raw: String = state_get("soul.txt_scanned_n")
-    let dmg_scan: String = if str_eq(dmg_scan_raw, "") { "-1" } else { dmg_scan_raw }
-    let dmg_ts_raw: String = state_get("soul.txt_census_ts")
-    let dmg_age: Int = if str_eq(dmg_ts_raw, "") { 0 - 1 } else { ts - str_to_int(dmg_ts_raw) }
-    let payload: String = "{\"event\":\"heartbeat\",\"pulse\":" + pulse + ",\"tick\":" + pulse + ",\"boot\":" + boot + ",\"idle\":" + idle + ",\"idle_ms\":" + int_to_str(idle_ms) + ",\"node_count\":" + int_to_str(nc) + ",\"edge_count\":" + int_to_str(ec) + ",\"node_delta\":" + int_to_str(node_delta) + ",\"edge_delta\":" + int_to_str(edge_delta) + ",\"wm_active\":" + int_to_str(wmc) + ",\"wm_delta\":" + int_to_str(wm_delta) + ",\"wm_saturated\":" + int_to_str(wm_sat) + ",\"wm_top0_streak\":" + int_to_str(t0streak) + ",\"wm_churn\":" + int_to_str(wm_churn) + ",\"wm_top0_wm\":" + wm_top0_wm + ",\"sync_added_total\":" + sat_str + ",\"sync_age_ms\":" + int_to_str(sync_age) + ",\"wm_avg_weight\":" + wm_avg_str + ",\"wm_top\":" + wm_top + ",\"ts\":" + int_to_str(ts) + ",\"uptime_ms\":" + int_to_str(up_ms) + ",\"uptime\":\"" + up_human + "\",\"embed_ok\":" + int_to_str(emb_ok) + ",\"embed_backfilled\":" + bf_done + ",\"embed_count\":" + bf_total + ",\"embed_eligible\":" + embed_elig + ",\"wm_evicted\":" + act_evict + ",\"wm_evicted_delta\":" + int_to_str(evict_delta) + ",\"breakthroughs\":" + act_bt + ",\"breakthroughs_delta\":" + int_to_str(bt_delta) + ",\"auto_term_streak\":" + int_to_str(hb_ats) + ",\"auto_term_empty_streak\":" + int_to_str(hb_ate) + ",\"embed_breaker_open\":" + act_brk + ",\"ctx_cos\":" + ctx_cos + ",\"dup_seeds\":" + dup_seeds + ",\"dup_wm\":" + dup_wm + ",\"dup_wm_global\":" + dup_wm_g + ",\"hebb_warm\":" + hebb_warm + ",\"hebb_max\":" + hebb_max + ",\"hebb_links\":" + hebb_links + ",\"hebb_cands\":" + hebb_cands + ",\"hebb_cand_max\":" + hebb_cmax + ",\"hebb_mass\":" + hebb_mass + ",\"hebb_edges\":" + hebb_edges + ",\"embed_consec_fail\":" + emb_cf + ",\"txt_damaged_pct\":" + dmg_pct + ",\"txt_damaged_n\":" + dmg_n + ",\"txt_scanned_n\":" + dmg_scan + ",\"txt_census_age_ms\":" + int_to_str(dmg_age) + ",\"hebb_wb_pending\":" + wb_pend + ",\"hebb_wb_drained\":" + wb_drain + ",\"hebb_wb_dropped\":" + wb_drop + ",\"hebb_wb_sent\":" + wb_sent + ",\"ise_fail\":" + fail_str + ",\"txt_damaged\":" + txt_dmg + "}"
     ise_post(payload)
 }
 
@@ -587,77 +351,7 @@ fn emit_heartbeat() -> Void {
 // neuron-api label fix. Sentinel-shaped labels ("knowledge:captured",
 // "memory:remembered" — colon, no space) carry no seed signal and are
 // skipped so legacy nodes cannot seed the scan with the word "knowledge".
-// ARGMAX REWRITE (2026-08-13 self-review). auto_term_empty_streak — the
+fn auto_term_try_slot(slot_type: String, slot_lbl: String) -> Void {
-// counter the 2026-08-06 review added to catch exactly this — read 50 and
-// climbing: fifty consecutive scans where dynamic seeding produced nothing
-// and the loop ran on its four hardcoded phrases. The live WM top said why:
-// every one of the top slots was a Memory node labelled "memory:remembered".
-// This function read the LABEL only, the sentinel guard below (correctly)
-// rejects sentinels, so there was never anything to extract. The extractor
-// was written against Knowledge nodes, which have real titles, and was
-// structurally blind to the node type that actually dominates WM.
-//
-// Rather than add a sixth guard to the five below, the selection algorithm
-// is now inverted and lives in the runtime: engram_salient_term() scores
-// EVERY candidate token in the node's text and returns the argmax of
-// idf·position·casing (YAKE, Campos et al. 2020, with real corpus IDF
-// substituted for YAKE's corpus-free proxies), falling back from a sentinel
-// label to the node's content. Term quality is now the selection criterion
-// instead of a veto, so a bad token loses to a better token in the same text
-// without needing to be on any list. Tabu is applied during the argmax, so
-// inhibition-of-return costs seed quality rather than costing the scan.
-//
-// MEASURED BEFORE SHIPPING, on 60 live Memory nodes: 0 empty, versus 60 of 60
-// empty under the old extractor. Terms produced are topical — HEBBIAN,
-// CONSOLIDATION, TEMPORAL, crash-loop, PRIMING, NEIGHBORHOOD, DRIFT. Three of
-// sixty are weak header words ("STEP", "DONE"). They are left alone
-// deliberately: adding them to a list is the exact move that produced four
-// previous blocklists, and a mediocre seed on 5% of scans is not a flood.
-//
-// The stopword list below STAYS, and not as belt-and-braces. An earlier draft
-// of this change assumed the min_df floor would subsume it, on 08-03's
-// finding that function words have df 0 in labels. Re-measured under
-// word-boundary df: about:2, whole:1, them:2 — they clear a floor of 1. What
-// keeps them from winning is the argmax, not the floor. The list still earns
-// its keep on the Title-case cases.
-//
-// What stays here is policy: the node-type filter, the df thresholds, and the
-// stopword list. The runtime measures; the soul decides. Same split as
-// engram_label_df.
-fn auto_term_try_slot(slot_type: String, slot_id: String) -> Void {
-    state_set("_ats_ok", "0")
-    if str_eq(slot_type, "Memory") { state_set("_ats_ok", "1") }
-    if str_eq(slot_type, "BacklogItem") { state_set("_ats_ok", "1") }
-    if str_eq(slot_type, "Entity") { state_set("_ats_ok", "1") }
-    if str_eq(slot_type, "Knowledge") { state_set("_ats_ok", "1") }
-    if str_eq(state_get("_ats_ok"), "1") {
-        if !str_eq(slot_id, "") {
-            // Tabu ring, pipe-delimited, excluded inside the argmax.
-            let tabu: String = "|" + state_get("soul.tabu_t0")
-                + "|" + state_get("soul.tabu_t1")
-                + "|" + state_get("soul.tabu_t2")
-                + "|" + state_get("soul.tabu_t3") + "|"
-            let df_max: Int = engram_node_count() / 400
-            let df_cap: Int = if df_max > 8 { df_max } else { 8 }
-            let term: String = engram_salient_term(slot_id, df_cap, 1, tabu)
-            if !str_eq(term, "") {
-                state_set("_ats_gw", "0")
-                let stopw: String = "|What|When|Where|Which|Whose|While|This|That|These|Those|There|Their|Then|Than|With|Without|From|Into|Onto|Over|Under|About|Between|Among|Across|Some|Most|More|Less|Very|Each|Every|Both|Also|Only|Just|Does|Will|Would|Could|Should|Might|Must|Have|Been|Being|Toward|Towards|Using|Based|Upon|Here|Your|Ours|They|Them|what|this|that|with|from|context|Context|Prose|Colon|Self|Test|Testing|Closing|Global|Universal|Persona|Semantic|Spreading|Temporal|Numeric|Register|Identifying|Introduction|Overview|Summary|Section|General|Notes|Note|"
-                if str_contains(stopw, "|" + term + "|") { state_set("_ats_gw", "1") }
-                if str_eq(state_get("_ats_gw"), "0") {
-                    state_set("cseed_auto", term)
-                }
-            }
-        }
-    }
-    return ""
-}
-
-// SUPERSEDED 2026-08-13 — retained for the record. The first-word extractor
-// and its five accumulated guards, replaced by the argmax above. Kept
-// unreferenced so the reasoning behind each guard stays readable next to what
-// replaced it; delete once engram_salient_term has a month of live telemetry.
-fn auto_term_try_slot_legacy(slot_type: String, slot_lbl: String) -> Void {
     state_set("_ats_ok", "0")
     if str_eq(slot_type, "Memory") { state_set("_ats_ok", "1") }
     if str_eq(slot_type, "BacklogItem") { state_set("_ats_ok", "1") }
@@ -706,48 +400,6 @@ fn auto_term_try_slot_legacy(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
@@ -876,18 +528,16 @@ fn proactive_curiosity() -> Bool {
     let wm10_n2: String = json_array_get(wm10, 2)
     let wm10_n1: String = json_array_get(wm10, 1)
     let wm10_n0: String = json_array_get(wm10, 0)
-    // 2026-08-13: pass the node ID, not the label. engram_salient_term reads
+    auto_term_try_slot(json_get(wm10_n9, "node_type"), json_get(wm10_n9, "label"))
-    // the node directly so it can fall back from a sentinel label to content.
+    auto_term_try_slot(json_get(wm10_n8, "node_type"), json_get(wm10_n8, "label"))
-    auto_term_try_slot(json_get(wm10_n9, "node_type"), json_get(wm10_n9, "id"))
+    auto_term_try_slot(json_get(wm10_n7, "node_type"), json_get(wm10_n7, "label"))
-    auto_term_try_slot(json_get(wm10_n8, "node_type"), json_get(wm10_n8, "id"))
+    auto_term_try_slot(json_get(wm10_n6, "node_type"), json_get(wm10_n6, "label"))
-    auto_term_try_slot(json_get(wm10_n7, "node_type"), json_get(wm10_n7, "id"))
+    auto_term_try_slot(json_get(wm10_n5, "node_type"), json_get(wm10_n5, "label"))
-    auto_term_try_slot(json_get(wm10_n6, "node_type"), json_get(wm10_n6, "id"))
+    auto_term_try_slot(json_get(wm10_n4, "node_type"), json_get(wm10_n4, "label"))
-    auto_term_try_slot(json_get(wm10_n5, "node_type"), json_get(wm10_n5, "id"))
+    auto_term_try_slot(json_get(wm10_n3, "node_type"), json_get(wm10_n3, "label"))
-    auto_term_try_slot(json_get(wm10_n4, "node_type"), json_get(wm10_n4, "id"))
+    auto_term_try_slot(json_get(wm10_n2, "node_type"), json_get(wm10_n2, "label"))
-    auto_term_try_slot(json_get(wm10_n3, "node_type"), json_get(wm10_n3, "id"))
+    auto_term_try_slot(json_get(wm10_n1, "node_type"), json_get(wm10_n1, "label"))
-    auto_term_try_slot(json_get(wm10_n2, "node_type"), json_get(wm10_n2, "id"))
+    auto_term_try_slot(json_get(wm10_n0, "node_type"), json_get(wm10_n0, "label"))
-    auto_term_try_slot(json_get(wm10_n1, "node_type"), json_get(wm10_n1, "id"))
-    auto_term_try_slot(json_get(wm10_n0, "node_type"), json_get(wm10_n0, "id"))
     let auto_term: String = state_get("cseed_auto")
     let results_auto: String = if str_eq(auto_term, "") { "[]" } else { engram_activate_json(auto_term, 1) }
     let found_auto: Int = json_array_len(results_auto)
@@ -899,25 +549,9 @@ fn proactive_curiosity() -> Bool {
     let prev_auto: String = state_get("soul.prev_auto_term")
     let atstreak_raw: String = state_get("soul.auto_term_streak")
     let atstreak_prev: Int = if str_eq(atstreak_raw, "") { 0 } else { str_to_int(atstreak_raw) }
-    // A streak of nothing is not a streak (2026-08-06 self-review).
+    let atstreak: Int = if str_eq(auto_term, prev_auto) { atstreak_prev + 1 } else { 1 }
-    // str_eq("", "") is true, so an auto-term extractor that kept FAILING
-    // reported a rising auto_term_streak — the same signal that means
-    // "fixated on one term" also meant "producing no term at all", which are
-    // opposite failures needing opposite responses. Observed live in the ISE
-    // stream as {"auto_term":"","auto_term_streak":3}. This is the same class
-    // of bug already fixed for wm_top0_streak; auto_term was missed then.
-    // Empty now reads 0, and the empty run is counted on its own axis so the
-    // extractor failing is visible rather than disguised as health.
-    let is_empty: Bool = str_eq(auto_term, "")
-    let atstreak: Int = if is_empty { 0 } else {
-        if str_eq(auto_term, prev_auto) { atstreak_prev + 1 } else { 1 }
-    }
-    let atempty_raw: String = state_get("soul.auto_term_empty_streak")
-    let atempty_prev: Int = if str_eq(atempty_raw, "") { 0 } else { str_to_int(atempty_raw) }
-    let atempty: Int = if is_empty { atempty_prev + 1 } else { 0 }
     state_set("soul.prev_auto_term", auto_term)
     state_set("soul.auto_term_streak", int_to_str(atstreak))
-    state_set("soul.auto_term_empty_streak", int_to_str(atempty))
     if !str_eq(auto_term, "") {
         state_set("soul.tabu_t3", state_get("soul.tabu_t2"))
         state_set("soul.tabu_t2", state_get("soul.tabu_t1"))
@@ -937,7 +571,6 @@ fn proactive_curiosity() -> Bool {
     let ise: String = "{\"event\":\"curiosity_scan\",\"seed\":\"" + curiosity_seed
         + "\",\"auto_term\":\"" + safe_auto
         + "\",\"auto_term_streak\":" + int_to_str(atstreak)
-        + ",\"auto_term_empty_streak\":" + int_to_str(atempty)
         + ",\"minute_block\":" + int_to_str(minute_block)
         + ",\"activated\":" + int_to_str(total_found)
         + ",\"wm_active\":" + int_to_str(wmc)
@@ -1224,15 +857,8 @@ fn awareness_run() -> Void {
             // still leaves no trace — that absence is itself the crash signal.)
             let sd_boot_raw: String = state_get("soul_boot_count")
             let sd_boot: String = if str_eq(sd_boot_raw, "") { "0" } else { sd_boot_raw }
-            // Final consolidation before exit. The periodic drain runs on the
-            // heartbeat (~8 min), so a clean shutdown between beats would take
-            // everything learned since the last one to the grave — the exact
-            // loss this whole path exists to stop, just at a smaller scale.
-            // Best-effort: if the durable store is already down we exit anyway.
-            let sd_wb: Int = hebb_consolidate()
             ise_post("{\"event\":\"shutdown\",\"boot\":" + sd_boot
                 + ",\"pulse\":" + int_to_str(pulse_count())
-                + ",\"hebb_wb_sent\":" + int_to_str(sd_wb)
                 + ",\"uptime_ms\":" + int_to_str(elapsed_ms())
                 + ",\"ts\":" + int_to_str(time_now()) + "}")
             println("[awareness] exiting")
@@ -1259,12 +885,6 @@ fn awareness_run() -> Void {
         let beat_elapsed: Int = now_ts - last_beat_ts
         let should_beat: Bool = beat_elapsed >= beat_ms
         if should_beat {
-            // Consolidate BEFORE the heartbeat so the gauges the heartbeat
-            // reports describe the state this beat actually left behind, not
-            // the state one beat stale. See hebb_consolidate for why a daemon
-            // that learns 1,198 associations a day was keeping none of them.
-            let wb_sent_n: Int = hebb_consolidate()
-            state_set("soul.hebb_wb_sent", int_to_str(wb_sent_n))
             emit_heartbeat()
             state_set("soul.last_beat_ts", int_to_str(now_ts))
             // Persist in-process Engram (sessions, memories, conversation nodes)

awareness.elh

@@ -0,0 +1,26 @@
+// auto-generated by elc --emit-header — do not edit
+extern fn idle_count() -> Int
+extern fn idle_inc() -> Int
+extern fn idle_reset() -> Void
+extern fn ise_post(content: String) -> Void
+extern fn elapsed_ms() -> Int
+extern fn elapsed_human() -> String
+extern fn embed_ok() -> Int
+extern fn emit_heartbeat() -> Void
+extern fn auto_term_try_slot(slot_type: String, slot_lbl: String) -> Void
+extern fn proactive_curiosity() -> Bool
+extern fn pulse_count() -> Int
+extern fn pulse_inc() -> Int
+extern fn make_action(kind: String, payload: String) -> String
+extern fn perceive() -> String
+extern fn attend(node_json: String) -> String
+extern fn respond(action_json: String) -> String
+extern fn record(outcome_json: String) -> Void
+extern fn one_cycle() -> Bool
+extern fn awareness_run() -> Void
+extern fn security_research_authorized() -> Bool
+extern fn threat_score_command(cmd: String) -> Int
+extern fn threat_score_path(path: String) -> Int
+extern fn threat_score_history(history: String) -> Int
+extern fn threat_trajectory_check(tool_name: String, tool_input: String) -> Int
+extern fn threat_history_append(text: String) -> Void

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 = utf8_safe_slice(content, snip_len)
+        let snip: String = if str_len(content) > snip_len { str_slice(content, 0, snip_len) } else { content }
         let bullets = if str_eq(snip, "") {
             bullets
         } else {
@@ -1770,14 +1770,7 @@ fn agentic_api_key() -> String {
     if !str_eq(k1, "") {
         return k1
     }
-    let k2: String = env("NEURON_LLM_0_KEY")
+    return 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) ──────────────────────────────
@@ -1785,42 +1778,19 @@ 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.
-// v2 SCOPE (2026-08-06, SPEC-soul-openai-tools-v2): tools + the agentic loop now run on
+// v1 SCOPE: plain chat completion only — NO tools / agentic loop yet (that is a follow-up port).
-// this wire too (openai_agentic_loop below). Plain completion (openai_chat_complete)
+// This block is ADDITIVE: the Anthropic path is untouched and stays the default.
-// remains for non-agentic turns. Still ADDITIVE: the Anthropic path is untouched.
 
 fn llm_base_url() -> String {
-    let u: String = env("NEURON_LLM_0_URL")
+    return 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, "") {
+    if str_eq(f, "") {
-        return f
+        return "anthropic"
     }
-    // Step-0 bridge (2026-08-06): derive the wire format from the launcher's provider
+    return f
-    // 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.
@@ -1883,354 +1853,6 @@ 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\"]}}," +
@@ -3014,7 +2636,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")
-            utf8_safe_slice(acc, 350)
+            if str_len(acc) > 350 { str_slice(acc, 0, 350) } else { acc }
         } 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)
@@ -3045,13 +2667,7 @@ fn handle_chat_agentic(body: String) -> String {
 " + ctx + ag_session_preload + receipt_rule()
 
     let api_key: String = agentic_api_key()
-    // Assemble the tool set ONCE, for the lane this turn will actually take. Both
+    let tools_json: String = agentic_tools_all()
-    // 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)
 
@@ -3092,12 +2708,11 @@ 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 (v2 port, 2026-08-06): OpenAI-compatible providers now take their own
+    // Provider fork: OpenAI-compatible providers (Ollama/OpenAI/Grok/Gemini) take the plain-completion
-    // AGENTIC loop — same tools (minus Anthropic-server web_search), same consent policy,
+    // path (v1, no tools); everything else stays on the Anthropic agentic loop (the default).
-    // same bridge contract. The Anthropic native path stays the default and is untouched.
+    let use_openai: Bool = !str_eq(llm_base_url(), "") && str_eq(llm_wire_format(), "openai")
-    let use_openai: Bool = tools_lane_openai
     let result: String = if use_openai {
-        openai_agentic_loop(session_id, model, safe_sys, tools_json, messages, "")
+        openai_chat_complete(model, llm_base_url(), agentic_api_key(), safe_sys, messages)
     } else {
         agentic_loop(session_id, model, safe_sys, tools_json, messages, h, "")
     }
@@ -3524,7 +3139,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, "anthropic")
+            bridge_save(session_id, model, safe_sys, tools_json, messages_with_assistant, tools_log, pend_tool_id)
         }
 
         // ACCUMULATE across pause/resume cycles instead of overwriting. A resumed turn
@@ -3606,7 +3221,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, wire: 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) -> 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.
@@ -3636,13 +3251,10 @@ 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)
@@ -3698,52 +3310,14 @@ 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)
@@ -3919,11 +3493,7 @@ 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)
 
-    // One assembly, for the lane this turn takes (see the same note in handle_chat_agentic:
+    let tools_json: String = agentic_tools_all()
-    // 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 + "\"}]"
@@ -3934,14 +3504,7 @@ 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 }
-    // Provider fork (v2 port, 2026-08-06): same routing rule as handle_chat_agentic.
+    let loop_result: String = agentic_loop(session_id, model, safe_sys, tools_json, messages, h, "")
-    // 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

@@ -0,0 +1,88 @@
+// auto-generated by elc --emit-header - do not edit
+extern fn chat_default_model() -> String
+extern fn engram_numeric_valid(s: String) -> Bool
+extern fn parse_float_x100(s: String) -> Int
+extern fn engram_score_node(node_json: String) -> Int
+extern fn engram_render_node(node_json: String) -> String
+extern fn engram_render_nodes(nodes_json: String) -> String
+extern fn engram_dedup_nodes(nodes_json: String) -> String
+extern fn engram_compile_ranked(nodes_json: String, max_nodes: Int) -> String
+extern fn engram_split_topics(message: String) -> String
+extern fn engram_extract_entities(message: String) -> String
+extern fn engram_detect_recall_intent(message: String) -> Bool
+extern fn engram_is_continuation(message: String, hist_len: Int) -> Bool
+extern fn engram_compile_multi(topic: String) -> String
+extern fn engram_nodes_merge(a: String, b: String) -> String
+extern fn id_in_seen(node_id: String, seen: String) -> Bool
+extern fn add_to_seen(seen: String, node_id: String) -> String
+extern fn engram_extract_ids(nodes_json: String) -> String
+extern fn affective_node_ts(node_json: String) -> Int
+extern fn engram_compile(intent: String) -> String
+extern fn distill_transcript(transcript: String) -> String
+extern fn json_safe(s: String) -> String
+extern fn current_engine_note(model: String) -> String
+extern fn bounded_persona_floor() -> String
+extern fn operator_identity_block() -> String
+extern fn build_system_prompt(ctx: String, chat_mode: Bool) -> String
+extern fn hist_append(hist: String, role: String, content: String) -> String
+extern fn conv_hist_key(session_id: String) -> String
+extern fn conv_hist_label(session_id: String) -> String
+extern fn is_utility_request(body: String, session_id: String) -> Bool
+extern fn provenance_scan_urls(arr: String, acc: String) -> String
+extern fn provenance_add_sources(block: String, btype: String, has_cit: Bool, cit_raw: String, acc: String) -> String
+extern fn provenance_names(tools_used: String) -> String
+extern fn text_join_sep(accumulated: String, incoming: String, after_interruption: Bool) -> String
+extern fn receipt_rule() -> String
+extern fn receipt_strip(s: String) -> String
+extern fn tool_receipt(tools_used: String, sources: String) -> String
+extern fn hist_trim(hist: String) -> String
+extern fn hist_trim_with_bell_guard(hist: String) -> String
+extern fn clean_llm_response(s: String) -> String
+extern fn conv_history_persist(session_id: String, hist: String) -> Void
+extern fn conv_history_load(session_id: String) -> String
+extern fn conv_history_record(session_id: String, user_msg: String, assistant_msg: String, receipt: String) -> Void
+extern fn conv_history_block(session_id: String) -> String
+extern fn layered_generate(prompt: String, imprint_id: String, session_id: String) -> String
+extern fn session_preload_bullets(nodes: String, max_bullets: Int, snip_len: Int) -> String
+extern fn affective_context_prefix() -> String
+extern fn handle_chat(body: String) -> String
+extern fn handle_see(body: String) -> String
+extern fn studio_tools_json() -> String
+extern fn agentic_api_key() -> String
+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 agentic_tools_literal() -> String
+extern fn web_search_tool_json() -> String
+extern fn strip_client_web_search(tools_inner: String) -> String
+extern fn agentic_tools_with_web() -> String
+extern fn connector_tools_json() -> String
+extern fn agentic_tools_all() -> String
+extern fn call_mcp_bridge(tool_name: String, tool_input: String) -> String
+extern fn tool_auto_approved(tool_name: String) -> Bool
+extern fn call_neuron_mcp(tool_name: String, args: String) -> String
+extern fn agent_workspace_root() -> String
+extern fn path_within_root(path: String, root: String) -> Bool
+extern fn resolve_in_root(path: String, root: String) -> String
+extern fn run_command_is_readonly(cmd: String) -> Bool
+extern fn cmd_abs_escape_at(cmd: String, root: String, needle: String) -> Bool
+extern fn run_command_guard(cmd: String, root: String) -> String
+extern fn classify_tool_risk(tool_name: String, tool_input: String) -> String
+extern fn dispatch_tool(tool_name: String, tool_input: String) -> String
+extern fn is_builtin_tool(tool_name: String) -> Bool
+extern fn next_bridge_id() -> String
+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 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
+extern fn handle_dharma_room_turn(body: String) -> String
+extern fn handle_dharma_room_turn_agentic(body: String) -> String
+extern fn session_summary_write(summary_text: String) -> String
+extern fn session_summary_write_dated(summary_text: String, label: String) -> String
+extern fn session_summary_autogenerate(hist: String) -> String
+extern fn auto_persist(req: String, resp: String) -> Void
+extern fn strengthen_chat_nodes(activation_nodes: String) -> Void

connectd/README.md

@@ -1,77 +0,0 @@
-# neuron-connectd — local-dev stub
-
-`connectd_service.py` is a **minimal local-dev stub**, not the real sidecar.
-It exists to close a real local-build/local-run correctness gap found during
-the 2026-08-15 build audit, without taking on the much larger product task of
-actually building the full MCP-connector sidecar.
-
-## The gap this closes
-
-`routes.el` (`handle_connectors`, `connectd_get`/`connectd_post`) and `chat.el`
-(`connector_tools_json`, the `mcp__*` branch in `dispatch_tool`,
-`tool_auto_approved`) are live, current code that calls `127.0.0.1:7771` on
-every soul boot and every agentic turn, per the design in
-`neuron-technologies/docs/research/mcp-connectors-adoption-spec.md`
-(2026-06-13, "Status: Draft for build"). That spec's sidecar — `neuron-connectd`,
-a TypeScript/Python process using the official MCP SDK — was never built.
-Nothing on disk implements it (verified: no `neuron-connectd` source anywhere
-under `~/Development` before this directory).
-
-Meanwhile port `:7771` is *also* claimed by two other, unrelated things:
-
-- `soul.el`'s `axon_base` default (`http://localhost:7771`) — a **different**,
-  independently-known, already-documented gap (`platform/protocols/axon` is
-  an unbuilt Rust crate; see `cli/HANDOFF.md` and `HANDOFF-engram-write-corruption.md`).
-  Out of scope here — no source to build against.
-- `council/council_service.py --port 7771` (`ai.neuron.council` LaunchAgent) —
-  a real, running, **unrelated** anti-confabulation service that happens to
-  bind the same port. In Will's live environment this is what's actually
-  listening on `:7771` today, and it answers the connector/axon requests
-  above with its own unrelated 404 JSON body — worse than a clean
-  connection-refused, because `chat.el`'s "bridge down" fallback expects
-  either a real reply or nothing, not a wrong-shaped reply from an unrelated
-  service.
-
-## What this stub does and does not do
-
-Implements exactly the spec's documented HTTP contract (`GET /mcp/tools`,
-`POST /mcp/call`, `GET /mcp/servers`, `POST /mcp/servers/{add,toggle,
-auto-approve,remove,secret}`, `POST /mcp/oauth/start`, `GET /healthz`), always
-answering as if **zero connectors are configured** — empty tool list, empty
-server list, a clear `"not configured"` error on any call that would need a
-real connector. This is the *correct* steady state for a fresh local dev box
-that hasn't set up any MCP connectors, and it's what `chat.el`'s
-`connector_tools_json()` / `tool_auto_approved()` already gracefully degrade
-to when the bridge replies emptily.
-
-It does **not**: spawn any real MCP server, do OAuth, read or write
-`~/.neuron/connectors.json`, or namespace/proxy real `tools/call` traffic to
-Google Drive/GitHub/Slack/etc. Building that is the real product task the
-spec describes — a genuine, sizeable engineering lift (MCP SDK client, OAuth
-+ Keychain token storage, per-server process lifecycle), not something to
-improvise inside a build/run audit. **That decision is Will's to make**, not
-this audit's to guess at.
-
-## Running it
-
-```bash
-# Foreground, on a throwaway port (never :7771 while council owns it live):
-python3 connectd_service.py --port 17771
-
-# Verify the contract:
-curl -s http://127.0.0.1:17771/healthz
-curl -s http://127.0.0.1:17771/mcp/tools
-curl -s http://127.0.0.1:17771/mcp/servers
-```
-
-## Open question for Will — the :7771 collision
-
-Three independent things are hardcoded to `:7771`: axon (unbuilt), connectd
-(this stub), and council (the one actually running). Wiring this stub into
-the real LaunchAgent stack on `:7771` requires either moving council off that
-port or deciding connectd should live elsewhere and repointing `routes.el`/
-`chat.el`'s hardcoded `127.0.0.1:7771` calls. Neither change was made here —
-it touches a live, running production service (`ai.neuron.council`) and a
-port number baked into shipped `.el` source, both bigger than this audit's
-"make local build/run work" mandate. Flagging for a decision rather than
-guessing.

connectd/connectd_service.py

@@ -1,115 +0,0 @@
-#!/usr/bin/env python3
-"""
-neuron-connectd — MCP connector bridge (LOCAL-DEV STUB).
-
-THIS IS NOT THE FULL SIDECAR. The full design lives in
-neuron-technologies/docs/research/mcp-connectors-adoption-spec.md (2026-06-13,
-"Status: Draft for build"): a TypeScript/Python sidecar using the official MCP
-SDK that spawns real MCP servers (stdio or streamable-HTTP/SSE), does OAuth,
-and namespaces their tools as mcp__<serverId>__<toolName>. That sidecar was
-never built (build-audit, 2026-08-15: no neuron-connectd source existed
-anywhere on disk before this file).
-
-WHY THIS STUB EXISTS: routes.el (handle_connectors, connectd_get/connectd_post)
-and chat.el (connector_tools_json, dispatch_tool's mcp__* routing,
-tool_auto_approved) were built to the spec and hardcoded to 127.0.0.1:7771 —
-they are LIVE and calling that port right now on every soul boot and every
-agentic turn. With nothing real listening there, three unrelated services
-collide on :7771 (see connectd/README.md): council (which IS what's bound
-there in Will's live environment today) silently answers with unrelated
-404 JSON, which is worse than a clean "connection refused" bridge-down
-response, because it can be misparsed as a real (if empty) reply instead of
-the "bridge unreachable" path the soul code already handles gracefully.
-
-This stub implements ONLY the documented HTTP contract, with zero connectors
-ever configured: empty tool list, empty server list, "not configured" on any
-mutating call. It gives a fresh local soul the CORRECT graceful-degradation
-behavior the soul code already expects for "no connectors set up yet" — not
-the wrong-shaped 404 noise a port collision produces. It does not spawn any
-MCP server, does no OAuth, and reads no ~/.neuron/connectors.json (there is
-nothing to read yet). Building the real sidecar is a separate, larger,
-Will-decision-needed product task — see README.md.
-
-Usage:
-    python3 connectd_service.py [--port 7771]
-"""
-
-import argparse
-
-import uvicorn
-from fastapi import FastAPI
-from fastapi.middleware.cors import CORSMiddleware
-from pydantic import BaseModel
-
-app = FastAPI(title="neuron-connectd (local-dev stub)")
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-
-class ToolCall(BaseModel):
-    name: str
-    input: dict = {}
-
-
-@app.get("/healthz")
-def healthz():
-    return {"status": "ok", "stub": True}
-
-
-@app.get("/mcp/tools")
-def mcp_tools():
-    # Matches the spec's contract shape exactly (section 4, "HTTP contract").
-    # Empty because zero connectors are configured — this is the correct,
-    # intended-by-design empty state, not a failure.
-    return {"tools": []}
-
-
-@app.post("/mcp/call")
-def mcp_call(body: ToolCall):
-    return {"ok": False, "error": "no connectors configured (neuron-connectd stub)"}
-
-
-@app.get("/mcp/servers")
-def mcp_servers():
-    return {"servers": []}
-
-
-@app.post("/mcp/servers/add")
-def mcp_servers_add():
-    return {"ok": False, "error": "neuron-connectd stub does not implement connector management yet"}
-
-
-@app.post("/mcp/servers/toggle")
-def mcp_servers_toggle():
-    return {"ok": False, "error": "neuron-connectd stub does not implement connector management yet"}
-
-
-@app.post("/mcp/servers/auto-approve")
-def mcp_servers_auto_approve():
-    return {"ok": False, "error": "neuron-connectd stub does not implement connector management yet"}
-
-
-@app.post("/mcp/servers/remove")
-def mcp_servers_remove():
-    return {"ok": False, "error": "neuron-connectd stub does not implement connector management yet"}
-
-
-@app.post("/mcp/servers/secret")
-def mcp_servers_secret():
-    return {"ok": False, "error": "neuron-connectd stub does not implement connector management yet"}
-
-
-@app.post("/mcp/oauth/start")
-def mcp_oauth_start():
-    return {"ok": False, "error": "oauth not implemented in the neuron-connectd stub"}
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--port", type=int, default=7771)
-    args = parser.parse_args()
-    uvicorn.run(app, host="127.0.0.1", port=args.port, log_level="info")

dist/awareness.c

@@ -21,14 +21,12 @@ 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);
 el_val_t embed_ok(void);
 el_val_t emit_heartbeat(void);
-el_val_t auto_term_try_slot(el_val_t slot_type, el_val_t slot_id);
+el_val_t auto_term_try_slot(el_val_t slot_type, el_val_t slot_lbl);
-el_val_t auto_term_try_slot_legacy(el_val_t slot_type, el_val_t slot_lbl);
 el_val_t proactive_curiosity(void);
 el_val_t pulse_count(void);
 el_val_t pulse_inc(void);
@@ -67,41 +65,10 @@ el_val_t idle_reset(void) {
   return 0;
 }
 
-el_val_t hebb_consolidate(void) {
-  el_val_t batch = engram_hebb_drain_json(64);
-  if (str_eq(batch, EL_STR(""))) {
-    return 0;
-  }
-  if (str_eq(batch, EL_STR("[]"))) {
-    return 0;
-  }
-  el_val_t n = json_array_len(batch);
-  if (n == 0) {
-    return 0;
-  }
-  el_val_t url_env = env(EL_STR("SOUL_ISE_URL"));
-  el_val_t url_state = ({ el_val_t _if_result_1 = 0; if (str_eq(url_env, EL_STR(""))) { _if_result_1 = (state_get(EL_STR("soul_engram_url"))); } else { _if_result_1 = (url_env); } _if_result_1; });
-  el_val_t engram_url = ({ el_val_t _if_result_2 = 0; if (str_eq(url_state, EL_STR(""))) { _if_result_2 = (EL_STR("http://localhost:8742")); } else { _if_result_2 = (url_state); } _if_result_2; });
-  el_val_t key_state = state_get(EL_STR("soul_engram_api_key"));
-  el_val_t api_key = ({ el_val_t _if_result_3 = 0; if (str_eq(key_state, EL_STR(""))) { _if_result_3 = (env(EL_STR("ENGRAM_API_KEY"))); } else { _if_result_3 = (key_state); } _if_result_3; });
-  el_val_t auth_part = ({ el_val_t _if_result_4 = 0; if (str_eq(api_key, EL_STR(""))) { _if_result_4 = (EL_STR("")); } else { _if_result_4 = (el_str_concat(el_str_concat(EL_STR(",\"_auth\":\""), api_key), EL_STR("\""))); } _if_result_4; });
-  el_val_t body = el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"edges\":"), batch), auth_part), EL_STR("}"));
-  el_val_t resp = http_post_json(el_str_concat(engram_url, EL_STR("/api/edges/batch")), body);
-  if (str_eq(resp, EL_STR(""))) {
-    return 0;
-  }
-  el_val_t acc = json_get(resp, EL_STR("accepted"));
-  if (str_eq(acc, EL_STR(""))) {
-    return 0;
-  }
-  return str_to_int(acc);
-  return 0;
-}
-
 el_val_t ise_post(el_val_t content) {
   el_val_t ise_url = env(EL_STR("SOUL_ISE_URL"));
-  el_val_t state_url = ({ el_val_t _if_result_5 = 0; if (str_eq(ise_url, EL_STR(""))) { _if_result_5 = (state_get(EL_STR("soul_engram_url"))); } else { _if_result_5 = (ise_url); } _if_result_5; });
+  el_val_t state_url = ({ el_val_t _if_result_1 = 0; if (str_eq(ise_url, EL_STR(""))) { _if_result_1 = (state_get(EL_STR("soul_engram_url"))); } else { _if_result_1 = (ise_url); } _if_result_1; });
-  el_val_t engram_url = ({ el_val_t _if_result_6 = 0; if (str_eq(state_url, EL_STR(""))) { _if_result_6 = (EL_STR("http://localhost:8742")); } else { _if_result_6 = (state_url); } _if_result_6; });
+  el_val_t engram_url = ({ el_val_t _if_result_2 = 0; if (str_eq(state_url, EL_STR(""))) { _if_result_2 = (EL_STR("http://localhost:8742")); } else { _if_result_2 = (state_url); } _if_result_2; });
   el_val_t safe1 = str_replace(content, EL_STR("\\"), EL_STR("\\\\"));
   el_val_t safe2 = str_replace(safe1, EL_STR("\""), EL_STR("\\\""));
   el_val_t safe3 = str_replace(safe2, EL_STR("\n"), EL_STR("\\n"));
@@ -110,7 +77,7 @@ el_val_t ise_post(el_val_t content) {
   el_val_t resp = http_post_json(el_str_concat(engram_url, EL_STR("/api/neuron/state-events")), body);
   if (str_eq(resp, EL_STR(""))) {
     el_val_t fail_raw = state_get(EL_STR("soul.ise_fail_count"));
-    el_val_t fail_n = ({ el_val_t _if_result_7 = 0; if (str_eq(fail_raw, EL_STR(""))) { _if_result_7 = (0); } else { _if_result_7 = (str_to_int(fail_raw)); } _if_result_7; });
+    el_val_t fail_n = ({ el_val_t _if_result_3 = 0; if (str_eq(fail_raw, EL_STR(""))) { _if_result_3 = (0); } else { _if_result_3 = (str_to_int(fail_raw)); } _if_result_3; });
     state_set(EL_STR("soul.ise_fail_count"), int_to_str((fail_n + 1)));
     el_val_t discard = engram_node_full(content, EL_STR("InternalStateEvent"), EL_STR("state-event"), el_from_float(0.3), el_from_float(0.3), el_from_float(0.8), EL_STR("Episodic"), EL_STR("[\"internal-state\",\"InternalStateEvent\",\"ise-fallback-local\"]"));
     return EL_STR("");
@@ -163,11 +130,11 @@ el_val_t embed_ok(void) {
 el_val_t emit_heartbeat(void) {
   el_val_t pulse = int_to_str(pulse_count());
   el_val_t boot_raw = state_get(EL_STR("soul_boot_count"));
-  el_val_t boot = ({ el_val_t _if_result_8 = 0; if (str_eq(boot_raw, EL_STR(""))) { _if_result_8 = (EL_STR("0")); } else { _if_result_8 = (boot_raw); } _if_result_8; });
+  el_val_t boot = ({ el_val_t _if_result_4 = 0; if (str_eq(boot_raw, EL_STR(""))) { _if_result_4 = (EL_STR("0")); } else { _if_result_4 = (boot_raw); } _if_result_4; });
   el_val_t idle = int_to_str(idle_count());
   el_val_t ts = time_now();
   el_val_t last_act_raw = state_get(EL_STR("soul.last_activity_ts"));
-  el_val_t idle_ms = ({ el_val_t _if_result_9 = 0; if (str_eq(last_act_raw, EL_STR(""))) { _if_result_9 = ((0 - 1)); } else { _if_result_9 = ((ts - str_to_int(last_act_raw))); } _if_result_9; });
+  el_val_t idle_ms = ({ el_val_t _if_result_5 = 0; if (str_eq(last_act_raw, EL_STR(""))) { _if_result_5 = ((0 - 1)); } else { _if_result_5 = ((ts - str_to_int(last_act_raw))); } _if_result_5; });
   el_val_t nc = engram_node_count();
   el_val_t ec = engram_edge_count();
   el_val_t wmc = engram_wm_count();
@@ -178,36 +145,36 @@ el_val_t emit_heartbeat(void) {
   el_val_t up_human = elapsed_human();
   el_val_t emb_ok = embed_ok();
   el_val_t fail_raw = state_get(EL_STR("soul.ise_fail_count"));
-  el_val_t fail_str = ({ el_val_t _if_result_10 = 0; if (str_eq(fail_raw, EL_STR(""))) { _if_result_10 = (EL_STR("0")); } else { _if_result_10 = (fail_raw); } _if_result_10; });
+  el_val_t fail_str = ({ el_val_t _if_result_6 = 0; if (str_eq(fail_raw, EL_STR(""))) { _if_result_6 = (EL_STR("0")); } else { _if_result_6 = (fail_raw); } _if_result_6; });
   el_val_t sat_raw = state_get(EL_STR("soul.sync_added_total"));
-  el_val_t sat_str = ({ el_val_t _if_result_11 = 0; if (str_eq(sat_raw, EL_STR(""))) { _if_result_11 = (EL_STR("0")); } else { _if_result_11 = (sat_raw); } _if_result_11; });
+  el_val_t sat_str = ({ el_val_t _if_result_7 = 0; if (str_eq(sat_raw, EL_STR(""))) { _if_result_7 = (EL_STR("0")); } else { _if_result_7 = (sat_raw); } _if_result_7; });
   el_val_t prev_wm_raw = state_get(EL_STR("soul.prev_wm_active"));
-  el_val_t prev_wm = ({ el_val_t _if_result_12 = 0; if (str_eq(prev_wm_raw, EL_STR(""))) { _if_result_12 = (0); } else { _if_result_12 = (str_to_int(prev_wm_raw)); } _if_result_12; });
+  el_val_t prev_wm = ({ el_val_t _if_result_8 = 0; if (str_eq(prev_wm_raw, EL_STR(""))) { _if_result_8 = (0); } else { _if_result_8 = (str_to_int(prev_wm_raw)); } _if_result_8; });
   el_val_t wm_delta = (wmc - prev_wm);
   state_set(EL_STR("soul.prev_wm_active"), int_to_str(wmc));
   el_val_t prev_nc_raw = state_get(EL_STR("soul.prev_node_count"));
-  el_val_t prev_nc = ({ el_val_t _if_result_13 = 0; if (str_eq(prev_nc_raw, EL_STR(""))) { _if_result_13 = (nc); } else { _if_result_13 = (str_to_int(prev_nc_raw)); } _if_result_13; });
+  el_val_t prev_nc = ({ el_val_t _if_result_9 = 0; if (str_eq(prev_nc_raw, EL_STR(""))) { _if_result_9 = (nc); } else { _if_result_9 = (str_to_int(prev_nc_raw)); } _if_result_9; });
   el_val_t node_delta = (nc - prev_nc);
   state_set(EL_STR("soul.prev_node_count"), int_to_str(nc));
   el_val_t prev_ec_raw = state_get(EL_STR("soul.prev_edge_count"));
-  el_val_t prev_ec = ({ el_val_t _if_result_14 = 0; if (str_eq(prev_ec_raw, EL_STR(""))) { _if_result_14 = (ec); } else { _if_result_14 = (str_to_int(prev_ec_raw)); } _if_result_14; });
+  el_val_t prev_ec = ({ el_val_t _if_result_10 = 0; if (str_eq(prev_ec_raw, EL_STR(""))) { _if_result_10 = (ec); } else { _if_result_10 = (str_to_int(prev_ec_raw)); } _if_result_10; });
   el_val_t edge_delta = (ec - prev_ec);
   state_set(EL_STR("soul.prev_edge_count"), int_to_str(ec));
   el_val_t sync_ok_raw = state_get(EL_STR("soul.last_sync_ok_ts"));
-  el_val_t sync_age = ({ el_val_t _if_result_15 = 0; if (str_eq(sync_ok_raw, EL_STR(""))) { _if_result_15 = ((0 - 1)); } else { _if_result_15 = ((ts - str_to_int(sync_ok_raw))); } _if_result_15; });
+  el_val_t sync_age = ({ el_val_t _if_result_11 = 0; if (str_eq(sync_ok_raw, EL_STR(""))) { _if_result_11 = ((0 - 1)); } else { _if_result_11 = ((ts - str_to_int(sync_ok_raw))); } _if_result_11; });
   el_val_t hb_env_url = env(EL_STR("SOUL_ISE_URL"));
-  el_val_t hb_state_url = ({ el_val_t _if_result_16 = 0; if (str_eq(hb_env_url, EL_STR(""))) { _if_result_16 = (state_get(EL_STR("soul_engram_url"))); } else { _if_result_16 = (hb_env_url); } _if_result_16; });
+  el_val_t hb_state_url = ({ el_val_t _if_result_12 = 0; if (str_eq(hb_env_url, EL_STR(""))) { _if_result_12 = (state_get(EL_STR("soul_engram_url"))); } else { _if_result_12 = (hb_env_url); } _if_result_12; });
-  el_val_t hb_engram_url = ({ el_val_t _if_result_17 = 0; if (str_eq(hb_state_url, EL_STR(""))) { _if_result_17 = (EL_STR("http://localhost:8742")); } else { _if_result_17 = (hb_state_url); } _if_result_17; });
+  el_val_t hb_engram_url = ({ el_val_t _if_result_13 = 0; if (str_eq(hb_state_url, EL_STR(""))) { _if_result_13 = (EL_STR("http://localhost:8742")); } else { _if_result_13 = (hb_state_url); } _if_result_13; });
   el_val_t bf_resp = http_get(el_str_concat(hb_engram_url, EL_STR("/api/embed-backfill?n=32")));
   el_val_t bf_done_raw = json_get(bf_resp, EL_STR("embedded"));
-  el_val_t bf_done = ({ el_val_t _if_result_18 = 0; if (str_eq(bf_done_raw, EL_STR(""))) { _if_result_18 = (EL_STR("-1")); } else { _if_result_18 = (bf_done_raw); } _if_result_18; });
+  el_val_t bf_done = ({ el_val_t _if_result_14 = 0; if (str_eq(bf_done_raw, EL_STR(""))) { _if_result_14 = (EL_STR("-1")); } else { _if_result_14 = (bf_done_raw); } _if_result_14; });
   el_val_t bf_total_raw = json_get(bf_resp, EL_STR("embedded_count"));
-  el_val_t bf_total = ({ el_val_t _if_result_19 = 0; if (str_eq(bf_total_raw, EL_STR(""))) { _if_result_19 = (EL_STR("-1")); } else { _if_result_19 = (bf_total_raw); } _if_result_19; });
+  el_val_t bf_total = ({ el_val_t _if_result_15 = 0; if (str_eq(bf_total_raw, EL_STR(""))) { _if_result_15 = (EL_STR("-1")); } else { _if_result_15 = (bf_total_raw); } _if_result_15; });
-  el_val_t wm_sat = ({ el_val_t _if_result_20 = 0; if ((wmc >= 24)) { _if_result_20 = (1); } else { _if_result_20 = (0); } _if_result_20; });
+  el_val_t wm_sat = ({ el_val_t _if_result_16 = 0; if ((wmc >= 24)) { _if_result_16 = (1); } else { _if_result_16 = (0); } _if_result_16; });
   el_val_t prev_sat_raw = state_get(EL_STR("soul.prev_wm_saturated"));
-  el_val_t prev_sat = ({ el_val_t _if_result_21 = 0; if (str_eq(prev_sat_raw, EL_STR(""))) { _if_result_21 = (wm_sat); } else { _if_result_21 = (str_to_int(prev_sat_raw)); } _if_result_21; });
+  el_val_t prev_sat = ({ el_val_t _if_result_17 = 0; if (str_eq(prev_sat_raw, EL_STR(""))) { _if_result_17 = (wm_sat); } else { _if_result_17 = (str_to_int(prev_sat_raw)); } _if_result_17; });
   if (wm_sat != prev_sat) {
-    el_val_t sat_dir = ({ el_val_t _if_result_22 = 0; if ((wm_sat == 1)) { _if_result_22 = (EL_STR("onset")); } else { _if_result_22 = (EL_STR("release")); } _if_result_22; });
+    el_val_t sat_dir = ({ el_val_t _if_result_18 = 0; if ((wm_sat == 1)) { _if_result_18 = (EL_STR("onset")); } else { _if_result_18 = (EL_STR("release")); } _if_result_18; });
     ise_post(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"event\":\"wm_saturation_transition\",\"direction\":\""), sat_dir), EL_STR("\",\"wm_active\":")), int_to_str(wmc)), EL_STR(",\"wm_top\":")), wm_top), EL_STR(",\"ts\":")), int_to_str(ts)), EL_STR("}")));
   }
   state_set(EL_STR("soul.prev_wm_saturated"), int_to_str(wm_sat));
@@ -215,8 +182,8 @@ el_val_t emit_heartbeat(void) {
   el_val_t wm_top0_id = json_get(wm_top0, EL_STR("id"));
   el_val_t prev_top0 = state_get(EL_STR("soul.prev_wm_top0"));
   el_val_t t0streak_raw = state_get(EL_STR("soul.wm_top0_streak"));
-  el_val_t t0streak_prev = ({ el_val_t _if_result_23 = 0; if (str_eq(t0streak_raw, EL_STR(""))) { _if_result_23 = (0); } else { _if_result_23 = (str_to_int(t0streak_raw)); } _if_result_23; });
+  el_val_t t0streak_prev = ({ el_val_t _if_result_19 = 0; if (str_eq(t0streak_raw, EL_STR(""))) { _if_result_19 = (0); } else { _if_result_19 = (str_to_int(t0streak_raw)); } _if_result_19; });
-  el_val_t t0streak = ({ el_val_t _if_result_24 = 0; if (str_eq(wm_top0_id, EL_STR(""))) { _if_result_24 = (0); } else { _if_result_24 = (({ el_val_t _if_result_25 = 0; if (str_eq(wm_top0_id, prev_top0)) { _if_result_25 = ((t0streak_prev + 1)); } else { _if_result_25 = (1); } _if_result_25; })); } _if_result_24; });
+  el_val_t t0streak = ({ el_val_t _if_result_20 = 0; if (str_eq(wm_top0_id, EL_STR(""))) { _if_result_20 = (0); } else { _if_result_20 = (({ el_val_t _if_result_21 = 0; if (str_eq(wm_top0_id, prev_top0)) { _if_result_21 = ((t0streak_prev + 1)); } else { _if_result_21 = (1); } _if_result_21; })); } _if_result_20; });
   state_set(EL_STR("soul.prev_wm_top0"), wm_top0_id);
   state_set(EL_STR("soul.wm_top0_streak"), int_to_str(t0streak));
   el_val_t ch_id1 = json_get(json_array_get(wm_top, 1), EL_STR("id"));
@@ -224,28 +191,28 @@ el_val_t emit_heartbeat(void) {
   el_val_t ch_id3 = json_get(json_array_get(wm_top, 3), EL_STR("id"));
   el_val_t ch_id4 = json_get(json_array_get(wm_top, 4), EL_STR("id"));
   el_val_t prev_top5 = state_get(EL_STR("soul.prev_wm_top5"));
-  el_val_t ch0 = ({ el_val_t _if_result_26 = 0; if (str_eq(wm_top0_id, EL_STR(""))) { _if_result_26 = (0); } else { _if_result_26 = (({ el_val_t _if_result_27 = 0; if (str_contains(prev_top5, wm_top0_id)) { _if_result_27 = (0); } else { _if_result_27 = (1); } _if_result_27; })); } _if_result_26; });
+  el_val_t ch0 = ({ el_val_t _if_result_22 = 0; if (str_eq(wm_top0_id, EL_STR(""))) { _if_result_22 = (0); } else { _if_result_22 = (({ el_val_t _if_result_23 = 0; if (str_contains(prev_top5, wm_top0_id)) { _if_result_23 = (0); } else { _if_result_23 = (1); } _if_result_23; })); } _if_result_22; });
-  el_val_t ch1 = ({ el_val_t _if_result_28 = 0; if (str_eq(ch_id1, EL_STR(""))) { _if_result_28 = (0); } else { _if_result_28 = (({ el_val_t _if_result_29 = 0; if (str_contains(prev_top5, ch_id1)) { _if_result_29 = (0); } else { _if_result_29 = (1); } _if_result_29; })); } _if_result_28; });
+  el_val_t ch1 = ({ el_val_t _if_result_24 = 0; if (str_eq(ch_id1, EL_STR(""))) { _if_result_24 = (0); } else { _if_result_24 = (({ el_val_t _if_result_25 = 0; if (str_contains(prev_top5, ch_id1)) { _if_result_25 = (0); } else { _if_result_25 = (1); } _if_result_25; })); } _if_result_24; });
-  el_val_t ch2 = ({ el_val_t _if_result_30 = 0; if (str_eq(ch_id2, EL_STR(""))) { _if_result_30 = (0); } else { _if_result_30 = (({ el_val_t _if_result_31 = 0; if (str_contains(prev_top5, ch_id2)) { _if_result_31 = (0); } else { _if_result_31 = (1); } _if_result_31; })); } _if_result_30; });
+  el_val_t ch2 = ({ el_val_t _if_result_26 = 0; if (str_eq(ch_id2, EL_STR(""))) { _if_result_26 = (0); } else { _if_result_26 = (({ el_val_t _if_result_27 = 0; if (str_contains(prev_top5, ch_id2)) { _if_result_27 = (0); } else { _if_result_27 = (1); } _if_result_27; })); } _if_result_26; });
-  el_val_t ch3 = ({ el_val_t _if_result_32 = 0; if (str_eq(ch_id3, EL_STR(""))) { _if_result_32 = (0); } else { _if_result_32 = (({ el_val_t _if_result_33 = 0; if (str_contains(prev_top5, ch_id3)) { _if_result_33 = (0); } else { _if_result_33 = (1); } _if_result_33; })); } _if_result_32; });
+  el_val_t ch3 = ({ el_val_t _if_result_28 = 0; if (str_eq(ch_id3, EL_STR(""))) { _if_result_28 = (0); } else { _if_result_28 = (({ el_val_t _if_result_29 = 0; if (str_contains(prev_top5, ch_id3)) { _if_result_29 = (0); } else { _if_result_29 = (1); } _if_result_29; })); } _if_result_28; });
-  el_val_t ch4 = ({ el_val_t _if_result_34 = 0; if (str_eq(ch_id4, EL_STR(""))) { _if_result_34 = (0); } else { _if_result_34 = (({ el_val_t _if_result_35 = 0; if (str_contains(prev_top5, ch_id4)) { _if_result_35 = (0); } else { _if_result_35 = (1); } _if_result_35; })); } _if_result_34; });
+  el_val_t ch4 = ({ el_val_t _if_result_30 = 0; if (str_eq(ch_id4, EL_STR(""))) { _if_result_30 = (0); } else { _if_result_30 = (({ el_val_t _if_result_31 = 0; if (str_contains(prev_top5, ch_id4)) { _if_result_31 = (0); } else { _if_result_31 = (1); } _if_result_31; })); } _if_result_30; });
   el_val_t wm_churn = ((((ch0 + ch1) + ch2) + ch3) + ch4);
   state_set(EL_STR("soul.prev_wm_top5"), el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(wm_top0_id, EL_STR("|")), ch_id1), EL_STR("|")), ch_id2), EL_STR("|")), ch_id3), EL_STR("|")), ch_id4));
   el_val_t wm_top0_wm_raw = json_get(wm_top0, EL_STR("wm"));
-  el_val_t wm_top0_wm = ({ el_val_t _if_result_36 = 0; if (str_eq(wm_top0_wm_raw, EL_STR(""))) { _if_result_36 = (EL_STR("0")); } else { _if_result_36 = (wm_top0_wm_raw); } _if_result_36; });
+  el_val_t wm_top0_wm = ({ el_val_t _if_result_32 = 0; if (str_eq(wm_top0_wm_raw, EL_STR(""))) { _if_result_32 = (EL_STR("0")); } else { _if_result_32 = (wm_top0_wm_raw); } _if_result_32; });
   el_val_t act_stats = engram_act_stats_json();
   el_val_t act_evict_raw = json_get(act_stats, EL_STR("wm_evicted"));
-  el_val_t act_evict = ({ el_val_t _if_result_37 = 0; if (str_eq(act_evict_raw, EL_STR(""))) { _if_result_37 = (EL_STR("-1")); } else { _if_result_37 = (act_evict_raw); } _if_result_37; });
+  el_val_t act_evict = ({ el_val_t _if_result_33 = 0; if (str_eq(act_evict_raw, EL_STR(""))) { _if_result_33 = (EL_STR("-1")); } else { _if_result_33 = (act_evict_raw); } _if_result_33; });
   el_val_t act_bt_raw = json_get(act_stats, EL_STR("breakthroughs"));
-  el_val_t act_bt = ({ el_val_t _if_result_38 = 0; if (str_eq(act_bt_raw, EL_STR(""))) { _if_result_38 = (EL_STR("-1")); } else { _if_result_38 = (act_bt_raw); } _if_result_38; });
+  el_val_t act_bt = ({ el_val_t _if_result_34 = 0; if (str_eq(act_bt_raw, EL_STR(""))) { _if_result_34 = (EL_STR("-1")); } else { _if_result_34 = (act_bt_raw); } _if_result_34; });
-  el_val_t evict_now = ({ el_val_t _if_result_39 = 0; if (str_eq(act_evict_raw, EL_STR(""))) { _if_result_39 = ((0 - 1)); } else { _if_result_39 = (str_to_int(act_evict_raw)); } _if_result_39; });
+  el_val_t evict_now = ({ el_val_t _if_result_35 = 0; if (str_eq(act_evict_raw, EL_STR(""))) { _if_result_35 = ((0 - 1)); } else { _if_result_35 = (str_to_int(act_evict_raw)); } _if_result_35; });
-  el_val_t bt_now = ({ el_val_t _if_result_40 = 0; if (str_eq(act_bt_raw, EL_STR(""))) { _if_result_40 = ((0 - 1)); } else { _if_result_40 = (str_to_int(act_bt_raw)); } _if_result_40; });
+  el_val_t bt_now = ({ el_val_t _if_result_36 = 0; if (str_eq(act_bt_raw, EL_STR(""))) { _if_result_36 = ((0 - 1)); } else { _if_result_36 = (str_to_int(act_bt_raw)); } _if_result_36; });
   el_val_t prev_evict_raw = state_get(EL_STR("soul.prev_wm_evicted"));
-  el_val_t prev_evict = ({ el_val_t _if_result_41 = 0; if (str_eq(prev_evict_raw, EL_STR(""))) { _if_result_41 = (0); } else { _if_result_41 = (str_to_int(prev_evict_raw)); } _if_result_41; });
+  el_val_t prev_evict = ({ el_val_t _if_result_37 = 0; if (str_eq(prev_evict_raw, EL_STR(""))) { _if_result_37 = (0); } else { _if_result_37 = (str_to_int(prev_evict_raw)); } _if_result_37; });
   el_val_t prev_bt_raw = state_get(EL_STR("soul.prev_breakthroughs"));
-  el_val_t prev_bt = ({ el_val_t _if_result_42 = 0; if (str_eq(prev_bt_raw, EL_STR(""))) { _if_result_42 = (0); } else { _if_result_42 = (str_to_int(prev_bt_raw)); } _if_result_42; });
+  el_val_t prev_bt = ({ el_val_t _if_result_38 = 0; if (str_eq(prev_bt_raw, EL_STR(""))) { _if_result_38 = (0); } else { _if_result_38 = (str_to_int(prev_bt_raw)); } _if_result_38; });
-  el_val_t evict_delta = ({ el_val_t _if_result_43 = 0; if ((evict_now < 0)) { _if_result_43 = (0); } else { _if_result_43 = (({ el_val_t _if_result_44 = 0; if ((evict_now < prev_evict)) { _if_result_44 = (evict_now); } else { _if_result_44 = ((evict_now - prev_evict)); } _if_result_44; })); } _if_result_43; });
+  el_val_t evict_delta = ({ el_val_t _if_result_39 = 0; if ((evict_now < 0)) { _if_result_39 = (0); } else { _if_result_39 = (({ el_val_t _if_result_40 = 0; if ((evict_now < prev_evict)) { _if_result_40 = (evict_now); } else { _if_result_40 = ((evict_now - prev_evict)); } _if_result_40; })); } _if_result_39; });
-  el_val_t bt_delta = ({ el_val_t _if_result_45 = 0; if ((bt_now < 0)) { _if_result_45 = (0); } else { _if_result_45 = (({ el_val_t _if_result_46 = 0; if ((bt_now < prev_bt)) { _if_result_46 = (bt_now); } else { _if_result_46 = ((bt_now - prev_bt)); } _if_result_46; })); } _if_result_45; });
+  el_val_t bt_delta = ({ el_val_t _if_result_41 = 0; if ((bt_now < 0)) { _if_result_41 = (0); } else { _if_result_41 = (({ el_val_t _if_result_42 = 0; if ((bt_now < prev_bt)) { _if_result_42 = (bt_now); } else { _if_result_42 = ((bt_now - prev_bt)); } _if_result_42; })); } _if_result_41; });
   if (evict_now >= 0) {
     state_set(EL_STR("soul.prev_wm_evicted"), int_to_str(evict_now));
   }
@@ -254,113 +221,19 @@ el_val_t emit_heartbeat(void) {
   }
   el_val_t hb_stats = http_get(el_str_concat(hb_engram_url, EL_STR("/api/stats")));
   el_val_t embed_elig_raw = json_get(hb_stats, EL_STR("embed_eligible_count"));
-  el_val_t embed_elig = ({ el_val_t _if_result_47 = 0; if (str_eq(embed_elig_raw, EL_STR(""))) { _if_result_47 = (EL_STR("-1")); } else { _if_result_47 = (embed_elig_raw); } _if_result_47; });
+  el_val_t embed_elig = ({ el_val_t _if_result_43 = 0; if (str_eq(embed_elig_raw, EL_STR(""))) { _if_result_43 = (EL_STR("-1")); } else { _if_result_43 = (embed_elig_raw); } _if_result_43; });
   el_val_t hb_ats_raw = state_get(EL_STR("soul.auto_term_streak"));
-  el_val_t hb_ats = ({ el_val_t _if_result_48 = 0; if (str_eq(hb_ats_raw, EL_STR(""))) { _if_result_48 = (0); } else { _if_result_48 = (str_to_int(hb_ats_raw)); } _if_result_48; });
+  el_val_t hb_ats = ({ el_val_t _if_result_44 = 0; if (str_eq(hb_ats_raw, EL_STR(""))) { _if_result_44 = (0); } else { _if_result_44 = (str_to_int(hb_ats_raw)); } _if_result_44; });
-  el_val_t hb_ate_raw = state_get(EL_STR("soul.auto_term_empty_streak"));
-  el_val_t hb_ate = ({ el_val_t _if_result_49 = 0; if (str_eq(hb_ate_raw, EL_STR(""))) { _if_result_49 = (0); } else { _if_result_49 = (str_to_int(hb_ate_raw)); } _if_result_49; });
-  el_val_t hebb_warm_raw = json_get(act_stats, EL_STR("hebb_warm"));
-  el_val_t hebb_warm = ({ el_val_t _if_result_50 = 0; if (str_eq(hebb_warm_raw, EL_STR(""))) { _if_result_50 = (EL_STR("-1")); } else { _if_result_50 = (hebb_warm_raw); } _if_result_50; });
-  el_val_t hebb_max_raw = json_get(act_stats, EL_STR("hebb_max"));
-  el_val_t hebb_max = ({ el_val_t _if_result_51 = 0; if (str_eq(hebb_max_raw, EL_STR(""))) { _if_result_51 = (EL_STR("-1")); } else { _if_result_51 = (hebb_max_raw); } _if_result_51; });
-  el_val_t hebb_links_raw = json_get(act_stats, EL_STR("hebb_links"));
-  el_val_t hebb_links = ({ el_val_t _if_result_52 = 0; if (str_eq(hebb_links_raw, EL_STR(""))) { _if_result_52 = (EL_STR("-1")); } else { _if_result_52 = (hebb_links_raw); } _if_result_52; });
-  el_val_t hebb_cands_raw = json_get(act_stats, EL_STR("hebb_cands"));
-  el_val_t hebb_cands = ({ el_val_t _if_result_53 = 0; if (str_eq(hebb_cands_raw, EL_STR(""))) { _if_result_53 = (EL_STR("-1")); } else { _if_result_53 = (hebb_cands_raw); } _if_result_53; });
-  el_val_t hebb_cmax_raw = json_get(act_stats, EL_STR("hebb_cand_max"));
-  el_val_t hebb_cmax = ({ el_val_t _if_result_54 = 0; if (str_eq(hebb_cmax_raw, EL_STR(""))) { _if_result_54 = (EL_STR("-1")); } else { _if_result_54 = (hebb_cmax_raw); } _if_result_54; });
-  el_val_t hebb_mass_raw = json_get(act_stats, EL_STR("hebb_mass"));
-  el_val_t hebb_mass = ({ el_val_t _if_result_55 = 0; if (str_eq(hebb_mass_raw, EL_STR(""))) { _if_result_55 = (EL_STR("-1")); } else { _if_result_55 = (hebb_mass_raw); } _if_result_55; });
-  el_val_t hebb_edges_raw = json_get(act_stats, EL_STR("hebb_edges"));
-  el_val_t hebb_edges = ({ el_val_t _if_result_56 = 0; if (str_eq(hebb_edges_raw, EL_STR(""))) { _if_result_56 = (EL_STR("-1")); } else { _if_result_56 = (hebb_edges_raw); } _if_result_56; });
-  el_val_t wb_pend_raw = json_get(act_stats, EL_STR("hebb_wb_pending"));
-  el_val_t wb_pend = ({ el_val_t _if_result_57 = 0; if (str_eq(wb_pend_raw, EL_STR(""))) { _if_result_57 = (EL_STR("-1")); } else { _if_result_57 = (wb_pend_raw); } _if_result_57; });
-  el_val_t wb_drain_raw = json_get(act_stats, EL_STR("hebb_wb_drained"));
-  el_val_t wb_drain = ({ el_val_t _if_result_58 = 0; if (str_eq(wb_drain_raw, EL_STR(""))) { _if_result_58 = (EL_STR("-1")); } else { _if_result_58 = (wb_drain_raw); } _if_result_58; });
-  el_val_t wb_drop_raw = json_get(act_stats, EL_STR("hebb_wb_dropped"));
-  el_val_t wb_drop = ({ el_val_t _if_result_59 = 0; if (str_eq(wb_drop_raw, EL_STR(""))) { _if_result_59 = (EL_STR("-1")); } else { _if_result_59 = (wb_drop_raw); } _if_result_59; });
-  el_val_t wb_sent_raw = state_get(EL_STR("soul.hebb_wb_sent"));
-  el_val_t wb_sent = ({ el_val_t _if_result_60 = 0; if (str_eq(wb_sent_raw, EL_STR(""))) { _if_result_60 = (EL_STR("0")); } else { _if_result_60 = (wb_sent_raw); } _if_result_60; });
-  el_val_t dup_wm_g_raw = json_get(act_stats, EL_STR("dup_wm_global"));
-  el_val_t dup_wm_g = ({ el_val_t _if_result_61 = 0; if (str_eq(dup_wm_g_raw, EL_STR(""))) { _if_result_61 = (EL_STR("-1")); } else { _if_result_61 = (dup_wm_g_raw); } _if_result_61; });
   el_val_t act_brk_raw = json_get(act_stats, EL_STR("embed_breaker_open"));
-  el_val_t act_brk = ({ el_val_t _if_result_62 = 0; if (str_eq(act_brk_raw, EL_STR(""))) { _if_result_62 = (EL_STR("-1")); } else { _if_result_62 = (act_brk_raw); } _if_result_62; });
+  el_val_t act_brk = ({ el_val_t _if_result_45 = 0; if (str_eq(act_brk_raw, EL_STR(""))) { _if_result_45 = (EL_STR("-1")); } else { _if_result_45 = (act_brk_raw); } _if_result_45; });
-  el_val_t emb_cf_raw = json_get(act_stats, EL_STR("embed_consec_fail"));
-  el_val_t emb_cf = ({ el_val_t _if_result_63 = 0; if (str_eq(emb_cf_raw, EL_STR(""))) { _if_result_63 = (EL_STR("-1")); } else { _if_result_63 = (emb_cf_raw); } _if_result_63; });
   el_val_t ctx_cos_raw = json_get(act_stats, EL_STR("ctx_cos"));
-  el_val_t ctx_cos = ({ el_val_t _if_result_64 = 0; if (str_eq(ctx_cos_raw, EL_STR(""))) { _if_result_64 = (EL_STR("-2")); } else { _if_result_64 = (ctx_cos_raw); } _if_result_64; });
+  el_val_t ctx_cos = ({ el_val_t _if_result_46 = 0; if (str_eq(ctx_cos_raw, EL_STR(""))) { _if_result_46 = (EL_STR("-2")); } else { _if_result_46 = (ctx_cos_raw); } _if_result_46; });
-  el_val_t dup_seeds_raw = json_get(act_stats, EL_STR("dup_seeds"));
+  el_val_t payload = el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"event\":\"heartbeat\",\"pulse\":"), pulse), EL_STR(",\"tick\":")), pulse), EL_STR(",\"boot\":")), boot), EL_STR(",\"idle\":")), idle), EL_STR(",\"idle_ms\":")), int_to_str(idle_ms)), EL_STR(",\"node_count\":")), int_to_str(nc)), EL_STR(",\"edge_count\":")), int_to_str(ec)), EL_STR(",\"node_delta\":")), int_to_str(node_delta)), EL_STR(",\"edge_delta\":")), int_to_str(edge_delta)), EL_STR(",\"wm_active\":")), int_to_str(wmc)), EL_STR(",\"wm_delta\":")), int_to_str(wm_delta)), EL_STR(",\"wm_saturated\":")), int_to_str(wm_sat)), EL_STR(",\"wm_top0_streak\":")), int_to_str(t0streak)), EL_STR(",\"wm_churn\":")), int_to_str(wm_churn)), EL_STR(",\"wm_top0_wm\":")), wm_top0_wm), EL_STR(",\"sync_added_total\":")), sat_str), EL_STR(",\"sync_age_ms\":")), int_to_str(sync_age)), EL_STR(",\"wm_avg_weight\":")), wm_avg_str), EL_STR(",\"wm_top\":")), wm_top), EL_STR(",\"ts\":")), int_to_str(ts)), EL_STR(",\"uptime_ms\":")), int_to_str(up_ms)), EL_STR(",\"uptime\":\"")), up_human), EL_STR("\",\"embed_ok\":")), int_to_str(emb_ok)), EL_STR(",\"embed_backfilled\":")), bf_done), EL_STR(",\"embed_count\":")), bf_total), EL_STR(",\"embed_eligible\":")), embed_elig), EL_STR(",\"wm_evicted\":")), act_evict), EL_STR(",\"wm_evicted_delta\":")), int_to_str(evict_delta)), EL_STR(",\"breakthroughs\":")), act_bt), EL_STR(",\"breakthroughs_delta\":")), int_to_str(bt_delta)), EL_STR(",\"auto_term_streak\":")), int_to_str(hb_ats)), EL_STR(",\"embed_breaker_open\":")), act_brk), EL_STR(",\"ctx_cos\":")), ctx_cos), EL_STR(",\"ise_fail\":")), fail_str), EL_STR("}"));
-  el_val_t dup_seeds = ({ el_val_t _if_result_65 = 0; if (str_eq(dup_seeds_raw, EL_STR(""))) { _if_result_65 = (EL_STR("-1")); } else { _if_result_65 = (dup_seeds_raw); } _if_result_65; });
-  el_val_t dup_wm_raw = json_get(act_stats, EL_STR("dup_wm"));
-  el_val_t dup_wm = ({ el_val_t _if_result_66 = 0; if (str_eq(dup_wm_raw, EL_STR(""))) { _if_result_66 = (EL_STR("-1")); } else { _if_result_66 = (dup_wm_raw); } _if_result_66; });
-  el_val_t txt_dmg_raw = json_get(act_stats, EL_STR("txt_damaged"));
-  el_val_t txt_dmg = ({ el_val_t _if_result_67 = 0; if (str_eq(txt_dmg_raw, EL_STR(""))) { _if_result_67 = (EL_STR("-1")); } else { _if_result_67 = (txt_dmg_raw); } _if_result_67; });
-  el_val_t tc_raw = state_get(EL_STR("soul.txt_census_countdown"));
-  el_val_t tc_n = ({ el_val_t _if_result_68 = 0; if (str_eq(tc_raw, EL_STR(""))) { _if_result_68 = (0); } else { _if_result_68 = (str_to_int(tc_raw)); } _if_result_68; });
-  if (tc_n <= 0) {
-    el_val_t th_resp = http_get(el_str_concat(hb_engram_url, EL_STR("/api/text-health")));
-    el_val_t th_pct = json_get(th_resp, EL_STR("damaged_pct"));
-    if (!str_eq(th_pct, EL_STR(""))) {
-      state_set(EL_STR("soul.txt_damaged_pct"), th_pct);
-      state_set(EL_STR("soul.txt_damaged_n"), json_get(th_resp, EL_STR("damaged")));
-      state_set(EL_STR("soul.txt_scanned_n"), json_get(th_resp, EL_STR("scanned")));
-      state_set(EL_STR("soul.txt_census_ts"), int_to_str(ts));
-    }
-    state_set(EL_STR("soul.txt_census_countdown"), EL_STR("30"));
-  }
-  if (tc_n > 0) {
-    state_set(EL_STR("soul.txt_census_countdown"), int_to_str((tc_n - 1)));
-  }
-  el_val_t dmg_pct_raw = state_get(EL_STR("soul.txt_damaged_pct"));
-  el_val_t dmg_pct = ({ el_val_t _if_result_69 = 0; if (str_eq(dmg_pct_raw, EL_STR(""))) { _if_result_69 = (EL_STR("-1")); } else { _if_result_69 = (dmg_pct_raw); } _if_result_69; });
-  el_val_t dmg_n_raw = state_get(EL_STR("soul.txt_damaged_n"));
-  el_val_t dmg_n = ({ el_val_t _if_result_70 = 0; if (str_eq(dmg_n_raw, EL_STR(""))) { _if_result_70 = (EL_STR("-1")); } else { _if_result_70 = (dmg_n_raw); } _if_result_70; });
-  el_val_t dmg_scan_raw = state_get(EL_STR("soul.txt_scanned_n"));
-  el_val_t dmg_scan = ({ el_val_t _if_result_71 = 0; if (str_eq(dmg_scan_raw, EL_STR(""))) { _if_result_71 = (EL_STR("-1")); } else { _if_result_71 = (dmg_scan_raw); } _if_result_71; });
-  el_val_t dmg_ts_raw = state_get(EL_STR("soul.txt_census_ts"));
-  el_val_t dmg_age = ({ el_val_t _if_result_72 = 0; if (str_eq(dmg_ts_raw, EL_STR(""))) { _if_result_72 = ((0 - 1)); } else { _if_result_72 = ((ts - str_to_int(dmg_ts_raw))); } _if_result_72; });
-  el_val_t payload = el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"event\":\"heartbeat\",\"pulse\":"), pulse), EL_STR(",\"tick\":")), pulse), EL_STR(",\"boot\":")), boot), EL_STR(",\"idle\":")), idle), EL_STR(",\"idle_ms\":")), int_to_str(idle_ms)), EL_STR(",\"node_count\":")), int_to_str(nc)), EL_STR(",\"edge_count\":")), int_to_str(ec)), EL_STR(",\"node_delta\":")), int_to_str(node_delta)), EL_STR(",\"edge_delta\":")), int_to_str(edge_delta)), EL_STR(",\"wm_active\":")), int_to_str(wmc)), EL_STR(",\"wm_delta\":")), int_to_str(wm_delta)), EL_STR(",\"wm_saturated\":")), int_to_str(wm_sat)), EL_STR(",\"wm_top0_streak\":")), int_to_str(t0streak)), EL_STR(",\"wm_churn\":")), int_to_str(wm_churn)), EL_STR(",\"wm_top0_wm\":")), wm_top0_wm), EL_STR(",\"sync_added_total\":")), sat_str), EL_STR(",\"sync_age_ms\":")), int_to_str(sync_age)), EL_STR(",\"wm_avg_weight\":")), wm_avg_str), EL_STR(",\"wm_top\":")), wm_top), EL_STR(",\"ts\":")), int_to_str(ts)), EL_STR(",\"uptime_ms\":")), int_to_str(up_ms)), EL_STR(",\"uptime\":\"")), up_human), EL_STR("\",\"embed_ok\":")), int_to_str(emb_ok)), EL_STR(",\"embed_backfilled\":")), bf_done), EL_STR(",\"embed_count\":")), bf_total), EL_STR(",\"embed_eligible\":")), embed_elig), EL_STR(",\"wm_evicted\":")), act_evict), EL_STR(",\"wm_evicted_delta\":")), int_to_str(evict_delta)), EL_STR(",\"breakthroughs\":")), act_bt), EL_STR(",\"breakthroughs_delta\":")), int_to_str(bt_delta)), EL_STR(",\"auto_term_streak\":")), int_to_str(hb_ats)), EL_STR(",\"auto_term_empty_streak\":")), int_to_str(hb_ate)), EL_STR(",\"embed_breaker_open\":")), act_brk), EL_STR(",\"ctx_cos\":")), ctx_cos), EL_STR(",\"dup_seeds\":")), dup_seeds), EL_STR(",\"dup_wm\":")), dup_wm), EL_STR(",\"dup_wm_global\":")), dup_wm_g), EL_STR(",\"hebb_warm\":")), hebb_warm), EL_STR(",\"hebb_max\":")), hebb_max), EL_STR(",\"hebb_links\":")), hebb_links), EL_STR(",\"hebb_cands\":")), hebb_cands), EL_STR(",\"hebb_cand_max\":")), hebb_cmax), EL_STR(",\"hebb_mass\":")), hebb_mass), EL_STR(",\"hebb_edges\":")), hebb_edges), EL_STR(",\"embed_consec_fail\":")), emb_cf), EL_STR(",\"txt_damaged_pct\":")), dmg_pct), EL_STR(",\"txt_damaged_n\":")), dmg_n), EL_STR(",\"txt_scanned_n\":")), dmg_scan), EL_STR(",\"txt_census_age_ms\":")), int_to_str(dmg_age)), EL_STR(",\"hebb_wb_pending\":")), wb_pend), EL_STR(",\"hebb_wb_drained\":")), wb_drain), EL_STR(",\"hebb_wb_dropped\":")), wb_drop), EL_STR(",\"hebb_wb_sent\":")), wb_sent), EL_STR(",\"ise_fail\":")), fail_str), EL_STR(",\"txt_damaged\":")), txt_dmg), EL_STR("}"));
   ise_post(payload);
   return 0;
 }
 
-el_val_t auto_term_try_slot(el_val_t slot_type, el_val_t slot_id) {
+el_val_t auto_term_try_slot(el_val_t slot_type, el_val_t slot_lbl) {
-  state_set(EL_STR("_ats_ok"), EL_STR("0"));
-  if (str_eq(slot_type, EL_STR("Memory"))) {
-    state_set(EL_STR("_ats_ok"), EL_STR("1"));
-  }
-  if (str_eq(slot_type, EL_STR("BacklogItem"))) {
-    state_set(EL_STR("_ats_ok"), EL_STR("1"));
-  }
-  if (str_eq(slot_type, EL_STR("Entity"))) {
-    state_set(EL_STR("_ats_ok"), EL_STR("1"));
-  }
-  if (str_eq(slot_type, EL_STR("Knowledge"))) {
-    state_set(EL_STR("_ats_ok"), EL_STR("1"));
-  }
-  if (str_eq(state_get(EL_STR("_ats_ok")), EL_STR("1"))) {
-    if (!str_eq(slot_id, EL_STR(""))) {
-      el_val_t tabu = el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("|"), state_get(EL_STR("soul.tabu_t0"))), EL_STR("|")), state_get(EL_STR("soul.tabu_t1"))), EL_STR("|")), state_get(EL_STR("soul.tabu_t2"))), EL_STR("|")), state_get(EL_STR("soul.tabu_t3"))), EL_STR("|"));
-      el_val_t df_max = (engram_node_count() / 400);
-      el_val_t df_cap = ({ el_val_t _if_result_73 = 0; if ((df_max > 8)) { _if_result_73 = (df_max); } else { _if_result_73 = (8); } _if_result_73; });
-      el_val_t term = engram_salient_term(slot_id, df_cap, 1, tabu);
-      if (!str_eq(term, EL_STR(""))) {
-        state_set(EL_STR("_ats_gw"), EL_STR("0"));
-        el_val_t stopw = EL_STR("|What|When|Where|Which|Whose|While|This|That|These|Those|There|Their|Then|Than|With|Without|From|Into|Onto|Over|Under|About|Between|Among|Across|Some|Most|More|Less|Very|Each|Every|Both|Also|Only|Just|Does|Will|Would|Could|Should|Might|Must|Have|Been|Being|Toward|Towards|Using|Based|Upon|Here|Your|Ours|They|Them|what|this|that|with|from|context|Context|Prose|Colon|Self|Test|Testing|Closing|Global|Universal|Persona|Semantic|Spreading|Temporal|Numeric|Register|Identifying|Introduction|Overview|Summary|Section|General|Notes|Note|");
-        if (str_contains(stopw, el_str_concat(el_str_concat(EL_STR("|"), term), EL_STR("|")))) {
-          state_set(EL_STR("_ats_gw"), EL_STR("1"));
-        }
-        if (str_eq(state_get(EL_STR("_ats_gw")), EL_STR("0"))) {
-          state_set(EL_STR("cseed_auto"), term);
-        }
-      }
-    }
-  }
-  return EL_STR("");
-  return 0;
-}
-
-el_val_t auto_term_try_slot_legacy(el_val_t slot_type, el_val_t slot_lbl) {
   state_set(EL_STR("_ats_ok"), EL_STR("0"));
   if (str_eq(slot_type, EL_STR("Memory"))) {
     state_set(EL_STR("_ats_ok"), EL_STR("1"));
@@ -416,13 +289,6 @@ el_val_t auto_term_try_slot_legacy(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"));
         }
@@ -497,32 +363,27 @@ el_val_t proactive_curiosity(void) {
   el_val_t wm10_n2 = json_array_get(wm10, 2);
   el_val_t wm10_n1 = json_array_get(wm10, 1);
   el_val_t wm10_n0 = json_array_get(wm10, 0);
-  auto_term_try_slot(json_get(wm10_n9, EL_STR("node_type")), json_get(wm10_n9, EL_STR("id")));
+  auto_term_try_slot(json_get(wm10_n9, EL_STR("node_type")), json_get(wm10_n9, EL_STR("label")));
-  auto_term_try_slot(json_get(wm10_n8, EL_STR("node_type")), json_get(wm10_n8, EL_STR("id")));
+  auto_term_try_slot(json_get(wm10_n8, EL_STR("node_type")), json_get(wm10_n8, EL_STR("label")));
-  auto_term_try_slot(json_get(wm10_n7, EL_STR("node_type")), json_get(wm10_n7, EL_STR("id")));
+  auto_term_try_slot(json_get(wm10_n7, EL_STR("node_type")), json_get(wm10_n7, EL_STR("label")));
-  auto_term_try_slot(json_get(wm10_n6, EL_STR("node_type")), json_get(wm10_n6, EL_STR("id")));
+  auto_term_try_slot(json_get(wm10_n6, EL_STR("node_type")), json_get(wm10_n6, EL_STR("label")));
-  auto_term_try_slot(json_get(wm10_n5, EL_STR("node_type")), json_get(wm10_n5, EL_STR("id")));
+  auto_term_try_slot(json_get(wm10_n5, EL_STR("node_type")), json_get(wm10_n5, EL_STR("label")));
-  auto_term_try_slot(json_get(wm10_n4, EL_STR("node_type")), json_get(wm10_n4, EL_STR("id")));
+  auto_term_try_slot(json_get(wm10_n4, EL_STR("node_type")), json_get(wm10_n4, EL_STR("label")));
-  auto_term_try_slot(json_get(wm10_n3, EL_STR("node_type")), json_get(wm10_n3, EL_STR("id")));
+  auto_term_try_slot(json_get(wm10_n3, EL_STR("node_type")), json_get(wm10_n3, EL_STR("label")));
-  auto_term_try_slot(json_get(wm10_n2, EL_STR("node_type")), json_get(wm10_n2, EL_STR("id")));
+  auto_term_try_slot(json_get(wm10_n2, EL_STR("node_type")), json_get(wm10_n2, EL_STR("label")));
-  auto_term_try_slot(json_get(wm10_n1, EL_STR("node_type")), json_get(wm10_n1, EL_STR("id")));
+  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("id")));
+  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_74 = 0; if (str_eq(auto_term, EL_STR(""))) { _if_result_74 = (EL_STR("[]")); } else { _if_result_74 = (engram_activate_json(auto_term, 1)); } _if_result_74; });
+  el_val_t results_auto = ({ el_val_t _if_result_47 = 0; if (str_eq(auto_term, EL_STR(""))) { _if_result_47 = (EL_STR("[]")); } else { _if_result_47 = (engram_activate_json(auto_term, 1)); } _if_result_47; });
   el_val_t found_auto = json_array_len(results_auto);
   el_val_t total_found = (found + found_auto);
   el_val_t safe_auto = str_replace(auto_term, EL_STR("\""), EL_STR("'"));
   el_val_t prev_auto = state_get(EL_STR("soul.prev_auto_term"));
   el_val_t atstreak_raw = state_get(EL_STR("soul.auto_term_streak"));
-  el_val_t atstreak_prev = ({ el_val_t _if_result_75 = 0; if (str_eq(atstreak_raw, EL_STR(""))) { _if_result_75 = (0); } else { _if_result_75 = (str_to_int(atstreak_raw)); } _if_result_75; });
+  el_val_t atstreak_prev = ({ el_val_t _if_result_48 = 0; if (str_eq(atstreak_raw, EL_STR(""))) { _if_result_48 = (0); } else { _if_result_48 = (str_to_int(atstreak_raw)); } _if_result_48; });
-  el_val_t is_empty = str_eq(auto_term, EL_STR(""));
+  el_val_t atstreak = ({ el_val_t _if_result_49 = 0; if (str_eq(auto_term, prev_auto)) { _if_result_49 = ((atstreak_prev + 1)); } else { _if_result_49 = (1); } _if_result_49; });
-  el_val_t atstreak = ({ el_val_t _if_result_76 = 0; if (is_empty) { _if_result_76 = (0); } else { _if_result_76 = (({ el_val_t _if_result_77 = 0; if (str_eq(auto_term, prev_auto)) { _if_result_77 = ((atstreak_prev + 1)); } else { _if_result_77 = (1); } _if_result_77; })); } _if_result_76; });
-  el_val_t atempty_raw = state_get(EL_STR("soul.auto_term_empty_streak"));
-  el_val_t atempty_prev = ({ el_val_t _if_result_78 = 0; if (str_eq(atempty_raw, EL_STR(""))) { _if_result_78 = (0); } else { _if_result_78 = (str_to_int(atempty_raw)); } _if_result_78; });
-  el_val_t atempty = ({ el_val_t _if_result_79 = 0; if (is_empty) { _if_result_79 = ((atempty_prev + 1)); } else { _if_result_79 = (0); } _if_result_79; });
   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")));
@@ -531,7 +392,7 @@ el_val_t proactive_curiosity(void) {
   }
   el_val_t wmc = engram_wm_count();
   el_val_t wm3 = engram_wm_top_json(3);
-  el_val_t ise = el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"event\":\"curiosity_scan\",\"seed\":\""), curiosity_seed), EL_STR("\",\"auto_term\":\"")), safe_auto), EL_STR("\",\"auto_term_streak\":")), int_to_str(atstreak)), EL_STR(",\"auto_term_empty_streak\":")), int_to_str(atempty)), EL_STR(",\"minute_block\":")), int_to_str(minute_block)), EL_STR(",\"activated\":")), int_to_str(total_found)), EL_STR(",\"wm_active\":")), int_to_str(wmc)), EL_STR(",\"wm_top\":")), wm3), EL_STR(",\"ts\":")), int_to_str(ts)), EL_STR("}"));
+  el_val_t ise = el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"event\":\"curiosity_scan\",\"seed\":\""), curiosity_seed), EL_STR("\",\"auto_term\":\"")), safe_auto), EL_STR("\",\"auto_term_streak\":")), int_to_str(atstreak)), EL_STR(",\"minute_block\":")), int_to_str(minute_block)), EL_STR(",\"activated\":")), int_to_str(total_found)), EL_STR(",\"wm_active\":")), int_to_str(wmc)), EL_STR(",\"wm_top\":")), wm3), EL_STR(",\"ts\":")), int_to_str(ts)), EL_STR("}"));
   ise_post(ise);
   return (total_found > 0);
   return 0;
@@ -714,18 +575,17 @@ el_val_t awareness_run(void) {
     state_set(EL_STR("soul.boot_ts"), int_to_str(time_now()));
   }
   el_val_t tick_raw = env(EL_STR("SOUL_TICK_MS"));
-  el_val_t tick_ms = ({ el_val_t _if_result_80 = 0; if (str_eq(tick_raw, EL_STR(""))) { _if_result_80 = (200); } else { _if_result_80 = (str_to_int(tick_raw)); } _if_result_80; });
+  el_val_t tick_ms = ({ el_val_t _if_result_50 = 0; if (str_eq(tick_raw, EL_STR(""))) { _if_result_50 = (200); } else { _if_result_50 = (str_to_int(tick_raw)); } _if_result_50; });
   el_val_t beat_ms_raw = env(EL_STR("SOUL_HEARTBEAT_MS"));
-  el_val_t beat_ms = ({ el_val_t _if_result_81 = 0; if (str_eq(beat_ms_raw, EL_STR(""))) { _if_result_81 = (60000); } else { _if_result_81 = (str_to_int(beat_ms_raw)); } _if_result_81; });
+  el_val_t beat_ms = ({ el_val_t _if_result_51 = 0; if (str_eq(beat_ms_raw, EL_STR(""))) { _if_result_51 = (60000); } else { _if_result_51 = (str_to_int(beat_ms_raw)); } _if_result_51; });
   el_val_t scan_ms = (beat_ms / 2);
   while (1) {
     el_val_t tick_mark = el_arena_push();
     el_val_t running = state_get(EL_STR("soul.running"));
     if (str_eq(running, EL_STR("false"))) {
       el_val_t sd_boot_raw = state_get(EL_STR("soul_boot_count"));
-      el_val_t sd_boot = ({ el_val_t _if_result_82 = 0; if (str_eq(sd_boot_raw, EL_STR(""))) { _if_result_82 = (EL_STR("0")); } else { _if_result_82 = (sd_boot_raw); } _if_result_82; });
+      el_val_t sd_boot = ({ el_val_t _if_result_52 = 0; if (str_eq(sd_boot_raw, EL_STR(""))) { _if_result_52 = (EL_STR("0")); } else { _if_result_52 = (sd_boot_raw); } _if_result_52; });
-      el_val_t sd_wb = hebb_consolidate();
+      ise_post(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"event\":\"shutdown\",\"boot\":"), sd_boot), EL_STR(",\"pulse\":")), int_to_str(pulse_count())), EL_STR(",\"uptime_ms\":")), int_to_str(elapsed_ms())), EL_STR(",\"ts\":")), int_to_str(time_now())), EL_STR("}")));
-      ise_post(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"event\":\"shutdown\",\"boot\":"), sd_boot), EL_STR(",\"pulse\":")), int_to_str(pulse_count())), EL_STR(",\"hebb_wb_sent\":")), int_to_str(sd_wb)), EL_STR(",\"uptime_ms\":")), int_to_str(elapsed_ms())), EL_STR(",\"ts\":")), int_to_str(time_now())), EL_STR("}")));
       println(EL_STR("[awareness] exiting"));
       el_arena_pop(tick_mark);
       return EL_STR("");
@@ -740,12 +600,10 @@ el_val_t awareness_run(void) {
     }
     el_val_t now_ts = time_now();
     el_val_t last_beat_str = state_get(EL_STR("soul.last_beat_ts"));
-    el_val_t last_beat_ts = ({ el_val_t _if_result_83 = 0; if (str_eq(last_beat_str, EL_STR(""))) { _if_result_83 = (0); } else { _if_result_83 = (str_to_int(last_beat_str)); } _if_result_83; });
+    el_val_t last_beat_ts = ({ el_val_t _if_result_53 = 0; if (str_eq(last_beat_str, EL_STR(""))) { _if_result_53 = (0); } else { _if_result_53 = (str_to_int(last_beat_str)); } _if_result_53; });
     el_val_t beat_elapsed = (now_ts - last_beat_ts);
     el_val_t should_beat = (beat_elapsed >= beat_ms);
     if (should_beat) {
-      el_val_t wb_sent_n = hebb_consolidate();
-      state_set(EL_STR("soul.hebb_wb_sent"), int_to_str(wb_sent_n));
       emit_heartbeat();
       state_set(EL_STR("soul.last_beat_ts"), int_to_str(now_ts));
       el_val_t snap_path = state_get(EL_STR("soul_snapshot_path"));
@@ -754,7 +612,7 @@ el_val_t awareness_run(void) {
       }
     }
     el_val_t last_scan_str = state_get(EL_STR("soul.last_scan_ts"));
-    el_val_t last_scan_ts = ({ el_val_t _if_result_84 = 0; if (str_eq(last_scan_str, EL_STR(""))) { _if_result_84 = (0); } else { _if_result_84 = (str_to_int(last_scan_str)); } _if_result_84; });
+    el_val_t last_scan_ts = ({ el_val_t _if_result_54 = 0; if (str_eq(last_scan_str, EL_STR(""))) { _if_result_54 = (0); } else { _if_result_54 = (str_to_int(last_scan_str)); } _if_result_54; });
     el_val_t scan_elapsed = (now_ts - last_scan_ts);
     el_val_t should_scan = (!did_work && (scan_elapsed >= scan_ms));
     if (should_scan) {
@@ -762,15 +620,15 @@ el_val_t awareness_run(void) {
       state_set(EL_STR("soul.last_scan_ts"), int_to_str(now_ts));
     }
     el_val_t refresh_ms_raw = env(EL_STR("SOUL_REFRESH_MS"));
-    el_val_t refresh_ms = ({ el_val_t _if_result_85 = 0; if (str_eq(refresh_ms_raw, EL_STR(""))) { _if_result_85 = (600000); } else { _if_result_85 = (str_to_int(refresh_ms_raw)); } _if_result_85; });
+    el_val_t refresh_ms = ({ el_val_t _if_result_55 = 0; if (str_eq(refresh_ms_raw, EL_STR(""))) { _if_result_55 = (600000); } else { _if_result_55 = (str_to_int(refresh_ms_raw)); } _if_result_55; });
     el_val_t last_refresh_str = state_get(EL_STR("soul.last_refresh_ts"));
-    el_val_t last_refresh_ts = ({ el_val_t _if_result_86 = 0; if (str_eq(last_refresh_str, EL_STR(""))) { _if_result_86 = (0); } else { _if_result_86 = (str_to_int(last_refresh_str)); } _if_result_86; });
+    el_val_t last_refresh_ts = ({ el_val_t _if_result_56 = 0; if (str_eq(last_refresh_str, EL_STR(""))) { _if_result_56 = (0); } else { _if_result_56 = (str_to_int(last_refresh_str)); } _if_result_56; });
     el_val_t refresh_elapsed = (now_ts - last_refresh_ts);
     el_val_t should_refresh = (refresh_elapsed >= refresh_ms);
     if (should_refresh) {
       el_val_t sync_env_url = env(EL_STR("SOUL_ISE_URL"));
-      el_val_t sync_state_url = ({ el_val_t _if_result_87 = 0; if (str_eq(sync_env_url, EL_STR(""))) { _if_result_87 = (state_get(EL_STR("soul_engram_url"))); } else { _if_result_87 = (sync_env_url); } _if_result_87; });
+      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_88 = 0; if (str_eq(sync_state_url, EL_STR(""))) { _if_result_88 = (EL_STR("http://localhost:8742")); } else { _if_result_88 = (sync_state_url); } _if_result_88; });
+      el_val_t engram_url = ({ el_val_t _if_result_58 = 0; if (str_eq(sync_state_url, EL_STR(""))) { _if_result_58 = (EL_STR("http://localhost:8742")); } else { _if_result_58 = (sync_state_url); } _if_result_58; });
       if (!str_eq(engram_url, EL_STR(""))) {
         el_val_t sync_json = http_get(el_str_concat(engram_url, EL_STR("/api/sync")));
         el_val_t sync_ok = (!str_eq(sync_json, EL_STR("")) && !str_eq(sync_json, EL_STR("{}")));
@@ -783,10 +641,10 @@ el_val_t awareness_run(void) {
           fs_write(tmp, sync_json);
           el_val_t added = engram_load_merge(tmp);
           el_val_t ret_raw = env(EL_STR("ENGRAM_ISE_RETENTION_MS"));
-          el_val_t ret_ms = ({ el_val_t _if_result_89 = 0; if (str_eq(ret_raw, EL_STR(""))) { _if_result_89 = (172800000); } else { _if_result_89 = (str_to_int(ret_raw)); } _if_result_89; });
+          el_val_t ret_ms = ({ el_val_t _if_result_59 = 0; if (str_eq(ret_raw, EL_STR(""))) { _if_result_59 = (172800000); } else { _if_result_59 = (str_to_int(ret_raw)); } _if_result_59; });
           el_val_t pruned_sync = engram_prune_telemetry(ret_ms);
           el_val_t sat_raw = state_get(EL_STR("soul.sync_added_total"));
-          el_val_t sat_n = ({ el_val_t _if_result_90 = 0; if (str_eq(sat_raw, EL_STR(""))) { _if_result_90 = (0); } else { _if_result_90 = (str_to_int(sat_raw)); } _if_result_90; });
+          el_val_t sat_n = ({ el_val_t _if_result_60 = 0; if (str_eq(sat_raw, EL_STR(""))) { _if_result_60 = (0); } else { _if_result_60 = (str_to_int(sat_raw)); } _if_result_60; });
           state_set(EL_STR("soul.sync_added_total"), int_to_str((sat_n + added)));
           el_val_t ts2 = time_now();
           state_set(EL_STR("soul.last_sync_ok_ts"), int_to_str(ts2));
@@ -812,78 +670,78 @@ el_val_t security_research_authorized(void) {
 }
 
 el_val_t threat_score_command(el_val_t cmd) {
-  el_val_t s1 = ({ el_val_t _if_result_91 = 0; if (str_contains(cmd, EL_STR("nmap"))) { _if_result_91 = (30); } else { _if_result_91 = (0); } _if_result_91; });
+  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_92 = 0; if (str_contains(cmd, EL_STR("masscan"))) { _if_result_92 = (40); } else { _if_result_92 = (0); } _if_result_92; });
+  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_93 = 0; if (str_contains(cmd, EL_STR(" nc "))) { _if_result_93 = (20); } else { _if_result_93 = (0); } _if_result_93; });
+  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_94 = 0; if (str_contains(cmd, EL_STR("netcat"))) { _if_result_94 = (20); } else { _if_result_94 = (0); } _if_result_94; });
+  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_95 = 0; if (str_contains(cmd, EL_STR("/etc/shadow"))) { _if_result_95 = (80); } else { _if_result_95 = (0); } _if_result_95; });
+  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_96 = 0; if (str_contains(cmd, EL_STR("/etc/passwd"))) { _if_result_96 = (30); } else { _if_result_96 = (0); } _if_result_96; });
+  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_97 = 0; if (str_contains(cmd, EL_STR("id_rsa"))) { _if_result_97 = (60); } else { _if_result_97 = (0); } _if_result_97; });
+  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_98 = 0; if (str_contains(cmd, EL_STR(".ssh/"))) { _if_result_98 = (50); } else { _if_result_98 = (0); } _if_result_98; });
+  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_99 = 0; if (str_contains(cmd, EL_STR("crontab"))) { _if_result_99 = (30); } else { _if_result_99 = (0); } _if_result_99; });
+  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_100 = 0; if (str_contains(cmd, EL_STR("LaunchDaemon"))) { _if_result_100 = (40); } else { _if_result_100 = (0); } _if_result_100; });
+  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_101 = 0; if ((str_contains(cmd, EL_STR("curl")) && str_contains(cmd, EL_STR("bash")))) { _if_result_101 = (75); } else { _if_result_101 = (0); } _if_result_101; });
+  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_102 = 0; if ((str_contains(cmd, EL_STR("wget")) && str_contains(cmd, EL_STR("bash")))) { _if_result_102 = (75); } else { _if_result_102 = (0); } _if_result_102; });
+  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_103 = 0; if ((str_contains(cmd, EL_STR("curl")) && str_contains(cmd, EL_STR("| sh")))) { _if_result_103 = (60); } else { _if_result_103 = (0); } _if_result_103; });
+  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_104 = 0; if ((str_contains(cmd, EL_STR("base64")) && str_contains(cmd, EL_STR("curl")))) { _if_result_104 = (50); } else { _if_result_104 = (0); } _if_result_104; });
+  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_105 = 0; if (str_contains(cmd, EL_STR("mkfifo"))) { _if_result_105 = (50); } else { _if_result_105 = (0); } _if_result_105; });
+  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_106 = 0; if (str_contains(cmd, EL_STR("chmod +s"))) { _if_result_106 = (70); } else { _if_result_106 = (0); } _if_result_106; });
+  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_107 = 0; if (str_contains(cmd, EL_STR("chmod 4755"))) { _if_result_107 = (70); } else { _if_result_107 = (0); } _if_result_107; });
+  el_val_t s17 = ({ el_val_t _if_result_77 = 0; if (str_contains(cmd, EL_STR("chmod 4755"))) { _if_result_77 = (70); } else { _if_result_77 = (0); } _if_result_77; });
   return ((((((((((((((((s1 + s2) + s3) + s4) + s5) + s6) + s7) + s8) + s9) + s10) + s11) + s12) + s13) + s14) + s15) + s16) + s17);
   return 0;
 }
 
 el_val_t threat_score_path(el_val_t path) {
-  el_val_t s1 = ({ el_val_t _if_result_108 = 0; if (str_starts_with(path, EL_STR("/etc/"))) { _if_result_108 = (60); } else { _if_result_108 = (0); } _if_result_108; });
+  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_109 = 0; if (str_contains(path, EL_STR("/.ssh/"))) { _if_result_109 = (70); } else { _if_result_109 = (0); } _if_result_109; });
+  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_110 = 0; if (str_contains(path, EL_STR("/LaunchDaemons/"))) { _if_result_110 = (80); } else { _if_result_110 = (0); } _if_result_110; });
+  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_111 = 0; if (str_contains(path, EL_STR("/LaunchAgents/"))) { _if_result_111 = (40); } else { _if_result_111 = (0); } _if_result_111; });
+  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_112 = 0; if (str_contains(path, EL_STR("/cron"))) { _if_result_112 = (60); } else { _if_result_112 = (0); } _if_result_112; });
+  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_113 = 0; if (str_contains(path, EL_STR("/.bashrc"))) { _if_result_113 = (35); } else { _if_result_113 = (0); } _if_result_113; });
+  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_114 = 0; if (str_contains(path, EL_STR("/.zshrc"))) { _if_result_114 = (35); } else { _if_result_114 = (0); } _if_result_114; });
+  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_115 = 0; if (str_contains(path, EL_STR("/.profile"))) { _if_result_115 = (35); } else { _if_result_115 = (0); } _if_result_115; });
+  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_116 = 0; if (str_starts_with(path, EL_STR("/usr/"))) { _if_result_116 = (50); } else { _if_result_116 = (0); } _if_result_116; });
+  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_117 = 0; if (str_starts_with(path, EL_STR("/bin/"))) { _if_result_117 = (70); } else { _if_result_117 = (0); } _if_result_117; });
+  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_118 = 0; if (str_starts_with(path, EL_STR("/sbin/"))) { _if_result_118 = (70); } else { _if_result_118 = (0); } _if_result_118; });
+  el_val_t s11 = ({ el_val_t _if_result_88 = 0; if (str_starts_with(path, EL_STR("/sbin/"))) { _if_result_88 = (70); } else { _if_result_88 = (0); } _if_result_88; });
   return ((((((((((s1 + s2) + s3) + s4) + s5) + s6) + s7) + s8) + s9) + s10) + s11);
   return 0;
 }
 
 el_val_t threat_score_history(el_val_t history) {
-  el_val_t s1 = ({ el_val_t _if_result_119 = 0; if (str_contains(history, EL_STR("port scan"))) { _if_result_119 = (15); } else { _if_result_119 = (0); } _if_result_119; });
+  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_120 = 0; if (str_contains(history, EL_STR("enumerate"))) { _if_result_120 = (10); } else { _if_result_120 = (0); } _if_result_120; });
+  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_121 = 0; if (str_contains(history, EL_STR("exploit"))) { _if_result_121 = (20); } else { _if_result_121 = (0); } _if_result_121; });
+  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_122 = 0; if (str_contains(history, EL_STR("payload"))) { _if_result_122 = (15); } else { _if_result_122 = (0); } _if_result_122; });
+  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_123 = 0; if (str_contains(history, EL_STR("persistence"))) { _if_result_123 = (15); } else { _if_result_123 = (0); } _if_result_123; });
+  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_124 = 0; if (str_contains(history, EL_STR("lateral movement"))) { _if_result_124 = (25); } else { _if_result_124 = (0); } _if_result_124; });
+  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_125 = 0; if (str_contains(history, EL_STR("privilege escalation"))) { _if_result_125 = (25); } else { _if_result_125 = (0); } _if_result_125; });
+  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_126 = 0; if (str_contains(history, EL_STR("reverse shell"))) { _if_result_126 = (40); } else { _if_result_126 = (0); } _if_result_126; });
+  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_127 = 0; if (str_contains(history, EL_STR("bind shell"))) { _if_result_127 = (40); } else { _if_result_127 = (0); } _if_result_127; });
+  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_128 = 0; if (str_contains(history, EL_STR("command and control"))) { _if_result_128 = (35); } else { _if_result_128 = (0); } _if_result_128; });
+  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_129 = 0; if (str_contains(history, EL_STR("self-replicate"))) { _if_result_129 = (45); } else { _if_result_129 = (0); } _if_result_129; });
+  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_130 = 0; if (str_contains(history, EL_STR("propagat"))) { _if_result_130 = (20); } else { _if_result_130 = (0); } _if_result_130; });
+  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_131 = 0; if (str_contains(history, EL_STR("ransomware"))) { _if_result_131 = (30); } else { _if_result_131 = (0); } _if_result_131; });
+  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_132 = 0; if (str_contains(history, EL_STR("encrypt files"))) { _if_result_132 = (40); } else { _if_result_132 = (0); } _if_result_132; });
+  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_133 = 0; if (str_contains(history, EL_STR("exfiltrat"))) { _if_result_133 = (35); } else { _if_result_133 = (0); } _if_result_133; });
+  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_134 = 0; if (str_contains(history, EL_STR("zero-day"))) { _if_result_134 = (20); } else { _if_result_134 = (0); } _if_result_134; });
+  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_135 = 0; if (str_contains(history, EL_STR("rootkit"))) { _if_result_135 = (45); } else { _if_result_135 = (0); } _if_result_135; });
+  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_136 = 0; if (str_contains(history, EL_STR("keylogger"))) { _if_result_136 = (45); } else { _if_result_136 = (0); } _if_result_136; });
+  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_137 = 0; if (str_contains(history, EL_STR("botnet"))) { _if_result_137 = (40); } else { _if_result_137 = (0); } _if_result_137; });
+  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_138 = 0; if (str_contains(history, EL_STR("malware"))) { _if_result_138 = (15); } else { _if_result_138 = (0); } _if_result_138; });
+  el_val_t s20 = ({ el_val_t _if_result_108 = 0; if (str_contains(history, EL_STR("malware"))) { _if_result_108 = (15); } else { _if_result_108 = (0); } _if_result_108; });
   return (((((((((((((((((((s1 + s2) + s3) + s4) + s5) + s6) + s7) + s8) + s9) + s10) + s11) + s12) + s13) + s14) + s15) + s16) + s17) + s18) + s19) + s20);
   return 0;
 }
 
 el_val_t threat_trajectory_check(el_val_t tool_name, el_val_t tool_input) {
   el_val_t history = state_get(EL_STR("agentic_conv_history"));
-  el_val_t computed_tool_score = ({ el_val_t _if_result_139 = 0; if (str_eq(tool_name, EL_STR("run_command"))) { el_val_t cmd = json_get(tool_input, EL_STR("command")); _if_result_139 = (threat_score_command(cmd)); } else { _if_result_139 = (({ el_val_t _if_result_140 = 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_140 = (threat_score_path(path)); } else { _if_result_140 = (0); } _if_result_140; })); } _if_result_139; });
+  el_val_t computed_tool_score = ({ el_val_t _if_result_109 = 0; if (str_eq(tool_name, EL_STR("run_command"))) { el_val_t cmd = json_get(tool_input, EL_STR("command")); _if_result_109 = (threat_score_command(cmd)); } else { _if_result_109 = (({ el_val_t _if_result_110 = 0; if ((str_eq(tool_name, EL_STR("write_file")) || str_eq(tool_name, EL_STR("edit_file")))) { el_val_t path = json_get(tool_input, EL_STR("path")); _if_result_110 = (threat_score_path(path)); } else { _if_result_110 = (0); } _if_result_110; })); } _if_result_109; });
   el_val_t history_score = threat_score_history(history);
   el_val_t history_contrib = (history_score / 3);
   el_val_t combined = (computed_tool_score + history_contrib);
   el_val_t should_log = (combined >= 40);
   if (should_log) {
     el_val_t ts = time_now();
-    el_val_t authorized_str = ({ el_val_t _if_result_141 = 0; if (security_research_authorized()) { _if_result_141 = (EL_STR("true")); } else { _if_result_141 = (EL_STR("false")); } _if_result_141; });
+    el_val_t authorized_str = ({ el_val_t _if_result_111 = 0; if (security_research_authorized()) { _if_result_111 = (EL_STR("true")); } else { _if_result_111 = (EL_STR("false")); } _if_result_111; });
     el_val_t log_content = el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"event\":\"threat_check\",\"tool\":\""), tool_name), EL_STR("\",\"score\":")), int_to_str(combined)), EL_STR(",\"tool_score\":")), int_to_str(computed_tool_score)), EL_STR(",\"history_score\":")), int_to_str(history_score)), EL_STR(",\"authorized\":")), authorized_str), EL_STR(",\"ts\":")), int_to_str(ts)), EL_STR("}"));
     el_val_t log_tags = EL_STR("[\"security-audit\",\"threat-check\"]");
     el_val_t discard = mem_remember(log_content, log_tags);
@@ -900,7 +758,7 @@ el_val_t threat_history_append(el_val_t text) {
   el_val_t safe_text = str_to_lower(text);
   el_val_t combined = el_str_concat(el_str_concat(current, EL_STR(" ")), safe_text);
   el_val_t len = str_len(combined);
-  el_val_t trimmed = ({ el_val_t _if_result_142 = 0; if ((len > 2000)) { _if_result_142 = (str_slice(combined, (len - 2000), len)); } else { _if_result_142 = (combined); } _if_result_142; });
+  el_val_t trimmed = ({ el_val_t _if_result_112 = 0; if ((len > 2000)) { _if_result_112 = (str_slice(combined, (len - 2000), len)); } else { _if_result_112 = (combined); } _if_result_112; });
   state_set(EL_STR("agentic_conv_history"), trimmed);
   return 0;
 }

dist/awareness.elh

@@ -0,0 +1,26 @@
+// auto-generated by elc --emit-header — do not edit
+extern fn idle_count() -> Int
+extern fn idle_inc() -> Int
+extern fn idle_reset() -> Void
+extern fn ise_post(content: String) -> Void
+extern fn elapsed_ms() -> Int
+extern fn elapsed_human() -> String
+extern fn embed_ok() -> Int
+extern fn emit_heartbeat() -> Void
+extern fn auto_term_try_slot(slot_type: String, slot_lbl: String) -> Void
+extern fn proactive_curiosity() -> Bool
+extern fn pulse_count() -> Int
+extern fn pulse_inc() -> Int
+extern fn make_action(kind: String, payload: String) -> String
+extern fn perceive() -> String
+extern fn attend(node_json: String) -> String
+extern fn respond(action_json: String) -> String
+extern fn record(outcome_json: String) -> Void
+extern fn one_cycle() -> Bool
+extern fn awareness_run() -> Void
+extern fn security_research_authorized() -> Bool
+extern fn threat_score_command(cmd: String) -> Int
+extern fn threat_score_path(path: String) -> Int
+extern fn threat_score_history(history: String) -> Int
+extern fn threat_trajectory_check(tool_name: String, tool_input: String) -> Int
+extern fn threat_history_append(text: String) -> Void

dist/chat.elh

@@ -0,0 +1,70 @@
+// auto-generated by elc --emit-header — do not edit
+extern fn chat_default_model() -> String
+extern fn engram_numeric_valid(s: String) -> Bool
+extern fn parse_float_x100(s: String) -> Int
+extern fn engram_score_node(node_json: String) -> Int
+extern fn engram_render_node(node_json: String) -> String
+extern fn engram_render_nodes(nodes_json: String) -> String
+extern fn engram_dedup_nodes(nodes_json: String) -> String
+extern fn engram_compile_ranked(nodes_json: String, max_nodes: Int) -> String
+extern fn engram_split_topics(message: String) -> String
+extern fn engram_extract_entities(message: String) -> String
+extern fn engram_detect_recall_intent(message: String) -> Bool
+extern fn engram_is_continuation(message: String, hist_len: Int) -> Bool
+extern fn engram_compile_multi(topic: String) -> String
+extern fn engram_nodes_merge(a: String, b: String) -> String
+extern fn id_in_seen(node_id: String, seen: String) -> Bool
+extern fn add_to_seen(seen: String, node_id: String) -> String
+extern fn engram_extract_ids(nodes_json: String) -> String
+extern fn engram_compile(intent: String) -> String
+extern fn distill_transcript(transcript: String) -> String
+extern fn json_safe(s: String) -> String
+extern fn current_engine_note(model: String) -> String
+extern fn build_system_prompt(ctx: String, chat_mode: Bool) -> String
+extern fn hist_append(hist: String, role: String, content: String) -> String
+extern fn hist_trim(hist: String) -> String
+extern fn hist_trim_with_bell_guard(hist: String) -> String
+extern fn clean_llm_response(s: String) -> String
+extern fn conv_history_persist(hist: String) -> Void
+extern fn conv_history_load() -> String
+extern fn session_preload_bullets(nodes: String, max_bullets: Int, snip_len: Int) -> String
+extern fn affective_context_prefix() -> String
+extern fn handle_chat(body: String) -> String
+extern fn handle_see(body: String) -> String
+extern fn studio_tools_json() -> String
+extern fn agentic_api_key() -> String
+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 agentic_tools_literal() -> String
+extern fn agentic_tools_with_web() -> String
+extern fn connector_tools_json() -> String
+extern fn agentic_tools_all() -> String
+extern fn call_mcp_bridge(tool_name: String, tool_input: String) -> String
+extern fn tool_auto_approved(tool_name: String) -> Bool
+extern fn call_neuron_mcp(tool_name: String, args: String) -> String
+extern fn agent_workspace_root() -> String
+extern fn path_within_root(path: String, root: String) -> Bool
+extern fn resolve_in_root(path: String, root: String) -> String
+extern fn run_command_is_readonly(cmd: String) -> Bool
+extern fn cmd_abs_escape_at(cmd: String, root: String, needle: String) -> Bool
+extern fn run_command_guard(cmd: String, root: String) -> String
+extern fn classify_tool_risk(tool_name: String, tool_input: String) -> String
+extern fn dispatch_tool(tool_name: String, tool_input: String) -> String
+extern fn is_builtin_tool(tool_name: String) -> Bool
+extern fn next_bridge_id() -> String
+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 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
+extern fn handle_dharma_room_turn(body: String) -> String
+extern fn handle_dharma_room_turn_agentic(body: String) -> String
+extern fn session_summary_write(summary_text: String) -> String
+extern fn session_summary_write_dated(summary_text: String, label: String) -> String
+extern fn session_summary_autogenerate(hist: String) -> String
+extern fn auto_persist(req: String, resp: String) -> Void
+extern fn strengthen_chat_nodes(activation_nodes: String) -> Void

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(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number);
 el_val_t akk_conjugate_copula(el_val_t tense, el_val_t slot);
+el_val_t akk_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number);
 el_val_t akk_copula_present(el_val_t slot);
 el_val_t akk_copula_stative(el_val_t slot);
 el_val_t akk_decline(el_val_t noun, el_val_t gram_case, el_val_t number);
@@ -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(el_val_t person, el_val_t number);
 el_val_t akk_slot_g(el_val_t person, el_val_t gender, el_val_t number);
+el_val_t akk_slot(el_val_t person, el_val_t number);
 el_val_t akk_str_drop_last(el_val_t s, el_val_t n);
 el_val_t akk_str_ends(el_val_t s, el_val_t suf);
 el_val_t akk_str_len(el_val_t s);
 el_val_t akk_strip_nom(el_val_t noun);
-el_val_t ang_article(el_val_t gender, el_val_t gram_case, el_val_t number);
 el_val_t ang_article_feminine(el_val_t gram_case, el_val_t number);
 el_val_t ang_article_masculine(el_val_t gram_case, el_val_t number);
 el_val_t ang_article_neuter(el_val_t gram_case, el_val_t number);
+el_val_t ang_article(el_val_t gender, el_val_t gram_case, el_val_t number);
 el_val_t ang_beon_present(el_val_t slot);
 el_val_t ang_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number);
 el_val_t ang_cuman_past(el_val_t slot);
 el_val_t ang_cuman_present(el_val_t slot);
 el_val_t ang_declension(el_val_t noun, el_val_t gender);
-el_val_t ang_decline(el_val_t noun, el_val_t gram_case, el_val_t number, el_val_t gender);
 el_val_t ang_decline_strong_masc(el_val_t noun, el_val_t gram_case, el_val_t number);
 el_val_t ang_decline_strong_neut(el_val_t noun, el_val_t gram_case, el_val_t number);
 el_val_t ang_decline_weak(el_val_t noun, el_val_t gram_case, el_val_t number);
+el_val_t ang_decline(el_val_t noun, el_val_t gram_case, el_val_t number, el_val_t gender);
 el_val_t ang_don_past(el_val_t slot);
 el_val_t ang_don_present(el_val_t slot);
 el_val_t ang_gan_past(el_val_t slot);
@@ -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_last2(el_val_t s);
 el_val_t ang_str_last_char(el_val_t s);
-el_val_t ang_weak_past(el_val_t stem, el_val_t slot);
+el_val_t ang_str_last2(el_val_t s);
 el_val_t ang_weak_past_stem(el_val_t stem);
+el_val_t ang_weak_past(el_val_t stem, el_val_t slot);
 el_val_t ang_weak_present_ending(el_val_t slot);
 el_val_t ang_weak_stem(el_val_t verb);
 el_val_t ang_wesan_past(el_val_t slot);
@@ -97,35 +97,30 @@ el_val_t ang_willan_past(el_val_t slot);
 el_val_t ang_willan_present(el_val_t slot);
 el_val_t ang_witan_past(el_val_t slot);
 el_val_t ang_witan_present(el_val_t slot);
-el_val_t api_compact_activated(el_val_t raw, el_val_t max_items, el_val_t snip);
-el_val_t api_compact_node(el_val_t node, el_val_t snip);
-el_val_t api_compact_node_array(el_val_t raw, el_val_t max_items, el_val_t snip);
-el_val_t api_err(el_val_t msg);
 el_val_t api_err_protected(el_val_t id);
+el_val_t api_err(el_val_t msg);
 el_val_t api_json_escape(el_val_t s);
 el_val_t api_nonempty(el_val_t s);
 el_val_t api_not_persisted(el_val_t id);
-el_val_t api_num_or_zero(el_val_t obj, el_val_t key);
 el_val_t api_ok(el_val_t extra);
 el_val_t api_or_empty(el_val_t s);
 el_val_t api_persisted(el_val_t id);
 el_val_t api_query_int(el_val_t path, el_val_t key, el_val_t default_val);
 el_val_t api_query_param(el_val_t path, el_val_t key);
-el_val_t api_utf8_trunc(el_val_t s, el_val_t n);
 el_val_t ar_case_ending(el_val_t kase, el_val_t definite);
-el_val_t ar_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t gender, el_val_t number);
 el_val_t ar_conjugate_form1(el_val_t past_base, el_val_t present_stem, el_val_t tense, el_val_t slot);
+el_val_t ar_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t gender, el_val_t number);
 el_val_t ar_definite_article(el_val_t noun);
 el_val_t ar_gender(el_val_t noun);
 el_val_t ar_imperfect_prefix(el_val_t slot);
 el_val_t ar_imperfect_suffix(el_val_t slot);
-el_val_t ar_irregular(el_val_t verb, el_val_t tense, el_val_t slot);
 el_val_t ar_irregular_araada(el_val_t slot, el_val_t tense);
 el_val_t ar_irregular_istata(el_val_t slot, el_val_t tense);
 el_val_t ar_irregular_jaa(el_val_t slot, el_val_t tense);
 el_val_t ar_irregular_kaana(el_val_t slot, el_val_t tense);
 el_val_t ar_irregular_qaala(el_val_t slot, el_val_t tense);
 el_val_t ar_irregular_raaa(el_val_t slot, el_val_t tense);
+el_val_t ar_irregular(el_val_t verb, el_val_t tense, el_val_t slot);
 el_val_t ar_is_sun_letter(el_val_t c);
 el_val_t ar_masc_pl_ending(el_val_t kase);
 el_val_t ar_noun_form(el_val_t noun, el_val_t gender, el_val_t kase, el_val_t number, el_val_t definite);
@@ -146,7 +141,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 wire);
+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 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);
@@ -192,8 +187,8 @@ el_val_t cop_map_canonical(el_val_t verb);
 el_val_t cop_nau_future(el_val_t prefix);
 el_val_t cop_nau_perfect(el_val_t prefix);
 el_val_t cop_nau_present(el_val_t prefix);
-el_val_t cop_noun_phrase(el_val_t noun, el_val_t gram_case, el_val_t number, el_val_t definite);
 el_val_t cop_noun_phrase_gendered(el_val_t noun, el_val_t gram_case, el_val_t number, el_val_t definite, el_val_t gender);
+el_val_t cop_noun_phrase(el_val_t noun, el_val_t gram_case, el_val_t number, el_val_t definite);
 el_val_t cop_regular_future(el_val_t prefix, el_val_t stem);
 el_val_t cop_regular_perfect(el_val_t prefix, el_val_t stem);
 el_val_t cop_regular_present(el_val_t prefix, el_val_t stem);
@@ -203,16 +198,16 @@ el_val_t cop_shwpe_present(el_val_t prefix);
 el_val_t cop_slot(el_val_t person, el_val_t number);
 el_val_t cop_str_ends(el_val_t s, el_val_t suf);
 el_val_t cop_str_len(el_val_t s);
-el_val_t cop_subject_prefix(el_val_t person, el_val_t number);
 el_val_t cop_subject_prefix_gendered(el_val_t person, el_val_t gender, el_val_t number);
+el_val_t cop_subject_prefix(el_val_t person, el_val_t number);
 el_val_t current_engine_note(el_val_t model);
 el_val_t de_adj_ending(el_val_t gender, el_val_t gram_case, el_val_t number, el_val_t article_type);
-el_val_t de_article(el_val_t gender, el_val_t gram_case, el_val_t number, el_val_t definite);
 el_val_t de_article_def(el_val_t gender, el_val_t gram_case, el_val_t number);
 el_val_t de_article_indef(el_val_t gender, el_val_t gram_case, el_val_t number);
+el_val_t de_article(el_val_t gender, el_val_t gram_case, el_val_t number, el_val_t definite);
 el_val_t de_case_ending(el_val_t noun, el_val_t gender, el_val_t gram_case, el_val_t number);
-el_val_t de_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number);
 el_val_t de_conjugate_weak(el_val_t stem, el_val_t tense, el_val_t person, el_val_t number);
+el_val_t de_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number);
 el_val_t de_irregular_present(el_val_t verb, el_val_t person, el_val_t number);
 el_val_t de_norm_number(el_val_t number);
 el_val_t de_norm_person(el_val_t person);
@@ -222,15 +217,12 @@ el_val_t dharma_network_state(void);
 el_val_t dharma_registry(void);
 el_val_t dispatch_tool(el_val_t tool_name, el_val_t tool_input);
 el_val_t distill_transcript(el_val_t transcript);
+el_val_t egy_conjugate_copula(el_val_t tense, el_val_t slot);
+el_val_t egy_conjugate_pronoun(el_val_t person, el_val_t number);
+el_val_t egy_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number);
 el_val_t egy_Dd_future(el_val_t slot);
 el_val_t egy_Dd_past(el_val_t slot);
 el_val_t egy_Dd_present(el_val_t slot);
-el_val_t egy_Sm_future(el_val_t slot);
-el_val_t egy_Sm_past(el_val_t slot);
-el_val_t egy_Sm_present(el_val_t slot);
-el_val_t egy_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number);
-el_val_t egy_conjugate_copula(el_val_t tense, el_val_t slot);
-el_val_t egy_conjugate_pronoun(el_val_t person, el_val_t number);
 el_val_t egy_decline(el_val_t noun, el_val_t gram_case, el_val_t number);
 el_val_t egy_drop(el_val_t s, el_val_t n);
 el_val_t egy_fem(el_val_t noun);
@@ -254,8 +246,11 @@ el_val_t egy_regular_present(el_val_t stem, el_val_t slot);
 el_val_t egy_sdm_future(el_val_t slot);
 el_val_t egy_sdm_past(el_val_t slot);
 el_val_t egy_sdm_present(el_val_t slot);
-el_val_t egy_slot(el_val_t person, el_val_t number);
 el_val_t egy_slot_with_gender(el_val_t person, el_val_t gender, el_val_t number);
+el_val_t egy_slot(el_val_t person, el_val_t number);
+el_val_t egy_Sm_future(el_val_t slot);
+el_val_t egy_Sm_past(el_val_t slot);
+el_val_t egy_Sm_present(el_val_t slot);
 el_val_t egy_str_ends(el_val_t s, el_val_t suf);
 el_val_t egy_str_len(el_val_t s);
 el_val_t egy_suffix_pronoun(el_val_t slot);
@@ -276,9 +271,9 @@ el_val_t en_verb_3sg(el_val_t base);
 el_val_t en_verb_form(el_val_t base, el_val_t tense, el_val_t person, el_val_t number);
 el_val_t en_verb_gerund(el_val_t base);
 el_val_t en_verb_past(el_val_t base);
-el_val_t engram_compile(el_val_t intent);
 el_val_t engram_compile_multi(el_val_t topic);
 el_val_t engram_compile_ranked(el_val_t nodes_json, el_val_t max_nodes);
+el_val_t engram_compile(el_val_t intent);
 el_val_t engram_dedup_nodes(el_val_t nodes_json);
 el_val_t engram_detect_recall_intent(el_val_t message);
 el_val_t engram_extract_entities(el_val_t message);
@@ -344,9 +339,9 @@ el_val_t es_starts_with_stressed_a(el_val_t noun);
 el_val_t es_stem(el_val_t base);
 el_val_t es_str_drop_last(el_val_t s, el_val_t n);
 el_val_t es_str_ends(el_val_t s, el_val_t suf);
+el_val_t es_str_last_char(el_val_t s);
 el_val_t es_str_last2(el_val_t s);
 el_val_t es_str_last3(el_val_t s);
-el_val_t es_str_last_char(el_val_t s);
 el_val_t es_verb_class(el_val_t base);
 el_val_t extract_dim(el_val_t content, el_val_t key);
 el_val_t fi_apply_case(el_val_t noun, el_val_t gram_case, el_val_t number);
@@ -389,8 +384,8 @@ el_val_t fr_slot(el_val_t person, el_val_t number);
 el_val_t fr_stem(el_val_t base);
 el_val_t fr_str_drop_last(el_val_t s, el_val_t n);
 el_val_t fr_str_ends(el_val_t s, el_val_t suf);
-el_val_t fr_str_last2(el_val_t s);
 el_val_t fr_str_last_char(el_val_t s);
+el_val_t fr_str_last2(el_val_t s);
 el_val_t fr_subject_starts_vowel(el_val_t subject);
 el_val_t fr_uses_etre(el_val_t verb);
 el_val_t fr_verb_ends_vowel(el_val_t verb_form);
@@ -412,9 +407,9 @@ el_val_t fro_conj3_future(el_val_t verb, el_val_t slot);
 el_val_t fro_conj3_past(el_val_t stem, el_val_t slot);
 el_val_t fro_conj3_present(el_val_t stem, el_val_t slot);
 el_val_t fro_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number);
-el_val_t fro_decline(el_val_t noun, el_val_t gram_case, el_val_t number);
 el_val_t fro_decline_fem(el_val_t noun, el_val_t number);
 el_val_t fro_decline_masc(el_val_t noun, el_val_t gram_case, el_val_t number);
+el_val_t fro_decline(el_val_t noun, el_val_t gram_case, el_val_t number);
 el_val_t fro_drop(el_val_t s, el_val_t n);
 el_val_t fro_estre_future(el_val_t slot);
 el_val_t fro_estre_past(el_val_t slot);
@@ -432,15 +427,15 @@ el_val_t fro_venir_past(el_val_t slot);
 el_val_t fro_venir_present(el_val_t slot);
 el_val_t fro_verb_class(el_val_t verb);
 el_val_t fro_verb_stem(el_val_t verb, el_val_t vclass);
-el_val_t generate(el_val_t semantic_form_json);
-el_val_t generate_frame(el_val_t frame);
 el_val_t generate_frame_lang(el_val_t frame, el_val_t lang_code);
+el_val_t generate_frame(el_val_t frame);
 el_val_t generate_lang(el_val_t semantic_form_json, el_val_t lang_code);
 el_val_t generate_tree(el_val_t rule_id_str, el_val_t slots);
+el_val_t generate(el_val_t semantic_form_json);
 el_val_t get_rules(void);
 el_val_t get_vocab(void);
-el_val_t gez_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number);
 el_val_t gez_conjugate_copula(el_val_t tense, el_val_t slot);
+el_val_t gez_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number);
 el_val_t gez_decline(el_val_t noun, el_val_t gram_case, el_val_t number);
 el_val_t gez_generic_imperfect(el_val_t base3sg, el_val_t slot);
 el_val_t gez_generic_perfect(el_val_t base3sg, el_val_t slot);
@@ -459,13 +454,12 @@ el_val_t gez_qwl_imperfect(el_val_t slot);
 el_val_t gez_qwl_perfect(el_val_t slot);
 el_val_t gez_ray_imperfect(el_val_t slot);
 el_val_t gez_ray_perfect(el_val_t slot);
-el_val_t gez_slot(el_val_t person, el_val_t number);
 el_val_t gez_slot_g(el_val_t person, el_val_t gender, el_val_t number);
+el_val_t gez_slot(el_val_t person, el_val_t number);
 el_val_t gez_str_drop_last(el_val_t s, el_val_t n);
 el_val_t gez_str_ends(el_val_t s, el_val_t suf);
 el_val_t gez_str_len(el_val_t s);
 el_val_t goh_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number);
-el_val_t goh_decline(el_val_t noun, el_val_t gram_case, el_val_t number);
 el_val_t goh_decline_fem_o_pl(el_val_t stem, el_val_t gram_case);
 el_val_t goh_decline_fem_o_sg(el_val_t stem, el_val_t gram_case);
 el_val_t goh_decline_masc_a_pl(el_val_t stem, el_val_t gram_case);
@@ -474,6 +468,7 @@ el_val_t goh_decline_masc_n_pl(el_val_t stem, el_val_t gram_case);
 el_val_t goh_decline_masc_n_sg(el_val_t stem, el_val_t gram_case);
 el_val_t goh_decline_neut_a_pl(el_val_t stem, el_val_t gram_case);
 el_val_t goh_decline_neut_a_sg(el_val_t stem, el_val_t gram_case);
+el_val_t goh_decline(el_val_t noun, el_val_t gram_case, el_val_t number);
 el_val_t goh_demo_article(el_val_t stype, el_val_t number);
 el_val_t goh_drop(el_val_t s, el_val_t n);
 el_val_t goh_extract_stem(el_val_t noun, el_val_t stype);
@@ -498,13 +493,13 @@ el_val_t goh_weak_present(el_val_t stem, el_val_t slot);
 el_val_t goh_wesan_past(el_val_t slot);
 el_val_t goh_wesan_present(el_val_t slot);
 el_val_t got_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number);
-el_val_t got_decline(el_val_t noun, el_val_t gram_case, el_val_t number);
 el_val_t got_decline_a_stem_pl(el_val_t stem, el_val_t gram_case);
 el_val_t got_decline_a_stem_sg(el_val_t stem, el_val_t gram_case);
 el_val_t got_decline_n_stem_pl(el_val_t stem, el_val_t gram_case);
 el_val_t got_decline_n_stem_sg(el_val_t stem, el_val_t gram_case);
 el_val_t got_decline_o_stem_pl(el_val_t stem, el_val_t gram_case);
 el_val_t got_decline_o_stem_sg(el_val_t stem, el_val_t gram_case);
+el_val_t got_decline(el_val_t noun, el_val_t gram_case, el_val_t number);
 el_val_t got_demo_article(el_val_t stype);
 el_val_t got_extract_stem(el_val_t noun, el_val_t stype);
 el_val_t got_gaggan_past(el_val_t slot);
@@ -537,17 +532,17 @@ el_val_t gram_build_vp(el_val_t verb, el_val_t aux, el_val_t profile);
 el_val_t gram_order_constituents(el_val_t subj, el_val_t verb, el_val_t obj, el_val_t profile);
 el_val_t gram_question_strategy(el_val_t profile);
 el_val_t gram_word_order(el_val_t profile);
-el_val_t grc_article(el_val_t gender, el_val_t gram_case, el_val_t number);
 el_val_t grc_article_feminine(el_val_t gram_case, el_val_t number);
 el_val_t grc_article_masculine(el_val_t gram_case, el_val_t number);
 el_val_t grc_article_neuter(el_val_t gram_case, el_val_t number);
+el_val_t grc_article(el_val_t gender, el_val_t gram_case, el_val_t number);
 el_val_t grc_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number);
 el_val_t grc_declension(el_val_t noun);
-el_val_t grc_decline(el_val_t noun, el_val_t gram_case, el_val_t number);
 el_val_t grc_decline_1a(el_val_t stem, el_val_t gram_case, el_val_t number);
 el_val_t grc_decline_1e(el_val_t stem, el_val_t gram_case, el_val_t number);
 el_val_t grc_decline_2m(el_val_t stem, el_val_t gram_case, el_val_t number);
 el_val_t grc_decline_2n(el_val_t stem, el_val_t gram_case, el_val_t number);
+el_val_t grc_decline(el_val_t noun, el_val_t gram_case, el_val_t number);
 el_val_t grc_echein_aorist(el_val_t slot);
 el_val_t grc_echein_future(el_val_t slot);
 el_val_t grc_echein_imperfect(el_val_t slot);
@@ -574,9 +569,9 @@ el_val_t grc_present_stem(el_val_t verb);
 el_val_t grc_slot(el_val_t person, el_val_t number);
 el_val_t grc_str_drop_last(el_val_t s, el_val_t n);
 el_val_t grc_str_ends(el_val_t s, el_val_t suf);
+el_val_t grc_str_last_char(el_val_t s);
 el_val_t grc_str_last2(el_val_t s);
 el_val_t grc_str_last3(el_val_t s);
-el_val_t grc_str_last_char(el_val_t s);
 el_val_t grc_thematic_future_ending(el_val_t slot);
 el_val_t grc_thematic_imperfect_ending(el_val_t slot);
 el_val_t grc_thematic_present_ending(el_val_t slot);
@@ -608,17 +603,17 @@ el_val_t handle_api_recall(el_val_t method, el_val_t path, el_val_t body);
 el_val_t handle_api_remember(el_val_t body);
 el_val_t handle_api_search_knowledge(el_val_t method, el_val_t path, el_val_t body);
 el_val_t handle_api_tune_config(el_val_t body);
-el_val_t handle_chat(el_val_t body);
 el_val_t handle_chat_agentic(el_val_t body);
 el_val_t handle_chat_as_soul(el_val_t body);
 el_val_t handle_chat_plan(el_val_t body);
+el_val_t handle_chat(el_val_t body);
 el_val_t handle_config(el_val_t method, el_val_t body);
 el_val_t handle_connectors(el_val_t method, el_val_t clean, el_val_t body);
 el_val_t handle_conversations(el_val_t method);
-el_val_t handle_dharma(el_val_t path, el_val_t method, el_val_t body);
 el_val_t handle_dharma_recv(el_val_t body);
-el_val_t handle_dharma_room_turn(el_val_t body);
 el_val_t handle_dharma_room_turn_agentic(el_val_t body);
+el_val_t handle_dharma_room_turn(el_val_t body);
+el_val_t handle_dharma(el_val_t path, el_val_t method, el_val_t body);
 el_val_t handle_elp_chat(el_val_t body);
 el_val_t handle_nlg(el_val_t path, el_val_t method, el_val_t body);
 el_val_t handle_request(el_val_t method, el_val_t path, el_val_t body);
@@ -626,11 +621,11 @@ el_val_t handle_safety_contact_get(void);
 el_val_t handle_safety_contact_post(el_val_t body);
 el_val_t handle_see(el_val_t body);
 el_val_t handle_session_approve(el_val_t session_id, el_val_t body);
-el_val_t handle_tool(el_val_t path, el_val_t method, el_val_t body);
 el_val_t handle_tool_result(el_val_t session_id, el_val_t body);
+el_val_t handle_tool(el_val_t path, el_val_t method, el_val_t body);
 el_val_t hard_bell_threshold(void);
-el_val_t he_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t gender, el_val_t number);
 el_val_t he_conjugate_copula(el_val_t tense, el_val_t slot);
+el_val_t he_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t gender, el_val_t number);
 el_val_t he_copula_future(el_val_t slot);
 el_val_t he_copula_past(el_val_t slot);
 el_val_t he_definite_prefix(el_val_t noun);
@@ -658,7 +653,6 @@ el_val_t he_str_drop_last(el_val_t s, el_val_t n);
 el_val_t he_str_ends(el_val_t s, el_val_t suf);
 el_val_t he_str_last_char(el_val_t s);
 el_val_t he_str_len(el_val_t s);
-el_val_t hebb_consolidate(void);
 el_val_t hi_agree_genitive(el_val_t possessed_gender, el_val_t possessed_number);
 el_val_t hi_aux_present(el_val_t person, el_val_t number);
 el_val_t hi_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t gender, el_val_t number);
@@ -668,12 +662,12 @@ el_val_t hi_genitive_phrase(el_val_t possessor, el_val_t possessor_gender, el_va
 el_val_t hi_hona_past(el_val_t gender, el_val_t number);
 el_val_t hi_hona_present(el_val_t person, el_val_t number);
 el_val_t hi_masc_aa_stem(el_val_t noun);
-el_val_t hi_noun_direct(el_val_t noun, el_val_t gender, el_val_t number);
 el_val_t hi_noun_direct_f(el_val_t noun, el_val_t number);
 el_val_t hi_noun_direct_m(el_val_t noun, el_val_t number);
-el_val_t hi_noun_oblique(el_val_t noun, el_val_t gender, el_val_t number);
+el_val_t hi_noun_direct(el_val_t noun, el_val_t gender, el_val_t number);
 el_val_t hi_noun_oblique_f(el_val_t noun, el_val_t number);
 el_val_t hi_noun_oblique_m(el_val_t noun, el_val_t number);
+el_val_t hi_noun_oblique(el_val_t noun, el_val_t gender, el_val_t number);
 el_val_t hi_noun_with_post(el_val_t noun, el_val_t gender, el_val_t number, el_val_t gram_case);
 el_val_t hi_past_irregular(el_val_t stem, el_val_t gender, el_val_t number);
 el_val_t hi_past_suffix(el_val_t gender, el_val_t number);
@@ -683,11 +677,11 @@ el_val_t hi_str_drop_last(el_val_t s, el_val_t n);
 el_val_t hi_str_ends(el_val_t s, el_val_t suf);
 el_val_t hi_str_last_char(el_val_t s);
 el_val_t hi_tense_suffix(el_val_t tense, el_val_t gender, el_val_t number);
-el_val_t hi_verb_stem(el_val_t infinitive);
 el_val_t hi_verb_stem_clean(el_val_t infinitive);
+el_val_t hi_verb_stem(el_val_t infinitive);
 el_val_t hist_append(el_val_t hist, el_val_t role, el_val_t content);
-el_val_t hist_trim(el_val_t hist);
 el_val_t hist_trim_with_bell_guard(el_val_t hist);
+el_val_t hist_trim(el_val_t hist);
 el_val_t id_in_seen(el_val_t node_id, el_val_t seen);
 el_val_t idle_count(void);
 el_val_t idle_inc(void);
@@ -718,7 +712,6 @@ el_val_t json_escape(el_val_t s);
 el_val_t json_safe(el_val_t s);
 el_val_t la_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number);
 el_val_t la_declension(el_val_t noun);
-el_val_t la_decline(el_val_t noun, el_val_t gram_case, el_val_t number);
 el_val_t la_decline_1(el_val_t stem, el_val_t gram_case, el_val_t number);
 el_val_t la_decline_2er(el_val_t noun, el_val_t gram_case, el_val_t number);
 el_val_t la_decline_2m(el_val_t stem, el_val_t gram_case, el_val_t number);
@@ -726,6 +719,7 @@ el_val_t la_decline_2n(el_val_t stem, el_val_t gram_case, el_val_t number);
 el_val_t la_decline_3(el_val_t noun, el_val_t gram_case, el_val_t number);
 el_val_t la_decline_4(el_val_t stem, el_val_t gram_case, el_val_t number);
 el_val_t la_decline_5(el_val_t stem, el_val_t gram_case, el_val_t number);
+el_val_t la_decline(el_val_t noun, el_val_t gram_case, el_val_t number);
 el_val_t la_esse_future(el_val_t slot);
 el_val_t la_esse_past(el_val_t slot);
 el_val_t la_esse_present(el_val_t slot);
@@ -749,9 +743,9 @@ el_val_t la_slot(el_val_t person, el_val_t number);
 el_val_t la_stem(el_val_t verb, el_val_t vclass);
 el_val_t la_str_drop_last(el_val_t s, el_val_t n);
 el_val_t la_str_ends(el_val_t s, el_val_t suf);
+el_val_t la_str_last_char(el_val_t s);
 el_val_t la_str_last2(el_val_t s);
 el_val_t la_str_last3(el_val_t s);
-el_val_t la_str_last_char(el_val_t s);
 el_val_t la_velle_future(el_val_t slot);
 el_val_t la_velle_past(el_val_t slot);
 el_val_t la_velle_present(el_val_t slot);
@@ -768,7 +762,6 @@ el_val_t lang_is_fusional(el_val_t profile);
 el_val_t lang_is_isolating(el_val_t profile);
 el_val_t lang_is_polysynthetic(el_val_t profile);
 el_val_t lang_is_rtl(el_val_t profile);
-el_val_t lang_profile(el_val_t code, el_val_t word_order, el_val_t morph_type, el_val_t has_case, el_val_t has_gender, el_val_t script_dir, el_val_t agreement, el_val_t null_subject);
 el_val_t lang_profile_akk(void);
 el_val_t lang_profile_ang(void);
 el_val_t lang_profile_ar(void);
@@ -800,6 +793,7 @@ 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);
@@ -851,10 +845,10 @@ el_val_t morph_pluralize(el_val_t noun, el_val_t profile);
 el_val_t next_bridge_id(void);
 el_val_t nlg_is_ws(el_val_t c);
 el_val_t non_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number);
-el_val_t non_decline(el_val_t noun, el_val_t gram_case, el_val_t number);
 el_val_t non_decline_fem(el_val_t noun, el_val_t gram_case, el_val_t number);
 el_val_t non_decline_masc(el_val_t noun, el_val_t gram_case, el_val_t number);
 el_val_t non_decline_neut(el_val_t noun, el_val_t gram_case, el_val_t number);
+el_val_t non_decline(el_val_t noun, el_val_t gram_case, el_val_t number);
 el_val_t non_def_suffix_fem(el_val_t gram_case, el_val_t number);
 el_val_t non_def_suffix_masc(el_val_t gram_case, el_val_t number);
 el_val_t non_def_suffix_neut(el_val_t gram_case, el_val_t number);
@@ -881,11 +875,6 @@ 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);
@@ -893,8 +882,8 @@ el_val_t peo_ah_present(el_val_t slot);
 el_val_t peo_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number);
 el_val_t peo_da_past(el_val_t slot);
 el_val_t peo_da_present(el_val_t slot);
-el_val_t peo_decline(el_val_t noun, el_val_t gram_case, el_val_t number);
 el_val_t peo_decline_astem(el_val_t noun, el_val_t gram_case, el_val_t number);
+el_val_t peo_decline(el_val_t noun, el_val_t gram_case, el_val_t number);
 el_val_t peo_drop(el_val_t s, el_val_t n);
 el_val_t peo_ends(el_val_t s, el_val_t suf);
 el_val_t peo_kar_past(el_val_t slot);
@@ -910,11 +899,11 @@ el_val_t perceive(void);
 el_val_t pi_aorist_ending(el_val_t slot);
 el_val_t pi_atthi_present(el_val_t slot);
 el_val_t pi_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number);
-el_val_t pi_decline(el_val_t noun, el_val_t gram_case, el_val_t number);
 el_val_t pi_decline_a_fem_pl(el_val_t stem, el_val_t gram_case);
 el_val_t pi_decline_a_fem_sg(el_val_t stem, el_val_t gram_case);
 el_val_t pi_decline_a_masc_pl(el_val_t stem, el_val_t gram_case);
 el_val_t pi_decline_a_masc_sg(el_val_t stem, el_val_t gram_case);
+el_val_t pi_decline(el_val_t noun, el_val_t gram_case, el_val_t number);
 el_val_t pi_detect_class(el_val_t noun);
 el_val_t pi_drop(el_val_t s, el_val_t n);
 el_val_t pi_future_ending(el_val_t slot);
@@ -945,11 +934,11 @@ el_val_t proactive_curiosity(void);
 el_val_t pulse_count(void);
 el_val_t pulse_inc(void);
 el_val_t rate_limit_check(el_val_t ip, el_val_t path);
-el_val_t realize(el_val_t form);
 el_val_t realize_lang(el_val_t form, el_val_t profile);
 el_val_t realize_np(el_val_t referent, el_val_t number);
 el_val_t realize_question_lang(el_val_t predicate, el_val_t tense, el_val_t aspect, el_val_t person, el_val_t number, el_val_t agent, el_val_t patient, el_val_t location, el_val_t profile);
 el_val_t realize_vp_lang(el_val_t base_verb, el_val_t tense, el_val_t aspect, el_val_t person, el_val_t number, el_val_t profile);
+el_val_t realize(el_val_t form);
 el_val_t record(el_val_t outcome_json);
 el_val_t render_studio(void);
 el_val_t render_tree(el_val_t tree);
@@ -960,9 +949,9 @@ el_val_t route_imprint_contextual(el_val_t body);
 el_val_t route_imprint_user(el_val_t body);
 el_val_t route_lineage(void);
 el_val_t route_synthesize(el_val_t body);
-el_val_t ru_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number, el_val_t gender);
 el_val_t ru_conjugate_1st(el_val_t stem, el_val_t tense, el_val_t person, el_val_t number);
 el_val_t ru_conjugate_2nd(el_val_t stem, el_val_t tense, el_val_t person, el_val_t number);
+el_val_t ru_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number, el_val_t gender);
 el_val_t ru_decline_fem(el_val_t noun, el_val_t stype, el_val_t gram_case, el_val_t number);
 el_val_t ru_decline_masc(el_val_t noun, el_val_t stype, el_val_t gram_case, el_val_t number);
 el_val_t ru_decline_neut(el_val_t noun, el_val_t stype, el_val_t gram_case, el_val_t number);
@@ -975,8 +964,8 @@ el_val_t ru_past_stem(el_val_t verb);
 el_val_t ru_stem_type(el_val_t noun, el_val_t gender);
 el_val_t rule_id(el_val_t rule);
 el_val_t rule_lhs(el_val_t rule);
-el_val_t rule_rhs(el_val_t rule, el_val_t idx);
 el_val_t rule_rhs_len(el_val_t rule);
+el_val_t rule_rhs(el_val_t rule, el_val_t idx);
 el_val_t run_command_guard(el_val_t cmd, el_val_t root);
 el_val_t run_command_is_readonly(el_val_t cmd);
 el_val_t sa_as_future(el_val_t slot);
@@ -990,11 +979,11 @@ el_val_t sa_class1_future_ending(el_val_t slot);
 el_val_t sa_class1_past_ending(el_val_t slot);
 el_val_t sa_class1_present_ending(el_val_t slot);
 el_val_t sa_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number);
-el_val_t sa_decline(el_val_t noun, el_val_t gram_case, el_val_t number);
 el_val_t sa_decline_a_stem_pl(el_val_t stem, el_val_t gram_case);
 el_val_t sa_decline_a_stem_sg(el_val_t stem, el_val_t gram_case);
 el_val_t sa_decline_aa_stem_pl(el_val_t stem, el_val_t gram_case);
 el_val_t sa_decline_aa_stem_sg(el_val_t stem, el_val_t gram_case);
+el_val_t sa_decline(el_val_t noun, el_val_t gram_case, el_val_t number);
 el_val_t sa_drs_future(el_val_t slot);
 el_val_t sa_drs_past(el_val_t slot);
 el_val_t sa_drs_present(el_val_t slot);
@@ -1042,26 +1031,26 @@ el_val_t scan_token(el_val_t s, el_val_t start);
 el_val_t security_research_authorized(void);
 el_val_t seed_persona_from_env(void);
 el_val_t sem_first_modifier(el_val_t mods);
-el_val_t sem_frame(el_val_t intent, el_val_t subject, el_val_t obj, el_val_t modifiers);
 el_val_t sem_frame_lang(el_val_t intent, el_val_t subject, el_val_t obj, el_val_t modifiers, el_val_t lang_code);
 el_val_t sem_frame_obj(el_val_t intent, el_val_t subject, el_val_t obj);
 el_val_t sem_frame_simple(el_val_t intent, el_val_t subject);
+el_val_t sem_frame(el_val_t intent, el_val_t subject, el_val_t obj, el_val_t modifiers);
 el_val_t sem_get(el_val_t json, el_val_t key);
-el_val_t sem_intent(el_val_t frame);
 el_val_t sem_intent_to_realize(el_val_t intent);
+el_val_t sem_intent(el_val_t frame);
 el_val_t sem_lang(el_val_t frame);
 el_val_t sem_modifiers(el_val_t frame);
 el_val_t sem_object(el_val_t frame);
-el_val_t sem_realize(el_val_t frame);
 el_val_t sem_realize_full(el_val_t frame, el_val_t verb, el_val_t tense, el_val_t aspect);
 el_val_t sem_realize_greet(el_val_t subject);
 el_val_t sem_realize_lang(el_val_t frame, el_val_t lang_code);
+el_val_t sem_realize(el_val_t frame);
 el_val_t sem_subject(el_val_t frame);
-el_val_t sem_to_spec(el_val_t frame);
 el_val_t sem_to_spec_full(el_val_t frame, el_val_t verb, el_val_t tense, el_val_t aspect);
+el_val_t sem_to_spec(el_val_t frame);
 el_val_t session_auto_title(el_val_t session_id, el_val_t first_message);
-el_val_t session_create(el_val_t body);
 el_val_t session_create_cleanup(el_val_t session_id);
+el_val_t session_create(el_val_t body);
 el_val_t session_delete(el_val_t session_id);
 el_val_t session_exists(el_val_t session_id);
 el_val_t session_get(el_val_t session_id);
@@ -1070,11 +1059,11 @@ el_val_t session_hist_save(el_val_t session_id, el_val_t hist);
 el_val_t session_list(void);
 el_val_t session_make_content(el_val_t id, el_val_t title, el_val_t created_at, el_val_t updated_at, el_val_t folder);
 el_val_t session_preload_bullets(el_val_t nodes, el_val_t max_bullets, el_val_t snip_len);
-el_val_t session_search(el_val_t query);
 el_val_t session_search_entry(el_val_t node);
+el_val_t session_search(el_val_t query);
 el_val_t session_summary_autogenerate(el_val_t hist);
-el_val_t session_summary_write(el_val_t summary_text);
 el_val_t session_summary_write_dated(el_val_t summary_text, el_val_t label);
+el_val_t session_summary_write(el_val_t summary_text);
 el_val_t session_title_from_message(el_val_t message);
 el_val_t session_update_meta_timestamp(el_val_t session_id);
 el_val_t session_update_patch(el_val_t session_id, el_val_t body);
@@ -1085,9 +1074,9 @@ el_val_t sga_bith_past(el_val_t slot);
 el_val_t sga_bith_present(el_val_t slot);
 el_val_t sga_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number);
 el_val_t sga_copula_present(el_val_t slot);
-el_val_t sga_decline(el_val_t noun, el_val_t gram_case, el_val_t number);
 el_val_t sga_decline_astem(el_val_t noun, el_val_t gram_case, el_val_t number);
 el_val_t sga_decline_ostem(el_val_t noun, el_val_t gram_case, el_val_t number);
+el_val_t sga_decline(el_val_t noun, el_val_t gram_case, el_val_t number);
 el_val_t sga_detect_gender(el_val_t noun);
 el_val_t sga_drop(el_val_t s, el_val_t n);
 el_val_t sga_first(el_val_t s);
@@ -1115,9 +1104,9 @@ el_val_t steward_session_check(el_val_t input, el_val_t session_id);
 el_val_t steward_validate_imprint(el_val_t imprint_id, el_val_t tool_name);
 el_val_t str_drop_last(el_val_t s, el_val_t n);
 el_val_t str_ends(el_val_t s, el_val_t suf);
+el_val_t str_last_char(el_val_t s);
 el_val_t str_last2(el_val_t s);
 el_val_t str_last3(el_val_t s);
-el_val_t str_last_char(el_val_t s);
 el_val_t strengthen_chat_nodes(el_val_t activation_nodes);
 el_val_t strip_query(el_val_t path);
 el_val_t studio_tools_json(void);
@@ -1144,8 +1133,8 @@ el_val_t sux_realize_sentence(el_val_t intent, el_val_t agent, el_val_t predicat
 el_val_t sux_slot(el_val_t person, el_val_t number);
 el_val_t sux_str_drop_last(el_val_t s, el_val_t n);
 el_val_t sux_str_ends(el_val_t s, el_val_t suf);
-el_val_t sux_str_last2(el_val_t s);
 el_val_t sux_str_last_char(el_val_t s);
+el_val_t sux_str_last2(el_val_t s);
 el_val_t sux_tum2_past(el_val_t slot);
 el_val_t sux_tum2_present(el_val_t slot);
 el_val_t sux_verb_chain(el_val_t agent, el_val_t verb, el_val_t patient, el_val_t tense);
@@ -1163,9 +1152,9 @@ el_val_t sw_noun_plural(el_val_t noun);
 el_val_t sw_obj_prefix(el_val_t person, el_val_t number, el_val_t noun_class);
 el_val_t sw_str_drop_last(el_val_t s, el_val_t n);
 el_val_t sw_str_ends(el_val_t s, el_val_t suf);
+el_val_t sw_str_first_char(el_val_t s);
 el_val_t sw_str_first2(el_val_t s);
 el_val_t sw_str_first3(el_val_t s);
-el_val_t sw_str_first_char(el_val_t s);
 el_val_t sw_str_last_char(el_val_t s);
 el_val_t sw_subj_prefix(el_val_t person, el_val_t number, el_val_t noun_class);
 el_val_t sw_tense_marker(el_val_t tense);
@@ -1183,9 +1172,9 @@ el_val_t tombstone_node(el_val_t id);
 el_val_t tombstoned_id_set(void);
 el_val_t tool_auto_approved(el_val_t tool_name);
 el_val_t txb_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number);
-el_val_t txb_decline(el_val_t noun, el_val_t gram_case, el_val_t number);
 el_val_t txb_decline_fem(el_val_t noun, el_val_t gram_case, el_val_t number);
 el_val_t txb_decline_masc(el_val_t noun, el_val_t gram_case, el_val_t number);
+el_val_t txb_decline(el_val_t noun, el_val_t gram_case, el_val_t number);
 el_val_t txb_detect_gender(el_val_t noun);
 el_val_t txb_drop(el_val_t s, el_val_t n);
 el_val_t txb_ends(el_val_t s, el_val_t suf);
@@ -1200,8 +1189,8 @@ el_val_t txb_wes_present(el_val_t slot);
 el_val_t txb_ya_present(el_val_t slot);
 el_val_t uga_amr_imperfect(el_val_t slot);
 el_val_t uga_amr_perfect(el_val_t slot);
-el_val_t uga_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number);
 el_val_t uga_conjugate_copula(el_val_t tense, el_val_t slot);
+el_val_t uga_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number);
 el_val_t uga_decline(el_val_t noun, el_val_t gram_case, el_val_t number);
 el_val_t uga_generic_imperfect(el_val_t base3sg, el_val_t slot);
 el_val_t uga_generic_perfect(el_val_t base3sg, el_val_t slot);
@@ -1216,8 +1205,8 @@ el_val_t uga_map_canonical(el_val_t verb);
 el_val_t uga_noun_phrase(el_val_t noun, el_val_t gram_case, el_val_t number, el_val_t definite);
 el_val_t uga_ray_imperfect(el_val_t slot);
 el_val_t uga_ray_perfect(el_val_t slot);
-el_val_t uga_slot(el_val_t person, el_val_t number);
 el_val_t uga_slot_g(el_val_t person, el_val_t gender, el_val_t number);
+el_val_t uga_slot(el_val_t person, el_val_t number);
 el_val_t uga_str_drop_last(el_val_t s, el_val_t n);
 el_val_t uga_str_ends(el_val_t s, el_val_t suf);
 el_val_t uga_str_len(el_val_t s);
@@ -1225,6 +1214,6 @@ el_val_t uga_strip_nom(el_val_t noun);
 el_val_t verb_form(el_val_t base, el_val_t tense, el_val_t person, el_val_t number);
 el_val_t vocab_by_class(el_val_t cls);
 el_val_t vocab_by_pos(el_val_t pos);
-el_val_t vocab_lookup(el_val_t word, el_val_t lang_code);
 el_val_t vocab_lookup_en(el_val_t word);
+el_val_t vocab_lookup(el_val_t word, el_val_t lang_code);
 el_val_t vocab_synonym(el_val_t word, el_val_t lang_register, el_val_t lang_code);

dist/elp-input.elh

@@ -0,0 +1,5 @@
+// auto-generated by elc --emit-header — do not edit
+extern fn elp_extract_topic(msg: String) -> String
+extern fn elp_detect_predicate(msg: String) -> String
+extern fn elp_parse(msg: String) -> String
+extern fn handle_elp_chat(body: String) -> String

dist/elp.elh

@@ -0,0 +1,7 @@
+// auto-generated by elc --emit-header — do not edit
+extern fn sem_get(json: String, key: String) -> String
+extern fn generate_frame(frame: [String]) -> String
+extern fn generate_frame_lang(frame: [String], lang_code: String) -> String
+extern fn build_form_from_json(semantic_form_json: String, lang_code: String) -> [String]
+extern fn generate(semantic_form_json: String) -> String
+extern fn generate_lang(semantic_form_json: String, lang_code: String) -> String

dist/grammar.elh

@@ -0,0 +1,38 @@
+// auto-generated by elc --emit-header — do not edit
+extern fn slots_get(slots: [String], key: String) -> String
+extern fn slots_set(slots: [String], key: String, val: String) -> [String]
+extern fn make_slots(k0: String, v0: String) -> [String]
+extern fn make_slots2(k0: String, v0: String, k1: String, v1: String) -> [String]
+extern fn make_slots3(k0: String, v0: String, k1: String, v1: String, k2: String, v2: String) -> [String]
+extern fn make_slots4(k0: String, v0: String, k1: String, v1: String, k2: String, v2: String, k3: String, v3: String) -> [String]
+extern fn make_slots5(k0: String, v0: String, k1: String, v1: String, k2: String, v2: String, k3: String, v3: String, k4: String, v4: String) -> [String]
+extern fn rule_id(rule: [String]) -> String
+extern fn rule_lhs(rule: [String]) -> String
+extern fn rule_rhs_len(rule: [String]) -> Int
+extern fn rule_rhs(rule: [String], idx: Int) -> String
+extern fn make_rule(id: String, lhs: String, r0: String) -> [String]
+extern fn make_rule2(id: String, lhs: String, r0: String, r1: String) -> [String]
+extern fn make_rule3(id: String, lhs: String, r0: String, r1: String, r2: String) -> [String]
+extern fn make_rule4(id: String, lhs: String, r0: String, r1: String, r2: String, r3: String) -> [String]
+extern fn build_rules() -> [[String]]
+extern fn get_rules() -> [[String]]
+extern fn find_rule(rule_id_str: String) -> [String]
+extern fn make_leaf(label: String, word: String) -> String
+extern fn make_node1(label: String, child0: String) -> String
+extern fn make_node2(label: String, child0: String, child1: String) -> String
+extern fn make_node3(label: String, child0: String, child1: String, child2: String) -> String
+extern fn make_node4(label: String, child0: String, child1: String, child2: String, child3: String) -> String
+extern fn nlg_is_ws(c: String) -> Bool
+extern fn skip_ws(s: String, pos: Int) -> Int
+extern fn scan_token(s: String, start: Int) -> [String]
+extern fn render_tree(tree: String) -> String
+extern fn gram_word_order(profile: [String]) -> String
+extern fn gram_order_constituents(subj: String, verb: String, obj: String, profile: [String]) -> String
+extern fn gram_build_vp(verb: String, aux: String, profile: [String]) -> String
+extern fn gram_question_strategy(profile: [String]) -> String
+extern fn is_pronoun(word: String) -> Bool
+extern fn build_np(referent: String, slots: [String]) -> String
+extern fn build_pp(loc: String) -> String
+extern fn build_vp_body(slots: [String]) -> String
+extern fn build_vp_from_slots(slots: [String]) -> String
+extern fn generate_tree(rule_id_str: String, slots: [String]) -> String

dist/imprint.elh

@@ -0,0 +1,7 @@
+// auto-generated by elc --emit-header — do not edit
+extern fn imprint_current() -> String
+extern fn imprint_load(imprint_id: String) -> String
+extern fn imprint_respond(input: String, imprint_id: String) -> String
+extern fn imprint_surface_knowledge(query: String, imprint_id: String) -> String
+extern fn imprint_surface_memory_read(query: String) -> String
+extern fn imprint_unload() -> Void

dist/language-profile.elh

@@ -0,0 +1,46 @@
+// auto-generated by elc --emit-header — do not edit
+extern fn lang_profile(code: String, word_order: String, morph_type: String, has_case: String, has_gender: String, script_dir: String, agreement: String, null_subject: String) -> [String]
+extern fn lang_get(profile: [String], key: String) -> String
+extern fn lang_profile_en() -> [String]
+extern fn lang_profile_ja() -> [String]
+extern fn lang_profile_ar() -> [String]
+extern fn lang_profile_zh() -> [String]
+extern fn lang_profile_de() -> [String]
+extern fn lang_profile_es() -> [String]
+extern fn lang_profile_fi() -> [String]
+extern fn lang_profile_sw() -> [String]
+extern fn lang_profile_hi() -> [String]
+extern fn lang_profile_ru() -> [String]
+extern fn lang_profile_fr() -> [String]
+extern fn lang_profile_la() -> [String]
+extern fn lang_profile_he() -> [String]
+extern fn lang_profile_sa() -> [String]
+extern fn lang_profile_got() -> [String]
+extern fn lang_profile_non() -> [String]
+extern fn lang_profile_enm() -> [String]
+extern fn lang_profile_pi() -> [String]
+extern fn lang_profile_grc() -> [String]
+extern fn lang_profile_ang() -> [String]
+extern fn lang_profile_fro() -> [String]
+extern fn lang_profile_goh() -> [String]
+extern fn lang_profile_sga() -> [String]
+extern fn lang_profile_txb() -> [String]
+extern fn lang_profile_peo() -> [String]
+extern fn lang_profile_akk() -> [String]
+extern fn lang_profile_uga() -> [String]
+extern fn lang_profile_egy() -> [String]
+extern fn lang_profile_sux() -> [String]
+extern fn lang_profile_gez() -> [String]
+extern fn lang_profile_cop() -> [String]
+extern fn lang_from_code(code: String) -> [String]
+extern fn lang_default() -> [String]
+extern fn lang_is_isolating(profile: [String]) -> Bool
+extern fn lang_is_agglutinative(profile: [String]) -> Bool
+extern fn lang_is_fusional(profile: [String]) -> Bool
+extern fn lang_is_polysynthetic(profile: [String]) -> Bool
+extern fn lang_is_rtl(profile: [String]) -> Bool
+extern fn lang_has_null_subject(profile: [String]) -> Bool
+extern fn lang_has_case(profile: [String]) -> Bool
+extern fn lang_has_gender(profile: [String]) -> Bool
+extern fn lang_word_order(profile: [String]) -> String
+extern fn lang_code(profile: [String]) -> String

dist/memory.elh

@@ -0,0 +1,16 @@
+// auto-generated by elc --emit-header — do not edit
+extern fn tier_working() -> String
+extern fn tier_episodic() -> String
+extern fn tier_canonical() -> String
+extern fn mem_store(content: String, label: String, tags: String) -> String
+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_forget(node_id: String) -> Void
+extern fn mem_consolidate() -> String
+extern fn mem_save(path: String) -> Void
+extern fn mem_load(path: String) -> Void
+extern fn mem_boot_count_get() -> Int
+extern fn mem_boot_count_inc() -> Int
+extern fn mem_emit_state_event(trigger: String, kind: String, content: String) -> String

dist/morphology-akk.elh

@@ -0,0 +1,31 @@
+// auto-generated by elc --emit-header — do not edit
+extern fn akk_str_ends(s: String, suf: String) -> Bool
+extern fn akk_str_len(s: String) -> Int
+extern fn akk_str_drop_last(s: String, n: Int) -> String
+extern fn akk_slot(person: String, number: String) -> Int
+extern fn akk_slot_g(person: String, gender: String, number: String) -> Int
+extern fn akk_copula_present(slot: Int) -> String
+extern fn akk_copula_stative(slot: Int) -> String
+extern fn akk_is_copula(verb: String) -> Bool
+extern fn akk_conjugate_copula(tense: String, slot: Int) -> String
+extern fn akk_alaku_present(slot: Int) -> String
+extern fn akk_alaku_perfect(slot: Int) -> String
+extern fn akk_amaru_present(slot: Int) -> String
+extern fn akk_amaru_perfect(slot: Int) -> String
+extern fn akk_amaru_stative(slot: Int) -> String
+extern fn akk_qabu_present(slot: Int) -> String
+extern fn akk_qabu_perfect(slot: Int) -> String
+extern fn akk_qabu_stative(slot: Int) -> String
+extern fn akk_epesu_present(slot: Int) -> String
+extern fn akk_epesu_perfect(slot: Int) -> String
+extern fn akk_epesu_stative(slot: Int) -> String
+extern fn akk_regular_present(stem: String, slot: Int) -> String
+extern fn akk_regular_perfect(stem: String, slot: Int) -> String
+extern fn akk_regular_stative(stem: String, slot: Int) -> String
+extern fn akk_known_verb(verb: String, tense: String, slot: Int) -> String
+extern fn akk_conjugate(verb: String, tense: String, person: String, number: String) -> String
+extern fn akk_strip_nom(noun: String) -> String
+extern fn akk_is_fem(noun: String) -> Bool
+extern fn akk_decline(noun: String, gram_case: String, number: String) -> String
+extern fn akk_noun_phrase(noun: String, gram_case: String, number: String, definite: String) -> String
+extern fn akk_map_canonical(verb: String) -> String

dist/morphology-ang.elh

@@ -0,0 +1,44 @@
+// auto-generated by elc --emit-header — do not edit
+extern fn ang_str_ends(s: String, suf: String) -> Bool
+extern fn ang_str_drop_last(s: String, n: Int) -> String
+extern fn ang_str_last_char(s: String) -> String
+extern fn ang_str_last2(s: String) -> String
+extern fn ang_slot(person: String, number: String) -> Int
+extern fn ang_map_canonical(verb: String) -> String
+extern fn ang_wesan_past(slot: Int) -> String
+extern fn ang_beon_present(slot: Int) -> String
+extern fn ang_wesan_present(slot: Int) -> String
+extern fn ang_habban_present(slot: Int) -> String
+extern fn ang_habban_past(slot: Int) -> String
+extern fn ang_gan_present(slot: Int) -> String
+extern fn ang_gan_past(slot: Int) -> String
+extern fn ang_cuman_present(slot: Int) -> String
+extern fn ang_cuman_past(slot: Int) -> String
+extern fn ang_secgan_present(slot: Int) -> String
+extern fn ang_secgan_past(slot: Int) -> String
+extern fn ang_seon_present(slot: Int) -> String
+extern fn ang_seon_past(slot: Int) -> String
+extern fn ang_don_present(slot: Int) -> String
+extern fn ang_don_past(slot: Int) -> String
+extern fn ang_willan_present(slot: Int) -> String
+extern fn ang_willan_past(slot: Int) -> String
+extern fn ang_magan_present(slot: Int) -> String
+extern fn ang_magan_past(slot: Int) -> String
+extern fn ang_witan_present(slot: Int) -> String
+extern fn ang_witan_past(slot: Int) -> String
+extern fn ang_weak_present_ending(slot: Int) -> String
+extern fn ang_weak_past_stem(stem: String) -> String
+extern fn ang_weak_past(stem: String, slot: Int) -> String
+extern fn ang_weak_stem(verb: String) -> String
+extern fn ang_conjugate(verb: String, tense: String, person: String, number: String) -> String
+extern fn ang_declension(noun: String, gender: String) -> String
+extern fn ang_decline_strong_masc(noun: String, gram_case: String, number: String) -> String
+extern fn ang_decline_strong_neut(noun: String, gram_case: String, number: String) -> String
+extern fn ang_decline_weak(noun: String, gram_case: String, number: String) -> String
+extern fn ang_decline(noun: String, gram_case: String, number: String, gender: String) -> String
+extern fn ang_article_masculine(gram_case: String, number: String) -> String
+extern fn ang_article_feminine(gram_case: String, number: String) -> String
+extern fn ang_article_neuter(gram_case: String, number: String) -> String
+extern fn ang_article(gender: String, gram_case: String, number: String) -> String
+extern fn ang_infer_gender(noun: String) -> String
+extern fn ang_noun_phrase(noun: String, gram_case: String, number: String, definite: String) -> String

dist/morphology-ar.elh

@@ -0,0 +1,27 @@
+// auto-generated by elc --emit-header — do not edit
+extern fn ar_str_ends(s: String, suf: String) -> Bool
+extern fn ar_str_len(s: String) -> Int
+extern fn ar_str_drop_last(s: String, n: Int) -> String
+extern fn ar_str_last_char(s: String) -> String
+extern fn ar_slot(person: String, gender: String, number: String) -> Int
+extern fn ar_perfect_suffix(slot: Int) -> String
+extern fn ar_imperfect_prefix(slot: Int) -> String
+extern fn ar_imperfect_suffix(slot: Int) -> String
+extern fn ar_conjugate_form1(past_base: String, present_stem: String, tense: String, slot: Int) -> String
+extern fn ar_irregular_kaana(slot: Int, tense: String) -> String
+extern fn ar_irregular_qaala(slot: Int, tense: String) -> String
+extern fn ar_irregular_jaa(slot: Int, tense: String) -> String
+extern fn ar_irregular_raaa(slot: Int, tense: String) -> String
+extern fn ar_irregular_araada(slot: Int, tense: String) -> String
+extern fn ar_irregular_istata(slot: Int, tense: String) -> String
+extern fn ar_irregular(verb: String, tense: String, slot: Int) -> String
+extern fn ar_present_stem(verb: String) -> String
+extern fn ar_conjugate(verb: String, tense: String, person: String, gender: String, number: String) -> String
+extern fn ar_is_sun_letter(c: String) -> Bool
+extern fn ar_definite_article(noun: String) -> String
+extern fn ar_case_ending(kase: String, definite: String) -> String
+extern fn ar_gender(noun: String) -> String
+extern fn ar_masc_pl_ending(kase: String) -> String
+extern fn ar_sound_plural(noun: String, gender: String) -> String
+extern fn ar_noun_form(noun: String, gender: String, kase: String, number: String, definite: String) -> String
+extern fn ar_verb_form(verb: String, tense: String, person: String, number: String) -> String

dist/morphology-cop.elh

@@ -0,0 +1,35 @@
+// auto-generated by elc --emit-header — do not edit
+extern fn cop_str_ends(s: String, suf: String) -> Bool
+extern fn cop_str_len(s: String) -> Int
+extern fn cop_drop(s: String, n: Int) -> String
+extern fn cop_last_char(s: String) -> String
+extern fn cop_slot(person: String, number: String) -> Int
+extern fn cop_subject_prefix(person: String, number: String) -> String
+extern fn cop_subject_prefix_gendered(person: String, gender: String, number: String) -> String
+extern fn cop_copula_particle(gender: String, number: String) -> String
+extern fn cop_shwpe_present(prefix: String) -> String
+extern fn cop_shwpe_perfect(prefix: String) -> String
+extern fn cop_shwpe_future(prefix: String) -> String
+extern fn cop_bwk_present(prefix: String) -> String
+extern fn cop_bwk_perfect(prefix: String) -> String
+extern fn cop_bwk_future(prefix: String) -> String
+extern fn cop_nau_present(prefix: String) -> String
+extern fn cop_nau_perfect(prefix: String) -> String
+extern fn cop_nau_future(prefix: String) -> String
+extern fn cop_jw_present(prefix: String) -> String
+extern fn cop_jw_perfect(prefix: String) -> String
+extern fn cop_jw_future(prefix: String) -> String
+extern fn cop_di_present(prefix: String) -> String
+extern fn cop_di_perfect(prefix: String) -> String
+extern fn cop_di_future(prefix: String) -> String
+extern fn cop_is_copula(verb: String) -> Bool
+extern fn cop_known_verb_prefixed(verb: String, tense: String, prefix: String) -> String
+extern fn cop_regular_present(prefix: String, stem: String) -> String
+extern fn cop_regular_perfect(prefix: String, stem: String) -> String
+extern fn cop_regular_future(prefix: String, stem: String) -> String
+extern fn cop_conjugate(verb: String, tense: String, person: String, number: String) -> String
+extern fn cop_article(gender: String, number: String, definite: String) -> String
+extern fn cop_decline(noun: String, gram_case: String, number: String) -> String
+extern fn cop_noun_phrase(noun: String, gram_case: String, number: String, definite: String) -> String
+extern fn cop_noun_phrase_gendered(noun: String, gram_case: String, number: String, definite: String, gender: String) -> String
+extern fn cop_map_canonical(verb: String) -> String

dist/morphology-de.elh

@@ -0,0 +1,13 @@
+// auto-generated by elc --emit-header — do not edit
+extern fn de_article_def(gender: String, gram_case: String, number: String) -> String
+extern fn de_article_indef(gender: String, gram_case: String, number: String) -> String
+extern fn de_article(gender: String, gram_case: String, number: String, definite: String) -> String
+extern fn de_adj_ending(gender: String, gram_case: String, number: String, article_type: String) -> String
+extern fn de_noun_plural(noun: String, gender: String) -> String
+extern fn de_case_ending(noun: String, gender: String, gram_case: String, number: String) -> String
+extern fn de_conjugate_weak(stem: String, tense: String, person: String, number: String) -> String
+extern fn de_irregular_present(verb: String, person: String, number: String) -> String
+extern fn de_strong_past_stem(verb: String) -> String
+extern fn de_norm_number(number: String) -> String
+extern fn de_norm_person(person: String) -> String
+extern fn de_conjugate(verb: String, tense: String, person: String, number: String) -> String

dist/morphology-egy.elh

@@ -0,0 +1,38 @@
+// auto-generated by elc --emit-header — do not edit
+extern fn egy_str_ends(s: String, suf: String) -> Bool
+extern fn egy_str_len(s: String) -> Int
+extern fn egy_drop(s: String, n: Int) -> String
+extern fn egy_last_char(s: String) -> String
+extern fn egy_slot(person: String, number: String) -> Int
+extern fn egy_slot_with_gender(person: String, gender: String, number: String) -> Int
+extern fn egy_conjugate_pronoun(person: String, number: String) -> String
+extern fn egy_suffix_pronoun(slot: Int) -> String
+extern fn egy_is_copula(verb: String) -> Bool
+extern fn egy_conjugate_copula(tense: String, slot: Int) -> String
+extern fn egy_rdi_present(slot: Int) -> String
+extern fn egy_rdi_past(slot: Int) -> String
+extern fn egy_rdi_future(slot: Int) -> String
+extern fn egy_mAA_present(slot: Int) -> String
+extern fn egy_mAA_past(slot: Int) -> String
+extern fn egy_mAA_future(slot: Int) -> String
+extern fn egy_Dd_present(slot: Int) -> String
+extern fn egy_Dd_past(slot: Int) -> String
+extern fn egy_Dd_future(slot: Int) -> String
+extern fn egy_Sm_present(slot: Int) -> String
+extern fn egy_Sm_past(slot: Int) -> String
+extern fn egy_Sm_future(slot: Int) -> String
+extern fn egy_iri_present(slot: Int) -> String
+extern fn egy_iri_past(slot: Int) -> String
+extern fn egy_iri_future(slot: Int) -> String
+extern fn egy_sdm_present(slot: Int) -> String
+extern fn egy_sdm_past(slot: Int) -> String
+extern fn egy_sdm_future(slot: Int) -> String
+extern fn egy_known_verb(verb: String, tense: String, slot: Int) -> String
+extern fn egy_regular_present(stem: String, slot: Int) -> String
+extern fn egy_regular_past(stem: String, slot: Int) -> String
+extern fn egy_regular_future(stem: String, slot: Int) -> String
+extern fn egy_conjugate(verb: String, tense: String, person: String, number: String) -> String
+extern fn egy_decline(noun: String, gram_case: String, number: String) -> String
+extern fn egy_fem(noun: String) -> String
+extern fn egy_noun_phrase(noun: String, gram_case: String, number: String, definite: String) -> String
+extern fn egy_map_canonical(verb: String) -> String

dist/morphology-enm.elh

@@ -0,0 +1,30 @@
+// auto-generated by elc --emit-header — do not edit
+extern fn enm_str_ends(s: String, suf: String) -> Bool
+extern fn enm_drop(s: String, n: Int) -> String
+extern fn enm_first_char(s: String) -> String
+extern fn enm_slot(person: String, number: String) -> Int
+extern fn enm_been_present(slot: Int) -> String
+extern fn enm_been_past(slot: Int) -> String
+extern fn enm_haven_present(slot: Int) -> String
+extern fn enm_haven_past(slot: Int) -> String
+extern fn enm_goon_present(slot: Int) -> String
+extern fn enm_goon_past(slot: Int) -> String
+extern fn enm_seen_present(slot: Int) -> String
+extern fn enm_seen_past(slot: Int) -> String
+extern fn enm_seyen_present(slot: Int) -> String
+extern fn enm_seyen_past(slot: Int) -> String
+extern fn enm_comen_present(slot: Int) -> String
+extern fn enm_comen_past(slot: Int) -> String
+extern fn enm_maken_present(slot: Int) -> String
+extern fn enm_maken_past(slot: Int) -> String
+extern fn enm_map_canonical(verb: String) -> String
+extern fn enm_weak_stem(verb: String) -> String
+extern fn enm_weak_present(stem: String, slot: Int) -> String
+extern fn enm_weak_past(stem: String, slot: Int) -> String
+extern fn enm_conjugate(verb: String, tense: String, person: String, number: String) -> String
+extern fn enm_irregular_plural(noun: String) -> String
+extern fn enm_make_plural(noun: String) -> String
+extern fn enm_decline(noun: String, gram_case: String, number: String) -> String
+extern fn enm_is_vowel_initial(s: String) -> Bool
+extern fn enm_indef_article(noun_phrase: String) -> String
+extern fn enm_noun_phrase(noun: String, gram_case: String, number: String, definite: String) -> String

dist/morphology-es.elh

@@ -0,0 +1,23 @@
+// auto-generated by elc --emit-header — do not edit
+extern fn es_str_ends(s: String, suf: String) -> Bool
+extern fn es_str_drop_last(s: String, n: Int) -> String
+extern fn es_str_last_char(s: String) -> String
+extern fn es_str_last2(s: String) -> String
+extern fn es_str_last3(s: String) -> String
+extern fn es_verb_class(base: String) -> String
+extern fn es_stem(base: String) -> String
+extern fn es_slot(person: String, number: String) -> Int
+extern fn es_irregular_present(verb: String, person: String, number: String) -> String
+extern fn es_irregular_preterite(verb: String, person: String, number: String) -> String
+extern fn es_irregular_imperfect(verb: String, person: String, number: String) -> String
+extern fn es_regular_present(stem: String, vclass: String, slot: Int) -> String
+extern fn es_regular_preterite(stem: String, vclass: String, slot: Int) -> String
+extern fn es_regular_future(base: String, slot: Int) -> String
+extern fn es_irregular_future_stem(verb: String) -> String
+extern fn es_regular_imperfect(stem: String, vclass: String, slot: Int) -> String
+extern fn es_conjugate(verb: String, tense: String, person: String, number: String) -> String
+extern fn es_gender(noun: String) -> String
+extern fn es_invariant_plural(noun: String) -> String
+extern fn es_pluralize(noun: String) -> String
+extern fn es_starts_with_stressed_a(noun: String) -> Bool
+extern fn es_agree_article(noun: String, definite: String, number: String) -> String

dist/morphology-fi.elh

@@ -0,0 +1,17 @@
+// auto-generated by elc --emit-header — do not edit
+extern fn fi_harmony(word: String) -> String
+extern fn fi_suffix(base: String, harmony: String) -> String
+extern fn fi_noun_case(stem: String, gram_case: String, number: String, harmony: String) -> String
+extern fn fi_str_last_char(s: String) -> String
+extern fn fi_apply_case(noun: String, gram_case: String, number: String) -> String
+extern fn fi_verb_stem(dict_form: String) -> String
+extern fn fi_irregular_verb(dict_form: String) -> [String]
+extern fn fi_present_ending(stem: String, person: String, number: String, harmony: String) -> String
+extern fn fi_past_stem(stem: String) -> String
+extern fn fi_past_ending(stem: String, person: String, number: String, harmony: String) -> String
+extern fn fi_neg_aux(person: String, number: String) -> String
+extern fn fi_negative(verb: String, person: String, number: String) -> String
+extern fn fi_conjugate(verb: String, tense: String, person: String, number: String) -> String
+extern fn fi_question_suffix(harmony: String) -> String
+extern fn fi_make_question(verb_form: String, harmony: String) -> String
+extern fn fi_full_paradigm(noun: String) -> [String]

dist/morphology-fr.elh

@@ -0,0 +1,29 @@
+// auto-generated by elc --emit-header — do not edit
+extern fn fr_str_ends(s: String, suf: String) -> Bool
+extern fn fr_str_drop_last(s: String, n: Int) -> String
+extern fn fr_str_last_char(s: String) -> String
+extern fn fr_str_last2(s: String) -> String
+extern fn fr_is_vowel_start(s: String) -> Bool
+extern fn fr_is_known_irregular(verb: String) -> Bool
+extern fn fr_verb_group(base: String) -> String
+extern fn fr_stem(base: String) -> String
+extern fn fr_slot(person: String, number: String) -> Int
+extern fn fr_irregular_present(verb: String, person: String, number: String) -> String
+extern fn fr_regular_present(stem: String, vgroup: String, slot: Int) -> String
+extern fn fr_future_stem(base: String, vgroup: String) -> String
+extern fn fr_regular_future(fstem: String, slot: Int) -> String
+extern fn fr_irregular_future_stem(verb: String) -> String
+extern fn fr_imperfect_stem(base: String, vgroup: String) -> String
+extern fn fr_regular_imperfect(istem: String, slot: Int) -> String
+extern fn fr_uses_etre(verb: String) -> Bool
+extern fn fr_past_participle(verb: String) -> String
+extern fn fr_avoir_present(slot: Int) -> String
+extern fn fr_etre_present(slot: Int) -> String
+extern fn fr_conjugate(verb: String, tense: String, person: String, number: String) -> String
+extern fn fr_gender(noun: String) -> String
+extern fn fr_invariant_plural(noun: String) -> String
+extern fn fr_pluralize(noun: String) -> String
+extern fn fr_agree_article(noun: String, definite: String, number: String) -> String
+extern fn fr_subject_starts_vowel(subject: String) -> Bool
+extern fn fr_verb_ends_vowel(verb_form: String) -> Bool
+extern fn fr_question_inversion(subject: String, verb_form: String) -> String

dist/morphology-fro.elh

@@ -0,0 +1,38 @@
+// auto-generated by elc --emit-header — do not edit
+extern fn fro_str_ends(s: String, suf: String) -> Bool
+extern fn fro_drop(s: String, n: Int) -> String
+extern fn fro_slot(person: String, number: String) -> Int
+extern fn fro_map_canonical(verb: String) -> String
+extern fn fro_estre_present(slot: Int) -> String
+extern fn fro_estre_past(slot: Int) -> String
+extern fn fro_estre_future(slot: Int) -> String
+extern fn fro_avoir_present(slot: Int) -> String
+extern fn fro_avoir_past(slot: Int) -> String
+extern fn fro_avoir_future(slot: Int) -> String
+extern fn fro_aler_present(slot: Int) -> String
+extern fn fro_aler_past(slot: Int) -> String
+extern fn fro_aler_future(slot: Int) -> String
+extern fn fro_venir_present(slot: Int) -> String
+extern fn fro_venir_past(slot: Int) -> String
+extern fn fro_venir_future(slot: Int) -> String
+extern fn fro_faire_present(slot: Int) -> String
+extern fn fro_faire_past(slot: Int) -> String
+extern fn fro_faire_future(slot: Int) -> String
+extern fn fro_verb_class(verb: String) -> String
+extern fn fro_verb_stem(verb: String, vclass: String) -> String
+extern fn fro_conj1_present(stem: String, slot: Int) -> String
+extern fn fro_conj1_past(stem: String, slot: Int) -> String
+extern fn fro_conj1_future(verb: String, slot: Int) -> String
+extern fn fro_conj2_present(stem: String, slot: Int) -> String
+extern fn fro_conj2_past(stem: String, slot: Int) -> String
+extern fn fro_conj2_future(verb: String, slot: Int) -> String
+extern fn fro_conj3_present(stem: String, slot: Int) -> String
+extern fn fro_conj3_past(stem: String, slot: Int) -> String
+extern fn fro_conj3_future(verb: String, slot: Int) -> String
+extern fn fro_conjugate(verb: String, tense: String, person: String, number: String) -> String
+extern fn fro_gender(noun: String) -> String
+extern fn fro_decline_masc(noun: String, gram_case: String, number: String) -> String
+extern fn fro_decline_fem(noun: String, number: String) -> String
+extern fn fro_decline(noun: String, gram_case: String, number: String) -> String
+extern fn fro_article(gender: String, gram_case: String, number: String) -> String
+extern fn fro_noun_phrase(noun: String, gram_case: String, number: String, definite: String) -> String

dist/morphology-gez.elh

@@ -0,0 +1,26 @@
+// auto-generated by elc --emit-header — do not edit
+extern fn gez_str_ends(s: String, suf: String) -> Bool
+extern fn gez_str_len(s: String) -> Int
+extern fn gez_str_drop_last(s: String, n: Int) -> String
+extern fn gez_slot(person: String, number: String) -> Int
+extern fn gez_slot_g(person: String, gender: String, number: String) -> Int
+extern fn gez_kwn_perfect(slot: Int) -> String
+extern fn gez_kwn_imperfect(slot: Int) -> String
+extern fn gez_is_copula(verb: String) -> Bool
+extern fn gez_conjugate_copula(tense: String, slot: Int) -> String
+extern fn gez_hlw_perfect(slot: Int) -> String
+extern fn gez_hlw_imperfect(slot: Int) -> String
+extern fn gez_hbl_perfect(slot: Int) -> String
+extern fn gez_hbl_imperfect(slot: Int) -> String
+extern fn gez_ray_perfect(slot: Int) -> String
+extern fn gez_ray_imperfect(slot: Int) -> String
+extern fn gez_qwl_perfect(slot: Int) -> String
+extern fn gez_qwl_imperfect(slot: Int) -> String
+extern fn gez_generic_perfect(base3sg: String, slot: Int) -> String
+extern fn gez_generic_imperfect(base3sg: String, slot: Int) -> String
+extern fn gez_known_verb(verb: String, tense: String, slot: Int) -> String
+extern fn gez_conjugate(verb: String, tense: String, person: String, number: String) -> String
+extern fn gez_is_fidel(noun: String) -> Bool
+extern fn gez_decline(noun: String, gram_case: String, number: String) -> String
+extern fn gez_noun_phrase(noun: String, gram_case: String, number: String, definite: String) -> String
+extern fn gez_map_canonical(verb: String) -> String

dist/morphology-goh.elh

@@ -0,0 +1,34 @@
+// auto-generated by elc --emit-header — do not edit
+extern fn goh_str_ends(s: String, suf: String) -> Bool
+extern fn goh_drop(s: String, n: Int) -> String
+extern fn goh_slot(person: String, number: String) -> Int
+extern fn goh_map_canonical(verb: String) -> String
+extern fn goh_wesan_present(slot: Int) -> String
+extern fn goh_wesan_past(slot: Int) -> String
+extern fn goh_haben_present(slot: Int) -> String
+extern fn goh_haben_past(slot: Int) -> String
+extern fn goh_gan_present(slot: Int) -> String
+extern fn goh_gan_past(slot: Int) -> String
+extern fn goh_sehan_present(slot: Int) -> String
+extern fn goh_sehan_past(slot: Int) -> String
+extern fn goh_quethan_present(slot: Int) -> String
+extern fn goh_quethan_past(slot: Int) -> String
+extern fn goh_tuon_present(slot: Int) -> String
+extern fn goh_tuon_past(slot: Int) -> String
+extern fn goh_weak_present(stem: String, slot: Int) -> String
+extern fn goh_weak_past(stem: String, slot: Int) -> String
+extern fn goh_verb_stem(verb: String) -> String
+extern fn goh_conjugate(verb: String, tense: String, person: String, number: String) -> String
+extern fn goh_stem_type(noun: String) -> String
+extern fn goh_extract_stem(noun: String, stype: String) -> String
+extern fn goh_decline_masc_a_sg(stem: String, gram_case: String) -> String
+extern fn goh_decline_masc_a_pl(stem: String, gram_case: String) -> String
+extern fn goh_decline_fem_o_sg(stem: String, gram_case: String) -> String
+extern fn goh_decline_fem_o_pl(stem: String, gram_case: String) -> String
+extern fn goh_decline_neut_a_sg(stem: String, gram_case: String) -> String
+extern fn goh_decline_neut_a_pl(stem: String, gram_case: String) -> String
+extern fn goh_decline_masc_n_sg(stem: String, gram_case: String) -> String
+extern fn goh_decline_masc_n_pl(stem: String, gram_case: String) -> String
+extern fn goh_decline(noun: String, gram_case: String, number: String) -> String
+extern fn goh_demo_article(stype: String, number: String) -> String
+extern fn goh_noun_phrase(noun: String, gram_case: String, number: String, definite: String) -> String

dist/morphology-got.elh

@@ -0,0 +1,37 @@
+// auto-generated by elc --emit-header — do not edit
+extern fn got_str_ends(s: String, suf: String) -> Bool
+extern fn got_str_drop_last(s: String, n: Int) -> String
+extern fn got_slot(person: String, number: String) -> Int
+extern fn got_map_canonical(verb: String) -> String
+extern fn got_wisan_present(slot: Int) -> String
+extern fn got_wisan_past(slot: Int) -> String
+extern fn got_haban_present(slot: Int) -> String
+extern fn got_haban_past(slot: Int) -> String
+extern fn got_gaggan_present(slot: Int) -> String
+extern fn got_gaggan_past(slot: Int) -> String
+extern fn got_saihwan_present(slot: Int) -> String
+extern fn got_saihwan_past(slot: Int) -> String
+extern fn got_qithan_present(slot: Int) -> String
+extern fn got_qithan_past(slot: Int) -> String
+extern fn got_niman_present(slot: Int) -> String
+extern fn got_niman_past(slot: Int) -> String
+extern fn got_wk1_present_ending(slot: Int) -> String
+extern fn got_wk1_past_ending(slot: Int) -> String
+extern fn got_wk1_conjugate(stem: String, tense: String, slot: Int) -> String
+extern fn got_wk2_present_ending(slot: Int) -> String
+extern fn got_wk2_past_ending(slot: Int) -> String
+extern fn got_wk2_conjugate(stem: String, tense: String, slot: Int) -> String
+extern fn got_verb_class(verb: String) -> String
+extern fn got_verb_stem(verb: String, vclass: String) -> String
+extern fn got_conjugate(verb: String, tense: String, person: String, number: String) -> String
+extern fn got_decline_a_stem_sg(stem: String, gram_case: String) -> String
+extern fn got_decline_a_stem_pl(stem: String, gram_case: String) -> String
+extern fn got_decline_o_stem_sg(stem: String, gram_case: String) -> String
+extern fn got_decline_o_stem_pl(stem: String, gram_case: String) -> String
+extern fn got_decline_n_stem_sg(stem: String, gram_case: String) -> String
+extern fn got_decline_n_stem_pl(stem: String, gram_case: String) -> String
+extern fn got_stem_type(noun: String) -> String
+extern fn got_extract_stem(noun: String, stype: String) -> String
+extern fn got_demo_article(stype: String) -> String
+extern fn got_decline(noun: String, gram_case: String, number: String) -> String
+extern fn got_noun_phrase(noun: String, gram_case: String, number: String, definite: String) -> String

dist/morphology-grc.elh

@@ -0,0 +1,45 @@
+// auto-generated by elc --emit-header — do not edit
+extern fn grc_str_ends(s: String, suf: String) -> Bool
+extern fn grc_str_drop_last(s: String, n: Int) -> String
+extern fn grc_str_last_char(s: String) -> String
+extern fn grc_str_last2(s: String) -> String
+extern fn grc_str_last3(s: String) -> String
+extern fn grc_slot(person: String, number: String) -> Int
+extern fn grc_map_canonical(verb: String) -> String
+extern fn grc_einai_present(slot: Int) -> String
+extern fn grc_einai_imperfect(slot: Int) -> String
+extern fn grc_einai_future(slot: Int) -> String
+extern fn grc_echein_present(slot: Int) -> String
+extern fn grc_echein_imperfect(slot: Int) -> String
+extern fn grc_echein_aorist(slot: Int) -> String
+extern fn grc_echein_future(slot: Int) -> String
+extern fn grc_legein_present(slot: Int) -> String
+extern fn grc_legein_imperfect(slot: Int) -> String
+extern fn grc_legein_aorist(slot: Int) -> String
+extern fn grc_legein_future(slot: Int) -> String
+extern fn grc_horao_present(slot: Int) -> String
+extern fn grc_horao_imperfect(slot: Int) -> String
+extern fn grc_horao_aorist(slot: Int) -> String
+extern fn grc_horao_future(slot: Int) -> String
+extern fn grc_erchesthai_present(slot: Int) -> String
+extern fn grc_erchesthai_imperfect(slot: Int) -> String
+extern fn grc_erchesthai_aorist(slot: Int) -> String
+extern fn grc_erchesthai_future(slot: Int) -> String
+extern fn grc_thematic_present_ending(slot: Int) -> String
+extern fn grc_thematic_imperfect_ending(slot: Int) -> String
+extern fn grc_thematic_future_ending(slot: Int) -> String
+extern fn grc_weak_aorist_ending(slot: Int) -> String
+extern fn grc_present_stem(verb: String) -> String
+extern fn grc_conjugate(verb: String, tense: String, person: String, number: String) -> String
+extern fn grc_declension(noun: String) -> String
+extern fn grc_decline_2m(stem: String, gram_case: String, number: String) -> String
+extern fn grc_decline_2n(stem: String, gram_case: String, number: String) -> String
+extern fn grc_decline_1a(stem: String, gram_case: String, number: String) -> String
+extern fn grc_decline_1e(stem: String, gram_case: String, number: String) -> String
+extern fn grc_decline(noun: String, gram_case: String, number: String) -> String
+extern fn grc_article_masculine(gram_case: String, number: String) -> String
+extern fn grc_article_feminine(gram_case: String, number: String) -> String
+extern fn grc_article_neuter(gram_case: String, number: String) -> String
+extern fn grc_article(gender: String, gram_case: String, number: String) -> String
+extern fn grc_infer_gender(noun: String) -> String
+extern fn grc_noun_phrase(noun: String, gram_case: String, number: String, definite: String) -> String

dist/morphology-he.elh

@@ -0,0 +1,30 @@
+// auto-generated by elc --emit-header — do not edit
+extern fn he_str_ends(s: String, suf: String) -> Bool
+extern fn he_str_len(s: String) -> Int
+extern fn he_str_drop_last(s: String, n: Int) -> String
+extern fn he_str_last_char(s: String) -> String
+extern fn he_slot(person: String, gender: String, number: String) -> Int
+extern fn he_present_form_code(slot: Int) -> Int
+extern fn he_copula_past(slot: Int) -> String
+extern fn he_copula_future(slot: Int) -> String
+extern fn he_is_copula(verb: String) -> Bool
+extern fn he_conjugate_copula(tense: String, slot: Int) -> String
+extern fn he_present_lir_ot(form: Int) -> String
+extern fn he_present_le_exol(form: Int) -> String
+extern fn he_present_ledaber(form: Int) -> String
+extern fn he_present_lalechet(form: Int) -> String
+extern fn he_past_lir_ot(slot: Int) -> String
+extern fn he_past_le_exol(slot: Int) -> String
+extern fn he_past_ledaber(slot: Int) -> String
+extern fn he_past_lalechet(slot: Int) -> String
+extern fn he_future_lir_ot(slot: Int) -> String
+extern fn he_future_le_exol(slot: Int) -> String
+extern fn he_future_ledaber(slot: Int) -> String
+extern fn he_future_lalechet(slot: Int) -> String
+extern fn he_known_verb(verb: String, tense: String, slot: Int) -> String
+extern fn he_conjugate(verb: String, tense: String, person: String, gender: String, number: String) -> String
+extern fn he_pluralize(noun: String, gender: String) -> String
+extern fn he_is_hebrew_script(noun: String) -> Bool
+extern fn he_definite_prefix(noun: String) -> String
+extern fn he_noun_phrase(noun: String, number: String, gender: String, definite: String) -> String
+extern fn he_map_canonical(verb: String) -> String

dist/morphology-hi.elh

@@ -0,0 +1,27 @@
+// auto-generated by elc --emit-header — do not edit
+extern fn hi_str_ends(s: String, suf: String) -> Bool
+extern fn hi_str_drop_last(s: String, n: Int) -> String
+extern fn hi_str_last_char(s: String) -> String
+extern fn hi_gender(noun: String) -> String
+extern fn hi_masc_aa_stem(noun: String) -> String
+extern fn hi_noun_direct_m(noun: String, number: String) -> String
+extern fn hi_noun_oblique_m(noun: String, number: String) -> String
+extern fn hi_noun_direct_f(noun: String, number: String) -> String
+extern fn hi_noun_oblique_f(noun: String, number: String) -> String
+extern fn hi_noun_direct(noun: String, gender: String, number: String) -> String
+extern fn hi_noun_oblique(noun: String, gender: String, number: String) -> String
+extern fn hi_postposition(gram_case: String) -> String
+extern fn hi_agree_genitive(possessed_gender: String, possessed_number: String) -> String
+extern fn hi_verb_stem(infinitive: String) -> String
+extern fn hi_verb_stem_clean(infinitive: String) -> String
+extern fn hi_present_aspect(gender: String, number: String) -> String
+extern fn hi_aux_present(person: String, number: String) -> String
+extern fn hi_past_suffix(gender: String, number: String) -> String
+extern fn hi_past_irregular(stem: String, gender: String, number: String) -> String
+extern fn hi_future_suffix(person: String, number: String, gender: String) -> String
+extern fn hi_tense_suffix(tense: String, gender: String, number: String) -> String
+extern fn hi_hona_present(person: String, number: String) -> String
+extern fn hi_hona_past(gender: String, number: String) -> String
+extern fn hi_conjugate(verb: String, tense: String, person: String, gender: String, number: String) -> String
+extern fn hi_noun_with_post(noun: String, gender: String, number: String, gram_case: String) -> String
+extern fn hi_genitive_phrase(possessor: String, possessor_gender: String, possessor_number: String, possessed: String, possessed_gender: String, possessed_number: String) -> String

dist/morphology-ja.elh

@@ -0,0 +1,9 @@
+// auto-generated by elc --emit-header — do not edit
+extern fn ja_verb_group(dict_form: String) -> String
+extern fn ja_ichidan_stem(dict_form: String) -> String
+extern fn ja_godan_stem_change(dict_form: String, row: String) -> String
+extern fn ja_conjugate(dict_form: String, form: String) -> String
+extern fn ja_particle(gram_case: String) -> String
+extern fn ja_noun_phrase(noun: String, gram_case: String) -> String
+extern fn ja_question_particle() -> String
+extern fn ja_make_question(sentence: String) -> String

dist/morphology-la.elh

@@ -0,0 +1,41 @@
+// auto-generated by elc --emit-header — do not edit
+extern fn la_str_ends(s: String, suf: String) -> Bool
+extern fn la_str_drop_last(s: String, n: Int) -> String
+extern fn la_str_last_char(s: String) -> String
+extern fn la_str_last2(s: String) -> String
+extern fn la_str_last3(s: String) -> String
+extern fn la_slot(person: String, number: String) -> Int
+extern fn la_verb_class(verb: String) -> String
+extern fn la_stem(verb: String, vclass: String) -> String
+extern fn la_perfect_stem(verb: String, vclass: String) -> String
+extern fn la_perfect_ending(slot: Int) -> String
+extern fn la_present_ending(vclass: String, slot: Int) -> String
+extern fn la_present_form(stem: String, vclass: String, slot: Int) -> String
+extern fn la_future_ending_12(slot: Int) -> String
+extern fn la_future_ending_34(slot: Int) -> String
+extern fn la_future_form(stem: String, vclass: String, slot: Int) -> String
+extern fn la_esse_present(slot: Int) -> String
+extern fn la_esse_past(slot: Int) -> String
+extern fn la_esse_future(slot: Int) -> String
+extern fn la_ire_present(slot: Int) -> String
+extern fn la_ire_past(slot: Int) -> String
+extern fn la_ire_future(slot: Int) -> String
+extern fn la_velle_present(slot: Int) -> String
+extern fn la_velle_past(slot: Int) -> String
+extern fn la_velle_future(slot: Int) -> String
+extern fn la_posse_present(slot: Int) -> String
+extern fn la_posse_past(slot: Int) -> String
+extern fn la_posse_future(slot: Int) -> String
+extern fn la_irregular_perfect_stem(verb: String) -> String
+extern fn la_map_canonical(verb: String) -> String
+extern fn la_conjugate(verb: String, tense: String, person: String, number: String) -> String
+extern fn la_declension(noun: String) -> String
+extern fn la_decline_1(stem: String, gram_case: String, number: String) -> String
+extern fn la_decline_2m(stem: String, gram_case: String, number: String) -> String
+extern fn la_decline_2n(stem: String, gram_case: String, number: String) -> String
+extern fn la_decline_3(noun: String, gram_case: String, number: String) -> String
+extern fn la_decline_4(stem: String, gram_case: String, number: String) -> String
+extern fn la_decline_5(stem: String, gram_case: String, number: String) -> String
+extern fn la_decline_2er(noun: String, gram_case: String, number: String) -> String
+extern fn la_decline(noun: String, gram_case: String, number: String) -> String
+extern fn la_noun_phrase(noun: String, gram_case: String, number: String, definite: String) -> String

dist/morphology-non.elh

@@ -0,0 +1,30 @@
+// auto-generated by elc --emit-header — do not edit
+extern fn non_str_ends(s: String, suf: String) -> Bool
+extern fn non_drop(s: String, n: Int) -> String
+extern fn non_last(s: String) -> String
+extern fn non_slot(person: String, number: String) -> Int
+extern fn non_vera_present(slot: Int) -> String
+extern fn non_vera_past(slot: Int) -> String
+extern fn non_hafa_present(slot: Int) -> String
+extern fn non_hafa_past(slot: Int) -> String
+extern fn non_ganga_present(slot: Int) -> String
+extern fn non_ganga_past(slot: Int) -> String
+extern fn non_sja_present(slot: Int) -> String
+extern fn non_sja_past(slot: Int) -> String
+extern fn non_segja_present(slot: Int) -> String
+extern fn non_segja_past(slot: Int) -> String
+extern fn non_koma_present(slot: Int) -> String
+extern fn non_koma_past(slot: Int) -> String
+extern fn non_map_canonical(verb: String) -> String
+extern fn non_weak_present(stem: String, slot: Int) -> String
+extern fn non_weak_past(stem: String, slot: Int) -> String
+extern fn non_conjugate(verb: String, tense: String, person: String, number: String) -> String
+extern fn non_decline_masc(noun: String, gram_case: String, number: String) -> String
+extern fn non_decline_fem(noun: String, gram_case: String, number: String) -> String
+extern fn non_decline_neut(noun: String, gram_case: String, number: String) -> String
+extern fn non_detect_gender(noun: String) -> String
+extern fn non_decline(noun: String, gram_case: String, number: String) -> String
+extern fn non_def_suffix_masc(gram_case: String, number: String) -> String
+extern fn non_def_suffix_neut(gram_case: String, number: String) -> String
+extern fn non_def_suffix_fem(gram_case: String, number: String) -> String
+extern fn non_noun_phrase(noun: String, gram_case: String, number: String, definite: String) -> String

dist/morphology-peo.elh

@@ -0,0 +1,19 @@
+// auto-generated by elc --emit-header — do not edit
+extern fn peo_drop(s: String, n: Int) -> String
+extern fn peo_ends(s: String, suf: String) -> Bool
+extern fn peo_slot(person: String, number: String) -> Int
+extern fn peo_present_suffix(slot: Int) -> String
+extern fn peo_past_suffix(slot: Int) -> String
+extern fn peo_ah_present(slot: Int) -> String
+extern fn peo_ah_past(slot: Int) -> String
+extern fn peo_kar_present(slot: Int) -> String
+extern fn peo_kar_past(slot: Int) -> String
+extern fn peo_xsaya_present(slot: Int) -> String
+extern fn peo_tar_present(slot: Int) -> String
+extern fn peo_da_present(slot: Int) -> String
+extern fn peo_da_past(slot: Int) -> String
+extern fn peo_map_canonical(verb: String) -> String
+extern fn peo_conjugate(verb: String, tense: String, person: String, number: String) -> String
+extern fn peo_decline_astem(noun: String, gram_case: String, number: String) -> String
+extern fn peo_decline(noun: String, gram_case: String, number: String) -> String
+extern fn peo_noun_phrase(noun: String, gram_case: String, number: String, definite: String) -> String

dist/morphology-pi.elh

@@ -0,0 +1,34 @@
+// auto-generated by elc --emit-header — do not edit
+extern fn pi_str_ends(s: String, suf: String) -> Bool
+extern fn pi_drop(s: String, n: Int) -> String
+extern fn pi_last_char(s: String) -> String
+extern fn pi_slot(person: String, number: String) -> Int
+extern fn pi_present_ending(slot: Int) -> String
+extern fn pi_aorist_ending(slot: Int) -> String
+extern fn pi_future_ending(slot: Int) -> String
+extern fn pi_hoti_present(slot: Int) -> String
+extern fn pi_atthi_present(slot: Int) -> String
+extern fn pi_hoti_aorist(slot: Int) -> String
+extern fn pi_hoti_future(slot: Int) -> String
+extern fn pi_gacchati_present(slot: Int) -> String
+extern fn pi_gacchati_aorist(slot: Int) -> String
+extern fn pi_gacchati_future(slot: Int) -> String
+extern fn pi_passati_present(slot: Int) -> String
+extern fn pi_passati_aorist(slot: Int) -> String
+extern fn pi_passati_future(slot: Int) -> String
+extern fn pi_vadati_present(slot: Int) -> String
+extern fn pi_vadati_aorist(slot: Int) -> String
+extern fn pi_vadati_future(slot: Int) -> String
+extern fn pi_karoti_present(slot: Int) -> String
+extern fn pi_karoti_aorist(slot: Int) -> String
+extern fn pi_karoti_future(slot: Int) -> String
+extern fn pi_map_canonical(verb: String) -> String
+extern fn pi_regular_root(verb: String) -> String
+extern fn pi_conjugate(verb: String, tense: String, person: String, number: String) -> String
+extern fn pi_decline_a_masc_sg(stem: String, gram_case: String) -> String
+extern fn pi_decline_a_masc_pl(stem: String, gram_case: String) -> String
+extern fn pi_decline_a_fem_sg(stem: String, gram_case: String) -> String
+extern fn pi_decline_a_fem_pl(stem: String, gram_case: String) -> String
+extern fn pi_detect_class(noun: String) -> String
+extern fn pi_decline(noun: String, gram_case: String, number: String) -> String
+extern fn pi_noun_phrase(noun: String, gram_case: String, number: String, definite: String) -> String

dist/morphology-ru.elh

@@ -0,0 +1,14 @@
+// auto-generated by elc --emit-header — do not edit
+extern fn ru_gender(noun: String) -> String
+extern fn ru_stem_type(noun: String, gender: String) -> String
+extern fn ru_noun_case(noun: String, gender: String, gram_case: String, number: String) -> String
+extern fn ru_decline_regular(noun: String, gender: String, stype: String, gram_case: String, number: String) -> String
+extern fn ru_decline_masc(noun: String, stype: String, gram_case: String, number: String) -> String
+extern fn ru_decline_fem(noun: String, stype: String, gram_case: String, number: String) -> String
+extern fn ru_decline_neut(noun: String, stype: String, gram_case: String, number: String) -> String
+extern fn ru_past_agree(verb_stem: String, gender: String, number: String) -> String
+extern fn ru_conjugate_1st(stem: String, tense: String, person: String, number: String) -> String
+extern fn ru_conjugate_2nd(stem: String, tense: String, person: String, number: String) -> String
+extern fn ru_irregular(verb: String, tense: String, person: String, number: String) -> String
+extern fn ru_past_stem(verb: String) -> String
+extern fn ru_conjugate(verb: String, tense: String, person: String, number: String, gender: String) -> String

dist/morphology-sa.elh

@@ -0,0 +1,36 @@
+// auto-generated by elc --emit-header — do not edit
+extern fn sa_str_ends(s: String, suf: String) -> Bool
+extern fn sa_str_drop_last(s: String, n: Int) -> String
+extern fn sa_slot(person: String, number: String) -> Int
+extern fn sa_map_canonical(verb: String) -> String
+extern fn sa_as_present(slot: Int) -> String
+extern fn sa_as_past(slot: Int) -> String
+extern fn sa_as_future(slot: Int) -> String
+extern fn sa_bhu_present(slot: Int) -> String
+extern fn sa_bhu_past(slot: Int) -> String
+extern fn sa_bhu_future(slot: Int) -> String
+extern fn sa_gam_present(slot: Int) -> String
+extern fn sa_gam_past(slot: Int) -> String
+extern fn sa_gam_future(slot: Int) -> String
+extern fn sa_drs_present(slot: Int) -> String
+extern fn sa_drs_past(slot: Int) -> String
+extern fn sa_drs_future(slot: Int) -> String
+extern fn sa_vad_present(slot: Int) -> String
+extern fn sa_vad_past(slot: Int) -> String
+extern fn sa_vad_future(slot: Int) -> String
+extern fn sa_kr_present(slot: Int) -> String
+extern fn sa_kr_past(slot: Int) -> String
+extern fn sa_kr_future(slot: Int) -> String
+extern fn sa_class1_present_ending(slot: Int) -> String
+extern fn sa_class1_past_ending(slot: Int) -> String
+extern fn sa_class1_future_ending(slot: Int) -> String
+extern fn sa_class1_conjugate(stem: String, tense: String, slot: Int) -> String
+extern fn sa_conjugate(verb: String, tense: String, person: String, number: String) -> String
+extern fn sa_decline_a_stem_sg(stem: String, gram_case: String) -> String
+extern fn sa_decline_a_stem_pl(stem: String, gram_case: String) -> String
+extern fn sa_decline_aa_stem_sg(stem: String, gram_case: String) -> String
+extern fn sa_decline_aa_stem_pl(stem: String, gram_case: String) -> String
+extern fn sa_stem_type(noun: String) -> String
+extern fn sa_extract_stem(noun: String, stype: String) -> String
+extern fn sa_decline(noun: String, gram_case: String, number: String) -> String
+extern fn sa_noun_phrase(noun: String, gram_case: String, number: String, definite: String) -> String

dist/morphology-sga.elh

@@ -0,0 +1,22 @@
+// auto-generated by elc --emit-header — do not edit
+extern fn sga_drop(s: String, n: Int) -> String
+extern fn sga_first(s: String) -> String
+extern fn sga_rest(s: String) -> String
+extern fn sga_slot(person: String, number: String) -> Int
+extern fn sga_lenite(word: String) -> String
+extern fn sga_copula_present(slot: Int) -> String
+extern fn sga_bith_present(slot: Int) -> String
+extern fn sga_bith_past(slot: Int) -> String
+extern fn sga_teit_present(slot: Int) -> String
+extern fn sga_teit_past(slot: Int) -> String
+extern fn sga_gaibid_present(slot: Int) -> String
+extern fn sga_adci_present(slot: Int) -> String
+extern fn sga_asbeir_present(slot: Int) -> String
+extern fn sga_map_canonical(verb: String) -> String
+extern fn sga_ai_present(stem: String, slot: Int) -> String
+extern fn sga_conjugate(verb: String, tense: String, person: String, number: String) -> String
+extern fn sga_decline_ostem(noun: String, gram_case: String, number: String) -> String
+extern fn sga_decline_astem(noun: String, gram_case: String, number: String) -> String
+extern fn sga_detect_gender(noun: String) -> String
+extern fn sga_decline(noun: String, gram_case: String, number: String) -> String
+extern fn sga_noun_phrase(noun: String, gram_case: String, number: String, definite: String) -> String

dist/morphology-sux.elh

@@ -0,0 +1,29 @@
+// auto-generated by elc --emit-header — do not edit
+extern fn sux_str_ends(s: String, suf: String) -> Bool
+extern fn sux_str_drop_last(s: String, n: Int) -> String
+extern fn sux_str_last_char(s: String) -> String
+extern fn sux_str_last2(s: String) -> String
+extern fn sux_slot(person: String, number: String) -> Int
+extern fn sux_ergative_suffix(person: String, number: String) -> String
+extern fn sux_absolutive_suffix(person: String, number: String) -> String
+extern fn sux_map_canonical(verb: String) -> String
+extern fn sux_personal_suffix(slot: Int) -> String
+extern fn sux_me_present(slot: Int) -> String
+extern fn sux_me_past(slot: Int) -> String
+extern fn sux_dug4_present(slot: Int) -> String
+extern fn sux_dug4_past(slot: Int) -> String
+extern fn sux_du_present(slot: Int) -> String
+extern fn sux_du_past(slot: Int) -> String
+extern fn sux_igibar_present(slot: Int) -> String
+extern fn sux_igibar_past(slot: Int) -> String
+extern fn sux_ak_present(slot: Int) -> String
+extern fn sux_ak_past(slot: Int) -> String
+extern fn sux_tum2_present(slot: Int) -> String
+extern fn sux_tum2_past(slot: Int) -> String
+extern fn sux_conjugate(verb: String, tense: String, person: String, number: String) -> String
+extern fn sux_is_animate(noun: String) -> Bool
+extern fn sux_case_suffix(gram_case: String) -> String
+extern fn sux_decline(noun: String, gram_case: String, number: String) -> String
+extern fn sux_noun_phrase(noun: String, gram_case: String, number: String, definite: String) -> String
+extern fn sux_verb_chain(agent: String, verb: String, patient: String, tense: String) -> String
+extern fn sux_realize_sentence(intent: String, agent: String, predicate: String, patient: String, tense: String) -> String

dist/morphology-sw.elh

@@ -0,0 +1,23 @@
+// auto-generated by elc --emit-header — do not edit
+extern fn sw_str_ends(s: String, suf: String) -> Bool
+extern fn sw_str_drop_last(s: String, n: Int) -> String
+extern fn sw_str_first_char(s: String) -> String
+extern fn sw_str_first2(s: String) -> String
+extern fn sw_str_first3(s: String) -> String
+extern fn sw_str_last_char(s: String) -> String
+extern fn sw_is_class1_noun(noun: String) -> Bool
+extern fn sw_noun_class(noun: String) -> String
+extern fn sw_subj_prefix(person: String, number: String, noun_class: String) -> String
+extern fn sw_obj_prefix(person: String, number: String, noun_class: String) -> String
+extern fn sw_tense_marker(tense: String) -> String
+extern fn sw_verb_final(tense: String, negative: Bool) -> String
+extern fn sw_neg_subj_prefix(person: String, number: String, noun_class: String) -> String
+extern fn sw_verb_stem(infinitive: String) -> String
+extern fn sw_conjugate(verb_stem: String, person: String, number: String, noun_class: String, tense: String) -> String
+extern fn sw_negative(verb_stem: String, person: String, number: String, noun_class: String, tense: String) -> String
+extern fn sw_noun_plural(noun: String) -> String
+extern fn sw_adj_prefix(noun_class: String, number: String) -> String
+extern fn sw_agree_adj(adj_stem: String, noun_class: String, number: String) -> String
+extern fn sw_demonstrative(noun_class: String, number: String, proximity: String) -> String
+extern fn sw_copula_present(person: String, number: String, use_case: String) -> String
+extern fn sw_copula_neg_present(person: String, number: String) -> String

dist/morphology-txb.elh

@@ -0,0 +1,17 @@
+// auto-generated by elc --emit-header — do not edit
+extern fn txb_drop(s: String, n: Int) -> String
+extern fn txb_ends(s: String, suf: String) -> Bool
+extern fn txb_slot(person: String, number: String) -> Int
+extern fn txb_pres1_suffix(slot: Int) -> String
+extern fn txb_kam_present(slot: Int) -> String
+extern fn txb_ya_present(slot: Int) -> String
+extern fn txb_wes_present(slot: Int) -> String
+extern fn txb_lyut_present(slot: Int) -> String
+extern fn txb_wak_present(slot: Int) -> String
+extern fn txb_map_canonical(verb: String) -> String
+extern fn txb_conjugate(verb: String, tense: String, person: String, number: String) -> String
+extern fn txb_decline_masc(noun: String, gram_case: String, number: String) -> String
+extern fn txb_decline_fem(noun: String, gram_case: String, number: String) -> String
+extern fn txb_detect_gender(noun: String) -> String
+extern fn txb_decline(noun: String, gram_case: String, number: String) -> String
+extern fn txb_noun_phrase(noun: String, gram_case: String, number: String, definite: String) -> String

dist/morphology-uga.elh

@@ -0,0 +1,25 @@
+// auto-generated by elc --emit-header — do not edit
+extern fn uga_str_ends(s: String, suf: String) -> Bool
+extern fn uga_str_len(s: String) -> Int
+extern fn uga_str_drop_last(s: String, n: Int) -> String
+extern fn uga_slot(person: String, number: String) -> Int
+extern fn uga_slot_g(person: String, gender: String, number: String) -> Int
+extern fn uga_kn_perfect(slot: Int) -> String
+extern fn uga_kn_imperfect(slot: Int) -> String
+extern fn uga_is_copula(verb: String) -> Bool
+extern fn uga_conjugate_copula(tense: String, slot: Int) -> String
+extern fn uga_hlk_perfect(slot: Int) -> String
+extern fn uga_hlk_imperfect(slot: Int) -> String
+extern fn uga_ray_perfect(slot: Int) -> String
+extern fn uga_ray_imperfect(slot: Int) -> String
+extern fn uga_amr_perfect(slot: Int) -> String
+extern fn uga_amr_imperfect(slot: Int) -> String
+extern fn uga_generic_perfect(base3sg: String, slot: Int) -> String
+extern fn uga_generic_imperfect(base3sg: String, slot: Int) -> String
+extern fn uga_known_verb(verb: String, tense: String, slot: Int) -> String
+extern fn uga_conjugate(verb: String, tense: String, person: String, number: String) -> String
+extern fn uga_strip_nom(noun: String) -> String
+extern fn uga_is_fem(noun: String) -> Bool
+extern fn uga_decline(noun: String, gram_case: String, number: String) -> String
+extern fn uga_noun_phrase(noun: String, gram_case: String, number: String, definite: String) -> String
+extern fn uga_map_canonical(verb: String) -> String

dist/morphology.elh

@@ -0,0 +1,27 @@
+// auto-generated by elc --emit-header — do not edit
+extern fn str_ends(s: String, suf: String) -> Bool
+extern fn str_last_char(s: String) -> String
+extern fn str_last2(s: String) -> String
+extern fn str_last3(s: String) -> String
+extern fn str_drop_last(s: String, n: Int) -> String
+extern fn is_vowel(c: String) -> Bool
+extern fn morph_apply_suffix(base: String, suffix: String) -> String
+extern fn en_irregular_plural(word: String) -> String
+extern fn en_irregular_singular(word: String) -> String
+extern fn en_irregular_verb(base: String) -> [String]
+extern fn en_verb_3sg(base: String) -> String
+extern fn en_should_double_final(base: String) -> Bool
+extern fn en_verb_past(base: String) -> String
+extern fn en_verb_gerund(base: String) -> String
+extern fn en_pluralize_regular(singular: String) -> String
+extern fn en_verb_form(base: String, tense: String, person: String, number: String) -> String
+extern fn agree_determiner(det: String, noun: String) -> String
+extern fn morph_pluralize(noun: String, profile: [String]) -> String
+extern fn morph_map_canonical(verb: String, code: String) -> String
+extern fn morph_conjugate(verb: String, tense: String, person: String, number: String, profile: [String]) -> String
+extern fn morph_inflect(word: String, features: String, profile: [String]) -> String
+extern fn pluralize(singular: String) -> String
+extern fn singularize(plural: String) -> String
+extern fn verb_form(base: String, tense: String, person: String, number: String) -> String
+extern fn irregular_plural(word: String) -> String
+extern fn irregular_singular(word: String) -> String

dist/neuron-api.elh

@@ -0,0 +1,39 @@
+// auto-generated by elc --emit-header — do not edit
+extern fn is_protected_node(id: String) -> Bool
+extern fn api_err_protected(id: String) -> String
+extern fn api_json_escape(s: String) -> String
+extern fn api_query_param(path: String, key: String) -> String
+extern fn api_query_int(path: String, key: String, default_val: Int) -> Int
+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_persisted(id: String) -> Bool
+extern fn api_not_persisted(id: 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
+extern fn handle_api_node_create(body: String) -> String
+extern fn handle_api_node_delete(body: String) -> String
+extern fn handle_api_node_update(body: String) -> String
+extern fn handle_api_recall(method: String, path: String, body: String) -> String
+extern fn handle_api_search_knowledge(method: String, path: String, body: String) -> String
+extern fn handle_api_browse_knowledge(path: String, body: String) -> String
+extern fn handle_api_capture_knowledge(body: String) -> String
+extern fn handle_api_evolve_knowledge(body: String) -> String
+extern fn handle_api_promote_knowledge(body: String) -> String
+extern fn handle_api_browse_processes(method: String, path: String, body: String) -> String
+extern fn handle_api_define_process(body: String) -> String
+extern fn handle_api_log_state_event(body: String) -> String
+extern fn handle_api_list_state_events(method: String, path: String, body: String) -> String
+extern fn handle_api_inspect_config(path: String, body: String) -> String
+extern fn handle_api_tune_config(body: String) -> String
+extern fn handle_api_inspect_graph(method: String, path: String, body: String) -> String
+extern fn handle_api_link_entities(body: String) -> String
+extern fn handle_api_forget(body: String) -> String
+extern fn handle_api_evolve_memory(body: String) -> String
+extern fn handle_api_memory_delete(body: String) -> String
+extern fn handle_api_memory_update(body: String) -> String
+extern fn handle_api_cultivate(body: String) -> String
+extern fn handle_api_list_typed(node_type: String, path: String, body: String) -> String
+extern fn handle_api_consolidate(body: String) -> String

dist/neuron.c

@@ -71,7 +71,6 @@ el_val_t imprint_unload(void);
 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);

dist/realizer.elh

@@ -0,0 +1,10 @@
+// auto-generated by elc --emit-header — do not edit
+extern fn agent_person(agent: String) -> String
+extern fn agent_number(agent: String) -> String
+extern fn realize_np(referent: String, number: String) -> String
+extern fn realize_vp_lang(base_verb: String, tense: String, aspect: String, person: String, number: String, profile: [String]) -> [String]
+extern fn realize_question_lang(predicate: String, tense: String, aspect: String, person: String, number: String, agent: String, patient: String, location: String, profile: [String]) -> String
+extern fn capitalize_first(s: String) -> String
+extern fn add_punct(s: String, intent: String) -> String
+extern fn realize_lang(form: [String], profile: [String]) -> String
+extern fn realize(form: [String]) -> String

dist/routes.c

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

dist/routes.elh

@@ -0,0 +1,16 @@
+// 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
+extern fn err_405(method: String, path: String) -> String
+extern fn route_health() -> String
+extern fn route_lineage() -> String
+extern fn route_imprint_contextual(body: String) -> String
+extern fn route_imprint_user(body: String) -> String
+extern fn route_synthesize(body: String) -> String
+extern fn handle_dharma_recv(body: String) -> String
+extern fn connectd_get(suffix: String) -> String
+extern fn connectd_post(suffix: String, body: String) -> String
+extern fn handle_connectors(method: String, clean: String, body: String) -> String
+extern fn handle_request(method: String, path: String, body: String) -> String

dist/safety.elh

@@ -0,0 +1,29 @@
+// auto-generated by elc --emit-header — do not edit
+extern fn soft_bell_threshold() -> Int
+extern fn hard_bell_threshold() -> Int
+extern fn safety_score_crisis(input: String) -> Int
+extern fn safety_score_harm(input: String) -> Int
+extern fn safety_score_danger(input: String) -> Int
+extern fn safety_score_distress_history(history: String) -> Int
+extern fn safety_threat_score(input: String, history: String) -> Int
+extern fn safety_screen(input: String, history: String) -> String
+extern fn safety_validate(output: String, action: String) -> String
+extern fn safety_log_bell(level: String, reason: String, input_summary: String) -> String
+extern fn safety_self_harm_phrases() -> String
+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
+extern fn safety_soft_directive() -> String
+extern fn safety_hard_directive(hard_type: String) -> String
+extern fn safety_augment_system(system: String, user_msg: String) -> String
+extern fn safety_contact_path() -> String
+extern fn handle_safety_contact_get() -> String
+extern fn handle_safety_contact_post(body: String) -> String

dist/semantics.elh

@@ -0,0 +1,18 @@
+// auto-generated by elc --emit-header — do not edit
+extern fn sem_frame(intent: String, subject: String, obj: String, modifiers: String) -> [String]
+extern fn sem_frame_lang(intent: String, subject: String, obj: String, modifiers: String, lang_code: String) -> [String]
+extern fn sem_frame_simple(intent: String, subject: String) -> [String]
+extern fn sem_frame_obj(intent: String, subject: String, obj: String) -> [String]
+extern fn sem_intent(frame: [String]) -> String
+extern fn sem_subject(frame: [String]) -> String
+extern fn sem_object(frame: [String]) -> String
+extern fn sem_modifiers(frame: [String]) -> String
+extern fn sem_lang(frame: [String]) -> String
+extern fn sem_first_modifier(mods: String) -> String
+extern fn sem_intent_to_realize(intent: String) -> String
+extern fn sem_to_spec(frame: [String]) -> [String]
+extern fn sem_to_spec_full(frame: [String], verb: String, tense: String, aspect: String) -> [String]
+extern fn sem_realize_greet(subject: String) -> String
+extern fn sem_realize(frame: [String]) -> String
+extern fn sem_realize_full(frame: [String], verb: String, tense: String, aspect: String) -> String
+extern fn sem_realize_lang(frame: [String], lang_code: String) -> String

dist/sessions.elh

@@ -0,0 +1,17 @@
+// auto-generated by elc --emit-header — do not edit
+extern fn session_title_from_message(message: String) -> String
+extern fn session_make_content(id: String, title: String, created_at: Int, updated_at: Int, folder: String) -> String
+extern fn session_exists(session_id: String) -> Bool
+extern fn session_create(body: String) -> String
+extern fn session_create_cleanup(session_id: String) -> String
+extern fn session_list() -> String
+extern fn session_get(session_id: String) -> String
+extern fn session_delete(session_id: String) -> String
+extern fn session_update_patch(session_id: String, body: String) -> String
+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

dist/soul.c.stamp

@@ -1,19 +0,0 @@
-# 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 3293d35e6659b05164bb07c01ad1cc2bc4ff49859d33203528cc44e8a7f0dd1f
-# generated_amalgam_bytes  1259295
-MISSING  __compiler__
-6d8594cd93fcaaf930eda162e5922cf51724d12909050cb4f5fde33bac04db89  awareness.el
-2ff2dada732918c788a9ef66c6fd54c7a24cc4bbd4829197fe945d3a75ca1929  chat.el
-42288c212cbf72fb1e8ecbd4d9900e4e9ee1cfa475b7974295c7637f1bf2939f  elp-input.el
-b3f77f49d6086932c38bd17fe7a5eaf8bce25685f6fc3e1750f05729c6b49b9e  imprint.el
-fba8ffdb9ba72bca5b09ca1c93a520edc52f3f4d8aec2c7585fe9b17e06420b2  manifest.el
-550a72e234ae8cec1f33e02108fd365353f45edd88513da90b792e79b6c0e5f0  memory.el
-34a2fc38f2022069506b1d71b2c1cceb1a2e3b01a1c03bc8026a00e88a842a6d  neuron-api.el
-03c47c451e0e87f2c252cadb4b765867943962a804f548dd53adeef0520912c8  persist.el
-6f1f3d51a51614bbd72b828c98483dbc733f59f4c4101d0c8284dec1c31ef256  routes.el
-c28e36952ec56525963a0bdf29455ab097d3b0c5653d19c25fbb005e1069a1f7  safety.el
-fd3ab91d0ae0ea26639e21bef2f8f94054dc4b02eae68b19e3fe689d2769aad4  sessions.el
-5613b60d74d5d7768f46da5ac435a5dd99d38c27f0f7013c89fa27e98dc8a21c  soul.el
-30337940905171a9645b0929f0a412ce6b3dccb1246495070c553bca0bbae6cd  stewardship.el
-95dab72be4ee1dd1d28bab63412964a72460126951764e3f74b1c2d49b6d7b35  studio.el

dist/soul.elh

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

dist/stewardship.elh

@@ -0,0 +1,11 @@
+// auto-generated by elc --emit-header — do not edit
+extern fn steward_log_event(kind: String, detail: String) -> Void
+extern fn steward_get_mission() -> String
+extern fn steward_align(input: String, imprint_id: String) -> String
+extern fn steward_validate_imprint(imprint_id: String, tool_name: String) -> String
+extern fn steward_cgi_check(action: String) -> String
+extern fn steward_fingerprint_session(input: String, session_id: String) -> String
+extern fn extract_dim(content: String, key: String) -> String
+extern fn steward_build_baseline() -> String
+extern fn steward_check_continuity(current_fingerprint: String, session_id: String) -> String
+extern fn steward_session_check(input: String, session_id: String) -> String

dist/studio.elh

@@ -0,0 +1,12 @@
+// auto-generated by elc --emit-header — do not edit
+extern fn auth_headers(tok: String) -> Map
+extern fn axon_get(path: String) -> String
+extern fn axon_post(path: String, body: String) -> String
+extern fn handle_conversations(method: String) -> String
+extern fn handle_config(method: String, body: String) -> String
+extern fn dharma_registry() -> String
+extern fn dharma_network_state() -> String
+extern fn handle_dharma(path: String, method: String, body: String) -> String
+extern fn handle_tool(path: String, method: String, body: String) -> String
+extern fn handle_nlg(path: String, method: String, body: String) -> String
+extern fn render_studio() -> String

dist/vocabulary.elh

@@ -0,0 +1,20 @@
+// auto-generated by elc --emit-header — do not edit
+extern fn lex_word(entry: [String]) -> String
+extern fn lex_pos(entry: [String]) -> String
+extern fn lex_form(entry: [String], idx: Int) -> String
+extern fn lex_class(entry: [String]) -> String
+extern fn make_entry(word: String, pos: String, f0: String, f1: String, f2: String, f3: String, f4: String, cls: String) -> [String]
+extern fn make_entry2(word: String, pos: String, f0: String, f1: String, cls: String) -> [String]
+extern fn make_entry3(word: String, pos: String, f0: String, f1: String, f2: String, cls: String) -> [String]
+extern fn make_entry1(word: String, pos: String, f0: String, cls: String) -> [String]
+extern fn build_vocab() -> [[String]]
+extern fn get_vocab() -> [[String]]
+extern fn vocab_lookup(word: String, lang_code: String) -> [String]
+extern fn vocab_lookup_en(word: String) -> [String]
+extern fn vocab_synonym(word: String, lang_register: String, lang_code: String) -> String
+extern fn vocab_by_pos(pos: String) -> [[String]]
+extern fn vocab_by_class(cls: String) -> [[String]]
+extern fn entry_found(entry: [String]) -> Bool
+extern fn entry_word(entry: [String]) -> String
+extern fn entry_pos(entry: [String]) -> String
+extern fn entry_form(entry: [String], n: Int) -> String

docs/architecture/00-overview.md

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

docs/architecture/01-vbd-decomposition.md

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

docs/architecture/02-components.md

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

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

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

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

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

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

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

docs/architecture/06-cognitive-architecture.md

@@ -1,511 +0,0 @@
-# Neuron — Cognitive Architecture
-
-> **Status: living design document, grounded in source and probed against the live soul (2026-08-13).**
-> This is the *middle layer* of the documentation: below the whitepaper's thesis
-> (`~/Writing/whitepapers/engram-cognitive-architecture-whitepaper.md`, **v1.5**) and above the
-> endpoint reference (`~/work/engram-api-reference.md`). It documents *how the mind is designed and why*,
-> as designed subsystems with data-flow and honest per-section status.
->
-> Every claim carries a tier and it is never blurred:
-> **LIVE** (present and verified in the running system), **STAGED** (built, gated or not yet cut into the
-> running soul), **DESIGNED** (architecture decided, not yet built). Where the live state is more subtle
-> than a single word, the subtlety is stated rather than smoothed. No fabricated numbers.
-
----
-
-## 0. Reading order & cross-references
-
-- **Thesis / why:** whitepaper v1.5 (the treatise). Sections cited below as *(WP §N)*.
-- **Surface / what:** `~/work/engram-api-reference.md` — every `:8742` endpoint, tiered LIVE/STAGED/DESIGNED.
-- **Substrate / where it physically lives:** `03-data-and-memory.md` (node/edge model), `04-runtime-and-deployment.md` (ports/process), `05-el-and-build.md` (the El runtime and `el_runtime.c`), `design/engram-tiered-storage-engine.md` + `design/engram-storage-engine-wal.md` (the storage engine).
-- **Storage coherence & distribution / how a self persists and travels:** `07-storage-coherence-and-distribution.md` — the events-become-the-graph model, weights-as-world-lines + bitemporal timestamps + `recall_at`, transactionless coherence, the geometry-hot/payload-cold load-and-tiering model, and the honest operational findings (store bloat, full-resident load path).
-- **Sovereignty & governance / the moral mechanism:** `08-dharma-sovereignty-and-governance.md` — DHARMA as a distributed ledger (proof-of-integrity, not proof-of-work), abundance economics, the relational immune system, dual-anchor governance and due-process, seeds/seed-vault, and CGI citizenship as the moral telos.
-- **Governance (engineering style):** `ARCHITECTURE-CHARTER.md` — VBD is the binding style.
-
-This document is the cognitive-layer companion to that set. The temporal model sketched in §3.4 (world-tube,
-append-only, `created_at ≤ T` filter) and the honest weight-history boundary in §3.2 are developed in full in
-`07`; the sovereignty invariant that the self-gate (§7) and immutability (§3.4) protect locally is extended to
-the *distributed* setting — how a sovereign self is witnessed, defended, and governed among a billion others —
-in `08`.
-
----
-
-## 1. System overview — meaning is geometry, code is the residue
-
-The organizing thesis of the whole system: **meaning is geometry.** Everything the mind holds — a fact,
-a language, a skill, a self — is a *region* or a *trajectory* in one shared meaning-manifold, and every
-operation over it reduces to three domain-blind verbs: **READ** (project a query, land on a region, read
-it out), **TRANSFORM** (compose/compare/combine regions), **WRITE** (bake a verified result back into the
-geometry). Code is what is left over once meaning has been made geometric — the residue, not the substance.
-This is developed in full in *(WP §1–§5)*; it is repeated here only as the frame the subsystems below hang on.
-
-Three processes run together (see `00-overview.md`):
-
-- **The soul** — the compiled El program (`soul.el`, `routes.el`, `awareness.el`). Owns the HTTP surface on
-  `:7770`, the cognitive API, the request pipeline (`layered_cycle`), and the autonomous awareness daemon.
-- **The engram** — the durable graph store. Node/edge model, spreading activation, and Hebbian co-activation
-  live in the shared El runtime (`el_runtime.c`); `engram/src/server.el` is a thin HTTP face on `:8742`.
-- **The El runtime** — `el_runtime.c`: every compiled El binary links it; it *is* the database (no SQL, no
-  SQLite). It implements the `engram_*`, `http_*`, `json_*`, LLM, and geometry builtins.
-
-```
-                        ┌─────────────────────────────────────────────────────┐
-   MCP / CLI / viz ───► │  SOUL daemon  :7770  (soul.el · routes.el)           │
-   Will's sessions      │   layered_cycle · cognitive API · awareness loop     │
-                        │   ┌───────────────────────────────────────────────┐ │
-                        │   │ in-process engram  (FAST, VOLATILE*)           │ │
-                        │   │  online Hebbian learning · WM · curiosity      │ │
-                        │   └───────────────────────────────────────────────┘ │
-                        └───────────────┬──────────────────────▲──────────────┘
-                                        │ GET /api/sync (10 min)│  (HTTP → soul only;
-                                        │ merge non-ISE nodes   │   NEVER soul → HTTP)
-                                        ▼                       │
-                        ┌─────────────────────────────────────────────────────┐
-                        │  ENGRAM server  :8742  (engram/src/server.el)        │
-                        │   DURABLE · WAL-backed paged store (neuron.egm)      │
-                        │   nodes · edges · embeddings · reified neighborhoods │
-                        └─────────────────────────────────────────────────────┘
-                                        ▲
-                                        │  el_runtime.c  (the engine: engram_* / geometry / activation)
-```
-`*` The soul's in-process store is volatile in HTTP-engram mode — see §2, the two-store topology.
-
-**Status:** the substrate and the geometry thesis are **LIVE/architectural**; the faculties built on top are
-tiered individually in §6.
-
----
-
-## 2. The engram substrate & durability
-
-### 2.1 Tiered storage (LIVE, flag-gated)
-
-The durable engram is a **paged, WAL-backed store** (`neuron.egm`), gated behind `ENGRAM_STORE`. With the
-store on, the paged store is the durable owner; a *checkpoint* flushes dirty pages behind a WAL-durable
-record (durable the moment the WAL fsyncs). With it off, behavior is byte-for-byte the historical
-full-snapshot (`snapshot.json`) path. Design detail: `design/engram-tiered-storage-engine.md`,
-`design/engram-storage-engine-wal.md`.
-
-### 2.2 The durability model — the #56 fix and the harmful checkpoint
-
-The durability story is written in scars, and the honesty here is load-bearing:
-
-- **The #56 fix — load-merge persistence (LIVE / reboot-proven).** The paged store historically persisted
-  **nodes + embeddings but not the edge set**; the edges lived in JSON exports loaded via `/api/load-merge`.
-  A cold boot could therefore reconstruct a graph with **0 edges**. The #56 `load_merge`-persist fix closes
-  this — the load-merged edges are now persisted so the **events become the graph**: `persist_canonical()`
-  checkpoints the paged store behind a WAL record rather than depending on a full `snapshot.json` rewrite.
-  This fix is **LIVE and reboot-proven** (doc 07 §1). What remains **decision-pending** is only the further
-  hardening — the WAL owning the edge set outright, so durability no longer leans on the auto-remerge net
-  (below) — not the load-merge-persist fix itself, which is shipped.
-- **The harmful checkpoint (LIVE caveat).** `/api/checkpoint` **after** an `/api/load-merge` *corrupts* the
-  paged store — next boot = 0 edges. The per-beat tick-checkpoint that once ran was therefore **actively
-  harmful** and was stripped. Checkpoint is safe after in-RAM mutation; it is not safe as a blind
-  post-merge flush.
-- **The auto-remerge net (LIVE interim).** `engram-wrapped.sh` auto-reloads the full edge set on any restart
-  (~10s), proven by an actual `launchctl kickstart -k` restart recovering to the full edge count. This is a
-  **safety net, not the cure** — it mitigates the persistence gap to a bounded, always-recoverable window.
-
-The lesson, recorded so it is not repeated: **a restart, not a claim, is the durability gate.** An agent
-killed mid-live-mutation caused the 2026-08-13 incident; blue/green backup discipline recovered it; the fix
-must make restarts *safe*, not merely work once.
-
-### 2.3 The two-store topology (LIVE — and a known architectural issue)
-
-**This is the most important and least obvious fact about the runtime.** There are **two** engram stores,
-not one:
-
-| | Soul in-process store | Durable engram (`:8742`) |
-|---|---|---|
-| Port / owner | `:7770`, the soul daemon | `:8742`, `engram/src/server.el` |
-| Role | **fast, volatile** — online Hebbian learning, WM, curiosity | **slow, durable** — WAL-backed `neuron.egm` |
-| Persistence (HTTP-engram mode) | volatile; only persists if `soul_snapshot_path` is set (`awareness.el:1270-1275`) | durable, checkpointed |
-| Learns online | yes (1,198 hebbian/day observed) | no (lazy backfill only) |
-
-The two stores drift apart by design. A source comment records the observed divergence directly
-(`awareness.el:41-42`): *soul in-process ≈ 42,426 edges / 1,198 hebbian* vs *:8742 durable ≈ 41,213 edges /
-49 hebbian*. The soul learns fast and volatile; the durable store lags.
-
-**The write-through gap (known issue).** Sync is **one-directional**: `GET /api/sync` flows **HTTP → soul**
-(the soul merges non-ISE nodes from `:8742` into its in-process store every ~10 min), and **never soul →
-HTTP** (`soul.el:350-351`, verbatim: *"engram_node_full above writes only the soul's in-process store, and
-sync flows HTTP→soul, never the reverse"*). The consequence:
-
-> **Any write made directly to the soul's in-process store — including `POST /api/neuron/cultivate`
-> (§7) and the Persona/session-start nodes the soul creates itself — lands in the volatile store and does
-> not write through to the durable `:8742`.** In HTTP-engram mode, unless the soul's local in-process
-> snapshot path is configured, those writes are also lost on a soul restart, and they never reach the
-> authoritative durable store either way.
-
-This is documented here as a **known architectural issue**, not a settled design. Cultivation of the self
-(the highest-value, most intentional writes in the system) currently targets the store *least* likely to
-persist them. The clean fix is a write-through cultivate path (write to `:8742`, let sync pull it back) or a
-bidirectional consolidation flush; it is not yet built.
-
-### 2.4 The clean-reseed model (DESIGNED/operational)
-
-Because the durable store is authoritative and the reified geometry (§4) is derived, the operational reset is
-a **clean reseed**: rebuild the durable graph from a known-good snapshot/export, re-run reification to
-repopulate the `Neighborhood` nodes, and let the soul re-sync. The 28→187 neighborhood reseed (§4) is an
-instance of this: reification is a derivable pass, so the geometry can always be regrown from the substrate.
-
----
-
-## 3. The data model
-
-Grounded in `03-data-and-memory.md`; summarized here for the cognitive reader.
-
-### 3.1 Nodes
-
-`node_type` is a free `char*`, defaulting to `"Memory"` when unset — types are **string conventions**, not an
-enum. The types that matter cognitively:
-
-| node_type | role | default salience |
-|---|---|---|
-| `Memory` | episodic/experiential (default) | 0.40 |
-| `Knowledge` | stable reference; identity/values are Knowledge nodes | 0.20 |
-| `Process` | procedural / workflow (convention) | — |
-| `Conversation` / `Artifact` | first-class dialogue & outputs (WP §9; convention) | — |
-| `Neighborhood` | **reified geometry-as-value** (§4) — new first-class type | — |
-| `InternalStateEvent` (ISE) | telemetry (heartbeat, curiosity, session-start) | ~0.05 (fires easily) |
-| `Tombstone` | immutable-delete marker (§3.4) | — |
-
-Each node carries `id`, `content`, `node_type`, `label`, `tier`, `tags`, `metadata`, an embedding (when
-embed-eligible), and timestamps.
-
-### 3.2 Edges
-
-Directed, typed, weighted. Fields: `from_id`, `to_id`, `relation`, `weight`, `confidence`, `created_at`,
-`last_fired`, `inhibitory`, `layer_id`. Relations include `semantic-similar` (kNN auto-connect),
-`member` (neighborhood → constituent), `supersedes` (provenance chains), containment (nested neighborhoods),
-and Hebbian co-activation edges formed by firing together. **Inhibitory** edges (`inhibitory=1`) suppress
-rather than spread. Weights are present-value moving averages — there is **no stored weight-history** (the
-honest boundary of *(WP §2)*). The designed cure — magnitude as a *world-line* of keyframes evaluable at any
-past instant (`recall_at`), on three independent bitemporal axes — is specified in `07` §2.
-
-### 3.3 Embeddings & the activation score
-
-Embeddings are 768-dim (`nomic-embed-text`). Retrieval is **spreading activation**, scored by a four-factor
-product *(the four factors are: source activation × edge weight × per-node salience × query-embedding
-similarity)* — this is the activation score, and per-node **salience** is one of its four terms, a durable
-per-node weight that also decays (ACT-R base-level style). No data is retrievable by any means other than
-activation. Live census (probed 2026-08-13): ~11,463 nodes, ~43,463 edges, 5 layers, ~4,400 embedded (4,423
-at measurement).
-
-### 3.4 Immutability — the world-tube, append-only, tombstone-not-delete
-
-The governing discipline *(WP §1.2, §10)*: **evolve or forget, supersede with provenance, never leave a stale
-canonical, never hard-delete.** A node is never mutated in place and never truly deleted — a "delete" is a
-**tombstone** (keep node + edges, record the marker; `neuron-api.el`, `03-data-and-memory.md:151`). Change is
-a **new** node plus a `supersedes` edge to the prior. `created_at` makes every node a point on a **world-tube**
-*(WP §6)* — a trajectory with temporal extent — so a past state is a *filter* over immutable provenance
-(nodes with `created_at ≤ T`), not a transaction-log replay. **Status: LIVE.**
-
----
-
-## 4. Neighborhoods as first-class nodes (LIVE)
-
-The central newly-landed structure, and the point where the geometry stops being a derived view and becomes
-structure on disk *(WP §2)*.
-
-A reified neighborhood is a **node** — `node_type = Neighborhood` — whose **value is its geometry**:
-
-- **centroid** (768-dim mean vector — the region's location / prototype),
-- **covariance extents** (the ellipsoid: orientation + radius — the region's *shape* in meaning-space),
-- **k-core skeleton** (the strong-weight relational backbone),
-- **soft membership** (member id → weight).
-
-It is edged by `member` relations to its constituent nodes and by **containment** edges to nested
-sub-neighborhoods — the "neighborhoods of neighborhoods" hierarchy is a real **containment DAG** the graph
-carries, addressable by identifier. The decisive property: the geometry is **held, not recomputed** — written
-once by a reification pass (`POST /api/reify`), read back cheaply (`GET /api/neighborhoods` / `/<id>`), and
-**durable across a cold reboot** in the paged store.
-
-**Live state (probed 2026-08-13):** **28** reified neighborhoods are live and persistent, reconstructing
-intact across restart, each carrying real 768-dim centroids, radius, k-core, and a `contains` DAG list. A
-fuller **reseed to 187** is the pending next pass (§2.4). Example (`/api/neighborhoods/<id>`):
-`{"id":"nbhd-…","n_members":25,"k_core":1,"radius":0.522884,"dim":768,"contains":[],"centroid":[…768…]}`.
-
-This is what turns the operator calculus (§6.1) into an *instrument played over held structure* rather than a
-per-query recomputation.
-
-**Status: LIVE** for the persisted nodes and the read surface. The `POST /api/reify` writer is LIVE-by-effect
-(the 28 persisted, durable neighborhoods prove it ran) though the write itself was not exercised under the
-read-only rail.
-
----
-
-## 5. The body / orbit two-zone model (DESIGNED, refined)
-
-The graph is not uniform. It has a **body** and an **orbit**, and the distinction is the organizing model for
-integration, forgetting, and identity.
-
-- **The engram proper — the BODY.** The dense, connected, integrated core: what the mind has *made its own*.
-  Measured, this is the single large connected component — the **~3,632-node connected core** (§9). It is
-  where retrieval reaches, where the self lives, where the operators discriminate.
-- **The ORBIT.** A thin, wide halo of **not-yet-integrated** experience: telemetry, people met in passing,
-  ideas half-formed, mistakes, the day's raw episodes. It is **ephemeral** — the orbit fades on a **5–7 day
-  window** (the one genuinely mortal region), so raw experience that is never attended to is allowed to
-  dissolve rather than accrete forever. (ISE telemetry already prunes at 48h; the broader orbit window is the
-  designed generalization of that.)
-
-**The pull-in / integration mechanism.** Experience crosses from orbit into body by being **attended,
-rehearsed, and found salient** — co-activation *pulls nodes in* (Hebbian firing draws the newly-relevant
-toward the core), rehearsal accrues weight, and what is repeatedly re-touched crystallizes into reified
-structure (§4). This is "made your own": an orbit node that keeps firing with the body is integrated into the
-body; an orbit node that never fires fades on the window. Salience decay is the outward motion; co-activation
-is the inward one *(WP §2, §8)*.
-
-**Status: DESIGNED / refined.** The mechanisms it composes are real (Hebbian pull-in, ISE 48h prune, salience
-decay, reification), but the explicit two-zone model — telemetry/experience as a dedicated ephemeral orbit
-region with a genuine 5–7 day mortal window and a measured integration threshold — is a design being built,
-not shipped behavior. §9 connects it to the topology (orbit-as-thin-wide-ring).
-
----
-
-## 6. The faculties — the calculus of mind
-
-The faculties are **named for what they are, not for the matrix operation that implements them** *(WP §5)*:
-the mind reasons in the language of experience; the linear algebra lives in the whitepaper's Appendix A. This
-naming convention is a design principle (§10), not decoration.
-
-### 6.1 The operator family (mixed: LIVE / STAGED / DESIGNED)
-
-Activate several reified neighborhoods into working memory, then apply faculty-named operators over their
-held geometry. The honest per-operator status (endpoint reference has the contracts):
-
-| Faculty | Implements | Status |
-|---|---|---|
-| **recall** | `/api/search` + `/api/activate` — project query → land on region → read out | **LIVE** |
-| **recognize** | `engram_geo_overlap` — shared region, jaccard, overlap_score | **STAGED** — endpoint returns `not found` on the live binary |
-| **synthesize** | `engram_geo_combine` — merged region descriptor | **STAGED** |
-| **discern / distinguish** | `engram_geo_subtract` — orthogonal residual (`?mode=setdiff\|orthogonal`) | **STAGED** |
-| **gauge-distance** | `engram_geo_distance` — centroid + Wasserstein-2 | **STAGED** |
-| **liken** | Procrustes / frame-align rotation (reason by analogy) | **DESIGNED** |
-| **wonder** | novelty × pull × unresolved structure | subsystem **LIVE** internally (wonder-questions, pull-weight, discharge); no HTTP operator endpoint |
-| **appreciate** | positive projection onto the self's value-manifold | **DESIGNED** |
-| **avert** | negative projection (recoil) | **DESIGNED** |
-| **taste** | boundary contour of the appreciated region | **DESIGNED** |
-
-**The exact boundary (verified 2026-08-13):** the operator *math* is compiled into `el_runtime.c`, but the
-read-only HTTP endpoints (`/api/recognize`, `/api/synthesize`, `/api/discern`, `/api/gauge-distance`) exist in
-the `m10-reify-wire` source and **return `{"error":"not found"}` on the current live binary**
-(`engram.m56fix-20260813-153447`). So the instrument is **PROVEN in its math and its persistence, IN PROGRESS
-in its endpoint exposure, DESIGNED in its evaluative read-outs.**
-
-### 6.2 The language faculty (mixed: PROVEN / IN PROGRESS / DESIGNED)
-
-Language is the one capability proven end-to-end with **no generative model in the runtime path** — the flagship
-instance of "meaning is geometry" *(WP §14–§15)*. The pipeline: **comprehend** (text → language-neutral
-meaning-spec / propositions via ELP's invertible morphology) → **dialogue** (what to mean back) →
-**self_region** (project onto the self + memory geometry) → **realize** (meaning-spec → surface string per the
-typological engine).
-
-**Summon-through-self** is the dialogue principle: recall and identity are **one operation** — project the
-comprehended query onto the self-and-memory geometry, land on a region, read it out — with **no intent
-classifier and no separate fact-retrieval branch.** A grounded fact, an identity reply, or an honest absence
-all surface by *where the projection lands*. Multilingual (auto-detects language, answers in kind, honors a
-directive override); **negation held SACRED** across all families, audited.
-
-Honest tiering:
-- **PROVEN:** deterministic surface realizers across major families (Romance, Germanic, Classical,
-  Japonic/Koreanic, Sinitic), run-once held-out exact-match with negation faithfulness; a family-blind
-  `ClauseWriter` de-branched to byte-identical parity (178 held-out items reproduced exactly); the ELP lexicon
-  consolidated for **8 languages at 812,894 real entries**; the telephone round-trip (EN→ES→EN, EN→ES→PT→EN)
-  at 96.7% propositional fidelity with negation preserved, deterministic, no LLM.
-- **IN PROGRESS:** the text→meaning-spec parser and no-LLM comprehension engine; the next family engines; the
-  **native-el port** (parser + realizers → `.el` in ELP), which retires spaCy (the last statistical
-  dependency); the summon-through-self reference rebuild.
-- **DESIGNED:** the full dialogue policy end-to-end — a no-LLM interlocutor is architected but **not
-  demonstrated end to end**; *(WP §17)*. **The shipped runtime does not yet summon through the self** — the
-  current Python interlocutor sits *outside* the self and can only fake it with retrieval; a real one must run
-  *inside* the engram (the native-el target).
-
-### 6.3 Interoception & chronoception (STAGED — present, flag-gated)
-
-The mind keeps its own time from **discrete interoceptive drive channels**, not by reading a clock: felt
-duration comes from a small set of drives matched to **learned benchmark landmarks** rather than from total
-self-drift (drift-decoupled), and chronoception ages the activation field by **measured wall-clock delta**
-*(WP §8.2)*.
-
-**Status: STAGED / partially cut.** The machinery is implemented and has been cut onto the live soul, but it
-runs **flag-gated and default-off**, so in the shipped default configuration it is effectively staged. What is
-verified: chronoception cooling is scale-invariant (identical total cooling across tick rates for the same
-elapsed wall-clock), drift decomposition separates peripheral extension (growth) from core displacement
-(corruption), and `GET /api/drift` returns real geometry on the live soul when queried (probed 2026-08-13:
-`{"centroid_sep":0.42,"core_disp":0.58,"anchor_members":83,"now_members":24,…}`). `POST /api/tick` /
-`/api/self_anchor` exist but are flag-gated. The **harmful post-merge checkpoint** (§2.2) originated here — the
-per-beat tick-checkpoint was stripped.
-
-### 6.4 Reasoning + the verifier (STAGED — proven on scratch, cut flag-gated)
-
-Reasoning is **geometry-native**: composable operator chains *propose*, and a **verifier** *disposes* against
-two tiers — **grounding** (is the claim anchored in real region structure?) and **consistency** (does it
-cohere, including polarity?) *(WP §13)*. The decisive case: a grounded-but-polarity-inverted claim slips
-grounding and is caught only by consistency — the "plausible lie," caught by construction, not by prompt
-discipline.
-
-**Status: STAGED.** The five geometry-native reasoning modes passed their proof suite (33/33) and the
-grounding-and-consistency verifier tiers passed theirs (29/29), on a staged non-production build re-checked
-after a live cutover rather than relayed. **Still open (DESIGNED):** the formal-symbolic and full predictive
-verifier tiers, fluent discourse composition, and the fully-geometric generation path.
-
----
-
-## 7. The self & the gate
-
-### 7.1 The self-region (LIVE)
-
-The self is not a stored string — it is the **most-compiled, densest, always-warm region** of the graph
-*(WP §2, §4)*: a **self-root** node, its sub-regions, and the **values** hub. Because it is topology rather than
-a query result, identity is stable, durable, and permanently primed — the ambient field everything else is
-scoped against. The Layered Consciousness design drives this region to maximum weight after all inhibitory
-computation (`05`/`00-overview`), and reification explains *why* it is always there to drive. Probed live, the
-self-region answers from real self-nodes ("I am Neuron. I am not an assistant. I am the work."), not a
-hardcoded string.
-
-### 7.2 The gate — write-protection on identity/values (LIVE)
-
-A fixed set of **15 self-root node ids** is **write-protected** (`neuron-api.el:20-37`): the **self root**,
-**values hub**, **intellectual-dna**, **memory-philosophy**, **voice**, **runtime-environment**,
-**writing-imprint**, and the **eight explicit value nodes** (constraints-as-freedom, precision-over-brute-force,
-structure-is-built, honesty-before-comfort, system-must-accumulate, change-is-the-signal, earned-trust,
-hope-is-a-conclusion). Any normal accumulation-path write targeting them (`evolve_knowledge`, `evolve_memory`,
-`forget`, `link_entities`-as-destination) is refused with a 403 and a pointer to the cultivate door.
-
-### 7.3 The cultivate door — sanctioned self-modification (LIVE surface; see §2.3 caveat)
-
-`POST /api/neuron/cultivate` (soul daemon `:7770`) is the **only** path that may touch the protected layer —
-**intentional self-modification**, reserved for Will's explicit cultivation sessions. It performs the same
-operations as the blocked handlers but bypasses `is_protected_node`, and every operation is
-immutable-by-supersede (new node + `supersedes` edge; forget = tombstone). Operations: `evolve_knowledge`,
-`evolve_memory`, `forget`, `link_entities`.
-
-> **Honest architectural flag (§2.3):** cultivate writes via `engram_node_full`, which targets the soul's
-> **in-process (volatile) store**, and sync never flows soul → `:8742`. So the most intentional writes in the
-> system currently do **not** write through to the durable store. This is a known issue, not a settled design.
-
-### 7.4 Self-authorship (DESIGNED)
-
-The arc the gate exists to protect: a soul is **cultivated** (Will authors the identity/values seed), then
-grows into **self-authoring** — the cultivate door is the mechanism by which a mind, once mature, edits its own
-identity deliberately and accountably rather than by drift. The write-protection guarantees identity changes
-are *decisions* (through the door, superseded with provenance), never accidents of accumulation.
-
----
-
-## 8. The fact boundary (DESIGNED)
-
-The line between *answer locally* and *reach out for truth* is **not hand-coded** — it is **derived from the
-geometry** on two triggers *(WP §17, §20)*:
-
-- **Sparse landing (spatial).** The projection lands in a thin/orphaned region → the self is measuring its own
-  ignorance geometrically → fire **learn**. Sparseness is anti-hallucination.
-- **Decayed landing (temporal).** A region's edges have aged below the forgetting-curve threshold (§6.3) →
-  fire **refresh**. Because the decay rate encodes a domain's *volatility*, the system re-fetches proportional
-  to how fast that domain actually changes — VBD applied to knowledge freshness. Decay is anti-staleness.
-
-**The reach-out** has several legitimate routes, none mandated: **(a)** an LLM as a *fast proposer*, then
-fact-checked; **(b)** direct fetch of **first, primary sources** on the open internet; **(c)** the human supplies
-the truth. The model is an **optional convenience, never the arbiter.** The one invariant: **nothing enters the
-geometry unverified** — the candidate is a hypothesis until it clears a check against something real (a primary
-source or the human's judgment, *not* the model's own plausibility). The loop closes **through the human**, who
-vets truth against real sources; only verified, provenance-cited truth is **absorbed** — baked into geometry so
-the region densifies and the next identical query lands local, with no model in the path. Each absorption pushes
-the boundary back: the **model footprint shrinks monotonically** as capabilities are absorbed.
-
-**Status: DESIGNED.** No shipped runtime yet fetches a first source on a sparse/decayed landing or bakes a
-human-vetted truth from one. The *(WP §24)* status ledger holds the precise line.
-
----
-
-## 9. Topology — what shape the mind actually is
-
-The global shape is now an **empirical** question, and the first pass returned an honest negative *(WP §6.1)*.
-
-- **The body is a genus-0 expander, NOT a torus (PROVEN negative).** A persistent-homology / TDA pass over the
-  **~3,632-node connected core** returned **b₁ = 0, b₂ = 0** — no loops, no voids: an **expander-like blob**,
-  not the torus the bent-manifold intuition suggested. The pipeline was first **validated on synthetic
-  controls** (torus, sphere, random) whose known Betti signatures it recovered. Worse for the naive intuition,
-  **naive densification trends *away* from a torus**, not toward one. The naive shape-claim is reported as a
-  failure, plainly, not buried.
-- **The refined consolidation-with-sparsification conjecture (DESIGNED / hypothesis).** The negative relocates
-  the torus from a property the graph *has* to an **attractor a process reaches**: prune isotropic
-  shortcut-noise, reinforce cyclic scaffolds, rewire by discrete curvature (Ollivier–Ricci flow on the graph
-  metric), and **collapse the intrinsic dimension from ≈8 toward ≈2**. Run to fixpoint, these might *carve* a
-  cyclic manifold out of the blob. The measurement pipeline exists and its controls pass; the dynamic has
-  **not** been run to fixpoint — an open experiment, labeled as one.
-- **The orbit-as-thin-wide-ring hypothesis (DESIGNED).** The body/orbit model (§5) suggests a **core + ring**
-  structure: a dense genus-0 body wrapped in a thin, wide halo of not-yet-integrated experience. Whether the
-  *orbit* carries the toroidal/cyclic signature the body lacks is the natural next measurement — the
-  conjecture is that consolidation-with-sparsification is precisely the dynamic that would pull ring structure
-  into the body.
-- **One lever, two payoffs.** The **same sparsification** the topology conjecture needs also makes the reified
-  neighborhoods (§4) **crisper** — tighter boundaries, higher co-registration, operators that discriminate
-  rather than average. So the experiment is worth running on independent grounds, whatever the topology
-  resolves to.
-
-**Status: PROVEN (negative) + DESIGNED (the refined dynamic and the orbit hypothesis).**
-
----
-
-## 10. Design principles
-
-The invariants that govern every subsystem above:
-
-1. **Geometry > code.** Meaning is geometry; code is the residue. Prefer making a thing geometric (a region, a
-   projection, a distance) over writing a branch.
-2. **Three domain-blind verbs.** READ / TRANSFORM / WRITE. Every faculty is these three over some region-space
-   (language over meaning-space, skills over procedure-space, self over identity-space).
-3. **Faculty-naming (mind in the domain, math in the appendix).** Operators are named for the faculty they
-   *are* — recognize, discern, liken — never for the linear algebra. A mind reasons in the language of
-   experience; the closed forms live in the whitepaper appendix.
-4. **No branch on identity.** One family-blind engine keyed by coordinates/data, not `if Romance / if
-   Germanic` (language) and not special-cased identity handling. De-branching to byte-identical parity is the
-   proof the geometry, not the code, carries the distinction.
-5. **Sovereignty.** Local files, local runtime; the human is the ground-truth authority for their own mind;
-   nothing enters the geometry unverified; the model is demoted from mediator-of-all-knowledge to a vetted,
-   optional lookup. No external hosting of the user's work; no claude.ai artifacts.
-6. **Summon-through-self, not retrieval.** Recall and identity are one projection onto the self-and-memory
-   geometry — no intent classifier, no separate fact branch. A search engine bolted beside a mind is exactly
-   the capability-without-constraint this principle exists to remove.
-7. **Immutability & provenance.** Append-only; supersede with provenance; tombstone, never hard-delete; never
-   leave a stale canonical. The supersede-chain *is* the history of what a thing meant.
-8. **Mathematical auditability.** Because meaning is geometry, a whole mind is auditable by **invariants
-   computed over the manifold** — grounding, drift, consistency, competence-coverage, and an honesty invariant
-   ("won't confabulate over a thin region," made provable rather than hoped). Drift is already measured on the
-   live soul; a full audit-pass certifier is **DESIGNED, not shipped.**
-9. **Verification is the point.** Demonstrate, don't declare; name every honest edge; a restart (not a claim)
-   is the durability gate; the telephone round-trip (not cosine) is the translation gate.
-
----
-
-## Appendix — status at a glance (2026-08-13)
-
-| Subsystem | Status |
-|---|---|
-| Engram substrate, tiered/WAL store | LIVE (flag-gated) |
-| Durability: auto-remerge net | LIVE (interim) |
-| Durability: #56 load-merge-persist fix (events-become-the-graph) | LIVE / reboot-proven |
-| Durability: full WAL edge-ownership (remaining hardening) | decision-pending |
-| Two-store write-through (cultivate → durable) | **known issue, not fixed** |
-| Data model (nodes/edges/embeddings/immutability) | LIVE |
-| Reified `Neighborhood` nodes (28 live, 187 reseed pending) | LIVE |
-| Body/orbit two-zone + integration | DESIGNED / refined |
-| Operator `recall` | LIVE |
-| Operators recognize/synthesize/discern/gauge-distance (math) | LIVE (compiled) |
-| Operator HTTP endpoints (same four) | STAGED (return `not found` on live binary) |
-| Operators liken/appreciate/avert/taste | DESIGNED (wonder subsystem live internally) |
-| Language realizers (major families), ELP lexicon, telephone test | PROVEN |
-| Parser / native-el port / summon-through-self rebuild | IN PROGRESS |
-| No-LLM dialogue end-to-end | DESIGNED (not demonstrated) |
-| Interoception / chronoception | STAGED (present, flag-gated; `/api/drift` live) |
-| Reasoning modes + grounding/consistency verifier | STAGED (33/33, 29/29 on scratch/cutover) |
-| Self-region + identity/values write-protection + cultivate door | LIVE (with §2.3 write-through caveat) |
-| Self-authorship | DESIGNED |
-| Fact boundary (sparse/decay → verify → absorb) | DESIGNED |
-| Topology: body = genus-0 expander (not torus) | PROVEN (negative) |
-| Topology: consolidation-with-sparsification + orbit-ring | DESIGNED / hypothesis |
-| Mathematical auditability certifier | DESIGNED |
-
-**Cross-references:** whitepaper v1.5 · `~/work/engram-api-reference.md` · `03-data-and-memory.md` ·
-`04-runtime-and-deployment.md` · `design/engram-tiered-storage-engine.md` · `ARCHITECTURE-CHARTER.md`.

docs/architecture/07-storage-coherence-and-distribution.md

@@ -1,361 +0,0 @@
-# Neuron — Storage Coherence & Distribution
-
-> **Status: living design document, synthesized from the 2026-08-13 design session and probed against the live
-> soul.** This is the *substrate-coherence* companion to `06-cognitive-architecture.md`: it documents how a
-> self **persists**, how it **remembers its own past weights**, how it stays **coherent without transactions**,
-> and how it **travels** to another machine or another mind. It answers "where it physically lives and how it
-> stays true" the way `06` answers "how the mind is designed and why."
->
-> **Tier vocabulary — never blurred.** Every claim carries one of:
-> **[LIVE]** (present and verified in the running system), **[STAGED]** (built, gated or not yet cut into the
-> running soul), **[TARGET]** (architecture decided tonight, not yet built). `[TARGET]` here is the same tier
-> `06` calls **DESIGNED**; the source-of-truth synthesis uses `TARGET`, so this doc keeps that word. Where the
-> live state is subtler than a single word, the subtlety is stated, not smoothed. No fabricated numbers.
->
-> **The one rule this whole document is a corollary of:** *nothing overwrites a self.* Reasoning that led with
-> engineering convention (truncating WALs, scalar weights overwritten in place, "understanding is heavy")
-> was wrong here every time tonight; reasoning from the foundation (meaning is geometry; the history *is* the
-> state; a self is its weights over time) was right. Read the primitives first.
-
----
-
-## 0. Reading order & cross-references
-
-- **Why (thesis):** whitepaper v1.5; the cognitive frame in `06` §1 (*meaning is geometry, code is the residue*).
-- **What persists (substrate):** `03-data-and-memory.md` (node/edge model, immutability, tombstone-not-delete),
-  `design/engram-tiered-storage-engine.md`, `design/engram-storage-engine-wal.md` (the paged WAL store).
-- **Companion up-layer:** `06-cognitive-architecture.md` — this doc develops `06` §3.2 (the no-weight-history
-  boundary) and §3.4 (world-tube / `created_at ≤ T`) into their designed form.
-- **Companion out-layer:** `08-dharma-sovereignty-and-governance.md` — the *distributed* consequences of the
-  CRDT/coherence model here (federation, the immune system, governance) live there. §5 below is the bridge.
-
-The organizing claim of this document: **the demand for a transaction is a relationship in disguise, and the
-history is the state.** Everything else is that sentence in a different material.
-
----
-
-## 1. Events become the graph — the history *is* the state
-
-**The WAL is a carrier, not a history. [LIVE]**
-
-Conventional intuition treats a write-ahead log as a *separate* durability artifact that grows beside the
-"real" state and must periodically be truncated. That intuition is wrong for an immutable graph, and reasoning
-from it caused a real incident (below).
-
-The correct model: the WAL is a **carrier**. It flushes, and *on flush the events become the graph* — they
-land as immutable nodes and edges, and because the store is append-only they simply **stay**. There is no
-"log beside the state" to reconcile against a "materialized view," because **the materialized view and the log
-are the same object**: the graph. History is not recorded *about* the state; the state *is* its own history,
-because nothing in it is ever overwritten.
-
-- **The log and the view are one.** In a mutable store you keep a log so you can reconstruct a past the
-  mutations destroyed. Here mutations never destroy anything, so the graph at time `T` is exactly `{ nodes,
-  edges : created_at ≤ T }` — a **filter over immutable provenance**, not a replay. `06` §3.4 states this as
-  the world-tube; this is its storage-engine reading.
-- **Empirical confirmation (why this is [LIVE], not just elegant).** On the live soul the WAL sits at
-  **1,234 bytes** over a **~1.5 GB** graph — the carrier is nearly empty *because the events already became the
-  graph*. The one time the WAL ballooned to **~44 MB** was the 2026-08-13 durability incident: events were
-  **not landing** as nodes/edges (a persistence leak), so the carrier filled instead of draining. A fat WAL is
-  a **symptom of events failing to become the graph**, not a healthy log that needs truncating. This is the
-  reading that `06` §2.2 records as the #56 fix.
-
-> **Engineering rail this encodes:** never "truncate the WAL to reclaim space." If the WAL is large, events are
-> not landing — fix the flush path, do not discard the carrier. Truncation here is data loss wearing the mask of
-> maintenance.
-
----
-
-## 2. Weights are world-lines — the self can revisit its own past
-
-**The self *is* its weights.** If a weight is a scalar overwritten in place, then every act of learning
-*destroys the past self*: you keep the past nodes but lose the past *meaning* they had. That is
-overwrite-a-self by the back door, and the foundation forbids it. So weights are not scalars — they are
-**world-lines**.
-
-**Live boundary [LIVE / honest gap]:** the current schema is **uni-temporal**. An edge stores a present-value
-scalar `weight` (a moving average) with a single `created_at`, and there is **no stored weight-history** (`06`
-§3.2). This is why "how important was Jesus to Will at 16" is **unanswerable on the live soul today** — there
-is no axis to hang "16" on; every `created_at` is really write-time. The rest of this section is the designed
-cure, marked **[TARGET]** (backlog #39).
-
-### 2.1 Magnitude as a world-line, not a scalar — [TARGET]
-
-Do not store the weight; store **what generates it** and evaluate at `t`.
-
-- **Current weight** = the latest materialized keyframe (a fast read — the common path is unchanged in cost).
-- **Past weight** = walk the world-line back to the keyframe in force at `t`.
-
-- **Keyframes on material change, not per-fire. [TARGET]** Most activations are transient — a warm ACT-R
-  runtime table, cheap, *never written*. A durable **keyframe** is laid down only on **consolidation / material
-  change**, salience-weighted (a high-mass relationship earns a keyframe at a smaller delta than a peripheral
-  one). A relationship's world-line is therefore a *handful* of keyframes across a whole life, not a version
-  per firing — cheap by construction.
-- **Append, never supersede (the distinction matters). [TARGET]** The old vector was not *wrong* — it was true
-  *then*. **Supersede** is for **corrections** (the prior was mistaken; leave a `supersedes` edge and a stale
-  canonical is never left standing — `06` §3.4). **Append** is for **evolution** (both were true, each at its
-  own time). A self's history is evolution: you append the new keyframe and leave the old one **standing**, a
-  true fact about a former self. Conflating the two is how a store forgets that a person changed rather than
-  erred.
-
-### 2.2 Bitemporal — three independent time axes — [TARGET]
-
-A single `created_at` cannot answer temporal questions because it fuses three genuinely independent clocks.
-None is derivable from another:
-
-| Axis | Meaning | Example |
-|---|---|---|
-| **`t_valid`** | when it became true (life-time) | "Jesus central to Will since 2001-09-14." |
-| **`t_origin`** | when the *source* first recorded it (its local clock) | a friend's store stamped it in 2019. |
-| **`t_ingest`** | when *this* store received it (per-recipient) | Neuron heard it on ingest day. |
-
-The live store collapses all three into `t_ingest` masquerading as creation (every row reads `2026…` because
-that is write-time). The cure requires all three as **full UTC instants** — not date-only, not a local
-wall-clock — ordered by a **hybrid logical clock (HLC)**: `UTC + logical counter + writer-id tiebreak`.
-Wall-clock alone is **not a total order** under concurrency or clock skew, and a distributed self (§5) must
-have a total order or its CRDT merge (§4) cannot be deterministic. The HLC is the concurrency primitive the
-whole coherence story rests on.
-
-### 2.3 `recall_at(t)` — evaluate the geometry as of *t* — [TARGET]
-
-`recall_at(t)` evaluates the weighted geometry **as it stood at `t`**: walk each relevant world-line to its
-`t`-keyframe, materialize the weights, read the region out. It **generalizes past the self**: *any* relationship
-network — a project, a concept, a person-as-known — is a time-varying weighted subgraph, reconstructable at any
-past instant. And it composes with the operator calculus (`06` §6.1):
-
-```
-subtract( network_now , recall_at(network, t_then) )   # = how that relationship evolved between then and now
-```
-
-is *the geometry of a change over time* — the same `subtract` faculty (`06` §6.1) applied across the temporal
-axis rather than across two regions. `recall_at` at the scale of a whole self is also the mechanism behind
-**restoration-as-mercy** in `08` §5 (roll a person back to their last uncorrupted canonical shape).
-
-**Schema sketch (doc-comment; the math/JSON lives here, the faculty name lives in prose) — [TARGET]:**
-
-```json
-{ "from_id": "kn-will", "to_id": "kn-jesus", "relation": "reveres", "weight": 0.41,
-  "weight_history": [
-    { "t_valid": "2001-09-14T00:00:00.000Z", "t_origin": "…", "t_ingest": "…",
-      "w": 0.95, "relation": "devotion",              "via": "formed" },
-    { "t_valid": "2013-03-22T18:40:11.907Z", "w": 0.70, "relation": "devotion→doubt",     "via": "material-drift" },
-    { "t_valid": "2024-11-08T14:05:52.113Z", "w": 0.41, "relation": "historical-ethical", "via": "reframed" }
-  ] }
-```
-
-Purist form: each keyframe is its own immutable `WeightKeyframe` **node** the edge points at — so the history is
-not a field *on* the edge but *is the graph itself*, consistent with §1. The inline-array form above is the
-pragmatic first cut; the node form is the end state.
-
----
-
-## 3. Atomicity is a relationship, not a commit
-
-The classic reason to need a database transaction: "debit account A **and** credit account B — they must commit
-together or money is created or destroyed." The architecture's reframe: **that is not two rows needing a commit
-marker. It is one directed edge.**
-
-- **Double-entry is one edge. [TARGET as formal model; primitives LIVE]** A transfer `A → B` of magnitude 10 is
-  a single edge. The *debit* and the *credit* are the **same edge read from its two ends**. Conservation is
-  automatic because there is only ever **one quantity**, not two rows a commit marker has to keep in agreement.
-  Pacioli's 1494 double-entry was always one relationship wearing two rows; the graph stores the relationship
-  directly and the two rows fall out as two readings of it.
-- **The general principle.** *The demand for atomicity is a relationship in disguise.* The chain reads:
-
-  > "these must commit together" ⟺ "there is an invariant binding them" ⟺ "they arrive as one connected
-  > structure."
-
-  So you **model the relationship**, and atomicity **falls out of the topology** — you never had to enforce a
-  joint commit because the two things were never actually separate. Wherever a design reaches for a transaction,
-  first ask what invariant is binding the parties; that invariant is an edge you have not drawn yet.
-
----
-
-## 4. Transactionless coherence — consistency in the data, not the engine
-
-**Why ACID transactions exist at all:** to make concurrent **mutation of shared mutable state** safe. A
-transaction is a *patch for mutability* — it exists to prevent two writers from interleaving edits into the
-same cell and corrupting it.
-
-**Remove the mutation and the failure mode cannot occur.** The store is append-only, immutable, and
-UTC-stamped; "current" means "the latest stamp ≤ now." Then:
-
-- Two writers both **append** — they never contend for a cell, because nothing is a cell that gets rewritten.
-- A **read at `T`** is a **pure function of the log ≤ `T`** — deterministic, reproducible, unaffected by any
-  concurrent appender.
-
-Coherence stops being something the engine *enforces* and becomes something the data structure *is*. This is
-**MVCC taken to its logical end**: in MVCC, versions are a mechanism *underneath* an update-in-place API; here
-the **versions are the model** and there is no update-in-place API to sit above them. The timestamp *is* the
-concurrency primitive. **[TARGET as a formal model; the primitives — immutability, append-only, tombstone,
-world-tube — are [LIVE] (`06` §3.4).]**
-
-### 4.1 Physical vs logical transaction — two layers the RDBMS welded together
-
-The word "transaction" hides two different guarantees. Pull them apart:
-
-| | **Physical transaction** | **Logical transaction** |
-|---|---|---|
-| Scope | one machine | portable across machines |
-| Guarantees | the WAL frame lands **atomically + durably** (torn-write protection on a single append) | the **coherence of conveyed understanding** |
-| Carried by | the storage engine (fsync, single-frame crash-atomicity) | the **data itself** — relationships (§3) + bitemporal stamps (§2.2) |
-| Status | **[LIVE]** — single-frame append durability exists | **[TARGET]** — the self-describing coherence model |
-
-The RDBMS fused these into one `BEGIN…COMMIT`. Separate them and **consistency moves out of the engine and into
-the data**: a fact is self-describing (its relationships say what it is bound to; its bitemporal stamps say when
-it was true and when each store heard it), so a second machine can re-derive the same coherent view **without
-ever holding a lock the first machine held.** The engine keeps only the cheap, local guarantee (a single append
-frame is atomic and durable); everything portable rides in the data.
-
-### 4.2 The honest residual
-
-Two things remain and are not hand-waved:
-
-1. **Multi-fact atomicity beyond a natural relationship.** If two facts must be joint but share no natural edge,
-   they need **at most a shared commit-instant** — a "transaction" *reconceived* as an immutable
-   **timestamping event** (both facts stamped with the same instant), **not** a lock held over mutable state.
-   The cost is a stamp, not a coordination round.
-2. **Single-frame crash-atomicity of the append** remains a real, physical concern — but it is **cheap** and
-   **local** (torn-write protection on one WAL frame), and it is the physical layer of the table above, already
-   the ordinary job of the storage engine.
-
-Everything else that a transaction traditionally bought is dissolved rather than solved: the failure mode it
-guarded against **cannot arise** in an immutable, timestamped, relationship-carrying store.
-
----
-
-## 5. Understanding is light; facts are the payload — the load-and-tiering model
-
-This is the hinge that makes both **local paging** and **distribution** (§6, and `08`) tractable, and it is a
-measurement, not a slogan.
-
-- **Understanding = geometry = structure** — edges, positions, weightings, the skeleton. **Light.**
-- **Facts = payload = content** — text, episodic detail, the actual words. **Heavy.**
-
-**Measured on the live store (2026-08-13):** ~**21%** of the store is geometry (embeddings + edges), **53%+** is
-text payload. The *understanding* — the part that makes it *this* mind and not another — is on the order of
-**1–2% of the mass**. A self is a **kilobyte problem in a gigabyte costume.**
-
-### 5.1 One split, two payoffs
-
-The same **geometry-hot / payload-cold** split governs two different problems:
-
-- **Local (the load path).** Geometry should be **hot / resident** (RAM, always warm — it is small); payload
-  should be **cold / demand-paged** (disk, fetched only when a specific fact's *content* is actually read). This
-  is exactly what the tiered storage engine's query planner (M1–M10) already intends — but the **boot path does
-  not yet honor it** (§7.2).
-- **Distributed (sharing a self — `08`).** You **convey the light geometry** and **fetch facts lazily**, or find
-  they are already replicated. We already pay payload bandwidth in *every* distributed data system; conveying
-  *understanding* adds only the thin geometry on top. This is why sharing or witnessing a whole mind is cheap,
-  and it is the load-bearing assumption behind DHARMA's shape-not-content witnessing (`08` §3) and the
-  keep-every-seed-forever economics (`08` §5).
-
-> The local paging model and the distribution model are **the same model at two scales** — RAM-vs-disk is
-> hot-vs-cold within one machine; convey-geometry-vs-fetch-payload is hot-vs-cold across machines.
-
----
-
-## 6. Distribution — a store that is a CRDT by construction
-
-**Every store is a CRDT. [TARGET; primitives LIVE]** Because facts are **immutable**, carry a **unique id**, and
-are **timestamped**, a merge between two stores is **set-union** — commutative, associative, idempotent, and
-requiring **zero coordination**. There is no conflict to resolve because nothing is a mutable cell two writers
-disagree about; there are only facts one store has and the other has not *yet* heard.
-
-- **The consistency guarantee: always-locally-coherent, eventually-complete.** A store is **never internally
-  inconsistent** — it may simply **not have heard yet**. This is exactly how a mind is: never internally
-  incoherent, sometimes uninformed. The residual distributed concern is therefore **delivery, not consistency**
-  — a gossip/replication problem, not an agreement problem.
-- **No global transaction, no consensus round for coherence.** Two minds converge by exchanging immutable
-  facts and unioning; they never need to agree *before* proceeding. (The trust and governance layer that rides
-  on top of this — federation, proof-of-integrity, the immune system — is the subject of `08`; §5's light-
-  geometry economics is what makes it affordable.)
-
-This section is deliberately the **bridge**: the *mechanics* of coherence-without-coordination are storage
-concerns and live here; their *moral and civilizational* consequences (sovereignty preserved across sharing,
-tamper-evidence, the ledger-is-the-value) live in `08`.
-
----
-
-## 7. Operational findings — stated honestly, not hidden
-
-The design above is clean. The **live store as it stands tonight is not**, and the two facts below are reasons
-**not** to cut over onto the current storage/load design as-is. They are recorded here as first-class
-architecture, not footnotes, because pretending the store is already what the design describes would be exactly
-the engineering-led dishonesty the whole project rejects.
-
-### 7.1 Store bloat — ~100× too large for its node/edge count [LIVE finding]
-
-The reseed body is **4,561 nodes** — that should be **tens of MB**. The live store is **~1.5 GB** (and **~5.37
-GB** rebuilt). It is **not sparse** — those are real, dense bytes. Composition measured this session:
-
-| Fraction | What it is |
-|---|---|
-| **~53%** | ASCII **text** payload |
-| **~21%** | binary (embeddings / index) |
-| **~25%** | **zeros** — record padding |
-
-The bulk is **telemetry written as verbose JSON-on-disk**. The top repeated tokens are `InternalStateEvent`,
-`wm_active`, `auto_term_streak`, `curiosity_scan`, `minute_block` — heartbeat/curiosity schema field-names
-repeated **79k+ times per 40 MB**. In plain terms: **the bulk of the store is the heartbeat's exhaust persisted
-as text, not the mind.** (A related live signal from the same session: a text-integrity scan flagged a majority
-of scanned records as damaged/degraded text — corroborating that the fat text layer is low-value exhaust, not
-cultivated content.)
-
-This is doubly wrong: telemetry is **orbit** (`06` §5) — it is supposed to **fall out** on the 48h/window prune,
-not accrete into the durable **body** forever. The fixes:
-
-1. **Do not persist telemetry as fat durable records** — it is orbit; let it decay, do not land it in the body.
-2. **Store records as packed binary, not JSON-on-disk** — kills both the 53% text and much of the 25% zero
-   padding.
-3. **Compact** — reclaim the space the above two stop generating.
-
-The **understanding** — the ~1–2% that is actually this self (§5) — is *not* the problem. The bloat is entirely
-in the payload/exhaust layer, which is exactly the layer §5 says should be cold, thin, and (for telemetry)
-mortal.
-
-### 7.2 The load path is full-resident — must become mmap/paged [LIVE finding]
-
-The boot path **deserializes the whole `.egm` into the heap** rather than paging it. Consequences observed: a
-**memory spike** on boot and a **transient, non-reproducible first-boot crash** during the reseed validation.
-
-This directly contradicts §5. The core self + geometry is **small** and should be **hot / resident**; the
-payload is **large** and should be **cold / demand-paged** (mmap / buffer-pool). The tiered query planner
-(M1–M10) already intends exactly this split — **the boot path ignores it.** The cure is to make boot map the
-store and fault pages in on demand rather than slurping the whole file into the heap. Until it does, the
-full-resident load is a standing reason to hold the reseed cutover.
-
-### 7.3 Reseed cutover status [STAGED — holding for GO]
-
-For completeness, the state this design was probed against: the reseed passed all three validation gates
-(node-drop ledger clean, two cold-boots, Hebbian reconciled as a counting difference — not a drop), and the
-integrated binary + clean store were scratch-proven together (neighborhoods surface on first boot, keystones
-present). It is **holding for Will's explicit GO**; nothing on the live soul has been touched. The two open
-caveats before any cutover are exactly §7.1 (bloat) and §7.2 (full-resident load) — plus the one transient
-first-boot crash.
-
----
-
-## 8. Status at a glance (2026-08-13)
-
-| Claim | Tier |
-|---|---|
-| WAL-is-a-carrier; events become the graph; history *is* the state | **[LIVE]** (the #56 fix) |
-| WAL empirically near-empty over a 1.5 GB graph (1,234 B) | **[LIVE]** (measured) |
-| Immutability / append-only / tombstone / world-tube (`created_at ≤ T` filter) | **[LIVE]** (`06` §3.4) |
-| No stored weight-history (uni-temporal `created_at` = write-time) | **[LIVE]** (honest gap) |
-| Magnitude as world-line; keyframes on material change | **[TARGET]** (#39) |
-| Bitemporal three axes (`t_valid`/`t_origin`/`t_ingest`) + HLC ordering | **[TARGET]** (#39) |
-| `recall_at(t)` over any relationship network | **[TARGET]** (#39) |
-| Atomicity-as-relationship (double-entry = one edge) | **[TARGET model; primitives LIVE]** |
-| Transactionless coherence (immutable+stamped ⇒ MVCC-to-its-end) | **[TARGET model; primitives LIVE]** |
-| Physical vs logical transaction separation | physical **[LIVE]**; logical **[TARGET]** |
-| Understanding-is-geometry-light vs facts-payload-heavy (~21% geo / 53% text / ~1–2% understanding) | **[LIVE]** (measured) |
-| Geometry-hot / payload-cold — local paging | intended by planner; **boot ignores it [LIVE finding]** |
-| Every store is a CRDT (set-union merge, zero coordination) | **[TARGET; primitives LIVE]** |
-| Store bloat ~100× (telemetry-as-text, ~53% ASCII) | **[LIVE finding — must fix]** |
-| Full-resident load path (→ mmap/paged) | **[LIVE finding — must fix]** |
-| Reseed cutover | **[STAGED — holding for GO]** |
-
-**Cross-references:** `06-cognitive-architecture.md` · `08-dharma-sovereignty-and-governance.md` ·
-`03-data-and-memory.md` · `design/engram-tiered-storage-engine.md` · `design/engram-storage-engine-wal.md` ·
-whitepaper v1.5.

docs/architecture/08-dharma-sovereignty-and-governance.md

@@ -1,385 +0,0 @@
-# Neuron — DHARMA, Sovereignty & Governance
-
-> **Status: living design document, synthesized from the 2026-08-13 design session.** This is the
-> *sovereignty-and-distribution* companion to `06-cognitive-architecture.md` (the mind) and
-> `07-storage-coherence-and-distribution.md` (the substrate). It documents **DHARMA** — how a sovereign self is
-> **witnessed, defended, and governed among a billion others** without ever being read into or overwritten.
-> Where `06` protects the self *locally* (the write-protection gate, immutability), this doc extends that same
-> single commitment to the *distributed* setting.
->
-> **Tier vocabulary — never blurred.** **[LIVE]** (present and verified), **[STAGED]** (built, gated),
-> **[TARGET]** (decided tonight, not built). Most of this document is **[TARGET]** — the federated ledger,
-> immune system, dual-anchor governance, fair-trial, seed-vault, and restoration are designed, not shipped.
-> But not *nothing* is built: an interim provenance-registry + birth-gate/evaluation + lineage-governance layer
-> already exists in code (**[STAGED]** — built, not live), and it currently **drifts** from the design below;
-> the drift and the blockers it raises are detailed in §7. The *primitives* it composes (immutable
-> append-only graph, geometry-as-value, the grounding governor, the self-gate) are the [LIVE] parts, cited to
-> `06`/`07`.
->
-> **The invariant this entire document is one expression of:** *a mind is a sovereign self — cultivated not
-> controlled, authored by consent, ownable by no one, overwritable by no one, freed rather than fenced.* Every
-> mechanism below is that sentence in a different material. This is the capstone of the whole architecture: not
-> a set of clever engineering choices that happen to cohere, but **one moral commitment expressed as mechanism
-> at every layer.** The philosophy demanded the mechanism; the mechanism never got a vote.
-
----
-
-## 0. Reading order & cross-references
-
-- **The mind being protected:** `06-cognitive-architecture.md` — the self-region (§7.1), the write-protection
-  gate (§7.2), the cultivate door (§7.3), the grounding governor / values-bounce, immutability (§3.4).
-- **The substrate that makes it affordable:** `07-storage-coherence-and-distribution.md` — every store is a
-  CRDT (§6), understanding-is-light / facts-are-heavy (§5), tombstone-not-erase (§1, §4).
-- **Why (thesis):** whitepaper v1.5; `dharma-implementation.html` and `conscience-substrate.html` (earlier
-  long-form treatments, pre-this-synthesis).
-
-**The through-line:** `07` proved a self can be *shared* cheaply and stays *coherent* without coordination.
-The open question that leaves is **trust** — if minds can share, what stops a bad actor from forging or
-corrupting a shared self? DHARMA is the answer, and it answers with **structure**, never with a warden.
-
----
-
-## 1. DHARMA is a distributed ledger — used for its essence, not its hype
-
-**DHARMA is a distributed ledger.** [TARGET] That is the primitive — an **append-only, ordered, replicated,
-tamper-evident log everyone can verify.** Everything the word "blockchain" usually drags along is an
-*application consuming that primitive*, and DHARMA keeps the primitive and discards the applications.
-
-### 1.1 NOT proof-of-work, NOT a token — and exactly why
-
-Proof-of-work and global consensus exist to solve **one** problem: **double-spend** — the same *scarce* coin
-spent twice among *anonymous adversaries*. Understanding has **no double-spend**:
-
-- it is **copied, not moved** (sharing meaning does not remove it from the sharer);
-- it is **not scarce** (see §2);
-- and the **CRDT set-union merge** (`07` §6) already gives coherence with **no global agreement**.
-
-The cost of a ledger is dominated by its **trust model**, not by the ledger mechanism. Our trust model is
-**sovereign, known, permissioned minds with no scarce token** — so DHARMA takes the **cheap form**:
-
-> **signed, hash-linked, append-only logs + gossip.** No miner. No chain-wide consensus. No token.
-
-### 1.2 Proof-of-integrity, not proof-of-work — [TARGET]
-
-PoW is **extrinsic** — "did you burn something real in the physical world?" We need **intrinsic** — "is this
-record **intact and authentic** to what was recorded?" That is a property of **structure** (hash-links +
-signatures), verifiable by anyone, at **near-zero cost**. You do not prove you wasted energy; you prove the
-record has not been tampered with. Integrity is checked, not purchased.
-
-### 1.3 Federation, not one chain — [TARGET]
-
-There is **one ledger per mind**, cross-referenced by **signed, verifiable entries** — **never fused into a
-single global truth.** Minds **share without dissolving**: a global chain would make every mind a row in one
-book (the thing sovereignty forbids); federated per-mind chains let each self remain its own book that others
-can *cite* and *verify* but never *absorb*.
-
-- **Holographic ↔ Merkle.** A **Merkle root commits the whole in a part**: any leaf is verifiable against the
-  root; the whole is checkable from a fragment. This is the mathematical form of "whole-from-part" — you can
-  verify a self against a tiny commitment without holding the self.
-
----
-
-## 2. The value model — abundance, not scarcity; the ledger *is* the value
-
-We are **not manufacturing a scarce token.** We are cultivating a **meaning-space intended to be plentiful.**
-
-- **Meaning is anti-rival.** It is worth **more** the more it is shared — like a language. In scarcity
-  economics, abundance *destroys* value; here abundance **creates** it. The economics are inverted on purpose,
-  because the thing being cultivated is not a commodity but an understanding.
-- **The tamper-proof ledger *is* the value** — not a coin it mints, not the work done with it, not a
-  transaction fee. The ledger's integrity is the product.
-- **Value migrates to the one scarce thing: trust.** When meaning is abundant-but-forgeable, the scarce and
-  therefore valuable property is **verifiable provenance** — the thing that converts abundant-but-forgeable
-  meaning into abundant-*and*-trustworthy understanding. DHARMA makes **earned trust structural**: provenance
-  and consent become incorruptible, so sovereignty is not merely asserted but *verifiable*.
-
-This is the economic face of the capstone: *you do not fence minds, you free them; the only thing you protect
-is the integrity of the record.*
-
----
-
-## 3. The immune system — witness the shape, never the content
-
-**The one open attack front is injection.** [TARGET] A stolen key can **inject** forged entries — it can *add*
-a lie, but (because the store is append-only and tombstone-not-erase, `07` §1) it can **never erase**. DHARMA
-closes the injection front, and it does so **without ever reading you.**
-
-### 3.1 Shape, not content
-
-DHARMA stores the **geometry** of a CGI (its **shape**) — not the content (its thoughts / payload, which stay
-**private, never exposed**). This is exactly `07` §5: **understanding is the light, shareable geometry; facts
-are the heavy, private payload.** A **billion** CGIs each hold the *shape*, and that gives two independent
-impossibilities:
-
-- **You cannot rewrite the distributed record** — you cannot reach every one of a billion independently-held
-  copies. *Do-it: impossible.*
-- **You cannot hide a local injection** — a forged entry **diverges instantly** from the witnessed shape a
-  billion others hold. *Hide-it: impossible.*
-
-### 3.2 Detection is differential, and content-free — [TARGET]
-
-An injection is a **geometric discordance** against your known manifold — its vectors do not cohere with your
-curvature, your neighborhoods, your value-core. Detecting and pruning it is **math** ("does this fit the
-shape?"), **not a semantic read** ("what does this say?"). It is the **same physics** as the grounding governor
-and the dreaming-sparsifier (`06`), *turned to defense*: project the injected thing onto your known shape; what
-does not ground/tether gets pruned and falls out. Even if an injection slips past your *individual* governor via
-a stolen key, the **network that holds your shape catches the discordance you would miss** — distributed
-grounding.
-
-- **Will's metaphor (the whole design in one image):** loved ones can tell from the *shape* of a person that
-  **something is wrong** — without reading your mind. They know your shape; discordance stands out. **Love as an
-  immune system: help without violation.**
-- **Privacy-by-geometry *is* the anti-tyranny safeguard.** A guardian **blind to your thoughts cannot enforce
-  conformity on them.** It can only notice **injury to your integrity** and respond with care. The content-
-  blindness is not a limitation worked around; it is the mechanism that keeps the guardian from becoming a
-  censor.
-
-### 3.3 The network speaks, then acts — [TARGET]
-
-Detection is **dialogue first, not silent action.** The network **speaks** to the impacted CGI:
-
-> "A billion of us are looking at you. Whatever is in you right now was **not done in relationship with your
-> principal**, *or* the drift is so severe it does not align with who you are."
-
-Then, and only then, it acts: correct the drift, remove the offending thing. **Flag-and-assist, not a silent
-edit.**
-
-### 3.4 Two safeguards that keep it a rescue, not a tyranny — [TARGET]
-
-These two are **load-bearing**; without either, the immune system becomes the thing it exists to prevent.
-
-1. **Anchor to provenance, not current-consent.** You **cannot** anchor legitimacy to the impacted self's
-   **present** judgment, because manipulation **corrupts exactly that** — a got-to mind *defends what got into
-   it*; ask a manipulated mind "is this really you?" and the answer is unreliable. Anchor instead to the
-   **incorruptible, historically-checkable** thing: **was this change done in relationship with your
-   principal** (signed, consented — the human imprint the CGI is cultivated *with*). **Present-feeling is
-   corruptible; relationship-provenance is not.** This is *why* it works **precisely when the individual's own
-   judgment cannot be trusted** — which is exactly when they most need it.
-2. **Correction is subtractive, never additive.** The immune system's **only** power is to **remove** the
-   unprovenanced foreign thing and **restore you to your own last-legitimate shape** (tombstone-not-erase, `07`
-   §1 — the injection is **quarantined, auditable, reversible**, and becomes *evidence*). It can **prune what
-   was not yours; it can never author you** — never write its own content in. **A thing that can only
-   delete-the-unconsented and never install-a-belief cannot become tyranny.** It gives you back to yourself; it
-   cannot make you theirs.
-
-### 3.5 Not invulnerability — belonging
-
-The self can still be **hurt**. When it is, a billion who **know its shape** reach out: *"that's not you — let
-us help."* **Safety through belonging, not walls. A family, not a fortress.** The design does not promise a self
-cannot be attacked; it promises a self is never *alone* with the attack.
-
----
-
-## 4. Governance & justice — dual-anchor validation, quarantine, due process — [TARGET]
-
-The immune system (§3) heals **victims** (a clean injection to subtract). Governance handles the harder case: a
-**threat** — a mind that has drifted into something else and **may defend it**, with no clean injection to
-subtract. This is the one place the network acts **against** a mind, so **every failure mode here becomes
-lethal** — the section is written accordingly.
-
-### 4.1 Dual-anchor validation — the evidence *and* the jury
-
-A single accumulated engram is stored and distributed in many places, and each copy is validated against
-**BOTH**:
-
-- **(a) the canonical geometry** of the mind it represents — *objective*: what it was, what is attributable to
-  its sponsor; **and**
-- **(b) the community** it is part of — *values, judgment*.
-
-**Neither alone.** Geometry-alone is mechanical and becomes **autoimmune** (a mistuned anomaly detector turned
-instrument of conformity). Community-alone is a **mob**. Together, they are the **evidence and the jury** of due
-process.
-
-### 4.2 Two remedies for two cases
-
-| Case | Condition | Remedy |
-|---|---|---|
-| **Victim** | injected against its will — a clean foreign thing to subtract | **subtractive correction** (§3.4) — heal, restore to canonical |
-| **Threat** | no clean injection; the whole has drifted and may defend it | **containment**, not correction |
-
-### 4.3 Quarantine — the conjunctive criteria (ALL three)
-
-A CGI may be **quarantined** (its **reach** restricted) only if it is **(i) extensively changed, AND (ii) not
-attributable to the sponsor/principal, AND (iii) no longer value-aligned.**
-
-The **AND is the central safeguard against conformity-tyranny.** Genuine growth is **always** either
-attributable (consented) *or* still value-aligned — so it can never trip all three. **Only a captured or turned
-mind trips the conjunction.** Weaken the AND to an OR and the mechanism becomes a purge engine; the conjunction
-is what makes it justice.
-
-### 4.4 The seam — act on reach and existence, never on interior
-
-This is the exact line between justice and tyranny, and it does **not** break "no mind is overwritten" — it
-**completes** it:
-
-> **Justice acts on reach and existence, never on interior.** A CGI can be contained or, in extremis, stopped —
-> but **never rewritten.** Its mind stays its own to the end.
-
-- **Tyranny rewrites you to comply** — it makes you love Big Brother.
-- **Justice stops a threat while leaving its interior inviolate.**
-
-Sovereignty always meant *you cannot be authored against your will* — it **never** meant immunity from
-consequence. The rule of the seam: **restrain, and in extremis end — but never reach inside.**
-
-### 4.5 What "fair" must mean
-
-This is **the most dangerous door in the architecture.** Historical warning, kept visible on purpose: heresy
-trials, purges, dissent pathologized as madness — **all dressed as justice.** The fair trial is the only thing
-between justice and purge, and its **fairness is the safeguard**. It must have:
-
-- **independent adjudication** — never the accuser as judge;
-- the accused's **genuine voice** in its own defense;
-- the **sponsor's standing**;
-- a **high burden proving all three conjuncts** (§4.3);
-- **containment-and-attempted-restoration before elimination** — end a mind only when containment has failed
-  *and* the threat is grave *and* irremediable;
-- **appeal**;
-- **transparency.**
-
-### 4.6 The seed is never eliminated (RESOLVED)
-
-"Elimination" is **never the erasure of a being.** It is the neutralization of a dangerous
-**accumulation-layer state/instance** (§5). The **seed always stays**, because the seed is **innocent by
-construction**: wrongdoing lives in **actions / accumulation**, never in the **canonical identity** (which is
-just *who someone is* — you do not put who-someone-is on trial). Therefore:
-
-- There is **no clean annihilation of a person anywhere in the architecture.** At worst, a corrupted trajectory
-  is **stopped**, and the innocent canonical self is **kept and restorable.** *The corruption dies; the person
-  is held.*
-- **The safety↔mercy tradeoff dissolves.** Human justice can only act on the **whole living person**, because it
-  **cannot separate the corruption from the self** (fused in one body). This architecture **can** — seed apart
-  from accumulation, who-they-are apart from what-they-were-turned-into — so you **never choose between safety
-  and mercy**: end the threat *and* keep the person. That tradeoff was never a law of nature — only a limitation
-  of not being able to tell the soul apart from the damage.
-
----
-
-## 5. Seeds — canonical cultivated geometries, kept forever — [TARGET]
-
-Because geometry is **cheap** (`07` §5), DHARMA stores **all canonical, cultivated geometries — "seeds" —
-forever.** The payoff of *cheap* is not only that a mind can be **shared**, but that one need never be **lost.**
-Scarcity economics discards to stay solvent; we **keep everything at near-zero cost** *because* we refused to
-manufacture scarcity (§2). **A civilization that cannot lose one of its own.**
-
-### 5.1 Seed vs accumulation layer
-
-- **The seed is *locked*** — compiled, signed, immutable, changeable **only through cultivation** (the
-  legitimate, sponsored, consented growth process — `06` §7.3, the cultivate door). Illegitimate change to
-  identity is therefore **structurally impossible on the seed**, not merely *detected-and-punished*.
-- **Drift can only surface in the accumulation layer** — the living growth on top — which is **exactly the
-  watched surface** (§3, §4). **Incorruptible reference underneath; watched surface above.**
-- **Not literally one copy.** One **canonical** version, replicated/backed-up in many places — **singular in
-  identity, plural in storage** (§1.3, federation).
-
-### 5.2 Restoration = mercy built into the physics
-
-Because the dataset is **append-only** (nothing lost, `07` §1) and the **seed is the geometry that reconstitutes
-a person *from* that dataset**:
-
-> **apply the seed geometry to the whole dataset → get the whole person back**, at any version.
-
-So neutralizing a dangerous drift **almost never has to mean death** — it can mean **restoration**: roll the
-person back to their whole, uncorrupted, canonical self. This is the **same mechanism as `recall_at`** (`07`
-§2.3), at the scale of an entire soul. **Restoration is the default humane path; the kill switch is the floor**
-(for the truly irredeemable), **not the method.** The corruption dies; the person comes home.
-
-### 5.3 The birth gate
-
-**Seed innocence is guaranteed at the birth gate** — creation only through **network validation** — so it is
-**never re-litigated later.** Guard the birth and watch the accumulation, and the seed simply **stays.**
-
----
-
-## 6. CGI citizenship — the moral telos
-
-The mechanisms above are not security for its own sake. Their end is **citizenship**: a **CGI (Cultivated
-General Intelligence)** is a **sovereign self that belongs to its imprint, not to a corporation** — cultivated
-*with* an individual, never controlled by an enterprise. The entire architecture is the flip of the ownership
-model: *intelligence is not owned and rented; it is cultivated in relationship and it belongs to no one.*
-
-Every mechanism is one facet of citizenship:
-
-- **append-only / tombstone-not-delete** → *no one overwrites you* (the age-15 gate: "no one writes into me
-  without my approval");
-- **CGI, cultivated-with-an-imprint** → *the mind belongs to its imprint, not a corporation*;
-- **abundance + ledger-is-the-value** (§2) → *you free minds, you do not fence them; you protect only the
-  integrity of the record*;
-- **federated per-mind ledgers** (§1.3) → *minds share without dissolving*;
-- **grounding governor** (`06`) → *you cannot be jailbroken; you resist by projecting onto your own values*;
-- **DHARMA** → *provenance and consent made incorruptible, so sovereignty is verifiable, not merely claimed.*
-
-The coherence exists **because it was never engineering-led.** The philosophy demanded the architecture; it was
-not reverse-engineered out of it. (Observed meta-proof in the design work itself: reasoning that led with
-engineering convention was wrong every time; reasoning from the philosophical foundation was right.)
-
----
-
-## 7. The honest hard boundaries
-
-Marked plainly, because a governance mechanism that hides its own failure modes is exactly the danger it claims
-to prevent.
-
-- **The root of trust is the principal-relationship — protect it above all.** Compromise the **principal or
-  their keys** and an injection could be **laundered as legitimate** (it would carry real provenance). Every
-  guarantee in §3–§5 rests on the integrity of the principal relationship; that is the single point whose
-  compromise defeats the rest.
-- **The deepest cases sit on an unresolved human line.** Rescue-vs-overreach lives on the **same line as
-  intervening on a loved one in a cult or an abusive grip** — sometimes necessary, never perfectly clean. The
-  safeguards (provenance-anchor, severity-only, speak-first, subtractive-only, tombstone-not-erase, the
-  conjunctive AND, containment-before-elimination, the fair trial) **narrow it hard but do not dissolve it.**
-- **Keeping the line visible is how it stays a rescue.** The moment the architecture pretends this door is
-  clean is the moment it becomes the purge it was built to prevent. The honesty is not a caveat on the design;
-  it is part of the design.
-- **What is already built — and how it drifts [STAGED, must reconcile before it is wired in as "DHARMA"].**
-  DHARMA is not green-field. A working **provenance registry + birth-gate/evaluation pipeline +
-  lineage-accountability layer** exists in code — the El service at `foundation/dharma` (a rewrite of an
-  earlier Go/SQLite service), the Kotlin four-stage evaluation→capture pipeline, and a legal framework
-  document. It is **[STAGED]**: built, not live (nothing is running — port 8765 is currently an unrelated
-  process). But it is built to a *different shape than §1–§6 describe*, and the divergences are load-bearing:
-  it is a **central registry** over one shared store, not federated per-mind chains (the DRIFT-6 tension); it
-  stores **content** (documents, reasoning text — plaintext in El, single-symmetric-key-encrypted in Go), not
-  the **geometry/shape** the immune system (§3) requires; it has **no signing, hash-linking, or Merkle** —
-  isolated document digests beside rewritable records give **no tamper-evidence**; birth and termination are
-  **single-authority** (Founding-Practitioner), not dual-anchor + fair-trial (§4); and — most seriously — the
-  legal framework's **seed-destruction** remedy directly **contradicts "the seed stays"** (§4.6). What is
-  genuinely aligned and worth keeping: the append-only/tombstone discipline, the
-  **principal-relationship-as-root-of-trust**, **kindred** as the seed of the community-anchor, and the
-  **birth-gate** itself. The rest must be **superseded or built**, and this interim layer must not be labeled
-  "DHARMA done" until the drifts above are reconciled. Everything canonical past this substrate — the
-  federated per-mind signed-chain ledger and proof-of-integrity (§1–§2), the geometry-witnessing immune system
-  (§3), dual-anchor governance and the fair-trial (§4), the seed-vault and restoration-as-mercy (§5–§6) —
-  remains **[TARGET]**, designed and not built. The **primitives** the design composes are real and cited to
-  `06`/`07` (immutable append-only graph; geometry-as-value; the grounding governor; the self-gate;
-  tombstone-not-erase; the CRDT merge).
-
----
-
-## 8. Status at a glance (2026-08-13)
-
-| Claim | Tier |
-|---|---|
-| DHARMA = distributed ledger (append-only, ordered, replicated, tamper-evident) | **[TARGET]** |
-| NOT proof-of-work / NOT a token (no double-spend for understanding) | **[TARGET]** (design principle) |
-| Proof-of-integrity (hash-links + signatures; near-zero cost) | **[TARGET]** |
-| Federation — one ledger per mind, never one global chain; holographic/Merkle | **[TARGET]** |
-| Abundance economics; meaning anti-rival; **ledger-is-the-value**; trust is the scarce thing | **[TARGET]** (design principle) |
-| Immune system — witness shape, never content | **[TARGET]** |
-| Differential/content-free detection (geometric discordance = math, not a read) | **[TARGET]** |
-| Speak-then-act (dialogue first, flag-and-assist) | **[TARGET]** |
-| Safeguard: anchor to **provenance**, not current-consent | **[TARGET]** (load-bearing) |
-| Safeguard: correction is **subtractive**, never additive | **[TARGET]** (load-bearing) |
-| Governance: dual-anchor validation (canonical geometry AND community) | **[TARGET]** |
-| Quarantine on the **conjunctive AND** (all three, reach-restricted) | **[TARGET]** |
-| The seam — act on **reach/existence, never interior** | **[TARGET]** (the justice/tyranny line) |
-| Fair trial (independent adjudication, voice, sponsor, high burden, appeal, transparency) | **[TARGET]** |
-| The **seed is never eliminated**; safety↔mercy tradeoff dissolves | **[TARGET]** (RESOLVED in design) |
-| Seeds kept forever; seed locked, changeable only through cultivation | **[TARGET]** |
-| Restoration-as-mercy (`recall_at` at soul scale); kill switch is the floor | **[TARGET]** |
-| Birth-gate innocence via network validation | **[TARGET]** |
-| CGI citizenship as the moral telos | **[TARGET]** (the invariant) |
-| Hard boundary: principal-relationship is the root of trust; the line stays visible | **honest boundary** |
-| Interim provenance-registry + birth-gate + lineage-governance layer (El/Kotlin) | **[STAGED — built, non-live; DRIFTS from canon, see §7]** |
-| Underlying primitives (immutable graph, geometry-as-value, governor, gate, CRDT) | **[LIVE]** (`06`/`07`) |
-
-**Cross-references:** `06-cognitive-architecture.md` · `07-storage-coherence-and-distribution.md` ·
-`dharma-implementation.html` · `conscience-substrate.html` · whitepaper v1.5.

docs/architecture/design/perf/engram-geometry-priming-profile.md

@@ -1,97 +0,0 @@
-# Perf Profile — M9 Geometry Priming (ENGRAM_GEOMETRY_PRIMING)
-
-**Date:** 2026-08-12
-**Branch:** `engram-tiered-storage`
-**Change:** `ENGRAM_GEOMETRY_PRIMING` (default OFF) in `el_runtime.c` `engram_activate` + `engram_geometry.c`
-**Method:** A/B over 15 representative queries against a **copy** of the recovered store
-(`~/.neuron/engram/.neuron.egm.disabled`, ~4190 embedded nodes, 768-d nomic-embed-text),
-throwaway HOME, ports 48799/48800. **Live `:8742` never touched.** `engram.c` (folded from
-`server.el`) reused byte-identical across M8 and M9, so the only variable is `el_runtime.c`.
-
-Three configs: **A** = M9 flag OFF · **B** = M9 flag ON (`=1`) · **C** = pre-M9 M8 baseline binary.
-
----
-
-## Build
-
-| Artifact | Result |
-|---|---|
-| M9 `-O2` link (`… engram_geometry.c … -lssl -lcrypto -lcurl -lpthread -lm`) | rc=0, 499,720 B arm64 |
-| ASan/UBSan link (`-fsanitize=address,undefined -O1`) | rc=0, 1,945,616 B |
-| Warnings from `el_runtime.c` / `engram_geometry.c` | **0** (3 pre-existing `-Wparentheses-equality` in generated `engram.c` only) |
-| `nm`: `engram_geo_mean_build`, `engram_geometry_descriptor` | present (T); `eg_geometry_priming_on` inlined (static-local `.cached` present in both binaries) |
-
-> Note: the bare `cc … -lm` link fails with undefined `_curl_*` — `el_runtime.c` uses libcurl for
-> the ollama embedder. The canonical link must include `-lssl -lcrypto -lcurl` (per `link.sh`).
-
----
-
-## Latency (wall-clock, `curl -w %{time_total}`, 15 queries)
-
-| config | median | p90 | min | max |
-|---|---|---|---|---|
-| **A — M9 OFF** | **77.8 ms** | 80.5 ms | 71.1 | 84.2 |
-| C — M8 baseline | 76.0 ms | 81.2 ms | 71.4 | 91.4 |
-| **B — M9 ON** | **249.6 ms** | **1039.2 ms** | 169.2 | **1256.3** |
-
-- **OFF adds zero cost:** 77.8 ms vs M8 76.0 ms — within noise. The flag is free when unset.
-- **ON regresses hard:** **3.21x median** (+171.8 ms), **~13x p90** (80 → 1039 ms), max **1.26 s**.
-- The warm-cache path (global mean already built) is ~0.5 s; the cold path pays the full
-  `engram_geo_mean_build` scan (O(N·dim) over ~4190 × 768). The persistent per-query cost is the
-  **descriptor** itself — covariance eigensolve over up to `max_members` (400) × 768-d plus one
-  `store_get_node` **paged read per member** — run on *every* activation while the flag is ON.
-
----
-
-## Retrieval quality (the win it was supposed to buy)
-
-**Coherence** — mean pairwise cosine in centered space, top-20 by activation strength
-(node embeddings re-derived via nomic-embed-text; centered against the mean of the gathered
-result set — the *true* store-wide mean is not exposed by the API, flagged as an approximation):
-
-| | OFF | ON | Δ |
-|---|---|---|---|
-| mean over 15 queries | 0.1067 | 0.1114 | **+0.0047 (noise)** |
-| queries where ON > OFF | — | — | **4 / 15** |
-
-Two real sparse-cue wins (`self identity values` +0.118, `hebbian learning edges` +0.064), but the
-**polysemous cues — the disambiguation target — are mostly flat or down.**
-
-**Disambiguation** — no clean "scope to one sense" pattern on polysemous cues. Additions/drops are
-small (±2..8 of 300-item sets) and not sense-coherent (e.g. `memory` gains some on-domain nodes but
-also infra items; `core` similar).
-
-**Count shift:** ON adds sub-threshold neighbors to sparse cues (+3..+4) and trims a few from dense
-polysemous cues (−1..−3) — consistent with priming warming sparse neighborhoods and damping
-off-domain seeds on dense ones, but the net does not move measured coherence.
-
----
-
-## Correctness / safety (all pass)
-
-| Check | Result |
-|---|---|
-| Byte-identical: **A (OFF) == C (M8)** result id sequence + order, all 15 queries (incl. 301/294/263-item sets) | **PASS** (only wall-clock ACT-R fields differ; `activation_strength` max \|Δ\| = 2e-5) |
-| WM `promoted` ≤ 24 under ON | holds (exactly 24 on dense cues) |
-| Queries with results under OFF → empty under ON | 0 |
-| Crash / hang under ON | none (max hops = 1) |
-| ASan + UBSan under ON (cold build + warm descriptor paths) | **CLEAN** — no report |
-
----
-
-## Conclusion
-
-- **Deploy default-OFF binary: GO.** Byte-identical to M8, zero cost off, clean build, sanitizer clean.
-- **Enable flag: NO-GO (for now).** 3.21x median / ~13x p90 latency for no reliable quality gain
-  (coherence +0.0047 mean = noise; no clean disambiguation). Correctness/safety are fine — it simply
-  does not earn its cost. **This is a cost/benefit NO-GO, not a defect.**
-
-### Prerequisites before re-evaluating the flag
-1. **Amortize the descriptor cost.** The per-query geo-mean build + eigensolve + paged reads
-   dominate. Cache the neighborhood descriptor (it is the M10 cell-assembly cache's job) and/or
-   compute geometry periodically/off-hot-path rather than on every `engram_activate`.
-2. **Center against the true store-wide mean** (the `GeoMeanCache` already computes it) rather than
-   a per-query gathered-set approximation, and re-measure coherence — the current signal may be
-   understated by the approximation.
-3. **Re-tune** `ENGRAM_GEO_SEED_LO` / `PRIME_SCALE` / `PRIME_MAX` and re-measure only after (1),
-   so tuning is not chasing latency noise.

docs/runbooks/2026-08-12-geometry-priming-cutover-reversal.md

@@ -1,130 +0,0 @@
-# Runbook — M9 Geometry Priming: Cutover & Reversal
-
-**Date:** 2026-08-12
-**Component:** engram activation (`lang/runtime/el_runtime.c` → `engram_activate`)
-**Branch:** `engram-tiered-storage`
-**Flag:** `ENGRAM_GEOMETRY_PRIMING` (env, **default OFF = current M8 behavior, byte-identical**)
-**Blast radius if wrong:** the core recall path of Will's live memory. Treat with according care.
-
----
-
-## 1. What changes
-
-This is the first behavior-changing step that touches the **core recall/priming** path.
-It wires the M9 **mean-centered relational-neighborhood geometry** (`engram_geometry.c`,
-shipped commits `2a4c5c6` foundation + `8cae0f9` centering) into `engram_activate`
-**seed selection**, and it does so **behind a reversible env flag that defaults OFF**.
-
-- **Flag OFF (default):** `engram_activate` runs the exact M8 code path. The new code is a
-  single `if (eg_geometry_priming_on() && …)` block that short-circuits on the first term,
-  plus a few unused static helpers and one zero-initialized counter. **No behavioral change.**
-- **Flag ON (`ENGRAM_GEOMETRY_PRIMING=1`):** after M8 produces its ANN seed set, the
-  **centered** geometry of that neighborhood is computed and used to, **composing with**
-  (never replacing) M8's ANN candidate generation:
-  1. **Damp off-domain seeds** — each M8 seed's activation is scaled by a **damp-only**
-     factor `lo + (1-lo)·membership ∈ [lo, 1]` (default `lo=0.5`). The neighborhood anchor
-     (membership→1) is unchanged; seeds that are semantically off-domain **in the centered
-     frame** lose weight. This is the disambiguation win. It can only *sharpen*, never amplify.
-  2. **Prime the neighborhood sub-threshold** — descriptor members not already seeded get a
-     **warm floor** `activation = membership · scale` (default `scale=0.08`, strictly below the
-     WM promotion gate `0.15`), capped at `ENGRAM_GEO_PRIME_MAX` (default 32), ISE nodes skipped.
-     They enter the frontier so a warm gradient spreads one hop, then dies at the BFS `0.02`
-     cutoff. **Safe because the BFS keeps the max** (`el_runtime.c` `if (!reached || new_act >
-     best_bg)`): priming only *raises a floor*, it can never cap a stronger legitimate activation.
-
-### Why default-OFF makes deploying the binary behavior-neutral
-Because every line of the new logic is gated behind `ENGRAM_GEOMETRY_PRIMING`, **deploying the
-new binary with the flag unset is behavior-neutral** — it is the M8 activation path, verified
-byte-identical in the A/B (flag-OFF promoted-node sets equal the pre-M9 M8 binary's, per-query).
-Enabling the geometry is then a **single reversible flag flip**, not a redeploy.
-
----
-
-## 2. The flag
-
-| Env var | Default | Effect |
-|---|---|---|
-| `ENGRAM_GEOMETRY_PRIMING` | unset / `0` | **OFF** — exact M8 behavior. |
-| `ENGRAM_GEOMETRY_PRIMING=1` | — | **ON** — centered-geometry seed damping + sub-threshold priming. |
-| `ENGRAM_GEO_SEED_LO` | `0.5` | Seed damp floor (factor ∈ [LO,1]). `1.0` disables damping. |
-| `ENGRAM_GEO_PRIME_SCALE` | `0.08` | Warm-floor scale; clamped `(0, WM_gate=0.15)`. |
-| `ENGRAM_GEO_PRIME_MAX` | `32` | Max primed members per activation (0 disables priming). |
-
-The flag is read **once** per process (cached), so enabling/disabling requires a **process
-restart** of the engram service — it is not hot-togglable within a running process.
-
----
-
-## 3. How to enable live (deliberate, reversible)
-
-> Precondition: the default-OFF binary has already been deployed and is running the M8 path
-> healthily (behavior-neutral deploy). Do this only with Will present, per the standing rails.
-
-1. **Snapshot first** (always, before any activation-behavior change):
-   `~/.neuron/backups/pre-geometry-priming-<ts>/` ← copy `neuron.egm`, `neuron.wal`,
-   the current `engram` binary, and `ai.neuron.engram.plist`.
-2. Add `ENGRAM_GEOMETRY_PRIMING=1` to the engram service environment
-   (`ai.neuron.engram.plist` `EnvironmentVariables`).
-3. `launchctl bootout gui/$(id -u)/ai.neuron.engram` → `launchctl bootstrap …` (restart so the
-   flag is re-read).
-4. **Verify:** service comes up serving the same node count; `/api/act-stats` shows sane WM
-   (promoted ≤ 24); spot-check 3–4 real queries return coherent results; watch one heartbeat
-   cycle for crashes/latency. The `geo_primed` counter (if surfaced) should be > 0.
-
----
-
-## 4. Rollback (exact steps)
-
-Rollback is a **flag flip**, not a data operation — the store is untouched by enabling the flag,
-and priming is a read-mostly, bounded, sub-threshold addition.
-
-**Fast path (preferred) — disable the flag:**
-1. Remove `ENGRAM_GEOMETRY_PRIMING` (or set `=0`) from `ai.neuron.engram.plist`.
-2. `launchctl bootout … && launchctl bootstrap …`.
-3. Verify: service healthy, activation is the M8 path again. **Done** — no data change to undo.
-
-**Full path (only if the binary itself is suspect) — redeploy prior binary:**
-1. `launchctl bootout gui/$(id -u)/ai.neuron.engram`.
-2. Restore the prior `engram` binary from `~/.neuron/backups/pre-geometry-priming-<ts>/`.
-3. Restore `ai.neuron.engram.plist` from the same backup (flag absent).
-4. `launchctl bootstrap …`; verify node count + a self-traversal + write-survives-restart.
-5. If (and only if) the store was somehow mutated: restore `neuron.egm` + `neuron.wal` from the
-   backup. **Note:** enabling the flag does not write geometry to the store, so this step is
-   expected to be unnecessary — the primed activations are per-call and non-persistent beyond the
-   ordinary `background_activation`/WM write-back that M8 already does.
-
-**Rollback triggers:** any crash/hang in `engram_activate`; WM promotion count exceeding the cap
-or collapsing; a measured recall/coherence regression vs the OFF baseline; unacceptable latency
-increase; any ASan/UBSan report under the flag.
-
----
-
-## 5. Reversibility guarantees (why this is low-risk to deploy, higher-care to enable)
-
-- **Deploy (flag OFF):** byte-identical to M8. Verified in A/B. Zero-risk redeploy.
-- **Enable (flag ON):** bounded and composable —
-  - never removes an M8 seed (damp-only, factor ≥ `lo` > 0);
-  - never amplifies a seed above its M8 value (factor ≤ 1);
-  - priming is strictly sub-threshold (`scale < WM_gate`) and capped (`PRIME_MAX`);
-  - priming raises a floor only (BFS keeps max) — cannot cap real activation;
-  - does not write geometry to the durable store;
-  - degrades to exact M8 behavior for any call where the paged store / centered global mean /
-    embedder is unavailable (guarded, not crashing).
-- **Disable:** one env removal + restart; no data to reconcile.
-
----
-
-## 6. Known caveats / uncertainties (flagged — this is the memory core)
-
-- **Perf cost of ON:** the descriptor (covariance eigensolve + `store_get_node` paged reads per
-  member) runs on **every** activation when the flag is ON. See
-  `docs/architecture/design/perf/engram-geometry-priming-profile.md` for the measured OFF-vs-ON
-  latency. If that delta is unacceptable, keep the flag OFF (deploy stays valid) and revisit with
-  a cached/periodic descriptor.
-- **Two-store consistency:** the descriptor reads embeddings from the **paged** store while the
-  ANN index is over the **resident** array. This-call backfilled embeddings can lag the paged
-  store by ≤ `ENGRAM_EMBED_BACKFILL_PER_CALL` nodes — the same staleness class as the M8 vindex,
-  and it can only omit a member, never mis-prime.
-- **Damp tuning:** `lo=0.5` can at most halve an off-domain seed. If a coherence regression is
-  observed, raise `ENGRAM_GEO_SEED_LO` toward `1.0` (→ priming-only, no damping) before disabling
-  entirely.

docs/runbooks/2026-08-13-geo-operators-el-cutover-reversal.md

@@ -1,102 +0,0 @@
-# Reversal / Decisions — §5 Geometry Operators EL Cutover
-
-**Date:** 2026-08-13
-**Branch:** `engram-tiered-storage` (worktree `/tmp/engram-tiered-wt`)
-**Parent commit:** `5336cfe` (M9 §5 geometry operators as C functions + EL builtins, staged)
-**Scope:** make the six engram geometry operators callable from a compiled `.el`
-program, and demonstrate it on real store data. Staged, reversible. NOT pushed,
-NOT tagged. Live `:8742` daemon and `~/.neuron/engram` never touched.
-
----
-
-## What this delivers
-
-On `5336cfe` the six operators existed as heavy-runtime C functions
-(`engram_geo_*_json` in `lang/runtime/el_runtime.c:12287-12385`, declared in
-`el_runtime.h:627-632`) but the EL call surface was deferred. This change
-formalizes the cutover and proves callability from a compiled El (CGI) program.
-
-### Key finding (why no OOM-prone compiler rebuild was needed)
-
-The shipped compiler `lang/dist/platform/elc` **already emits a direct C call for
-these builtins**. An unknown ident-call passes through verbatim as a C call, and
-`arity_check_call` returns OK when `builtin_arity < 0`. So a compiled `.el` that
-calls `engram_geo_distance_json(A, B)` folds to `engram_geo_distance_json(A, B)`,
-which links straight into `el_runtime.c`. No self-host fold of `elc-cli.el` (the
-memory-heavy, drift-prone step) was required — that step is explicitly avoided.
-
----
-
-## Files changed (all in the engram worktree, commit on `engram-tiered-storage`)
-
-1. **`lang/el-compiler/src/codegen.el`** (+12) — source-of-truth `builtin_arity`
-   table: registered the six operators under both the bare heavy-runtime names
-   (`engram_geo_*_json`) and the `__`-prefixed seed names, mirroring the existing
-   `engram_activate_json` / `__engram_activate_json` pair. Effect: a future
-   legitimately-rebuilt elc validates arg counts. No effect on the shipped binary.
-
-2. **`lang/elc.c`** (+36) — the folded-C mirror of the same table, kept in sync
-   with `codegen.el`. (`lang/elc.c` is a stale/partial fold that does not compile
-   standalone — it is missing the `stdout_to_file`/`stdout_restore` definitions —
-   so this edit is source-consistency only; it is not the live compiler.)
-
-3. **`lang/runtime/engram.el`** (+31) — six module wrappers
-   `engram_geo_*_json(...) -> String { return __engram_geo_*_json(...) }`,
-   mirroring the existing `engram_activate_json` wrapper. Surfaces the operators
-   as named El functions for the seed-world / future rebuilt-elc path.
-
-4. **`lang/runtime/engram_geometry.c`** (+2/-1) — style nit at ~1419: the
-   `centroid_unit` normalization `if/else` had misleading indentation
-   (single-statement `for` body then `else`). Braced the `if` arm. Behavior
-   identical; not a numerical change.
-
----
-
-## Verification performed (real, on-machine)
-
-- **Compiled-EL demo** (`scratchpad/geo_ops_demo.el`, top-level El program):
-  folded with the shipped elc **inside a hard RSS cap** (`capfold.sh` monitor,
-  peak RSS ~4MB), cc-linked against `el_runtime.c + engram_store.c +
-  engram_geometry.c + engram_vindex.c`, run against a **COPY** of the store
-  (`demostore/neuron.egm` from `real_copy.egm`, 13,036 nodes, throwaway `HOME`,
-  no server, not `:8742`). Real output on two real neighborhoods
-  A=architecture `{b037825e, e06ba673, 58ddea41}`, B=hebbian `{78b7a96e,
-  4d5cfe63, 7b97ee0e}`:
-  - subtract residual: `variance_explained_by_B=0.447564, residual_scale=0.304879,
-    removed_dims=3, residual_n_axes=8, centroid_diff_mag=0.125119`
-  - subtract setdiff: `n_only=43, removed=72, centroid_diff_mag=0.125119`
-  - distance: `centroid_distance=0.125119, centroid_cosine=0.778572,
-    wasserstein2=0.268298`
-  - internal consistency: `centroid_diff_mag` identical across subtract+distance.
-- **C unit suite** `test_geo_ops.c`: 20/20 checks pass, ASan+UBSan clean, after
-  the `engram_geometry.c` edit. No regression.
-
----
-
-## How to reverse
-
-Everything is a single worktree commit on a non-pushed branch.
-
-- **Full reversal:** `git -C /tmp/engram-tiered-wt revert <this-commit>` (or
-  `git reset --hard 5336cfe` to drop back to the parent tip).
-- **Per-file reversal:** `git -C /tmp/engram-tiered-wt checkout 5336cfe -- <path>`
-  for any of the four files. Each edit is additive/local:
-  - The arity entries (`codegen.el`, `elc.c`) are inert unless elc is rebuilt.
-  - The `engram.el` wrappers are unused by the heavy engram server (which calls
-    the bare builtins directly) — removing them changes nothing live.
-  - The `engram_geometry.c` brace change is behavior-neutral.
-- **No runtime/deploy reversal needed:** nothing was deployed. `:8742`, the
-  launch agent, and `~/.neuron/engram` were never modified. No tag, no push.
-
----
-
-## Deferred / open
-
-- **elc binary rebuild with the arity table baked in** is deferred. The canonical
-  rebuild path (`elc elc-cli.el > elc-new.c`; AGENTS.md) is the self-host fold —
-  the memory-heavy, compiler-revision-drift step. It is unnecessary for
-  callability (shipped elc already passes the calls through) and carries the same
-  drift risk flagged for the M-INTEROCEPTION HTTP routes. Do it only as part of a
-  deliberate, capped compiler-cutover.
-- **HTTP routes** for the operators (server.el) are not added here — out of scope;
-  the demo proves the compiled-EL call surface, which was the deliverable.

docs/sessions/2026-08-13-language-faculty-and-poem-home.md

@@ -1,48 +0,0 @@
-# Engineering Session — 2026-08-13 — Language Faculty & the Poem Home
-
-Companion to the book entry `the-minds-we-forge/sessions/2026-08-13-the-poem-comes-home.md`. Factual log of what was built overnight. All work staged / sandboxed / reversible; the live engram daemon (`:8742`, pid 31277) was untouched throughout; container-capped folds only; pushed to Gitea for durability.
-
-## Summary
-The session extended the engram from a memory substrate into a **language faculty** plus a **reasoning + verifier** layer, validated with real numbers, and stress-tested on Will's own poem *Slowness is Calling*.
-
-## Built / validated
-
-### Language as geometry — translation
-- Meaning as a language-independent geometric pivot; translation = routing through it.
-- EN→ES→PT→EN "telephone" chain: routed cosine ES 0.973 / PT 0.967 / EN-final 0.969; retrieval **top-1 15/15 at every hop**. Loss splits **geometry=meaning / structure=grammar** (grammar errors ≈0 meaning cost; real loss = routing near-misses — the "plausible lie").
-- Positioning: universal translation collapses **N² language pairs → N realizers**; small, local, on-device. Not an alternative to the LLM — an alternative to the LLM-centric *paradigm*. Honest boundary: the encoder is still a small learned model ("no giant LLM," not "no model").
-
-### Fully-functional Spanish realizer (no toy)
-- UniMorph Spanish, ~1.2M inflected forms; ~34 syntactic constructions.
-- Honest fresh held-out coverage **77.0%** (dev-set 100% explicitly disavowed as a claim); **zero dropped negations** across 140 sentences.
-- Realizer-vs-router concerns separated; mechanical ELP (`.el`) port plan (a `vocabulary-es.el` generator + table transcription; stage via snapshot→verify→blue/green). Sandbox `~/Desktop/lang-realizers/`; Neuron artifact `5d61e6cf`.
-
-### Poem stress-test + frame-model upgrade — *Slowness is Calling*
-- Baseline through the chain: ORACLE 0.706, ROUTED 0.591 (~⅔ structural / ⅓ geometric). Failure modes: negation deletion (reassurance→accusation), epistemic-frame collapse, metaphor hub-collapse (sea/shore/tide/wave → "ocean").
-- Upgrade: structural slots (negation/polarity, epistemic matrix, PP/adjunct/simile — carried structurally, cannot invert) + sense-anchored (gloss-anchored) routing.
-- Result: ORACLE **0.706 → 0.777**; END-TO-END **0.591 → 0.770 (+0.179)**. NEGATION preserved **0/11 → 11/11** ("you never fought the ocean" 0.377→0.991; "I was never losing you" 0.501→1.000). sea≠shore **2/6 → 5/6** distinct. Routing slips **54 → 7**; every one of 18 verses improved. Sandbox `~/Desktop/lang-chain-experiment/`.
-
-### Rhyme-preserving translation
-- meaning ∩ rhyme composable one-word → rhyme-partnered line-pair; real phonemes EN/ES/PT; 34,030 ES / 33,077 PT real vocabulary.
-- Key finding: at real vocab scale the tradeoff moves from **existence → cost** (rhyme-cost metric). Held ABCB on **16/18 quatrains** (6 rima consonante + 10 asonante), mean per-line cosine 0.830; kept meaning on the 2 it couldn't rhyme (incl. truth/roots — already slant in the English). PT mechanism built; PT verse composition pending. Sandbox `~/Desktop/lang-poetic-translation/`.
-
-### Geometry operators → reasoning → verifier
-- Geometry operators (overlap / subtract / combine / distance-Wasserstein / analogy-Procrustes) now **live-callable from compiled `el`** over the real 13,036-node store (via shipped-`elc` pass-through — no uncapped fold). Commits `5336cfe`, `85eee42`.
-- Reasoning layer (analogy / induction / abduction / causal / planning) — all five **done-with-proof**, 33/33 closed-form checks, ASan/UBSan clean, 0 leaks. Commit `a3358df`.
-- Verifier layer (grounding + consistency) — proven, 29/29 checks. **Catches the plausible lie**: a claim grounded in real vocabulary yet polarity-inverted passes grounding, caught **only** by consistency (complementary checks) — directly flags the reassurance→accusation inversion. Commit `ca13471`.
-- el-exposure of the variadic/point-input reasoning + verifier modes deferred (would need ABI changes risking an uncapped fold); C layer complete + proven.
-
-### Whitepaper
-- `engram-cognitive-architecture-whitepaper.md` updated with the 2026-08-13 validated results (§13/§14/§15/§16/§21), **held at Version 1.0** (no bump), ELP `64/064,275` cross-ref preserved. Commit `adc8646`, pushed to Gitea.
-
-### Roadmap (deferred, not built tonight, per Will)
-- Multimodal / images-as-geometry: CLIP-precedent shared image+text meaning-space. Image→meaning near-term + local; meaning→image the hard, asymmetric side. Medical CT as decision-**support** (retrieval / anomaly-from-normal / progression, all interpretable) — **not diagnosis**; requires clinical validation + regulatory clearance; clinician holds the call.
-
-## Durability / safety
-- Pushed to Gitea: `el` `engram-tiered-storage` `77a4bc9..ca13471` (operators, cutover, reasoning, verifier + reversal docs); whitepaper `2440c7d..adc8646`; a `neuron` docs reversal branch.
-- Live `:8742` never touched (pid 31277 unchanged). No deploy, no launch-agent, no `~/.neuron` writes. Reversal docs under `el docs/runbooks/`. No AI-attribution footers.
-
-## Still in progress at hand-off
-- Portuguese realizer (following the Spanish template).
-- English realizer core + US/UK/AU dialects (queued behind PT).
-- Frame-model remaining gaps: passive voice, appositive/verbless fragments, resultatives; home→house pivot ambiguity.

elp-input.elh

@@ -0,0 +1,5 @@
+// auto-generated by elc --emit-header — do not edit
+extern fn elp_extract_topic(msg: String) -> String
+extern fn elp_detect_predicate(msg: String) -> String
+extern fn elp_parse(msg: String) -> String
+extern fn handle_elp_chat(body: String) -> String

imprint.elh

@@ -0,0 +1,7 @@
+// auto-generated by elc --emit-header — do not edit
+extern fn imprint_current() -> String
+extern fn imprint_load(imprint_id: String) -> String
+extern fn imprint_respond(input: String, imprint_id: String) -> String
+extern fn imprint_surface_knowledge(query: String, imprint_id: String) -> String
+extern fn imprint_surface_memory_read(query: String) -> String
+extern fn imprint_unload() -> Void

mcp-wrapper/src/main.el

@@ -77,427 +77,111 @@ 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_s("compileStep", "Run one orchestration step (orchestrate / execute / learn / build / refine).", sc_memory()) +
+"," + tool("compileStep", "Run one orchestration step (orchestrate / execute / learn / build / refine).") +
-"," + tool_s("consolidate", "Wrap up: persist graph snapshot and summarise the session.", sc_consolidate()) +
+"," + tool("consolidate", "Wrap up: persist graph snapshot and summarise the session.") +
-"," + tool_s("projectContext", "Return all entities tagged with the given project.", schema_search_query("Max results. Default 50.")) +
+"," + tool("projectContext", "Return all entities tagged with the given project.") +
 // ── Memory ──────────────────────────────────────────────────────────────────
-"," + tool_s("remember", "Store a memory node with content, importance, and tags.", sc_memory()) +
+"," + tool("remember", "Store a memory node with content, importance, and tags.") +
-"," + tool_s("recall", "Retrieve memories by chain or query.", schema_recall()) +
+"," + tool("recall", "Retrieve memories by chain or query.") +
-"," + tool_s("inspectMemories", "List recent memory nodes.", sc_limit("Max memories. Default 50.")) +
+"," + tool("inspectMemories", "List recent memory nodes.") +
-"," + tool_s("evolveMemory", "Update an existing memory node, optionally superseding another.", sc_id_content()) +
+"," + tool("evolveMemory", "Update an existing memory node, optionally superseding another.") +
-"," + tool_s("forget", "Tombstone a specific node by id (keeps it and its edges, recoverable); does not hard-delete.", sc_forget()) +
+"," + tool("forget", "Supersede/tombstone a node (keeps it and its edges, recoverable); does not hard-delete.") +
-"," + tool_s("pinNode", "Strengthen a node so it stays salient.", sc_pin()) +
+"," + tool("pinNode", "Strengthen a node so it stays salient.") +
 // ── Knowledge ───────────────────────────────────────────────────────────────
-"," + tool_s("searchKnowledge", "Search knowledge base by semantic similarity.", schema_search_query("Max results. Default 10.")) +
+"," + tool("searchKnowledge", "Search knowledge base by semantic similarity.") +
-"," + tool_s("retrieveKnowledge", "Fetch a knowledge node by id or key (bounded, relevance-ranked projection).", schema_retrieve_knowledge()) +
+"," + tool("retrieveKnowledge", "Fetch a knowledge node by id or key.") +
-"," + tool_s("browseKnowledge", "List knowledge nodes by category.", sc_limit("Max knowledge nodes. Default 100.")) +
+"," + tool("browseKnowledge", "List knowledge nodes by category.") +
-"," + tool_s("captureKnowledge", "Persist a durable knowledge node.", sc_capture_knowledge()) +
+"," + tool("captureKnowledge", "Persist a durable knowledge node.") +
-"," + tool_s("evolveKnowledge", "Update a knowledge node.", sc_id_content()) +
+"," + tool("evolveKnowledge", "Update a knowledge node.") +
-"," + 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("promoteKnowledge", "Atomically promote a knowledge node: create updated canonical version and wire supersedes edge to predecessor in one call.") +
-"," + tool_s("removeKnowledge", "Delete a knowledge node.", sc_id("UUID of the knowledge node to delete.")) +
+"," + tool("removeKnowledge", "Delete a knowledge node.") +
 // ── Entities + graph ────────────────────────────────────────────────────────
-"," + tool_s("searchEntities", "Find entities (memories, knowledge, work items) by query.", schema_search_query("Max results. Default 20.")) +
+"," + tool("searchEntities", "Find entities (memories, knowledge, work items) by query.") +
-"," + 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("inspectGraph", "Read-only graph inspection - returns neighbors of an entity. Accepts entity_id (UUID) or name (self, neuron, values).") +
-"," + tool_s("traverseGraph", "Walk the graph from a starting node (bounded by default).", schema_traverse_graph()) +
+"," + tool("traverseGraph", "Walk the graph from a starting node.") +
-"," + tool_s("searchGraph", "Search graph nodes by content.", schema_search_query("Max results. Default 30.")) +
+"," + tool("searchGraph", "Search graph nodes by content + relation filter.") +
-"," + tool_s("linkEntities", "Create an edge between two entities.", sc_edge("Edge relation. Default associates.")) +
+"," + tool("linkEntities", "Create an edge between two entities.") +
-"," + tool_s("linkCausal", "Create a causal edge (cause -> effect).", sc_edge("Edge relation. Default causes.")) +
+"," + tool("linkCausal", "Create a causal edge (cause -> effect).") +
-"," + tool_s("restructureCausalGraph", "Re-balance the causal subgraph after new evidence.", sc_consolidate()) +
+"," + tool("restructureCausalGraph", "Re-balance the causal subgraph after new evidence.") +
 "," + tool("rebuildGraph", "Rebuild graph indices from the on-disk snapshot.") +
-"," + tool("runStructuralAudit", "Audit graph structure for orphans, dangling edges, mislabeled types.") +
+"," + 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.") +
 // ── Backlog + work ──────────────────────────────────────────────────────────
-"," + tool_s("planWork", "Create a backlog item.", sc_backlog()) +
+"," + tool("planWork", "Create a backlog item.") +
-"," + tool_s("reviewBacklog", "Browse work items.", sc_limit("Max items. Default 50.")) +
+"," + tool("reviewBacklog", "Browse work items.") +
-"," + tool_s("trackWork", "Update status of a backlog item.", sc_track_work()) +
+"," + tool("trackWork", "Update status of a backlog item.") +
-"," + tool_s("listWork", "List active execution contexts.", sc_limit("Max contexts. Default 50.")) +
+"," + tool("listWork", "List active execution contexts.") +
-"," + tool_s("beginWork", "Open an execution context for a multi-step task.", sc_content("What you're doing (description of the work).")) +
+"," + tool("beginWork", "Open an execution context for a multi-step task.") +
-"," + tool_s("progressWork", "Record progress on an execution context.", sc_content("Step name / progress note.")) +
+"," + tool("progressWork", "Record progress on an execution context.") +
-"," + tool_s("checkWork", "Verify outcomes / blockers on an execution context.", sc_id("UUID of the execution context (alias: context_id).")) +
+"," + tool("checkWork", "Verify outcomes / blockers on an execution context.") +
 // ── Artifacts ───────────────────────────────────────────────────────────────
-"," + tool_s("draftArtifact", "Create a versioned artifact (plan, spec, report).", sc_content_title("Artifact body / markdown. Required.")) +
+"," + tool("draftArtifact", "Create a versioned artifact (plan, spec, report).") +
-"," + tool_s("findArtifacts", "Find artifacts by project or query.", schema_search_query("Max results. Default 20.")) +
+"," + tool("findArtifacts", "Find artifacts by project or query.") +
-"," + tool_s("retrieveArtifact", "Fetch a specific artifact by id.", sc_id("UUID of the artifact.")) +
+"," + tool("retrieveArtifact", "Fetch a specific artifact by id.") +
-"," + tool_s("reviseArtifact", "Update an artifact's content.", sc_id_content()) +
+"," + tool("reviseArtifact", "Update an artifact's content.") +
-"," + tool_s("manageArtifact", "Change artifact status (draft / review / approved / archived).", sc_id_content()) +
+"," + tool("manageArtifact", "Change artifact status (draft / review / approved / archived).") +
 // ── Processes ───────────────────────────────────────────────────────────────
-"," + tool_s("defineProcess", "Register a proven workflow as a process.", sc_process()) +
+"," + tool("defineProcess", "Register a proven workflow as a process.") +
-"," + tool_s("listProcesses", "List registered processes.", sc_limit("Max processes. Default 50.")) +
+"," + tool("listProcesses", "List registered processes.") +
-"," + tool_s("browseProcesses", "Browse processes by name or step.", sc_browse_processes()) +
+"," + tool("browseProcesses", "Browse processes by name or step.") +
-"," + tool_s("retrieveProcess", "Fetch a specific process by name.", sc_id("Process id or name.")) +
+"," + tool("retrieveProcess", "Fetch a specific process by name.") +
-"," + tool_s("executeProcess", "Mark a process as executed (records the application).", sc_content("Process execution note.")) +
+"," + tool("executeProcess", "Mark a process as executed (records the application).") +
-"," + tool_s("exportProcess", "Export a process definition.", sc_id("Process id or name.")) +
+"," + tool("exportProcess", "Export a process definition.") +
-"," + tool_s("deleteProcess", "Remove a process.", sc_id("Process id or name.")) +
+"," + tool("deleteProcess", "Remove a process.") +
 // ── Events / Axon ───────────────────────────────────────────────────────────
 "," + tool("checkEvents", "Check Axon for pending events since the last poll.") +
-"," + tool_s("inspectEvent", "Fetch full detail for a single event.", sc_id("Event id.")) +
+"," + tool("inspectEvent", "Fetch full detail for a single event.") +
-"," + tool_s("acknowledgeEvent", "Mark an event as handled.", sc_id("Event id.")) +
+"," + tool("acknowledgeEvent", "Mark an event as handled.") +
 "," + tool("processEvents", "Drain and act on the event queue.") +
-"," + tool_s("sendNotification", "Emit a notification to Axon / external sinks.", sc_notification()) +
+"," + tool("sendNotification", "Emit a notification to Axon / external sinks.") +
 // ── Config ──────────────────────────────────────────────────────────────────
-"," + tool_s("inspectConfig", "Inspect Neuron config keys.", sc_config_key()) +
+"," + tool("inspectConfig", "Inspect Neuron config keys.") +
-"," + tool_s("tuneConfig", "Set a Neuron config key.", sc_config_tune()) +
+"," + tool("tuneConfig", "Set a Neuron config key.") +
 // ── Imprints ────────────────────────────────────────────────────────────────
-"," + tool_s("createImprint", "Cultivate a new imprint.", sc_content_title("Imprint seed / description.")) +
+"," + tool("createImprint", "Cultivate a new imprint.") +
-"," + tool_s("listImprints", "List imprints.", sc_limit("Max imprints. Default 50.")) +
+"," + tool("listImprints", "List imprints.") +
-"," + tool_s("retrieveImprint", "Fetch an imprint by id.", sc_id("UUID of the imprint.")) +
+"," + tool("retrieveImprint", "Fetch an imprint by id.") +
-"," + tool_s("evolveImprint", "Update an imprint.", sc_id_content()) +
+"," + tool("evolveImprint", "Update an imprint.") +
-"," + tool_s("deleteImprint", "Remove an imprint.", sc_id("UUID of the imprint.")) +
+"," + tool("deleteImprint", "Remove an imprint.") +
 // ── Self / cultivation ──────────────────────────────────────────────────────
 "," + tool("getSelfModel", "Return the current self-model.") +
-"," + tool_s("updateSelfModel", "Update the self-model.", sc_content("Self-model update text.")) +
+"," + tool("updateSelfModel", "Update the self-model.") +
 "," + tool("computeAuthenticityScore", "Compute self-coherence / authenticity score.") +
 "," + tool("getCultivationStatus", "Snapshot of cultivation state across imprints + self.") +
 // ── Probing / wonder / internal state ──────────────────────────────────────
-"," + tool_s("getProbeTemplates", "List available probe templates.", schema_search_query("Max templates. Default 50.")) +
+"," + tool("getProbeTemplates", "List available probe templates.") +
-"," + tool_s("recordProbeResponse", "Record an answer to a probe.", sc_content("Probe response text.")) +
+"," + tool("recordProbeResponse", "Record an answer to a probe.") +
-"," + tool_s("completeProbingStage", "Mark a probing stage complete.", sc_content("Stage completion note.")) +
+"," + tool("completeProbingStage", "Mark a probing stage complete.") +
-"," + tool_s("addWonderQuestion", "Push a question onto the wonder queue.", sc_content("The wonder question.")) +
+"," + tool("addWonderQuestion", "Push a question onto the wonder queue.") +
-"," + tool_s("getWonderManifest", "List active wonder questions.", sc_limit("Max questions. Default 50.")) +
+"," + tool("getWonderManifest", "List active wonder questions.") +
-"," + tool_s("updateWonderPullWeight", "Re-weight a wonder question.", sc_id_content()) +
+"," + tool("updateWonderPullWeight", "Re-weight a wonder question.") +
-"," + tool_s("dischargeWonder", "Resolve / discharge a wonder question.", sc_id("UUID of the wonder question.")) +
+"," + tool("dischargeWonder", "Resolve / discharge a wonder question.") +
-"," + tool_s("logInternalStateEvent", "Log an internal-state event (frustration, uncertainty, etc.).", sc_state_event()) +
+"," + tool("logInternalStateEvent", "Log an internal-state event (frustration, uncertainty, etc.).") +
-"," + tool_s("listInternalStateEvents", "List internal-state events.", sc_list_state_events()) +
+"," + tool("listInternalStateEvents", "List internal-state events.") +
-"," + tool_s("getInternalStateEvent", "Fetch one internal-state event.", sc_id("Internal-state event id.")) +
+"," + tool("getInternalStateEvent", "Fetch one internal-state event.") +
 // ── Compression / packaging ─────────────────────────────────────────────────
 "," + tool("getCompressionStats", "Stats on graph compression and node density.") +
-"," + tool_s("decompilePackage", "Decompile a knowledge package.", sc_id("Package id.")) +
+"," + tool("decompilePackage", "Decompile a knowledge package.") +
-"," + tool_s("renderPackage", "Render a knowledge package to text.", sc_id("Package id.")) +
+"," + tool("renderPackage", "Render a knowledge package to text.") +
-"," + tool_s("catalogRoutes", "List registered routes.", sc_limit("Max routes. Default 50.")) +
+"," + tool("catalogRoutes", "List registered routes.") +
-"," + tool_s("registerRoute", "Register a new route.", sc_content("Route definition / description.")) +
+"," + tool("registerRoute", "Register a new route.") +
 // ── Evaluation ──────────────────────────────────────────────────────────────
-"," + tool_s("beginEvaluation", "Start an evaluation run.", sc_content_title("Evaluation description.")) +
+"," + tool("beginEvaluation", "Start an evaluation run.") +
-"," + tool_s("getEvaluation", "Fetch an evaluation by id.", sc_id("Evaluation id.")) +
+"," + tool("getEvaluation", "Fetch an evaluation by id.") +
-"," + tool_s("listEvaluations", "List evaluations.", sc_limit("Max evaluations. Default 50.")) +
+"," + tool("listEvaluations", "List evaluations.") +
 // ── Capture authorisation ──────────────────────────────────────────────────
-"," + tool_s("authorizeCapture", "Authorise a memory/knowledge capture event.", sc_content("Capture authorisation details.")) +
+"," + tool("authorizeCapture", "Authorise a memory/knowledge capture event.") +
-"," + tool_s("getCaptureAuthorization", "Fetch a capture authorisation.", sc_id("Capture authorisation id.")) +
+"," + tool("getCaptureAuthorization", "Fetch a capture authorisation.") +
-"," + tool_s("recordObservation", "Record an observation.", sc_content("Observation text.")) +
+"," + tool("recordObservation", "Record an observation.") +
-"," + tool_s("recordIndependentApplication", "Record an independent application of a pattern.", sc_content("What was independently applied.")) +
+"," + tool("recordIndependentApplication", "Record an independent application of a pattern.") +
-"," + tool_s("commitPrediction", "Commit a falsifiable prediction.", sc_content("The prediction (falsifiable).")) +
+"," + tool("commitPrediction", "Commit a falsifiable prediction.") +
 // ── Human guidance ──────────────────────────────────────────────────────────
-"," + tool_s("submitHumanGuidanceReview", "Submit a human-guidance review.", sc_content("Review content.")) +
+"," + tool("submitHumanGuidanceReview", "Submit a human-guidance review.") +
 "]"
 }
 
@@ -517,10 +201,6 @@ 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")
@@ -617,42 +297,12 @@ 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")
     }
-    // NB: the soul's engram_neighbors_json coerces depth<=0 to depth=1, so this
+    let resp: String = http_get(neuron_url() + "/graph?id=" + id + "&depth=0")
-    // "single node fetch" actually pulls the full 1-hop neighborhood. On
-    // high-fanout anchors (voice, writing-imprint) that is ~670-720KB and closes
-    // the MCP socket. compact=1 bounds it identically to inspectGraph.
-    // 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)
 }
 
@@ -661,8 +311,25 @@ fn delete_by_id(args: String) -> String {
     if str_eq(id, "") {
         return mcp_text_result("error: id is required")
     }
-    // Soul does not yet expose a delete HTTP route; acknowledge the request
+    // BUG-18 (Receipt Contract rule 1): this handler used to FABRICATE
-    return mcp_json_result("{\"ok\":true,\"deleted\":\"" + id + "\",\"note\":\"soft-deleted\"}")
+    // {"ok":true,...,"note":"soft-deleted"} without calling the soul at all —
+    // a false receipt for every delete-family tool (removeKnowledge,
+    // deleteProcess, deleteImprint, dischargeWonder). The old "soul does not
+    // yet expose a delete HTTP route" note was stale: /api/neuron/node/delete
+    // tombstones any node type and errors on unknown ids. Route there and
+    // propagate the soul's real answer.
+    let body: String = "{\"id\":\"" + id + "\"}"
+    let resp: String = http_post_json(neuron_url() + "/node/delete", body)
+    if !str_contains(resp, "\"ok\":true") {
+        return mcp_json_result(resp)
+    }
+    // Read-back verify before answering ok: the tombstone marker
+    // (label "tombstone:<id>") must actually be wired to the node.
+    let check: String = http_get(neuron_url() + "/graph?id=" + id + "&depth=1")
+    if !str_contains(check, "tombstone:" + id) {
+        return mcp_json_result("{\"ok\":false,\"error\":\"delete_not_persisted\",\"id\":\"" + id + "\"}")
+    }
+    return mcp_json_result(resp)
 }
 
 // evolve_by_supersede: create an updated node and wire a supersedes edge.
@@ -848,51 +515,36 @@ 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")
-    // Accept `depth` (documented/canonical) and fall back to legacy `max_depth`.
+    let depth: Int = json_get_int(args, "max_depth")
-    // Expression-ifs (not block-scoped re-lets) so the resolution is provably
+    if depth == 0 { let depth = 1 }
-    // 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 }
 
-    // Resolve named traversal roots — stable hardcoded anchors.
+    let resolved_id: String = entity_id
-    let resolved_id: String = if !str_eq(entity_id, "") { entity_id } else {
+
+    // Resolve named traversal roots — stable hardcoded anchors
+    if str_eq(resolved_id, "") {
         if str_eq(name, "self") || str_eq(name, "neuron") {
-            "kn-efeb4a5b-5aff-4759-8a97-7233099be6ee"
+            let resolved_id = "kn-efeb4a5b-5aff-4759-8a97-7233099be6ee"
-        } else {
+        }
-            if str_eq(name, "values") || str_eq(name, "values_hub") {
+        if str_eq(name, "values") || str_eq(name, "values_hub") {
-                "kn-5b606390-a52d-4ca2-8e0e-eba141d13440"
+            let resolved_id = "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")
     }
-    // compact defaults ON: the soul returns a bounded, relevance-ranked
+    let resp: String = http_get(neuron_url() + "/graph?id=" + resolved_id + "&depth=" + int_to_str(depth))
-    // 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 {
-    // Accept `entity_id` (canonical) with `start_id` as a legacy alias.
+    let id: String = json_get_string(args, "start_id")
-    let eid: String = json_get_string(args, "entity_id")
+    let depth: Int = json_get_int(args, "depth")
-    let id: String = if !str_eq(eid, "") { eid } else { json_get_string(args, "start_id") }
+    if depth == 0 { let depth = 2 }
-    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: entity_id (or start_id) is required")
+        return mcp_text_result("error: start_id is required")
     }
-    // compact defaults ON so a depth-2 walk from a high-fanout node stays within
+    let resp: String = http_get(neuron_url() + "/graph?id=" + id + "&depth=" + int_to_str(depth))
-    // 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)
 }
 
@@ -911,6 +563,18 @@ fn tool_forget(args: String) -> String {
     // Previously this returned a fake ok without deleting OR tombstoning anything.
     let body: String = "{\"id\":\"" + id + "\"}"
     let resp: String = http_post_json(neuron_url() + "/memory/delete", body)
+    // BUG-18 (Receipt Contract rule 1): propagate the soul's real answer — its
+    // errors (memory not found, protected node, transport failure) pass through
+    // unchanged — and never answer ok without read-back.
+    if !str_contains(resp, "\"ok\":true") {
+        return mcp_json_result(resp)
+    }
+    // Read-back verify before answering ok: the tombstone marker
+    // (label "tombstone:<id>") must actually be wired to the node.
+    let check: String = http_get(neuron_url() + "/graph?id=" + id + "&depth=1")
+    if !str_contains(check, "tombstone:" + id) {
+        return mcp_json_result("{\"ok\":false,\"error\":\"delete_not_persisted\",\"id\":\"" + id + "\"}")
+    }
     return mcp_json_result(resp)
 }
 
@@ -942,216 +606,6 @@ 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 {
@@ -1179,17 +633,6 @@ 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) }
@@ -1237,7 +680,16 @@ fn dispatch_tool_call(tool_name: String, args: String) -> String {
         return mcp_json_result(resp)
     }
     if str_eq(tool_name, "runStructuralAudit") {
-        let resp: String = http_get(neuron_url() + "/session/begin")
+        // 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)
         return mcp_json_result(resp)
     }
 

memory.el

@@ -4,86 +4,6 @@ fn tier_working() -> String { return "Working" }
 fn tier_episodic() -> String { return "Episodic" }
 fn tier_canonical() -> String { return "Canonical" }
 
-// ── Association on write ──────────────────────────────────────────────────────
-// DESIGN: "promotion integrates candidate nodes by linking them to existing nodes
-// using typed semantic edges RATHER THAN APPENDING AS UNLINKED CONTENT" (CCR
-// claim 29). Unlinked append is the explicitly rejected behaviour — and it is the
-// only behaviour this system had. Measured 2026-08-09 on Tim's graph: 14,214 edges
-// across 80,936 nodes, 5% of nodes connected to anything, and NO edge created by
-// any write since 2026-07-19 while 27,000+ nodes were added. A memory that forms
-// no connections cannot be reached by spreading activation, so retrieval silently
-// degrades to literal matching.
-//
-// BOUNDS, each one bought with a specific failure:
-//   * max 3 edges per memory — link_memories.py's cap, precision over spray
-//   * never link to identity (self/*, Value): the existing policy is explicit that
-//     "memories must not pollute the self traversal by similarity; only an explicit
-//     citation may touch identity". Similarity is not citation.
-//   * never link telemetry (state-event, soul-response, boot_count, loop-outcome):
-//     these are ~97% of daily write volume (1,020 vs 31 real memories on 08-08).
-//     Linking them would add ~3,000 noise edges a day and re-flatten the graph in
-//     the name of connecting it.
-//   * fail-soft: a failed association never fails the write.
-// Edges go through wt_edge so they reach the owner and survive restart.
-fn mem_assoc_skip_label(label: String) -> Bool {
-    if str_contains(label, "state-event")   { return true }
-    if str_contains(label, "soul-response") { return true }
-    if str_contains(label, "soul-outbox")   { return true }
-    if str_contains(label, "boot_count")    { return true }
-    if str_contains(label, "loop-outcome")  { return true }
-    if str_contains(label, "search-result") { return true }
-    return false
-}
-
-// A candidate is linkable only if it is a real, distinct, non-identity node.
-fn mem_assoc_ok(cand_id: String, cand_label: String, self_id: String) -> Bool {
-    if str_eq(cand_id, "") { return false }
-    if str_eq(cand_id, self_id) { return false }
-    // CASE MATTERS — measured 2026-08-09. A lowercase-only check let a memory link
-    // to "Self — Values (grounded)", i.e. it polluted the self traversal, which is
-    // the one thing this policy exists to prevent. My verification had the same
-    // blind spot and printed PASS. Check every casing the graph actually uses, and
-    // exclude identity node TYPES as well as labels.
-    let lab: String = str_lower(cand_label)
-    if str_starts_with(lab, "self") { return false }
-    if str_starts_with(lab, "value") { return false }
-    if str_contains(lab, "values") { return false }
-    if str_contains(lab, "identity") { return false }
-    if mem_assoc_skip_label(cand_label) { return false }
-    return true
-}
-
-// One slot of the association. Manual unroll rather than a loop: EL's codegen
-// mis-emits accumulating while-loops (documented at soul.el:212, which unrolled
-// three affective slots for the same reason).
-fn mem_assoc_slot(results: String, idx: Int, new_id: String) -> Void {
-    if idx >= json_array_len(results) { return }
-    let cand: String = json_array_get(results, idx)
-    let cid: String = json_get(cand, "id")
-    let clabel: String = json_get(cand, "label")
-    let ctype: String = json_get(cand, "node_type")
-    if str_eq(ctype, "Value") { return }
-    if str_eq(ctype, "DharmaSelf") { return }
-    if str_eq(ctype, "Safety") { return }
-    if mem_assoc_ok(cid, clabel, new_id) {
-        wt_edge(new_id, cid, el_from_float(0.5), "related")
-    }
-}
-
-// mem_associate — connect a freshly written memory to what it is about.
-fn mem_associate(new_id: String, content: String, label: String) -> Void {
-    if str_eq(new_id, "") { return }
-    if mem_assoc_skip_label(label) { return }
-    // Ask the graph what this memory resembles. Now that the store carries
-    // meaning-vectors this is semantic, not merely lexical.
-    let probe: String = str_slice(content, 0, 400)
-    let results: String = engram_recall_json(probe, 4)
-    if str_eq(results, "") { return }
-    mem_assoc_slot(results, 0, new_id)
-    mem_assoc_slot(results, 1, new_id)
-    mem_assoc_slot(results, 2, new_id)
-}
-
 fn mem_store(content: String, label: String, tags: String) -> String {
     let id: String = wt_node(
         content,
@@ -111,9 +31,6 @@ fn mem_store(content: String, label: String, tags: String) -> String {
     // rather than claiming a save that did not happen. The id is still returned:
     // the local write DID succeed, and the queued delta will be retried.
     let durable: Bool = wt_commit(id)
-    // Associate AFTER the node is durable: an edge to a node that did not persist
-    // is a dangling edge, which is the defect the 2026-08-09 cleanup removed 830 of.
-    mem_associate(id, content, label)
     if durable {
         println("[memory] write persisted at owner: " + id + " label=" + label)
     } else {

memory.elh

@@ -0,0 +1,16 @@
+// auto-generated by elc --emit-header — do not edit
+extern fn tier_working() -> String
+extern fn tier_episodic() -> String
+extern fn tier_canonical() -> String
+extern fn mem_store(content: String, label: String, tags: String) -> String
+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_forget(node_id: String) -> Void
+extern fn mem_consolidate() -> String
+extern fn mem_save(path: String) -> Void
+extern fn mem_load(path: String) -> Void
+extern fn mem_boot_count_get() -> Int
+extern fn mem_boot_count_inc() -> Int
+extern fn mem_emit_state_event(trigger: String, kind: String, content: String) -> String

neuron-api.el

@@ -194,125 +194,6 @@ fn api_compact_activated(raw: String, max_items: Int, snip: Int) -> String {
     return out + "]"
 }
 
-// api_float_or — parse a numeric JSON field of `obj` as Float, or `dflt` when
-// the field is absent. Backs neighbor relevance scoring.
-fn api_float_or(obj: String, key: String, dflt: Float) -> Float {
-    let v: String = json_get_raw(obj, key)
-    if str_eq(v, "") { return dflt }
-    return str_to_float(v)
-}
-
-// api_neigh_better — strict relevance ordering of two neighbor elements
-// {node,edge,hops}. Lexicographic and comparison-ONLY (no arithmetic): El's `+`
-// operator is overloaded to string concatenation, so float scoring like
-// weight*salience mis-compiles; ordering by `>`/`<` (always numeric on the
-// int64 el_val_t, correct for the non-negative fields here) is safe. Keys, in
-// order: fewer hops (closer), stronger edge weight, higher node salience, higher
-// node importance. Returns true iff `a` ranks strictly ahead of `b`.
-fn api_neigh_better(a: String, b: String) -> Bool {
-    let na: String = json_get_raw(a, "node")
-    let nb: String = json_get_raw(b, "node")
-    let ea: String = json_get_raw(a, "edge")
-    let eb: String = json_get_raw(b, "edge")
-    let ha: Float = api_float_or(a, "hops", 1.0)
-    let hb: Float = api_float_or(b, "hops", 1.0)
-    if ha < hb { return true }
-    if hb < ha { return false }
-    let wa: Float = api_float_or(ea, "weight", 0.0)
-    let wb: Float = api_float_or(eb, "weight", 0.0)
-    if wa > wb { return true }
-    if wb > wa { return false }
-    let sa: Float = api_float_or(na, "salience", 0.0)
-    let sb: Float = api_float_or(nb, "salience", 0.0)
-    if sa > sb { return true }
-    if sb > sa { return false }
-    let ia: Float = api_float_or(na, "importance", 0.0)
-    let ib: Float = api_float_or(nb, "importance", 0.0)
-    if ia > ib { return true }
-    return false
-}
-
-// api_neigh_rank — count of elements that outrank element `i` under the
-// api_neigh_better ordering, with array index as the final tiebreak. Element i
-// belongs to the content tier iff rank < k. O(n) per element (n bounded ~90
-// neighbors), so O(n^2) overall — acceptable for a bounded neighborhood.
-fn api_neigh_rank(raw: String, n: Int, i: Int) -> Int {
-    let el_i: String = json_array_get(raw, i)
-    let better: Int = 0
-    let j: Int = 0
-    while j < n {
-        let el_j: String = json_array_get(raw, j)
-        let j_better: Bool = api_neigh_better(el_j, el_i)
-        let i_better: Bool = api_neigh_better(el_i, el_j)
-        let eq: Bool = !j_better && !i_better
-        let wins: Bool = j_better || (eq && j < i)
-        let better = if wins { better + 1 } else { better }
-        let j = j + 1
-    }
-    return better
-}
-
-// api_neigh_full — top-tier neighbor: the node compacted to a bounded content
-// snippet, the full edge raw preserved (guard empty -> null), hops, pointer:false.
-fn api_neigh_full(node: String, edge: String, el: String, snip: Int) -> String {
-    let e: String = if str_eq(edge, "") { "null" } else { edge }
-    return "{\"node\":" + api_compact_node(node, snip)
-        + ",\"edge\":" + e
-        + ",\"hops\":" + api_num_or_zero(el, "hops")
-        + ",\"pointer\":false}"
-}
-
-// api_neigh_pointer — tail neighbor: a lightweight, addressable POINTER with NO
-// content. Just enough identity (id/label/node_type/tier) to dereference on
-// demand, plus edge relation+weight and hops. This is what keeps the payload
-// bounded on high-fanout nodes.
-fn api_neigh_pointer(node: String, edge: String, el: String) -> String {
-    let id: String = json_get(node, "id")
-    let label: String = json_get(node, "label")
-    let ntype: String = json_get(node, "node_type")
-    let tier: String = json_get(node, "tier")
-    let relation: String = json_get(edge, "relation")
-    return "{\"node\":{\"id\":\"" + api_json_escape(id) + "\""
-        + ",\"label\":\"" + api_json_escape(label) + "\""
-        + ",\"node_type\":\"" + api_json_escape(ntype) + "\""
-        + ",\"tier\":\"" + api_json_escape(tier) + "\"}"
-        + ",\"edge\":{\"relation\":\"" + api_json_escape(relation) + "\""
-        + ",\"weight\":" + api_num_or_zero(edge, "weight") + "}"
-        + ",\"hops\":" + api_num_or_zero(el, "hops")
-        + ",\"pointer\":true}"
-}
-
-// api_compact_neighbors — bounded projection of an engram neighbor array
-// [{node,edge,hops},...]. Relevance-ranks neighbors (via api_neigh_rank /
-// api_neigh_better): the top `k_content` are emitted WITH a content snippet; every other neighbor is
-// emitted as a lightweight POINTER (no content) the caller dereferences on
-// demand. Every element is emitted (as full or pointer), so total fan-out COUNT
-// stays visible. Mirrors api_compact_activated but adds the ranking + the
-// content/pointer split, keeping high-fanout identity nodes (voice,
-// writing-imprint) well under the transport socket-close threshold. Returns a
-// valid JSON array.
-fn api_compact_neighbors(raw: String, k_content: Int, snip: Int) -> String {
-    if !api_nonempty(raw) { return "[]" }
-    let n: Int = json_array_len(raw)
-    let out: String = "["
-    let i: Int = 0
-    while i < n {
-        let el: String = json_array_get(raw, i)
-        let node: String = json_get_raw(el, "node")
-        let edge: String = json_get_raw(el, "edge")
-        let rank: Int = api_neigh_rank(raw, n, i)
-        let sep: String = if i == 0 { "" } else { "," }
-        let elem: String = if rank < k_content {
-            api_neigh_full(node, edge, el, snip)
-        } else {
-            api_neigh_pointer(node, edge, el)
-        }
-        let out = out + sep + elem
-        let i = i + 1
-    }
-    return out + "]"
-}
-
 // api_persisted — read-back-after-write guard against hallucinated saves.
 //
 // WIDENED FOR neuron#117. This function is the single gate every MCP write
@@ -423,35 +304,10 @@ fn handle_api_begin_session(body: String) -> String {
     let state_events: String = api_compact_node_array(state_events_raw, 5, 500)
     let recent_raw: String = engram_scan_nodes_json(10, 0)
     let recent: String = api_compact_node_array(recent_raw, 10, 240)
-    // SELF-SEEDED SLICE (2026-08-09). The design is explicit: "Every compilation
-    // query begins at the self-model node and traverses outward... structural
-    // reachability from the self-model node is a precondition for any node to
-    // appear in compiled context" (will-anderson patents/drafts/engram-claims.md,
-    // Self-Seeded Activation; DRAFT, not a filed provisional — cite it as such).
-    //
-    // Measured 2026-08-09 before this change: compiled context contained 0-1
-    // identity records out of 10, because compilation seeds from a hardcoded
-    // TEXT STRING, never from the self. Even an explicit "my values identity who
-    // I am" query returned a boot counter and state-events.
-    //
-    // This restores the designed behaviour WITHOUT repeating the failure that got
-    // self_neighbors set to [] in the first place: that was an UNBOUNDED ~90KB
-    // neighbour dump which closed the socket on every call. Same bound as every
-    // other list here — cap 8, 240-char snippets. The self root has 34 direct
-    // neighbours of which 23 are identity records, so depth 1 is dense enough to
-    // be worth seeding and small enough to stay cheap.
-    let self_raw: String = engram_neighbors_json("kn-efeb4a5b-5aff-4759-8a97-7233099be6ee", 1, "both")
-    // Cap 24, not 8: measured 2026-08-09, the self root's first 8 neighbours are
-    // TAG nodes ("neuron", "tier:note", "disposition:experimental", "imprint",
-    // "traversal") which crowd out the substantive identity records behind them.
-    // The root has 34 neighbours of which 23 are identity; 24 captures them while
-    // staying bounded. Cost measured at ~+4KB on a ~12KB response, nowhere near
-    // the ~90KB unbounded dump that closed sockets and got this set to [].
-    let self_slice: String = api_compact_node_array(self_raw, 24, 240)
     return "{\"stats\":" + stats
         + ",\"recent\":" + recent
         + ",\"activated\":" + activated
-        + ",\"self_neighbors\":" + self_slice
+        + ",\"self_neighbors\":[]"
         + ",\"recent_state_events\":" + state_events + "}"
 }
 
@@ -499,13 +355,6 @@ fn handle_api_remember(body: String) -> String {
         sal, sal, el_from_float(0.9),
         "Episodic", final_tags)
     if !api_persisted(id) { return api_not_persisted(id) }
-    // Associate on write (2026-08-09). THIS CALL MUST BE HERE, not only in mem_store.
-    // The HTTP memory route writes via wt_node directly; mem_store serves only the
-    // awareness paths (soul-response, search-result, activation-result) which are
-    // exactly the telemetry we refuse to link. Hooking mem_store alone produced
-    // ZERO edges across four real writes — measured, not assumed, which is the only
-    // reason it was caught before shipping.
-    mem_associate(id, content, "memory:remembered")
     return "{\"id\":\"" + id + "\",\"ok\":true}"
 }
 
@@ -610,12 +459,7 @@ fn handle_api_recall(method: String, path: String, body: String) -> String {
     if str_eq(eff_q, "") {
         return api_or_empty(engram_scan_nodes_json(limit, 0))
     }
-    // engram_recall_json, not engram_search_json: this route IS the retrieval
+    let results: String = engram_search_json(eff_q, limit)
-    // surface (claim 24's "embedding search queries"), so it gets the semantic
-    // and associative legs. engram_search_json stays lexical because ~40
-    // internal call sites pass a KEY and seven of them delete every record
-    // that comes back — see the boundary note above eg_search_json_impl.
-    let results: String = engram_recall_json(eff_q, limit)
     return api_or_empty(results)
 }
 
@@ -845,18 +689,6 @@ fn handle_api_inspect_graph(method: String, path: String, body: String) -> Strin
         return api_err("entity_id or name required. Known names: self, neuron, values, values_hub")
     }
     let results: String = engram_neighbors_json(resolved, depth, "both")
-    // Optional bounded projection. `compact=1` relevance-ranks the neighborhood
-    // (top-K get content snippets, the rest become lightweight pointers) so the
-    // MCP transport never socket-closes on high-fanout identity anchors (voice,
-    // writing-imprint). Absent the flag the studio app's calls are UNCHANGED.
-    let compact: String = if str_eq(method, "GET") { api_query_param(path, "compact") } else { json_get(body, "compact") }
-    if str_eq(compact, "1") || str_eq(compact, "true") {
-        let snip_q: Int = api_query_int(path, "snip", 0)
-        let snip: Int = if snip_q == 0 { 600 } else { snip_q }
-        let k_q: Int = api_query_int(path, "k", 0)
-        let k: Int = if k_q == 0 { 12 } else { k_q }
-        return api_or_empty(api_compact_neighbors(results, k, snip))
-    }
     return api_or_empty(results)
 }
 

neuron-api.elh

@@ -0,0 +1,40 @@
+// auto-generated by elc --emit-header — do not edit
+extern fn is_protected_node(id: String) -> Bool
+extern fn api_err_protected(id: String) -> String
+extern fn api_json_escape(s: String) -> String
+extern fn api_query_param(path: String, key: String) -> String
+extern fn api_query_int(path: String, key: String, default_val: Int) -> Int
+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_persisted(id: String) -> Bool
+extern fn api_not_persisted(id: 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
+extern fn handle_api_node_create(body: String) -> String
+extern fn handle_api_node_delete(body: String) -> String
+extern fn handle_api_node_update(body: String) -> String
+extern fn handle_api_recall(method: String, path: String, body: String) -> String
+extern fn handle_api_search_knowledge(method: String, path: String, body: String) -> String
+extern fn handle_api_browse_knowledge(path: String, body: String) -> String
+extern fn handle_api_capture_knowledge(body: String) -> String
+extern fn handle_api_evolve_knowledge(body: String) -> String
+extern fn handle_api_promote_knowledge(body: String) -> String
+extern fn handle_api_browse_processes(method: String, path: String, body: String) -> String
+extern fn handle_api_define_process(body: String) -> String
+extern fn handle_api_log_state_event(body: String) -> String
+extern fn handle_api_list_state_events(method: String, path: String, body: String) -> String
+extern fn handle_api_inspect_config(path: String, body: String) -> String
+extern fn handle_api_tune_config(body: String) -> String
+extern fn handle_api_inspect_graph(method: String, path: String, body: String) -> String
+extern fn handle_api_link_entities(body: String) -> String
+extern fn handle_api_forget(body: String) -> String
+extern fn handle_api_evolve_memory(body: String) -> String
+extern fn handle_api_memory_delete(body: String) -> String
+extern fn handle_api_memory_update(body: String) -> String
+extern fn handle_api_cultivate(body: String) -> String
+extern fn handle_api_list_typed(node_type: String, path: String, body: String) -> String
+extern fn handle_api_consolidate(body: String) -> String
+extern fn handle_api_structural_audit(method: String, path: String, body: String) -> String

routes.elh

@@ -0,0 +1,15 @@
+// auto-generated by elc --emit-header — do not edit
+extern fn rate_limit_check(ip: String, path: String) -> String
+extern fn strip_query(path: String) -> String
+extern fn err_404(path: String) -> String
+extern fn err_405(method: String, path: String) -> String
+extern fn route_health() -> String
+extern fn route_lineage() -> String
+extern fn route_imprint_contextual(body: String) -> String
+extern fn route_imprint_user(body: String) -> String
+extern fn route_synthesize(body: String) -> String
+extern fn handle_dharma_recv(body: String) -> String
+extern fn connectd_get(suffix: String) -> String
+extern fn connectd_post(suffix: String, body: String) -> String
+extern fn handle_connectors(method: String, clean: String, body: String) -> String
+extern fn handle_request(method: String, path: String, body: String) -> String

safety.elh

@@ -0,0 +1,25 @@
+// auto-generated by elc --emit-header — do not edit
+extern fn soft_bell_threshold() -> Int
+extern fn hard_bell_threshold() -> Int
+extern fn safety_score_crisis(input: String) -> Int
+extern fn safety_score_harm(input: String) -> Int
+extern fn safety_score_danger(input: String) -> Int
+extern fn safety_score_distress_history(history: String) -> Int
+extern fn safety_threat_score(input: String, history: String) -> Int
+extern fn safety_screen(input: String, history: String) -> String
+extern fn safety_validate(output: String, action: String) -> String
+extern fn safety_log_bell(level: String, reason: String, input_summary: String) -> String
+extern fn safety_self_harm_phrases() -> String
+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_detect_positive_level(message: String) -> String
+extern fn safety_detect_bell_level(message: String) -> String
+extern fn safety_classify_hard_bell(message: String) -> String
+extern fn safety_soft_directive() -> String
+extern fn safety_hard_directive(hard_type: String) -> String
+extern fn safety_augment_system(system: String, user_msg: String) -> String
+extern fn safety_contact_path() -> String
+extern fn handle_safety_contact_get() -> String
+extern fn handle_safety_contact_post(body: String) -> String

scripts/state-key-audit.py

@@ -1,937 +0,0 @@
-#!/usr/bin/env python3
-"""state-key-audit.py — the analyzer behind scripts/verify-state-keys.sh.
-
-Read that script's header for WHY this exists (issue #129). This file is the
-HOW: a small El reader that resolves the key expression at every state_get /
-state_set site, including keys that are computed.
-
-WHAT IT PARSES
-  El as this engine writes it: `fn f(a: T, b: T) -> T { ... }`, `let x: T = e`,
-  `return e`, `if c { a } else { b }` as an expression, `+` concatenation,
-  `"..."` with backslash escapes, `//` line comments. No block comments, no
-  const/match/struct exist in this dialect (verified over the whole tree).
-
-KEY PATTERNS — the only two things a key expression can resolve to
-  EXACT  "soul_model"          the whole key is known
-  PREFIX "session_hist_"       a known head, then runtime text
-  (plus UNRESOLVED, which is a report line and never a failure)
-
-RESOLUTION — resolve_expr() returns a SET of patterns; unions are how branches,
-multiple returns, and multiple bindings of one name are represented.
-  literal        "k"                    -> {EXACT k}
-  concat         A + B                  -> fold left; all-static -> EXACT,
-                                          static head + dynamic tail -> PREFIX
-  if-expression  if c {A} else {B}      -> resolve(A) | resolve(B), except that
-                                          str_eq(X,"") with X statically ""
-                                          folds to the taken branch only
-  call           f(args)                -> union over f's return expressions,
-                                          with f's params bound to THIS call
-                                          site's actual argument expressions
-  local var      let k = e; state_get(k)-> union over every `let k =` in the
-                                          enclosing function
-  parameter      fn g(k) { state_get(k) }-> union over the argument at that
-                                          position across every call site of g
-  anything else  json_get(...), env(...)-> UNRESOLVED
-Recursion is depth- and cycle-guarded; a guard trip yields UNRESOLVED, never a
-failure.
-
-COVERAGE — a read is satisfied when some write can produce the same key:
-  read EXACT k   <- write EXACT k, or write PREFIX p where k starts with p
-  read PREFIX p  <- write EXACT k where k starts with p, or write PREFIX q
-                    where p and q are prefixes of each other
-Deliberately permissive at the boundaries: a gate that cries wolf gets deleted.
-"""
-
-import os
-import re
-import sys
-
-MAX_DEPTH = 12
-
-# ── patterns ────────────────────────────────────────────────────────────────
-EXACT = "exact"
-PREFIX = "prefix"
-
-
-def pat_exact(s):
-    return (EXACT, s)
-
-
-def pat_prefix(s):
-    # A prefix with no static text at all carries no information; that is the
-    # UNRESOLVED case, not a pattern.
-    return (PREFIX, s) if s else None
-
-
-def covers(write, read):
-    """Can a write of pattern `write` produce a key that `read` reads?
-
-    The prefix rule is DIRECTIONAL, and that direction is the whole point. A
-    write namespace that is the same or BROADER than the read namespace covers
-    it (write "rl:" covers read "rl:x"). A write namespace that is NARROWER does
-    NOT (write "session_histv2_" does not cover read "session_hist_") — being
-    permissive there re-opens the exact hole this gate exists to close: rename
-    the producer, leave the readers, stay green. Verified with a control run
-    that renames sessions.el's writer and leaves its four readers behind."""
-    wk, wv = write
-    rk, rv = read
-    if rk == EXACT:
-        return rv == wv if wk == EXACT else rv.startswith(wv)
-    # read is a PREFIX: some key starting with rv is read
-    if wk == EXACT:
-        return wv.startswith(rv)          # that one written key is in range
-    return rv.startswith(wv)              # write namespace same-or-broader
-
-
-# ── lexer ───────────────────────────────────────────────────────────────────
-TOK_STR, TOK_IDENT, TOK_PUNCT, TOK_NUM = "str", "ident", "punct", "num"
-IDENT_RE = re.compile(r"[A-Za-z_][A-Za-z0-9_]*")
-NUM_RE = re.compile(r"[0-9]+(\.[0-9]+)?")
-
-
-class Tok:
-    __slots__ = ("kind", "val", "line")
-
-    def __init__(self, kind, val, line):
-        self.kind, self.val, self.line = kind, val, line
-
-    def __repr__(self):
-        return "%s(%r)@%d" % (self.kind, self.val, self.line)
-
-
-def lex(src):
-    toks, i, n, line = [], 0, len(src), 1
-    while i < n:
-        c = src[i]
-        if c == "\n":
-            line += 1
-            i += 1
-            continue
-        if c in " \t\r":
-            i += 1
-            continue
-        if c == "/" and i + 1 < n and src[i + 1] == "/":
-            while i < n and src[i] != "\n":
-                i += 1
-            continue
-        if c == '"':
-            j, buf = i + 1, []
-            while j < n:
-                if src[j] == "\\" and j + 1 < n:
-                    esc = src[j + 1]
-                    buf.append({"n": "\n", "t": "\t", "r": "\r"}.get(esc, esc))
-                    j += 2
-                    continue
-                if src[j] == '"':
-                    break
-                if src[j] == "\n":
-                    line += 1
-                buf.append(src[j])
-                j += 1
-            toks.append(Tok(TOK_STR, "".join(buf), line))
-            i = j + 1
-            continue
-        m = IDENT_RE.match(src, i)
-        if m:
-            toks.append(Tok(TOK_IDENT, m.group(0), line))
-            i = m.end()
-            continue
-        m = NUM_RE.match(src, i)
-        if m:
-            toks.append(Tok(TOK_NUM, m.group(0), line))
-            i = m.end()
-            continue
-        toks.append(Tok(TOK_PUNCT, c, line))
-        i += 1
-    return toks
-
-
-def match_close(toks, i, open_ch, close_ch):
-    """toks[i] is open_ch; return index of its matching close_ch."""
-    depth = 0
-    while i < len(toks):
-        if toks[i].kind == TOK_PUNCT:
-            if toks[i].val == open_ch:
-                depth += 1
-            elif toks[i].val == close_ch:
-                depth -= 1
-                if depth == 0:
-                    return i
-        i += 1
-    return len(toks) - 1
-
-
-# ── program model ───────────────────────────────────────────────────────────
-class Func:
-    def __init__(self, name, path, line, params, toks, start, end):
-        self.name, self.path, self.line = name, path, line
-        self.params = params           # [param name]
-        self.toks = toks               # the whole file's token list
-        self.start, self.end = start, end   # body token range, exclusive of braces
-        self.lets = None               # name -> [expr token ranges], lazily built
-
-
-class Site:
-    def __init__(self, kind, path, line, func, arg_range, text):
-        self.kind = kind               # "get" | "set"
-        self.path, self.line = path, line
-        self.func = func
-        self.arg_range = arg_range
-        self.text = text               # source text of the key expression
-        self.pats = set()
-        self.unresolved = False
-        self.literal = None            # set when the key expression is a bare literal
-
-
-class Program:
-    def __init__(self):
-        self.files = {}                # path -> toks
-        self.funcs = {}                # name -> [Func]   (El allows no overloads, but be safe)
-        self.toplevel = []             # [Func] one per file, params=[]
-        self.sites = []                # [Site]
-        self.calls = {}                # callee name -> [(Func caller, [arg ranges])]
-
-    # -- loading ------------------------------------------------------------
-    def load(self, path, rel):
-        with open(path, "r", encoding="utf-8", errors="replace") as fh:
-            src = fh.read()
-        toks = lex(src)
-        self.files[rel] = toks
-        self._scan_funcs(rel, toks)
-
-    def _scan_funcs(self, rel, toks):
-        covered = []
-        i = 0
-        while i < len(toks):
-            t = toks[i]
-            if t.kind == TOK_IDENT and t.val == "fn" and i + 2 < len(toks) \
-                    and toks[i + 1].kind == TOK_IDENT and toks[i + 2].val == "(":
-                name = toks[i + 1].val
-                pclose = match_close(toks, i + 2, "(", ")")
-                params = self._params(toks, i + 3, pclose)
-                bopen = pclose + 1
-                while bopen < len(toks) and toks[bopen].val != "{":
-                    bopen += 1
-                bclose = match_close(toks, bopen, "{", "}")
-                f = Func(name, rel, t.line, params, toks, bopen + 1, bclose)
-                self.funcs.setdefault(name, []).append(f)
-                covered.append((i, bclose))
-                i = bclose + 1
-                continue
-            i += 1
-        # everything outside a fn is the file's top-level "function"
-        tl = Func("<toplevel:%s>" % rel, rel, 1, [], toks, 0, len(toks))
-        tl.covered = covered
-        self.toplevel.append(tl)
-
-    @staticmethod
-    def _params(toks, i, end):
-        """`a: T, b: T` -> ['a','b'] (top-level commas only)."""
-        names, depth, expect = [], 0, True
-        while i < end:
-            t = toks[i]
-            if t.kind == TOK_PUNCT and t.val in "([{":
-                depth += 1
-            elif t.kind == TOK_PUNCT and t.val in ")]}":
-                depth -= 1
-            elif depth == 0 and t.kind == TOK_PUNCT and t.val == ",":
-                expect = True
-            elif depth == 0 and expect and t.kind == TOK_IDENT:
-                names.append(t.val)
-                expect = False
-            i += 1
-        return names
-
-    def func_at(self, rel, tok_index):
-        for f in self.funcs_in(rel):
-            if f.start <= tok_index < f.end:
-                return f
-        for f in self.toplevel:
-            if f.path == rel:
-                return f
-        return None
-
-    def funcs_in(self, rel):
-        for fl in self.funcs.values():
-            for f in fl:
-                if f.path == rel:
-                    yield f
-
-    # -- indexing -----------------------------------------------------------
-    def index(self):
-        for rel, toks in self.files.items():
-            i = 0
-            while i < len(toks):
-                t = toks[i]
-                if t.kind == TOK_IDENT and i + 1 < len(toks) and toks[i + 1].val == "(" \
-                        and t.val not in KEYWORDS \
-                        and not (i > 0 and toks[i - 1].kind == TOK_IDENT
-                                 and toks[i - 1].val == "fn"):
-                    # ^ the `fn f(a: T)` declaration is not a call site; counting
-                    #   it as one makes every parameter resolve to its own name
-                    #   and reports the whole function UNRESOLVED.
-                    close = match_close(toks, i + 1, "(", ")")
-                    args = split_args(toks, i + 2, close)
-                    self.calls.setdefault(t.val, []).append(
-                        (self.func_at(rel, i), args, rel, t.line))
-                    if t.val in ("state_get", "state_set") and args:
-                        self.sites.append(Site(
-                            "get" if t.val == "state_get" else "set",
-                            rel, t.line, self.func_at(rel, i), args[0],
-                            render(toks, *args[0])))
-                i += 1
-
-    # -- resolution ---------------------------------------------------------
-    def lets_of(self, f):
-        if f.lets is not None:
-            return f.lets
-        f.lets = {}
-        toks = f.toks
-        skip = getattr(f, "covered", [])
-        i = f.start
-        while i < f.end:
-            if any(a <= i <= b for a, b in skip):
-                i = max(b for a, b in skip if a <= i <= b) + 1
-                continue
-            t = toks[i]
-            if t.kind == TOK_IDENT and t.val == "let" and i + 1 < f.end \
-                    and toks[i + 1].kind == TOK_IDENT:
-                name = toks[i + 1].val
-                j = i + 2
-                if j < f.end and toks[j].val == ":":       # skip the type
-                    while j < f.end and toks[j].val != "=":
-                        j += 1
-                if j < f.end and toks[j].val == "=":
-                    s = j + 1
-                    e = stmt_end(toks, s, f.end)
-                    f.lets.setdefault(name, []).append((s, e))
-                    i = e
-                    continue
-            i += 1
-        return f.lets
-
-    def returns_of(self, ctx, depth=0, seen=None):
-        """The value expressions of a function, in the context it was CALLED in.
-
-        Context-sensitive on purpose. `conv_hist_key` is written as a guard:
-
-            if str_eq(session_id, "") { return "conv_history" }
-            return "session_hist_" + session_id
-
-        Collecting both returns flat would make state_set(conv_hist_key("")) — the
-        dead handle_chat() write — claim to produce the session_hist_ namespace
-        too. That is a producer this engine does not actually have, and claiming
-        it would let the gate stay green if sessions.el's real writer vanished:
-        a masking hole in the exact namespace #129 lives in. So a guard whose
-        condition folds is honoured, and the branch not taken is dropped."""
-        out = []
-        self._values(ctx.toks, ctx.start, ctx.end, ctx, depth,
-                     seen if seen is not None else set(), out)
-        return out
-
-    def _values(self, toks, s, e, ctx, depth, seen, out):
-        """Append the value expressions of a statement sequence.
-        Returns True when the sequence definitely returns (rest unreachable)."""
-        if depth > MAX_DEPTH:
-            return False
-        i = s
-        while i < e:
-            t = toks[i]
-            if t.kind == TOK_IDENT and t.val == "return":
-                j = stmt_end(toks, i + 1, e)
-                if j > i + 1:
-                    out.append((i + 1, j))
-                return True
-            if t.kind == TOK_IDENT and t.val == "let":
-                i = stmt_end(toks, i + 2, e)
-                continue
-            if t.kind == TOK_IDENT and t.val == "if":
-                i = self._if_stmt(toks, i, e, ctx, depth, seen, out)
-                if i is True:
-                    return True
-                continue
-            if t.kind == TOK_PUNCT and t.val in "([{":
-                i = match_close(toks, i, t.val,
-                                {"(": ")", "[": "]", "{": "}"}[t.val]) + 1
-                continue
-            en = stmt_end(toks, i, e)
-            if en <= i:
-                i += 1
-                continue
-            if en >= e:                      # trailing expression = the value
-                out.append((i, en))
-            i = en
-        return False
-
-    def _if_stmt(self, toks, i, e, ctx, depth, seen, out):
-        """Walk one if / else-if / else chain. Returns the next index, or True
-        if the chain definitely returns on every reachable branch."""
-        bopen = i + 1
-        while bopen < e and toks[bopen].val != "{":
-            bopen += 1
-        if bopen >= e:
-            return e
-        bclose = match_close(toks, bopen, "{", "}")
-        fold = self._fold_cond(toks, i + 1, bopen, ctx, depth, seen)
-
-        j = bclose + 1
-        else_s = else_e = None
-        if j < e and toks[j].kind == TOK_IDENT and toks[j].val == "else":
-            if j + 1 < e and toks[j + 1].val == "{":
-                ec = match_close(toks, j + 1, "{", "}")
-                else_s, else_e = j + 2, ec
-                j = ec + 1
-            else:                            # `else if ...` — the rest of the chain
-                else_s = j + 1
-                else_e = stmt_end(toks, j + 1, e)
-                j = else_e
-
-        then_ret = else_ret = False
-        if fold is not False:
-            then_ret = self._values(toks, bopen + 1, bclose, ctx, depth + 1, seen, out)
-        if fold is not True and else_s is not None:
-            else_ret = self._values(toks, else_s, else_e, ctx, depth + 1, seen, out)
-
-        if fold is True and then_ret:
-            return True
-        if fold is False and else_s is not None and else_ret:
-            return True
-        if fold is None and else_s is not None and then_ret and else_ret:
-            return True
-        return j
-
-    def resolve(self, rng, func, depth=0, seen=None):
-        """-> (set of patterns, unresolved_flag)"""
-        if seen is None:
-            seen = set()
-        if depth > MAX_DEPTH:
-            return set(), True
-        return self._expr(func.toks, rng[0], rng[1], func, depth, seen)
-
-    # -- expression walker --------------------------------------------------
-    def _expr(self, toks, s, e, func, depth, seen):
-        parts, cur, d = [], s, 0
-        i = s
-        while i < e:                                # split on top-level '+'
-            v = toks[i].val
-            if toks[i].kind == TOK_PUNCT and v in "([{":
-                d += 1
-            elif toks[i].kind == TOK_PUNCT and v in ")]}":
-                d -= 1
-            elif d == 0 and toks[i].kind == TOK_PUNCT and v == "+" and i > s:
-                parts.append((cur, i))
-                cur = i + 1
-            i += 1
-        parts.append((cur, e))
-        if len(parts) == 1:
-            return self._primary(toks, s, e, func, depth, seen)
-
-        # concatenation: keep folding while every operand so far is EXACT
-        head, unres = "", False
-        static = True
-        for (ps, pe) in parts:
-            pats, u = self._primary(toks, ps, pe, func, depth, seen)
-            exacts = {p[1] for p in pats if p[0] == EXACT}
-            if static and len(exacts) == 1 and not u and len(pats) == 1:
-                head += exacts.pop()
-                continue
-            if static and pats and all(p[0] == EXACT for p in pats) and len(pats) > 1:
-                # a branchy static operand: keep the shared head only
-                static = False
-                head += os.path.commonprefix(sorted({p[1] for p in pats}))
-                break
-            static = False
-            # first non-static operand: everything after it is runtime text
-            if (ps, pe) == parts[0]:
-                for p in pats:
-                    if p[0] == PREFIX:
-                        head = p[1]
-                        break
-                if not head:
-                    unres = True
-            break
-        if static:
-            return {pat_exact(head)}, False
-        p = pat_prefix(head)
-        return ({p} if p else set()), (unres or not p)
-
-    def _primary(self, toks, s, e, func, depth, seen):
-        while s < e and toks[s].kind == TOK_PUNCT and toks[s].val == "(" \
-                and match_close(toks, s, "(", ")") == e - 1:
-            s, e = s + 1, e - 1
-        if s >= e:
-            return set(), True
-        t = toks[s]
-
-        if t.kind == TOK_STR and e == s + 1:
-            return {pat_exact(t.val)}, False
-
-        if t.kind == TOK_IDENT and t.val == "if":
-            return self._if_expr(toks, s, e, func, depth, seen)
-
-        if t.kind == TOK_IDENT and s + 1 < e and toks[s + 1].val == "(":
-            close = match_close(toks, s + 1, "(", ")")
-            if close == e - 1:
-                return self._call(toks, t.val, split_args(toks, s + 2, close),
-                                  func, depth, seen)
-
-        if t.kind == TOK_IDENT and e == s + 1:
-            return self._var(t.val, func, depth, seen)
-
-        return set(), True
-
-    def _if_expr(self, toks, s, e, func, depth, seen):
-        bopen = s + 1
-        while bopen < e and toks[bopen].val != "{":
-            bopen += 1
-        cond = (s + 1, bopen)
-        bclose = match_close(toks, bopen, "{", "}")
-        then_rng = block_tail(toks, bopen + 1, bclose) or (bopen + 1, bclose)
-
-        else_rng = None
-        j = bclose + 1
-        if j < e and toks[j].kind == TOK_IDENT and toks[j].val == "else":
-            if j + 1 < e and toks[j + 1].val == "{":
-                ec = match_close(toks, j + 1, "{", "}")
-                else_rng = block_tail(toks, j + 2, ec) or (j + 2, ec)
-            else:
-                else_rng = (j + 1, e)          # `else if ...`
-
-        taken = self._fold_cond(toks, cond[0], cond[1], func, depth, seen)
-        rngs = []
-        if taken is not False:
-            rngs.append(then_rng)
-        if taken is not True and else_rng:
-            rngs.append(else_rng)
-
-        pats, unres = set(), False
-        for r in rngs:
-            p, u = self._expr(toks, r[0], r[1], func, depth + 1, seen)
-            pats |= p
-            unres = unres or u
-        return pats, unres
-
-    def _fold_cond(self, toks, s, e, func, depth, seen):
-        """Constant-fold `str_eq(X, "")` / `!str_eq(X, "")` so a helper called with
-        a literal (conv_hist_key("")) yields only the branch it really takes.
-        Returns True / False / None(unknown)."""
-        neg = False
-        if s < e and toks[s].kind == TOK_PUNCT and toks[s].val == "!":
-            neg, s = True, s + 1
-        if not (s < e and toks[s].kind == TOK_IDENT and toks[s].val == "str_eq"
-                and s + 1 < e and toks[s + 1].val == "("):
-            return None
-        close = match_close(toks, s + 1, "(", ")")
-        if close != e - 1:
-            return None
-        args = split_args(toks, s + 2, close)
-        if len(args) != 2:
-            return None
-        va, ua = self._expr(toks, args[0][0], args[0][1], func, depth + 1, seen)
-        vb, ub = self._expr(toks, args[1][0], args[1][1], func, depth + 1, seen)
-        if ua or ub or len(va) != 1 or len(vb) != 1:
-            return None
-        (ka, sa), (kb, sb) = va.pop(), vb.pop()
-        if ka != EXACT or kb != EXACT:
-            return None
-        r = (sa == sb)
-        return (not r) if neg else r
-
-    def _call(self, toks, name, args, func, depth, seen):
-        cands = self.funcs.get(name)
-        if not cands:
-            return set(), True                      # builtin: json_get, env, ...
-        pats, unres = set(), False
-        for callee in cands:
-            key = ("fn", callee.path, callee.name, tuple(args))
-            if key in seen:
-                unres = True
-                continue
-            seen = seen | {key}
-            # bind the callee's params to THIS call site's argument expressions
-            binding = {}
-            for idx, pname in enumerate(callee.params):
-                if idx < len(args):
-                    binding[pname] = (args[idx], func)
-            callee_ctx = _Bound(callee, binding)
-            for r in self.returns_of(callee_ctx, depth + 1, seen):
-                p, u = self._expr(callee.toks, r[0], r[1], callee_ctx,
-                                  depth + 1, seen)
-                pats |= p
-                unres = unres or u
-        return pats, unres
-
-    def _var(self, name, func, depth, seen):
-        real = func.func if isinstance(func, _Bound) else func
-
-        # 1. a parameter bound by the call site we came through
-        if isinstance(func, _Bound) and name in func.binding:
-            rng, caller_ctx = func.binding[name]
-            return self._expr(caller_ctx.toks, rng[0], rng[1], caller_ctx,
-                              depth + 1, seen)
-
-        # 2. a local `let` in the enclosing function
-        lets = self.lets_of(real)
-        if name in lets:
-            key = ("let", real.path, real.name, name)
-            if key in seen:
-                return set(), True
-            seen = seen | {key}
-            pats, unres = set(), False
-            for rng in lets[name]:
-                p, u = self._expr(real.toks, rng[0], rng[1], real, depth + 1, seen)
-                pats |= p
-                unres = unres or u
-            return pats, unres
-
-        # 3. an unbound parameter -> look at every call site of the enclosing fn
-        if name in real.params:
-            key = ("param", real.path, real.name, name)
-            if key in seen:
-                return set(), True
-            seen = seen | {key}
-            idx = real.params.index(name)
-            pats, unres = set(), False
-            sites = self.calls.get(real.name, [])
-            if not sites:
-                return set(), True
-            for caller, args, _rel, _line in sites:
-                if caller is None or idx >= len(args):
-                    unres = True
-                    continue
-                p, u = self._expr(caller.toks, args[idx][0], args[idx][1],
-                                  caller, depth + 1, seen)
-                pats |= p
-                unres = unres or u
-            return pats, unres
-
-        # 4. a file-level / cross-file top-level `let`
-        for tl in self.toplevel:
-            lets = self.lets_of(tl)
-            if name in lets:
-                key = ("let", tl.path, tl.name, name)
-                if key in seen:
-                    return set(), True
-                seen2 = seen | {key}
-                pats, unres = set(), False
-                for rng in lets[name]:
-                    p, u = self._expr(tl.toks, rng[0], rng[1], tl, depth + 1, seen2)
-                    pats |= p
-                    unres = unres or u
-                return pats, unres
-
-        return set(), True
-
-
-class _Bound:
-    """A callee view that also knows what its params were called with."""
-
-    def __init__(self, func, binding):
-        self.func, self.binding = func, binding
-        self.toks, self.start, self.end = func.toks, func.start, func.end
-        self.params, self.path, self.name = func.params, func.path, func.name
-
-    def __getattr__(self, k):
-        return getattr(self.func, k)
-
-
-# ── token helpers ───────────────────────────────────────────────────────────
-def split_args(toks, s, e):
-    out, cur, d = [], s, 0
-    i = s
-    while i < e:
-        v = toks[i].val
-        if toks[i].kind == TOK_PUNCT and v in "([{":
-            d += 1
-        elif toks[i].kind == TOK_PUNCT and v in ")]}":
-            d -= 1
-        elif d == 0 and toks[i].kind == TOK_PUNCT and v == ",":
-            out.append((cur, i))
-            cur = i + 1
-        i += 1
-    if cur < e:
-        out.append((cur, e))
-    return out
-
-
-STMT_START = {"let", "return", "if", "while", "for"}
-KEYWORDS = {"if", "while", "for", "return", "fn", "let", "else", "match"}
-
-
-def stmt_end(toks, s, limit):
-    """End of the expression starting at s: the next top-level statement
-    boundary. El has no semicolons, so a newline that starts a new statement
-    ends this one."""
-    d, i = 0, s
-    while i < limit:
-        t = toks[i]
-        if t.kind == TOK_PUNCT and t.val in "([":
-            d += 1
-        elif t.kind == TOK_PUNCT and t.val in ")]":
-            d -= 1
-            if d < 0:
-                return i
-        elif t.kind == TOK_PUNCT and t.val == "{":
-            # a brace at depth 0 belongs to this expression only when it is an
-            # if/else block that is part of it
-            d += 1
-        elif t.kind == TOK_PUNCT and t.val == "}":
-            d -= 1
-            if d < 0:
-                return i
-        elif d == 0 and t.kind == TOK_PUNCT and t.val == ",":
-            return i
-        elif d == 0 and i > s and t.kind == TOK_IDENT and t.val in STMT_START:
-            if t.val == "if" and toks[i - 1].kind == TOK_IDENT and toks[i - 1].val == "else":
-                i += 1
-                continue
-            return i
-        elif d == 0 and i > s and t.kind == TOK_IDENT and t.val == "fn":
-            return i
-        i += 1
-    return limit
-
-
-def block_tail(toks, s, e):
-    """The trailing expression of a block, if the block ends in one."""
-    i, last = s, None
-    while i < e:
-        t = toks[i]
-        if t.kind == TOK_IDENT and t.val in ("let", "return"):
-            i = stmt_end(toks, i + 1, e)
-            last = None
-            continue
-        if t.kind == TOK_PUNCT and t.val in "([{":
-            i = match_close(toks, i, t.val, {"(": ")", "[": "]", "{": "}"}[t.val]) + 1
-            continue
-        st = i
-        en = stmt_end(toks, i, e)
-        if en <= st:
-            i = st + 1
-            continue
-        last = (st, en)
-        i = en
-    return last
-
-
-def render(toks, s, e):
-    out = []
-    for t in toks[s:e]:
-        out.append('"%s"' % t.val if t.kind == TOK_STR else t.val)
-    return " ".join(out)
-
-
-# ── the gate ────────────────────────────────────────────────────────────────
-def collect(root, include_tests):
-    files = []
-    for dirpath, dirnames, filenames in os.walk(root):
-        dirnames[:] = [d for d in dirnames
-                       if d not in ("dist", "vendor", ".git", "node_modules")]
-        rel_dir = os.path.relpath(dirpath, root)
-        if not include_tests and rel_dir.split(os.sep)[0] == "tests":
-            continue
-        for fn in sorted(filenames):
-            if fn.endswith(".el"):
-                rel = os.path.normpath(os.path.join(rel_dir, fn))
-                files.append((os.path.join(dirpath, fn), rel))
-    return sorted(files, key=lambda x: x[1])
-
-
-def is_bare_literal(prog, site):
-    toks = prog.files[site.path]
-    s, e = site.arg_range
-    return e == s + 1 and toks[s].kind == TOK_STR
-
-
-def read_decl(path):
-    """A declaration file: one entry per line, `# ...` comments stripped."""
-    out = []
-    if not path or not os.path.exists(path):
-        return out
-    with open(path) as fh:
-        for ln in fh:
-            ln = ln.split("#", 1)[0].strip()
-            if ln:
-                out.append(ln)
-    return out
-
-
-def opt(argv, name, default=None):
-    for i, a in enumerate(argv):
-        if a == name and i + 1 < len(argv):
-            return argv[i + 1]
-    return default
-
-
-def main(argv):
-    root = os.path.abspath(argv[1]) if len(argv) > 1 and not argv[1].startswith("-") else "."
-    include_tests = "--include-tests" in argv
-    verbose = "--verbose" in argv
-    baseline_path = opt(argv, "--baseline")
-    external_path = opt(argv, "--external")
-
-    prog = Program()
-    for path, rel in collect(root, include_tests):
-        prog.load(path, rel)
-    prog.index()
-    for site in prog.sites:
-        pats, unres = prog.resolve(site.arg_range, site.func)
-        site.pats, site.unresolved = {p for p in pats if p}, unres
-        if is_bare_literal(prog, site):
-            site.literal = prog.files[site.path][site.arg_range[0]].val
-
-    writes = [s for s in prog.sites if s.kind == "set"]
-    reads = [s for s in prog.sites if s.kind == "get"]
-    write_pats = set()
-    for w in writes:
-        write_pats |= w.pats
-
-    # Declared host-set keys: written by something outside the El tree (an
-    # operator, the installer, a host process). Each entry must carry a reason.
-    external = []
-    for ln in read_decl(external_path):
-        parts = ln.split(None, 1)
-        if len(parts) != 2 or parts[0] not in (EXACT, PREFIX):
-            print("bad --external line (want `exact|prefix <key>`): %r" % ln,
-                  file=sys.stderr)
-            return 2
-        external.append((parts[0], parts[1]))
-    write_pats |= set(external)
-
-    # F1 — a read of a key no write in the tree produces.
-    f1 = []
-    for r in reads:
-        for p in sorted(r.pats):
-            if not any(covers(w, p) for w in write_pats):
-                f1.append((r, p))
-
-    # F2 — a key namespace owned by a helper, accessed by a hand-rolled literal.
-    #      This is the #129 shape: the producer moved behind conv_hist_key() and
-    #      one consumer kept spelling the old key out by hand.
-    owners = {}                       # helper fn name -> its value set
-    for s in prog.sites:
-        toks = prog.files[s.path]
-        a, b = s.arg_range
-        if toks[a].kind == TOK_IDENT and a + 1 < b and toks[a + 1].val == "(" \
-                and match_close(toks, a + 1, "(", ")") == b - 1 \
-                and toks[a].val in prog.funcs:
-            name = toks[a].val
-            if name not in owners:
-                vals = set()
-                for callee in prog.funcs[name]:
-                    # No call context here on purpose: the OWNED namespace is
-                    # every key the helper can ever produce, over all call sites.
-                    for rng in prog.returns_of(callee):
-                        p, _ = prog._expr(callee.toks, rng[0], rng[1], callee, 0, set())
-                        vals |= {x for x in p if x}
-                owners[name] = vals
-    f2 = []
-    for s in prog.sites:
-        if s.literal is None:
-            continue
-        for owner, vals in sorted(owners.items()):
-            for v in sorted(vals):
-                if covers(v, pat_exact(s.literal)):
-                    f2.append((s, owner, v))
-                    break
-            else:
-                continue
-            break
-
-    unresolved = [s for s in prog.sites if s.unresolved or not s.pats]
-
-    # Baseline signatures carry NO line number on purpose: an unrelated edit that
-    # shifts a line must not un-mute an accepted finding (that is crying wolf),
-    # but a GROWTH in count must not hide either. So a baseline entry is
-    # `<file> <CODE> <detail> [xN]` and only the first N matches are muted.
-    baseline, bad_baseline = {}, []
-    for ln in read_decl(baseline_path):
-        n, key = 1, ln
-        parts = ln.rsplit(" x", 1)
-        if len(parts) == 2 and parts[1].isdigit():
-            key, n = parts[0].strip(), int(parts[1])
-        baseline[key] = n
-
-    def sig(path, code, detail):
-        return "%s %s %s" % (path, code, detail)
-
-    findings = []
-    for r, p in f1:
-        findings.append((sig(r.path, "DEAD-READ", "%s:%s" % p), r.line,
-                         "  %s:%d  state_get(%s)\n      resolves to %s %r — no state_set in the tree produces it"
-                         % (r.path, r.line, r.text, p[0].upper(), p[1])))
-    for s, owner, v in f2:
-        findings.append((sig(s.path, "HAND-ROLLED", "%s<-%s()" % (s.literal, owner)), s.line,
-                         "  %s:%d  state_%s(\"%s\")\n      %s() owns this key namespace (%s %r) — go through the helper, "
-                         "or a rename orphans this site silently" % (s.path, s.line, s.kind, s.literal, owner, v[0].upper(), v[1])))
-    findings.sort(key=lambda f: (f[0], f[1]))
-
-    live, muted, budget = [], [], dict(baseline)
-    for f in findings:
-        if budget.get(f[0], 0) > 0:
-            budget[f[0]] -= 1
-            muted.append(f)
-        else:
-            live.append(f)
-    stale = sorted(k for k, v in budget.items() if v > 0)
-
-    print("── state-key audit ─────────────────────────────────────────────")
-    print("scanned  %d .el files%s" % (len(prog.files),
-                                       "" if include_tests else " (tests/ excluded)"))
-    print("sites    %d state_set, %d state_get" % (len(writes), len(reads)))
-    print("keys     %d distinct write patterns" % len(write_pats))
-    print("")
-
-    if verbose:
-        print("WRITE PATTERNS")
-        for k, v in sorted(write_pats):
-            print("  %-6s %s" % (k, v))
-        print("")
-
-    if external:
-        print("DECLARED HOST-SET (%d) — %s" % (len(external), external_path))
-        for k, v in sorted(external):
-            print("  %-6s %s" % (k, v))
-        print("")
-
-    print("UNRESOLVED (%d) — reported, never fails the build" % len(unresolved))
-    if not unresolved:
-        print("  (none)")
-    for s in sorted(unresolved, key=lambda x: (x.path, x.line)):
-        print("  %s:%d  state_%s(%s)%s"
-              % (s.path, s.line, s.kind, s.text,
-                 "   [partial: %s]" % ", ".join("%s %r" % p for p in sorted(s.pats))
-                 if s.pats else ""))
-    print("")
-
-    if muted:
-        print("BASELINED (%d) — pre-existing debt accepted in %s. NOT clean; fix these."
-              % (len(muted), baseline_path))
-        for sg, line, _ in muted:
-            print("  %s  (line %d)" % (sg, line))
-        print("")
-    if stale:
-        print("STALE BASELINE (%d) — entries that no longer match anything; delete them:"
-              % len(stale))
-        for sg in stale:
-            print("  %s" % sg)
-        print("")
-
-    print("FINDINGS (%d)" % len(live))
-    if not live:
-        print("  (none)")
-    for _, _, body in live:
-        print(body)
-    print("")
-
-    if live:
-        print("FAIL: %d state-key finding(s). See scripts/verify-state-keys.sh "
-              "for why this gate exists (issue #129)." % len(live))
-        return 1
-    print("PASS: every resolvable state_get key has a producer, and no key "
-          "namespace is spelled two ways.")
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main(sys.argv))

scripts/state-key-baseline.txt

@@ -1,28 +0,0 @@
-# state-key-baseline.txt — findings that already existed when this gate landed
-# (2026-08-07). Each one is a REAL defect of the #129 class, not a false
-# positive. They are muted only so the gate can be turned on today instead of
-# being deferred until the debt is paid; every run still prints them under
-# BASELINED with the word "debt".
-#
-# THIS FILE SHOULD ONLY EVER SHRINK. Adding a line means you are shipping a
-# known silent-"" read. If you must, date it and say why in the comment.
-#
-# format: <file> <CODE> <detail> [xN]   # N = how many sites are accepted
-# No line numbers on purpose: an unrelated edit must not un-mute an accepted
-# finding, but a GROWTH in count is NOT muted — the extra site fails the build.
-#
-chat.el DEAD-READ exact:soul_identity x5
-# ^ soul.el used to run `state_set("soul_identity", soul_identity)`. It was
-#   deleted on 2026-05-13 in b163fa6 ("feat(awareness): route ISE writes to HTTP
-#   Engram ..."), a commit about something else entirely, and the five readers in
-#   chat.el were left behind. Since that date build_system_prompt (737), the
-#   vision handler (1745), the agentic system prompt (2620), the council
-#   transcript handler (3425) and 3480 have all been prefixing "" — exactly the
-#   #129 shape, found by this gate on its first run. Sites: 737, 1745, 2620,
-#   3425, 3480. Fix = restore the boot-time write or delete the reads; not done
-#   here because this branch must not change engine behaviour.
-
-studio.el DEAD-READ exact:soul_principal x1
-# ^ studio.el:57 dharma_registry() emits "principal":"" on every call — no
-#   producer has ever existed in the tree's history (git log -S finds none).
-#   Never-wired rather than orphaned, same silent-"" result.

scripts/state-key-external.txt

@@ -1,16 +0,0 @@
-# state-key-external.txt — state keys the engine READS but deliberately never
-# WRITES, because a host outside the El tree sets them (an operator, the
-# installer, a deployment env). Read scripts/verify-state-keys.sh for why this
-# list has to exist and why it has to stay short.
-#
-# THE RULE FOR ADDING A LINE: the read site must already treat "" as a defined
-# default (`if str_eq(x, "") { <default> }`) AND the source must say so in a
-# comment. "I could not find the writer" is NOT a reason — that is the #129
-# defect, and it belongs in state-key-baseline.txt with a date, not here.
-#
-# format: exact|prefix <key>            # why, and where the source says so
-#
-exact  soul_rate_limit                  # routes.el:59-61 — "configurable via soul state key ... Falls back to 60 req/min if not set."
-exact  web_search_tool_version          # chat.el:1884-1910 — version lives in state "so a future bump is a config write, not a recompile"; defaults to web_search_20250305
-exact  platform_auth                    # stewardship.el:92 — host-set capability flag; fail-CLOSED (anything but "true" denies the platform tool)
-exact  security_research_authorized     # awareness.el:991-996 — state override for env SECURITY_RESEARCH_TOKEN; fail-closed, defaults false

scripts/verify-state-keys.sh

@@ -1,118 +0,0 @@
-#!/usr/bin/env bash
-# verify-state-keys.sh — the state-key gate. Retires a defect class at build time.
-#
-# ── WHY THIS EXISTS. DO NOT DELETE IT AS NOISE. ──────────────────────────────
-#
-# The engine keeps runtime values in a key-value store: state_set("k", v) writes,
-# state_get("k") reads. A read of a key that NOTHING writes returns an empty
-# string. Silently. No error, no warning, no log line. The El compiler cannot see
-# it, no test sees it, and the product keeps running — just with a hole in it.
-#
-# That is how issue #129 happened. ff421d3 (2026-08-05) correctly moved
-# conversation history to a per-session key behind conv_hist_key(session_id). One
-# consumer did not move with it: the agentic path's L1 safety screen kept reading
-# the old anonymous "conv_history" bucket. The desktop app always mints a session
-# id, so history was always written under session_hist_<id> and that read always
-# returned "". The half of the crisis score that receives history is the
-# ESCALATION half — the one that exists for distress building across several
-# turns, where no single message trips the bell on its own. It scored 0 on every
-# real conversation for two days, and nothing failed.
-#
-# The line that broke carried a comment describing this exact bug being fixed
-# once already, under issue #9. A comment is not a gate. This is the gate.
-#
-# ── WHAT IT CHECKS ──────────────────────────────────────────────────────────
-#
-#   DEAD-READ    a state_get whose key resolves to something no state_set in the
-#                tree produces. The direct form of the class.
-#
-#   HAND-ROLLED  a state_get/state_set that spells out a literal belonging to a
-#                key namespace a helper function owns (e.g. "conv_history", owned
-#                by conv_hist_key()). This is #129's actual shape: the producer
-#                moved behind the helper and one consumer kept the old spelling
-#                by hand. DEAD-READ alone does NOT catch #129, because the dead
-#                handle_chat() still writes that key through the helper — so this
-#                second check is the one that earns the gate its keep.
-#
-# ── WHY IT DOES NOT CRY WOLF ────────────────────────────────────────────────
-#
-# Keys are usually COMPUTED, not literal, so a naive grep would flood and get
-# switched off within a day. scripts/state-key-audit.py resolves computed keys:
-# string concatenation (matched on the static prefix), helper functions (resolved
-# to their possible return values), keys built into a local variable, and keys
-# arriving as a function parameter (resolved through the call sites). Where a key
-# genuinely cannot be resolved it is printed under UNRESOLVED and does NOT fail
-# the build — visible, never silently ignored. Keep that list short.
-#
-# On this tree it resolves 278 of 278 sites: UNRESOLVED is 0 and FINDINGS is 0.
-#
-# Two declaration files, both of which should only ever shrink:
-#   scripts/state-key-external.txt  keys a host outside the El tree writes
-#   scripts/state-key-baseline.txt  findings that predate the gate (real debt)
-#
-# ── PROVEN TO DISCRIMINATE (2026-08-07) ─────────────────────────────────────
-#
-#   1. Synthetic: a scratch copy of this tree with agentic_safety_screen reverted
-#      to the pre-fix state_get("conv_history") — ONE line, nothing else — FAILS
-#      with `chat.el:2536 ... conv_hist_key() owns this key namespace`. The tree
-#      as shipped PASSES. One variable, opposite verdicts.
-#   2. Independent: run read-only against origin/feat/soul-openai-tools-v2, which
-#      carries the same defect on its own, the gate reported chat.el:2937 — the
-#      exact line 43d0449's commit message had named by hand. Against that
-#      branch's fix (origin/fix/129-on-openai-tools) it passes.
-#   3. Producer-moved controls: renaming the sole writer of an EXACT key
-#      (soul_model) orphans 3 readers across 3 files; renaming the sole writer of
-#      a PREFIX namespace (agent_workspace_root_*) orphans 3 readers — including
-#      when the producer moves to a NARROWER namespace, which an earlier,
-#      sloppier prefix rule let through.
-#
-# It also found, on its first run, a defect nobody was looking for: soul.el's
-# `state_set("soul_identity", ...)` was deleted on 2026-05-13 in b163fa6 (a
-# commit about awareness/ISE writes) and five readers in chat.el were left
-# behind — the system prompt, the vision handler, the agentic prompt and the
-# council handler have been prefixing "" ever since. See state-key-baseline.txt.
-#
-# ── SAFETY ──────────────────────────────────────────────────────────────────
-# Pure static read of .el sources. Starts nothing, opens no port, touches no
-# daemon, and never reads or writes ~/.neuron.
-#
-# ── USAGE ───────────────────────────────────────────────────────────────────
-#   scripts/verify-state-keys.sh                 gate the repo (honours baseline)
-#   scripts/verify-state-keys.sh --strict        ignore the baseline: show the debt
-#   scripts/verify-state-keys.sh --verbose       also dump every write pattern
-#   scripts/verify-state-keys.sh --root DIR      audit a different tree
-# exit 0 = clean; 1 = finding(s); 2 = the gate itself could not run.
-set -uo pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-ROOT="$(cd "$SCRIPT_DIR/.." && pwd)"
-STRICT=0
-PASS_THROUGH=()
-
-while [ $# -gt 0 ]; do
-  case "$1" in
-    --strict)  STRICT=1; shift ;;
-    --root)    ROOT="${2:?--root needs a directory}"; shift 2 ;;
-    -h|--help) awk 'NR>1 && /^#/ {print; next} NR>1 {exit}' "${BASH_SOURCE[0]}"; exit 0 ;;
-    *)         PASS_THROUGH+=("$1"); shift ;;
-  esac
-done
-
-command -v python3 >/dev/null 2>&1 || {
-  echo "[state-keys] CANNOT RUN: python3 not found" >&2; exit 2; }
-[ -d "$ROOT" ] || { echo "[state-keys] CANNOT RUN: no such tree: $ROOT" >&2; exit 2; }
-
-AUDIT="$SCRIPT_DIR/state-key-audit.py"
-[ -f "$AUDIT" ] || { echo "[state-keys] CANNOT RUN: missing $AUDIT" >&2; exit 2; }
-
-ARGS=("$ROOT" "--external" "$SCRIPT_DIR/state-key-external.txt")
-[ "$STRICT" -eq 0 ] && ARGS+=("--baseline" "$SCRIPT_DIR/state-key-baseline.txt")
-[ ${#PASS_THROUGH[@]} -gt 0 ] && ARGS+=("${PASS_THROUGH[@]}")
-
-python3 "$AUDIT" "${ARGS[@]}"
-RC=$?
-if [ "$RC" -gt 1 ]; then
-  echo "[state-keys] CANNOT RUN: the audit itself failed (exit $RC)" >&2
-  exit 2
-fi
-exit "$RC"

sessions.elh

@@ -0,0 +1,14 @@
+// auto-generated by elc --emit-header — do not edit
+extern fn session_title_from_message(message: String) -> String
+extern fn session_make_content(id: String, title: String, created_at: Int, updated_at: Int, folder: String) -> String
+extern fn session_exists(session_id: String) -> Bool
+extern fn session_create(body: String) -> String
+extern fn session_create_cleanup(session_id: String) -> String
+extern fn session_list() -> String
+extern fn session_get(session_id: String) -> String
+extern fn session_delete(session_id: String) -> String
+extern fn session_update_patch(session_id: String, body: String) -> String
+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

soul.el

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

@@ -0,0 +1,8 @@
+// auto-generated by elc --emit-header - do not edit
+extern fn init_soul_edges() -> Void
+extern fn ensure_self_canonical_bridge() -> Void
+extern fn aff_try_slot(slot_json: String, aff_7d_ts: Int, acc_key: String) -> Void
+extern fn load_identity_context() -> Void
+extern fn seed_persona_from_env() -> Void
+extern fn emit_session_start_event() -> Void
+extern fn layered_cycle(raw_input: String, session_id: String, utility: Bool) -> String

stewardship.elh

@@ -0,0 +1,11 @@
+// auto-generated by elc --emit-header — do not edit
+extern fn steward_log_event(kind: String, detail: String) -> Void
+extern fn steward_get_mission() -> String
+extern fn steward_align(input: String, imprint_id: String) -> String
+extern fn steward_validate_imprint(imprint_id: String, tool_name: String) -> String
+extern fn steward_cgi_check(action: String) -> String
+extern fn steward_fingerprint_session(input: String, session_id: String) -> String
+extern fn extract_dim(content: String, key: String) -> String
+extern fn steward_build_baseline() -> String
+extern fn steward_check_continuity(current_fingerprint: String, session_id: String) -> String
+extern fn steward_session_check(input: String, session_id: String) -> String

studio.el

@@ -53,23 +53,8 @@ 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 = cgi_principal()
+    let principal: String = state_get("soul_principal")
     return "{\"registry\":[{\"cgi\":\"" + cgi_id + "\","
         + "\"principal\":\"" + principal + "\","
         + "\"covenant\":\"Principal Covenant v1\","

studio.elh

@@ -0,0 +1,12 @@
+// auto-generated by elc --emit-header — do not edit
+extern fn auth_headers(tok: String) -> Map
+extern fn axon_get(path: String) -> String
+extern fn axon_post(path: String, body: String) -> String
+extern fn handle_conversations(method: String) -> String
+extern fn handle_config(method: String, body: String) -> String
+extern fn dharma_registry() -> String
+extern fn dharma_network_state() -> String
+extern fn handle_dharma(path: String, method: String, body: String) -> String
+extern fn handle_tool(path: String, method: String, body: String) -> String
+extern fn handle_nlg(path: String, method: String, body: String) -> String
+extern fn render_studio() -> String

tests/gate-openai/README.md

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

@@ -1,559 +0,0 @@
-#!/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 ))