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

# Conflicts:
#	memory.elh
#	neuron-api.elh
#	routes.elh
#	safety.elh
#	sessions.elh
#	soul.elh

.gitea/workflows/ci.yaml

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

.gitignore

@@ -7,5 +7,15 @@ 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

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

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

README.md

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

@@ -1269,10 +1269,29 @@ fn awareness_run() -> Void {
             state_set("soul.last_beat_ts", int_to_str(now_ts))
             // Persist in-process Engram (sessions, memories, conversation nodes)
             // to local snapshot so they survive restarts.
+            // FILE MODE ONLY: "soul_snapshot_path" is set exclusively in the
+            // genesis+safe_to_seed branch of soul.el, and safe_to_seed is
+            // unconditionally false when ENGRAM_URL is set. In HTTP mode the
+            // owner persists; the soul must not (soul.el:571-573).
             let snap_path: String = state_get("soul_snapshot_path")
             if !str_eq(snap_path, "") {
                 mem_save(snap_path)
             }
+            // WRITE-THROUGH RETRY (neuron#117). The HTTP-mode counterpart of the
+            // save above: hand anything still spooled to the persistence owner.
+            //
+            // This is the retry arm of the whole design. Deltas that could not be
+            // pushed — owner down, owner restarting, transient refusal — stay on
+            // disk and are re-offered here every heartbeat until they land. It is
+            // also the catch-all for writes made by the awareness loop itself,
+            // which never passes through the HTTP handler's flush point.
+            //
+            // No-op with no HTTP call when the spool is empty or ENGRAM_URL is
+            // unset, so an idle soul in file mode pays nothing for this.
+            let wt_pushed: Int = wt_drain()
+            if wt_pushed < 0 {
+                ise_post("{\"event\":\"write_through_backlog\",\"ts\":" + int_to_str(now_ts) + "}")
+            }
         }
 
         // Curiosity scan: idle-gated AND wall-clock based. Only fires when the

awareness.elh

@@ -1,26 +0,0 @@
-// 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.elh

@@ -1,71 +0,0 @@
-// 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 bounded_persona_floor() -> String
-extern fn build_system_prompt(ctx: String, chat_mode: Bool) -> String
-extern fn hist_append(hist: String, role: String, content: String) -> String
-extern fn hist_trim(hist: String) -> String
-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

connectd/README.md

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

@@ -0,0 +1,115 @@
+#!/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.elh

@@ -1,26 +0,0 @@
-// 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

@@ -1,70 +0,0 @@
-// 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

@@ -5,6 +5,15 @@ el_val_t add_punct(el_val_t s, el_val_t intent);
 el_val_t add_to_seen(el_val_t seen, el_val_t node_id);
 el_val_t aff_try_slot(el_val_t slot_json, el_val_t aff_7d_ts, el_val_t acc_key);
 el_val_t affective_context_prefix(void);
+el_val_t is_utility_request(el_val_t body, el_val_t session_id);
+el_val_t operator_identity_block(void);
+el_val_t provenance_add_sources(el_val_t block, el_val_t btype, el_val_t has_cit, el_val_t cit_raw, el_val_t acc);
+el_val_t provenance_names(el_val_t tools_used);
+el_val_t provenance_scan_urls(el_val_t arr, el_val_t acc);
+el_val_t text_join_sep(el_val_t accumulated, el_val_t incoming, el_val_t after_interruption);
+el_val_t receipt_rule(void);
+el_val_t receipt_strip(el_val_t s);
+el_val_t tool_receipt(el_val_t tools_used, el_val_t sources);
 el_val_t agent_number(el_val_t agent);
 el_val_t agent_person(el_val_t agent);
 el_val_t agent_workspace_root(void);
@@ -137,7 +146,7 @@ el_val_t awareness_run(void);
 el_val_t axon_get(el_val_t path);
 el_val_t axon_post(el_val_t path, el_val_t body);
 el_val_t bounded_persona_floor(void);
-el_val_t bridge_save(el_val_t session_id, el_val_t model, el_val_t safe_sys, el_val_t tools_json, el_val_t messages, el_val_t tools_log, el_val_t tool_use_id);
+el_val_t bridge_save(el_val_t session_id, el_val_t model, el_val_t safe_sys, el_val_t tools_json, el_val_t messages, el_val_t tools_log, el_val_t tool_use_id, el_val_t wire);
 el_val_t build_form_from_json(el_val_t semantic_form_json, el_val_t lang_code);
 el_val_t build_np(el_val_t referent, el_val_t slots);
 el_val_t build_pp(el_val_t loc);
@@ -156,8 +165,12 @@ el_val_t cmd_abs_escape_at(el_val_t cmd, el_val_t root, el_val_t needle);
 el_val_t connectd_get(el_val_t suffix);
 el_val_t connectd_post(el_val_t suffix, el_val_t body);
 el_val_t connector_tools_json(void);
-el_val_t conv_history_load(void);
-el_val_t conv_history_persist(el_val_t hist);
+el_val_t conv_hist_key(el_val_t session_id);
+el_val_t conv_hist_label(el_val_t session_id);
+el_val_t conv_history_block(el_val_t session_id);
+el_val_t conv_history_load(el_val_t session_id);
+el_val_t conv_history_persist(el_val_t session_id, el_val_t hist);
+el_val_t conv_history_record(el_val_t session_id, el_val_t user_msg, el_val_t assistant_msg, el_val_t receipt);
 el_val_t cop_article(el_val_t gender, el_val_t number, el_val_t definite);
 el_val_t cop_bwk_future(el_val_t prefix);
 el_val_t cop_bwk_perfect(el_val_t prefix);
@@ -788,7 +801,8 @@ 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_word_order(el_val_t profile);
-el_val_t layered_cycle(el_val_t raw_input);
+el_val_t layered_cycle(el_val_t raw_input, el_val_t session_id, el_val_t utility);
+el_val_t layered_generate(el_val_t prompt, el_val_t imprint_id, el_val_t session_id);
 el_val_t lex_class(el_val_t entry);
 el_val_t lex_form(el_val_t entry, el_val_t idx);
 el_val_t lex_pos(el_val_t entry);
@@ -867,6 +881,11 @@ el_val_t non_weak_past(el_val_t stem, el_val_t slot);
 el_val_t non_weak_present(el_val_t stem, el_val_t slot);
 el_val_t one_cycle(void);
 el_val_t openai_chat_complete(el_val_t model, el_val_t base_url, el_val_t api_key, el_val_t safe_sys, el_val_t messages_json);
+el_val_t openai_tools_json(el_val_t tools_anthropic);
+el_val_t json_trim_dangling_escape(el_val_t s);
+el_val_t utf8_safe_slice(el_val_t s, el_val_t n);
+el_val_t agentic_tools_no_web(void);
+el_val_t openai_agentic_loop(el_val_t session_id, el_val_t model, el_val_t safe_sys, el_val_t tools_json, el_val_t messages_in, el_val_t tools_log_in);
 el_val_t parse_float_x100(el_val_t s);
 el_val_t path_within_root(el_val_t path, el_val_t root);
 el_val_t peo_ah_past(el_val_t slot);

dist/elp-input.elh

@@ -1,5 +0,0 @@
-// 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

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

@@ -1,38 +0,0 @@
-// 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

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

@@ -1,46 +0,0 @@
-// 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

@@ -1,16 +0,0 @@
-// 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

@@ -1,31 +0,0 @@
-// 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

@@ -1,44 +0,0 @@
-// 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

@@ -1,27 +0,0 @@
-// 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

@@ -1,35 +0,0 @@
-// 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

@@ -1,13 +0,0 @@
-// 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

@@ -1,38 +0,0 @@
-// 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

@@ -1,30 +0,0 @@
-// 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

@@ -1,23 +0,0 @@
-// 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

@@ -1,17 +0,0 @@
-// 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

@@ -1,29 +0,0 @@
-// 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

@@ -1,38 +0,0 @@
-// 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

@@ -1,26 +0,0 @@
-// 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

@@ -1,34 +0,0 @@
-// 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

@@ -1,37 +0,0 @@
-// 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

@@ -1,45 +0,0 @@
-// 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

@@ -1,30 +0,0 @@
-// 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

@@ -1,27 +0,0 @@
-// 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

@@ -1,9 +0,0 @@
-// 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

@@ -1,41 +0,0 @@
-// 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

@@ -1,30 +0,0 @@
-// 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

@@ -1,19 +0,0 @@
-// 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

@@ -1,34 +0,0 @@
-// 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

@@ -1,14 +0,0 @@
-// 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

@@ -1,36 +0,0 @@
-// 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

@@ -1,22 +0,0 @@
-// 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

@@ -1,29 +0,0 @@
-// 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

@@ -1,23 +0,0 @@
-// 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

@@ -1,17 +0,0 @@
-// 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

@@ -1,25 +0,0 @@
-// 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

@@ -1,27 +0,0 @@
-// 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.c

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

dist/neuron-api.elh

@@ -1,39 +0,0 @@
-// 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

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

dist/realizer.elh

@@ -1,10 +0,0 @@
-// 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.elh

@@ -1,16 +0,0 @@
-// 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

@@ -1,29 +0,0 @@
-// 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

@@ -1,18 +0,0 @@
-// 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

@@ -1,17 +0,0 @@
-// 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-with-nlg.el

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

dist/soul.c.stamp

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

@@ -1,8 +0,0 @@
-// 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

@@ -1,11 +0,0 @@
-// 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

@@ -1,12 +0,0 @@
-// 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

@@ -1,20 +0,0 @@
-// 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/NARRATED-RUNS-ENGINE-NOTES-20260713.md

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

elp-input.elh

@@ -1,5 +0,0 @@
-// 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

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

@@ -293,8 +293,108 @@ fn sc_list_state_events() -> String {
     )
 }
 
+// ── 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.") +
@@ -417,6 +517,10 @@ fn fire_activation(seed: String) -> String {
 // pick_activation_seed — extract the best semantic seed from a tool call's args.
 // Priority: query > content > title > description > summary > action > name.
 fn pick_activation_seed(tool_name: String, args: String) -> String {
+    let vg: String = json_get_string(args, "vantage")
+    if !str_eq(vg, "") { return vg }
+    let sd: String = json_get_string(args, "seeds")
+    if !str_eq(sd, "") { return sd }
     let q: String = json_get_string(args, "query")
     if !str_eq(q, "") { return q }
     let c: String = json_get_string(args, "content")
@@ -838,6 +942,216 @@ fn tool_inspect_config(args: String) -> String {
     return mcp_json_result(resp)
 }
 
+// ── Collapsed-surface op handlers (the 9 visible ops) ─────────────────────────
+// Each re-faces the SAME proven soul :7770 /api/neuron/* routes the 87 aliases use,
+// so Layer-1 works against live today. Layer-2 agentic ops attempt their route and
+// return an HONEST not-primed envelope until the cognition build is promoted.
+
+// Identity keystones — write-protected (self root + values hub).
+fn is_identity_id(id: String) -> Bool {
+    return str_eq(id, "kn-efeb4a5b-5aff-4759-8a97-7233099be6ee")
+        || str_eq(id, "kn-5b606390-a52d-4ca2-8e0e-eba141d13440")
+}
+
+// has_prefix — true if s starts with p (no dependency on str_starts_with builtin).
+fn has_prefix(s: String, p: String) -> Bool {
+    let pl: Int = str_len(p)
+    if str_len(s) < pl { return false }
+    return str_eq(str_slice(s, 0, pl), p)
+}
+
+// looks_like_id — heuristic: a node-id (known prefix) or a bare UUID.
+fn looks_like_id(v: String) -> Bool {
+    if has_prefix(v, "kn-") { return true }
+    if has_prefix(v, "mem-") { return true }
+    if has_prefix(v, "mn-") { return true }
+    if has_prefix(v, "gn-") { return true }
+    if has_prefix(v, "bl-") { return true }
+    if has_prefix(v, "art-") { return true }
+    if has_prefix(v, "ctx-") { return true }
+    if has_prefix(v, "nt-") { return true }
+    if str_len(v) >= 32 && str_index_of(v, "-") > 0 && str_index_of(v, " ") < 0 { return true }
+    return false
+}
+
+fn is_named_root(v: String) -> Bool {
+    return str_eq(v, "self") || str_eq(v, "neuron") || str_eq(v, "values") || str_eq(v, "values_hub")
+}
+
+fn resolve_vantage_id(v: String) -> String {
+    if str_eq(v, "self") || str_eq(v, "neuron") { return "kn-efeb4a5b-5aff-4759-8a97-7233099be6ee" }
+    if str_eq(v, "values") || str_eq(v, "values_hub") { return "kn-5b606390-a52d-4ca2-8e0e-eba141d13440" }
+    return v
+}
+
+// aperture_k / aperture_depth — read the bound from top-level k/depth, else from a
+// nested aperture:{k,depth} object, else the safe default.
+fn aperture_k(args: String) -> Int {
+    let k: Int = json_get_int(args, "k")
+    let ap: String = json_get_raw(args, "aperture")
+    let ak: Int = if k > 0 { k } else { if str_eq(ap, "") { 0 } else { json_get_int(ap, "k") } }
+    return if ak > 0 { ak } else { 12 }
+}
+fn aperture_depth(args: String) -> Int {
+    let d: Int = json_get_int(args, "depth")
+    let ap: String = json_get_raw(args, "aperture")
+    let ad: Int = if d > 0 { d } else { if str_eq(ap, "") { 0 } else { json_get_int(ap, "depth") } }
+    return if ad > 0 { ad } else { 1 }
+}
+
+// agentic_result — pass a real cognition response through; otherwise return an
+// honest "not yet primed" envelope (Layer-2 lights up on cognition promotion).
+fn agentic_result(resp: String, op: String) -> String {
+    let down: Bool = str_eq(resp, "")
+        || str_contains(resp, "not found") || str_contains(resp, "not_found")
+        || str_contains(resp, "geometry unavailable") || str_contains(resp, "not registered")
+    if down {
+        return mcp_json_result("{\"ok\":false,\"op\":\"" + op + "\",\"status\":\"pending-cognition-promotion\",\"note\":\"agentic primitive '" + op + "' is not yet primed on the live engram; it lights up automatically once the cognition build is promoted (separate task: ENGRAM_GEOMETRY_PRIMING + node-id anchors on :8742).\"}")
+    }
+    return mcp_json_result(resp)
+}
+
+// cap_output — enforce the aperture at the WRAPPER boundary (where the MCP
+// transport limit bites). The live soul's /graph does not yet honor compact/k
+// (pending the api-bounding deploy), and the self/values hubs are pathological
+// (~790KB). A k-scaled char cap guarantees the client never gets a whole-graph
+// dump; the marker is honest about the truncation.
+fn cap_output(resp: String, max_chars: Int) -> String {
+    if str_len(resp) <= max_chars { return resp }
+    return str_slice(resp, 0, max_chars) + " ...[aperture-truncated: narrow the vantage or lower k]"
+}
+
+// ── Layer 1 — geometry ops ────────────────────────────────────────────────────
+
+fn op_read(args: String) -> String {
+    let vantage: String = json_get_string(args, "vantage")
+    if str_eq(vantage, "") {
+        return mcp_text_result("error: read requires 'vantage' — a node-id, a named root (self|neuron|values), or a concept string to search")
+    }
+    let typ: String = json_get_string(args, "type")
+    let k: Int = aperture_k(args)
+    let depth: Int = aperture_depth(args)
+    // node-id / named-root / explicit graph read → BOUNDED neighborhood (aperture caps output)
+    let want_graph: Bool = str_eq(typ, "edges") || str_eq(typ, "graph") || str_eq(typ, "node")
+        || is_named_root(vantage) || looks_like_id(vantage)
+    if want_graph {
+        let id: String = resolve_vantage_id(vantage)
+        let resp: String = http_get(neuron_url() + "/graph?id=" + id + "&depth=" + int_to_str(depth) + "&compact=1&snip=600&k=" + int_to_str(k))
+        // Aperture cap at the wrapper boundary: base + per-neighbor budget.
+        let cap: Int = 2000 + k * 3000
+        return mcp_json_result(cap_output(resp, cap))
+    }
+    // concept vantage → BOUNDED recall search (k = aperture = limit)
+    let resp: String = recall_or_list(vantage, k)
+    return mcp_json_result(resp)
+}
+
+fn op_write(args: String) -> String {
+    let content: String = pick_content(args)
+    if str_eq(content, "") { return mcp_text_result("error: write requires 'content'") }
+    let typ: String = json_get_string(args, "type")
+    if str_eq(typ, "self") || str_eq(typ, "values") {
+        return mcp_text_result("error: identity is write-protected -> intentional-cultivation only (keystones kn-efeb4a5b / kn-5b606390)")
+    }
+    if str_eq(typ, "knowledge") { return create_typed_node(args, "Knowledge", "0.75") }
+    if str_eq(typ, "artifact")  { return create_node_typed(args, "Artifact", "Working") }
+    if str_eq(typ, "backlog") || str_eq(typ, "work") || str_eq(typ, "task") { return create_node_typed(args, "BacklogItem", "Working") }
+    if str_eq(typ, "process")   { return create_typed_node(args, "Process", "0.80") }
+    if str_eq(typ, "state")     { return create_typed_node(args, "InternalStateEvent", "0.60") }
+    return create_typed_node(args, "Memory", "0.60")
+}
+
+fn op_relate(args: String) -> String {
+    let from_a: String = json_get_string(args, "from")
+    let from_id: String = if str_eq(from_a, "") { json_get_string(args, "from_id") } else { from_a }
+    let to_a: String = json_get_string(args, "to")
+    let to_id: String = if str_eq(to_a, "") { json_get_string(args, "to_id") } else { to_a }
+    if str_eq(from_id, "") || str_eq(to_id, "") {
+        return mcp_text_result("error: relate requires 'from' and 'to' node-ids")
+    }
+    if is_identity_id(from_id) || is_identity_id(to_id) {
+        return mcp_text_result("error: identity keystone is write-protected")
+    }
+    let rel_a: String = json_get_string(args, "relationship")
+    let rel_b: String = if str_eq(rel_a, "") { json_get_string(args, "relation") } else { rel_a }
+    let rel: String = if str_eq(rel_b, "") { "associates" } else { rel_b }
+    let body: String = "{\"from_id\":\"" + from_id + "\",\"to_id\":\"" + to_id + "\",\"relation\":\"" + rel + "\"}"
+    let resp: String = http_post_json(neuron_url() + "/graph/link", body)
+    return mcp_json_result(resp)
+}
+
+fn op_supersede(args: String) -> String {
+    let id: String = pick_id(args)
+    if str_eq(id, "") { return mcp_text_result("error: supersede requires 'id'") }
+    if is_identity_id(id) { return mcp_text_result("error: identity keystone is write-protected") }
+    let action: String = json_get_string(args, "action")
+    if str_eq(action, "tombstone") {
+        let body: String = "{\"id\":\"" + id + "\"}"
+        let resp: String = http_post_json(neuron_url() + "/memory/delete", body)
+        return mcp_json_result(resp)
+    }
+    if str_eq(action, "promote") {
+        return tool_promote_knowledge(args)
+    }
+    let typ: String = json_get_string(args, "type")
+    let nt: String = if str_eq(typ, "knowledge") { "Knowledge" } else { "Memory" }
+    return evolve_by_supersede(args, nt)
+}
+
+// ── Layer 2 — agentic primitives (pending cognition promotion) ────────────────
+
+fn op_think(args: String) -> String {
+    let seeds: String = json_get_string(args, "seeds")
+    if str_eq(seeds, "") { return mcp_text_result("error: think requires 'seeds' (node-id anchors, comma-separated)") }
+    let f_raw: String = json_get_string(args, "faculty")
+    let f: String = if str_eq(f_raw, "") { "reason" } else { f_raw }
+    let resp: String = http_get(neuron_url() + "/think?seeds=" + seeds + "&faculty=" + f)
+    return agentic_result(resp, "think")
+}
+
+fn op_attend(args: String) -> String {
+    let node: String = json_get_string(args, "node")
+    if str_eq(node, "") { return mcp_text_result("error: attend requires 'node' (region node-id)") }
+    let observer: String = json_get_string(args, "observer")
+    let salience: String = json_get_string(args, "salience")
+    let body: String = "{\"node\":\"" + node + "\",\"observer\":\"" + json_escape(observer) + "\",\"salience\":\"" + json_escape(salience) + "\"}"
+    let resp: String = http_post_json(neuron_url() + "/attend", body)
+    return agentic_result(resp, "attend")
+}
+
+fn op_assert(args: String) -> String {
+    let claim: String = json_get_string(args, "claim")
+    if str_eq(claim, "") { return mcp_text_result("error: assert requires 'claim'") }
+    let for_whom: String = json_get_string(args, "for_whom")
+    let floor: String = json_get_string(args, "floor")
+    let body: String = "{\"claim\":\"" + json_escape(claim) + "\",\"for_whom\":\"" + json_escape(for_whom) + "\",\"floor\":\"" + json_escape(floor) + "\"}"
+    let resp: String = http_post_json(neuron_url() + "/assert", body)
+    return agentic_result(resp, "assert")
+}
+
+fn op_ground(args: String) -> String {
+    let claim: String = json_get_string(args, "claim")
+    let evidence: String = json_get_string(args, "evidence")
+    if str_eq(claim, "") || str_eq(evidence, "") {
+        return mcp_text_result("error: ground requires 'claim' and 'evidence' (node-id regions)")
+    }
+    let for_whom: String = json_get_string(args, "for_whom")
+    let body: String = "{\"claim\":\"" + claim + "\",\"evidence\":\"" + evidence + "\",\"for_whom\":\"" + json_escape(for_whom) + "\"}"
+    let resp: String = http_post_json(neuron_url() + "/ground", body)
+    return agentic_result(resp, "ground")
+}
+
+fn op_learn(args: String) -> String {
+    let seeds: String = json_get_string(args, "seeds")
+    if str_eq(seeds, "") { return mcp_text_result("error: learn requires 'seeds'") }
+    let f_raw: String = json_get_string(args, "faculty")
+    let f: String = if str_eq(f_raw, "") { "induce" } else { f_raw }
+    let keystone: String = json_get_string(args, "keystone")
+    let body: String = "{\"seeds\":\"" + seeds + "\",\"faculty\":\"" + f + "\",\"keystone\":\"" + json_escape(keystone) + "\"}"
+    let resp: String = http_post_json(neuron_url() + "/learn", body)
+    return agentic_result(resp, "learn")
+}
+
 // ── Dispatcher ────────────────────────────────────────────────────────────────
 
 fn dispatch_tool_call(tool_name: String, args: String) -> String {
@@ -865,6 +1179,17 @@ fn dispatch_tool_call(tool_name: String, args: String) -> String {
         let _act: String = fire_activation(seed)
     }
 
+    // ── Collapsed surface — the 9 VISIBLE ops (the old 87 names below remain as HIDDEN ALIASES) ──
+    if str_eq(tool_name, "read")      { return op_read(args) }
+    if str_eq(tool_name, "write")     { return op_write(args) }
+    if str_eq(tool_name, "relate")    { return op_relate(args) }
+    if str_eq(tool_name, "supersede") { return op_supersede(args) }
+    if str_eq(tool_name, "think")     { return op_think(args) }
+    if str_eq(tool_name, "attend")    { return op_attend(args) }
+    if str_eq(tool_name, "assert")    { return op_assert(args) }
+    if str_eq(tool_name, "ground")    { return op_ground(args) }
+    if str_eq(tool_name, "learn")     { return op_learn(args) }
+
     // ── Session + orchestration ─────────────────────────────────────────────
     if str_eq(tool_name, "beginSession")     { return tool_begin_session(args) }
     if str_eq(tool_name, "getInstructions")  { return tool_get_instructions(args) }

memory.el

@@ -1,9 +1,91 @@
+import "persist.el"
+
 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 = engram_node_full(
+    let id: String = wt_node(
         content,
         "Memory",
         label,
@@ -17,13 +99,26 @@ fn mem_store(content: String, label: String, tags: String) -> String {
         println("[memory] write rejected by engram (empty id): label=" + label)
         return ""
     }
-    // Read back to verify the node actually persisted — guards against silent write failures.
-    let readback: String = engram_get_node_json(id)
-    if str_eq(readback, "") || str_eq(readback, "{}") {
-        println("[memory] WRITE VERIFY FAILED: label=" + label + " id=" + id + " — node absent after write")
-        return ""
+    // wt_node has already read the node back locally and returns "" if it did
+    // not land, so the old duplicate read-back here is gone.
+    //
+    // HONESTY (neuron#117): the receipt now says WHERE the write is.
+    // The old unconditional "write verified" line asserted against the soul's
+    // own RAM — true in memory, false on disk — and printed ~115,000 times on
+    // Tim's machine while the canonical snapshot sat frozen for three days.
+    // wt_commit flushes the spool and then asks the OWNER. When it says false
+    // the node is real and recallable but not yet durable, and the log says so
+    // rather than claiming a save that did not happen. The id is still returned:
+    // the local write DID succeed, and the queued delta will be retried.
+    let durable: Bool = wt_commit(id)
+    // 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 {
+        println("[memory] write IN MEMORY ONLY (queued for owner, not yet durable): " + id + " label=" + label)
     }
-    println("[memory] write verified: " + id + " ok")
     return id
 }
 
@@ -51,12 +146,12 @@ fn mem_strengthen(node_id: String) -> Void {
 // memory.el (imported first) so awareness.el and neuron-api.el can both call it.
 fn mem_tombstone(node_id: String) -> String {
     let tags: String = "[\"Tombstone\",\"status:deleted\"]"
-    let marker: String = engram_node_full(
+    let marker: String = wt_node(
         node_id, "Tombstone", "tombstone:" + node_id,
         el_from_float(0.01), el_from_float(0.01), el_from_float(1.0),
         "Episodic", tags)
     if !str_eq(marker, "") {
-        engram_connect(marker, node_id, el_from_float(1.0), "tombstones")
+        wt_edge(marker, node_id, el_from_float(1.0), "tombstones")
     }
     return marker
 }

memory.elh

@@ -1,17 +0,0 @@
-// 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_tombstone(node_id: String) -> String
-extern fn mem_forget(node_id: String) -> Void
-extern fn mem_consolidate() -> String
-extern fn mem_save(path: String) -> Void
-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

@@ -59,8 +59,14 @@ fn api_query_param(path: String, key: String) -> String {
     if pos < 0 { return "" }
     let after: String = str_slice(qs, pos + str_len(needle), str_len(qs))
     let amp: Int = str_index_of(after, "&")
-    if amp < 0 { return after }
-    return str_slice(after, 0, amp)
+    let raw: String = if amp < 0 { after } else { str_slice(after, 0, amp) }
+    // URL-decode the extracted value BEFORE any downstream tokenizing. Clients
+    // percent-encode spaces (%20) and form-encode them as '+', so a multi-word
+    // query like "foo bar" arrives as "foo%20bar" / "foo+bar". Left undecoded,
+    // the ranked lexical search sees a single un-splittable token and matches
+    // nothing (single-word queries still hit). url_decode maps '+' -> space
+    // and %XX -> byte, restoring the word boundaries for recall + knowledge search.
+    return url_decode(raw)
 }
 
 fn api_query_int(path: String, key: String, default_val: Int) -> Int {
@@ -308,15 +314,24 @@ fn api_compact_neighbors(raw: String, k_content: Int, snip: Int) -> String {
 }
 
 // api_persisted — read-back-after-write guard against hallucinated saves.
-// After a write builtin returns an id, confirm the node is actually queryable
-// via engram_get_node_json(id) (returns "" or "null" when missing). Returns
-// true only when the node is genuinely persisted.
+//
+// WIDENED FOR neuron#117. This function is the single gate every MCP write
+// handler passes through before it reports success (10 call sites), which makes
+// it the right place to close the honesty gap rather than editing ten receipts.
+//
+// It used to read back from engram_get_node_json — the SOUL'S OWN in-process
+// graph. In HTTP-engram mode that asserts the wrong thing: the soul is not the
+// persistence owner, so a node present in its RAM and absent from the owner read
+// as "persisted" and then vanished on the next restart. The guard was doing
+// exactly what its comment promised and still certifying writes that did not
+// survive. It now flushes the write-through spool and asks the OWNER.
+//
+// In file mode (no ENGRAM_URL) the soul IS the owner and wt_commit collapses to
+// the original local read-back — unchanged behaviour, which is what keeps this
+// reversible.
 fn api_persisted(id: String) -> Bool {
     if str_eq(id, "") { return false }
-    let node: String = engram_get_node_json(id)
-    // engram_get_node_json returns "{}" (empty object) when node is not found — not "" or "null".
-    // Check all three to guard against any runtime variation.
-    return !str_eq(node, "") && !str_eq(node, "null") && !str_eq(node, "{}")
+    return wt_commit(id)
 }
 
 // api_not_persisted — standard error for a write that did not read back.
@@ -390,32 +405,53 @@ fn memory_hide_tombstoned(raw: String, path: String) -> String {
 // Spread-activates from session intent, loads self-root neighbors,
 // surfaces recent InternalStateEvent nodes, returns stats + recent nodes.
 fn handle_api_begin_session(body: String) -> String {
-    // PAYLOAD BOUND (2026-07-30 self-review): this handler was the only
-    // working-set endpoint that concatenated UNBOUNDED engram queries —
+    // PAYLOAD BOUND: this handler was the highest-fanout working-set endpoint —
     // a depth-2 spread PLUS the full neighbor dump of the self-identity hub
-    // (highest-fanout node in the graph, ~80KB alone; node JSON carries full
-    // content + embeddings). On the ~12k-node store the assembled response
-    // ran to multiple MB, then roughly doubled through two rounds of JSON
-    // re-escaping in the MCP wrapper — the client saw "socket connection
-    // closed unexpectedly" on every beginSession call. Fix: depth-2 → depth-1
-    // spread, and drop the self-hub dump entirely (identity loading has its
-    // own dedicated tool, inspectGraph; duplicating it here served nothing).
-    // self_neighbors key retained as [] for response-shape compatibility.
+    // (~90KB alone; node JSON carries full content + embeddings). On the ~12k-node
+    // store the assembled response ran to ~900KB, then roughly doubled through two
+    // rounds of JSON re-escaping in the MCP wrapper — the client saw "socket
+    // connection closed unexpectedly" on every beginSession call. Fix: depth-2 →
+    // depth-1 spread, drop the self-hub dump (identity loading has its own tool,
+    // inspectGraph), cap every list, and project each node to a light identity +
+    // a bounded, UTF-8-safe content snippet. self_neighbors kept as [] for
+    // response-shape compatibility. Response drops ~900KB → ~12KB; full content
+    // stays available on demand via recall / fetch / inspectGraph.
     let stats: String = engram_stats_json()
-    // PAYLOAD BOUND (2026-07-31): compact every list to a digest. The raw
-    // activate/scan builtins emit FULL node objects (content up to ~90KB each);
-    // unbounded concatenation reached ~900KB and closed the MCP client socket.
-    // Cap counts + project to identity + UTF-8-safe content snippets → <~150KB.
     let activated_raw: String = engram_activate_json("session start recent memory important", 1)
     let activated: String = api_compact_activated(activated_raw, 8, 240)
     let state_events_raw: String = engram_scan_nodes_by_type_json("InternalStateEvent", 5, 0)
     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_neighbors\":" + self_slice
         + ",\"recent_state_events\":" + state_events + "}"
 }
 
@@ -423,9 +459,9 @@ fn handle_api_begin_session(body: String) -> String {
 // Spread-activates from "active work" intent + recent nodes.
 fn handle_api_compile_ctx(body: String) -> String {
     let stats: String = engram_stats_json()
-    // PAYLOAD BOUND (2026-07-31): same digest treatment as begin_session. This
-    // handler's depth-2 spread returns even more full nodes, so bounding here is
-    // essential — cap to 10 activated + 20 recent, project to snippets.
+    // PAYLOAD BOUND: same digest treatment as begin_session. This handler's
+    // depth-2 spread returns even more full nodes, so bounding here is essential —
+    // cap to 10 activated + 20 recent, project to UTF-8-safe snippets.
     let activated_raw: String = engram_activate_json("active work context current task in progress", 2)
     let activated: String = api_compact_activated(activated_raw, 10, 240)
     let recent_raw: String = engram_scan_nodes_json(20, 0)
@@ -459,10 +495,17 @@ fn handle_api_remember(body: String) -> String {
         let inner: String = str_slice(base_tags, 1, str_len(base_tags) - 1)
         "[" + inner + ",\"project:" + project + "\"]"
     }
-    let id: String = engram_node_full(content, "Memory", "memory:remembered",
+    let id: String = wt_node(content, "Memory", "memory:remembered",
         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}"
 }
 
@@ -486,7 +529,7 @@ fn handle_api_node_create(body: String) -> String {
             if str_eq(importance, "low") { 0.25 } else { 0.5 }
         }
     }
-    let id: String = engram_node_full(content, node_type, label,
+    let id: String = wt_node(content, node_type, label,
         sal, sal, el_from_float(0.9),
         tier, tags)
     if !api_persisted(id) { return api_not_persisted(id) }
@@ -539,11 +582,11 @@ fn handle_api_node_update(body: String) -> String {
     }
     let body_tags: String = json_get(body, "tags")
     let tags: String = if str_eq(body_tags, "") { "[\"" + node_type + "\"]" } else { body_tags }
-    let new_id: String = engram_node_full(content, node_type, label,
+    let new_id: String = wt_node(content, node_type, label,
         el_from_float(0.5), el_from_float(0.5), el_from_float(0.8),
         tier, tags)
     if !api_persisted(new_id) { return api_not_persisted(new_id) }
-    engram_connect(new_id, id, el_from_float(0.9), "supersedes")
+    wt_edge(new_id, id, el_from_float(0.9), "supersedes")
     return "{\"id\":\"" + new_id + "\",\"supersedes\":\"" + id + "\",\"ok\":true}"
 }
 
@@ -567,7 +610,12 @@ 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))
     }
-    let results: String = engram_search_json(eff_q, limit)
+    // engram_recall_json, not engram_search_json: this route IS the retrieval
+    // 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)
 }
 
@@ -615,7 +663,7 @@ fn handle_api_capture_knowledge(body: String) -> String {
     let full: String = if str_eq(title, "") { content } else { title + ": " + content }
     let lbl: String = str_slice(title, 0, 80)
     let tags: String = "[\"Knowledge\",\"captured\"]"
-    let id: String = engram_node_full(full, "Knowledge", lbl,
+    let id: String = wt_node(full, "Knowledge", lbl,
         el_from_float(0.85), el_from_float(0.8), el_from_float(0.9),
         "Episodic", tags)
     if !api_persisted(id) { return api_not_persisted(id) }
@@ -630,12 +678,12 @@ fn handle_api_evolve_knowledge(body: String) -> String {
     if !str_eq(prior_id, "") && is_protected_node(prior_id) { return api_err_protected(prior_id) }
     let tags: String = "[\"Knowledge\",\"evolved\"]"
     // Empty label → engram_node_full derives content[:60] (LABEL FIX 2026-07-23).
-    let new_id: String = engram_node_full(content, "Knowledge", "",
+    let new_id: String = wt_node(content, "Knowledge", "",
         el_from_float(0.75), el_from_float(0.75), el_from_float(0.9),
         "Episodic", tags)
     if !api_persisted(new_id) { return api_not_persisted(new_id) }
     if !str_eq(prior_id, "") {
-        engram_connect(new_id, prior_id, el_from_float(0.9), "supersedes")
+        wt_edge(new_id, prior_id, el_from_float(0.9), "supersedes")
     }
     return "{\"id\":\"" + new_id + "\",\"supersedes\":\"" + prior_id + "\",\"ok\":true}"
 }
@@ -652,11 +700,11 @@ fn handle_api_promote_knowledge(body: String) -> String {
         "[\"Knowledge\",\"tier:canonical\",\"disposition:stable\"]"
     } else { tags_raw }
     // Empty label → engram_node_full derives content[:60] (LABEL FIX 2026-07-23).
-    let new_id: String = engram_node_full(content, "Knowledge", "",
+    let new_id: String = wt_node(content, "Knowledge", "",
         el_from_float(0.9), el_from_float(0.9), el_from_float(1.0),
         "Canonical", tags)
     if !api_persisted(new_id) { return api_not_persisted(new_id) }
-    engram_connect(new_id, prior_id, el_from_float(0.95), "supersedes")
+    wt_edge(new_id, prior_id, el_from_float(0.95), "supersedes")
     return "{\"ok\":true,\"new_id\":\"" + new_id + "\",\"supersedes\":\"" + prior_id + "\"}"
 }
 
@@ -679,7 +727,7 @@ fn handle_api_define_process(body: String) -> String {
     if str_eq(content, "") { return api_err("content is required") }
     let label: String = if str_eq(name, "") { "process:unnamed" } else { "process:" + name }
     let tags: String = "[\"Process\"]"
-    let id: String = engram_node_full(content, "Process", label,
+    let id: String = wt_node(content, "Process", label,
         el_from_float(0.8), el_from_float(0.8), el_from_float(0.9),
         "Canonical", tags)
     if !api_persisted(id) { return api_not_persisted(id) }
@@ -764,7 +812,7 @@ fn handle_api_tune_config(body: String) -> String {
     if str_eq(key, "") { return api_err("key is required") }
     let content: String = "config:" + key + "=" + value
     let tags: String = "[\"ConfigEntry\",\"config\"]"
-    let id: String = engram_node_full(content, "ConfigEntry", key,
+    let id: String = wt_node(content, "ConfigEntry", key,
         el_from_float(0.85), el_from_float(0.85), el_from_float(0.9),
         "Canonical", tags)
     if !api_persisted(id) { return api_not_persisted(id) }
@@ -823,7 +871,7 @@ fn handle_api_link_entities(body: String) -> String {
     if is_protected_node(to_id) { return api_err_protected(to_id) }
     let relation: String = json_get(body, "relation")
     let eff_relation: String = if str_eq(relation, "") { "associates" } else { relation }
-    engram_connect(from_id, to_id, el_from_float(0.5), eff_relation)
+    wt_edge(from_id, to_id, el_from_float(0.5), eff_relation)
     return "{\"ok\":true,\"from_id\":\"" + from_id + "\",\"to_id\":\"" + to_id + "\",\"relation\":\"" + eff_relation + "\"}"
 }
 
@@ -856,11 +904,11 @@ fn handle_api_evolve_memory(body: String) -> String {
         }
     }
     let tags: String = "[\"Memory\",\"evolved\"]"
-    let new_id: String = engram_node_full(content, "Memory", "memory:evolved",
+    let new_id: String = wt_node(content, "Memory", "memory:evolved",
         sal, sal, el_from_float(0.9),
         "Episodic", tags)
     if !str_eq(prior_id, "") && !str_eq(new_id, "") {
-        engram_connect(new_id, prior_id, el_from_float(0.9), "supersedes")
+        wt_edge(new_id, prior_id, el_from_float(0.9), "supersedes")
     }
     return "{\"id\":\"" + new_id + "\",\"supersedes\":\"" + prior_id + "\",\"ok\":true}"
 }
@@ -918,11 +966,11 @@ fn handle_api_cultivate(body: String) -> String {
         let content: String = json_get(body, "content")
         if str_eq(content, "") { return api_err("content is required") }
         let tags: String = "[\"Knowledge\",\"evolved\",\"cultivated\"]"
-        let new_id: String = engram_node_full(content, "Knowledge", "knowledge:cultivated",
+        let new_id: String = wt_node(content, "Knowledge", "knowledge:cultivated",
             el_from_float(0.75), el_from_float(0.75), el_from_float(0.9),
             "Episodic", tags)
         if !str_eq(prior_id, "") && !str_eq(new_id, "") {
-            engram_connect(new_id, prior_id, el_from_float(0.9), "supersedes")
+            wt_edge(new_id, prior_id, el_from_float(0.9), "supersedes")
         }
         return "{\"id\":\"" + new_id + "\",\"supersedes\":\"" + prior_id + "\",\"ok\":true,\"cultivated\":true}"
     }
@@ -938,11 +986,11 @@ fn handle_api_cultivate(body: String) -> String {
             }
         }
         let tags: String = "[\"Memory\",\"evolved\",\"cultivated\"]"
-        let new_id: String = engram_node_full(content, "Memory", "memory:cultivated",
+        let new_id: String = wt_node(content, "Memory", "memory:cultivated",
             sal, sal, el_from_float(0.9),
             "Episodic", tags)
         if !str_eq(prior_id, "") && !str_eq(new_id, "") {
-            engram_connect(new_id, prior_id, el_from_float(0.9), "supersedes")
+            wt_edge(new_id, prior_id, el_from_float(0.9), "supersedes")
         }
         return "{\"id\":\"" + new_id + "\",\"supersedes\":\"" + prior_id + "\",\"ok\":true,\"cultivated\":true}"
     }
@@ -962,7 +1010,7 @@ fn handle_api_cultivate(body: String) -> String {
         if str_eq(to_id, "") { return api_err("to_id is required") }
         let relation: String = json_get(body, "relation")
         let eff_relation: String = if str_eq(relation, "") { "associates" } else { relation }
-        engram_connect(from_id, to_id, el_from_float(0.5), eff_relation)
+        wt_edge(from_id, to_id, el_from_float(0.5), eff_relation)
         return "{\"ok\":true,\"from_id\":\"" + from_id + "\",\"to_id\":\"" + to_id + "\",\"relation\":\"" + eff_relation + "\",\"cultivated\":true}"
     }
 
@@ -997,7 +1045,7 @@ fn handle_api_consolidate(body: String) -> String {
     if !str_eq(summary, "") {
         let safe_summary: String = str_replace(summary, "\"", "'")
         let tags: String = "[\"SessionSummary\",\"consolidate\"]"
-        let summary_id: String = engram_node_full(
+        let summary_id: String = wt_node(
             "[session-summary] " + safe_summary,
             "SessionSummary", "session:summary",
             el_from_float(0.7), el_from_float(0.7), el_from_float(0.9),
@@ -1009,3 +1057,462 @@ fn handle_api_consolidate(body: String) -> String {
     }
     return "{\"ok\":true,\"snapshot\":\"" + snap + "\"}"
 }
+
+// ── Stage 1: structural audit ─────────────────────────────────────────────────
+//
+// WHAT THIS IMPLEMENTS
+//   The CGI provisional, 05-detailed-description.md, "Stage 1: Structural audit
+//   430". Verbatim, the audit module evaluates: the density and typed
+//   distribution of causal edges; the consistency between value nodes and
+//   execution-record neighborhoods; the richness and connectivity of the
+//   self-model; and the authenticity of open-question nodes in the wonder
+//   manifest. It "produces a coherence assessment 432 — NOT A BINARY SCORE but
+//   an annotated characterization of the graph's structural properties".
+//
+//   That last clause is the whole shape of this handler. Every finding carries
+//   its own numbers AND a plain-language note saying what the numbers mean and
+//   how they were obtained. There is no pass/fail, no percentage-of-health, no
+//   composite score, and `"score":null` is emitted explicitly so a downstream
+//   reader cannot mistake its absence for an omission.
+//
+// WHY IT EXISTS NOW, AND WHY THE FIRST FINDING IS THE ONE IT IS
+//   `runStructuralAudit` has been an advertised MCP tool with nothing behind it:
+//   the dispatcher GET'd /session/begin and returned that blob (mcp-wrapper/src/
+//   main.el). Meanwhile the failure the audit would have caught ran silently for
+//   about three weeks — the soul reported 103,089 nodes while the engram, which
+//   OWNS persistence, held ~79,900; a crash discarded the difference. Every boot
+//   reported green throughout, because nothing in the system ever compared the
+//   two sides. So finding 1 is owner-versus-runtime divergence: it is the check
+//   whose absence cost real memory, and it is cheap and exact.
+//
+// WHAT IS DELIBERATELY NOT HERE (stage 1b, see the `deferred` array in the
+// response): value/execution-record consistency and wonder-manifest
+// authenticity. Both need node types that barely exist in this graph today —
+// the response MEASURES those populations and reports the counts as the reason,
+// rather than asserting a deferral without evidence.
+//
+// MEASUREMENT HONESTY: EXACT WHERE CHEAP, SAMPLED WHERE NOT, ALWAYS LABELLED
+//   Counts, edge typing and self-model connectivity are exact. Orphan rate and
+//   dangling-edge rate are SAMPLED, because the engram runtime has no node-id
+//   index — `engram_find_node_index` is a linear scan over every node, so an
+//   exhaustive dangling check is O(nodes x edges) (~2.2e9 string compares at
+//   today's scale, tens of seconds inside one request). The samples are UNIFORM
+//   across the whole population, not head-of-list, and every sampled figure is
+//   emitted with its own `sampled` / `population` fields plus an extrapolation
+//   labelled as such. Raise `?edge_sample=` / `?node_sample=` to the population
+//   size to run either check exhaustively and pay the time. The real fix is an
+//   id index in the runtime; that is the engram repo's, not this handler's.
+
+// audit_pct1 — one-decimal percentage as a bare JSON number, sign-safe.
+// Integer math only: EL has no fixed-precision formatter, and float_to_str
+// would put an unbounded mantissa in the response.
+fn audit_pct1(num: Int, den: Int) -> String {
+    if den <= 0 { return "null" }
+    let neg: Bool = num < 0
+    let a: Int = if neg { 0 - num } else { num }
+    let tenths: Int = (a * 1000) / den
+    let whole: Int = tenths / 10
+    let frac: Int = tenths - (whole * 10)
+    let sign: String = if neg { "-" } else { "" }
+    return sign + int_to_str(whole) + "." + int_to_str(frac)
+}
+
+// audit_finding — the one envelope every finding uses: name, the measurements,
+// and the annotation. Keeping it in one place is what stops the characterization
+// from degenerating into a bag of numbers with no reading attached.
+fn audit_finding(name: String, measured: String, note: String) -> String {
+    return "{\"finding\":\"" + name + "\""
+        + ",\"measured\":{" + measured + "}"
+        + ",\"note\":\"" + api_json_escape(note) + "\"}"
+}
+
+// audit_str_at — read the quoted string value starting at byte `start`.
+// Slices a bounded window rather than the tail of the (multi-MB) edges array, so
+// this is O(window) per call instead of O(remaining input).
+fn audit_str_at(s: String, start: Int, maxlen: Int) -> String {
+    let n: Int = str_len(s)
+    if start < 0 || start >= n { return "" }
+    let end_guess: Int = start + maxlen
+    let stop: Int = if end_guess > n { n } else { end_guess }
+    let win: String = str_slice(s, start, stop)
+    let q: Int = str_index_of(win, "\"")
+    if q < 0 { return "" }
+    return str_slice(win, 0, q)
+}
+
+// audit_rel_count — exact count of edges carrying `rel`, by scanning the emitted
+// edge array for the literal `"relation":"<rel>"`. engram_emit_edge_json writes
+// metadata ESCAPED as a string, so no nested object can contain that literal and
+// the count cannot be inflated by edge payloads.
+fn audit_rel_count(edges: String, rel: String) -> Int {
+    return str_count(edges, "\"relation\":\"" + rel + "\"")
+}
+
+// audit_owner_stats — ask the persistence OWNER for its own counts.
+// Returns "" when there is no HTTP owner configured or the owner is unreachable;
+// both are reported as findings, never as a failure of the audit.
+fn audit_owner_stats(url: String) -> String {
+    if str_eq(url, "") { return "" }
+    return http_get(url + "/api/stats")
+}
+
+// audit_divergence — FINDING 1. Runtime (this soul's in-process graph) versus
+// the persistence owner's own count. Trend is measured against the previous
+// audit recorded in soul state, so a second call answers "is the gap growing?"
+// rather than just restating it.
+fn audit_divergence() -> String {
+    let rt_nodes: Int = engram_node_count()
+    let rt_edges: Int = engram_edge_count()
+    let url: String = wt_engram_url()
+
+    if str_eq(url, "") {
+        return audit_finding("owner_runtime_divergence",
+            "\"runtime_nodes\":" + int_to_str(rt_nodes)
+            + ",\"runtime_edges\":" + int_to_str(rt_edges)
+            + ",\"owner\":\"none\",\"owner_reachable\":false",
+            "No HTTP persistence owner is configured, so this soul IS the owner "
+            + "(file mode) and divergence is not defined. This check only has "
+            + "meaning when ENGRAM_URL points at a separate engram that owns the "
+            + "canonical store.")
+    }
+
+    let stats: String = audit_owner_stats(url)
+    // REACHABILITY IS PROVED BY THE PAYLOAD, NOT BY A NON-EMPTY REPLY.
+    // http_get does not return "" on a connection failure — it returns a JSON
+    // error object ({"error":"Failed to connect to ... Couldn't connect to
+    // server"}). Testing only for "" made a DEAD owner read as reachable with
+    // node_count 0, i.e. the audit would have reported a 100% divergence and
+    // named it as data loss. That false positive is worse than no check at all:
+    // it is precisely the kind of confident wrong answer this route exists to
+    // stop. Require the field the contract promises.
+    let owner_nc_raw: String = json_get_raw(stats, "node_count")
+    if str_eq(stats, "") || str_eq(owner_nc_raw, "") {
+        return audit_finding("owner_runtime_divergence",
+            "\"runtime_nodes\":" + int_to_str(rt_nodes)
+            + ",\"runtime_edges\":" + int_to_str(rt_edges)
+            + ",\"owner\":\"" + api_json_escape(url) + "\",\"owner_reachable\":false"
+            + ",\"owner_reply\":\"" + api_json_escape(api_utf8_trunc(stats, 200)) + "\"",
+            "The persistence owner at " + url + " did not return a node_count "
+            + "from GET /api/stats. Divergence is UNKNOWN, NOT ZERO — an owner "
+            + "that cannot be read is exactly the condition under which the "
+            + "runtime's own count means least, and reporting 0 for the owner "
+            + "would manufacture a total-loss reading out of a network error. "
+            + "Reported as a finding rather than raised as an error so the rest "
+            + "of the audit still returns; the owner's raw reply is in "
+            + "owner_reply.")
+    }
+
+    let ow_nodes: Int = json_get_int(stats, "node_count")
+    let ow_edges: Int = json_get_int(stats, "edge_count")
+    let d_nodes: Int = rt_nodes - ow_nodes
+    let d_edges: Int = rt_edges - ow_edges
+
+    // Trend against the previous audit in this soul's state.
+    let prev_raw: String = state_get("audit_prev_node_delta")
+    let prev: Int = str_to_int(prev_raw)
+    let abs_now: Int = if d_nodes < 0 { 0 - d_nodes } else { d_nodes }
+    let abs_prev: Int = if prev < 0 { 0 - prev } else { prev }
+    let trend: String = if str_eq(prev_raw, "") {
+        "no_prior_audit"
+    } else {
+        if abs_now > abs_prev { "growing" } else {
+            if abs_now < abs_prev { "shrinking" } else { "flat" }
+        }
+    }
+    state_set("audit_prev_node_delta", int_to_str(d_nodes))
+    state_set("audit_prev_ts", int_to_str(time_now()))
+
+    let note_head: String = if d_nodes == 0 {
+        "Runtime and owner agree on node count."
+    } else {
+        "Runtime holds " + int_to_str(d_nodes) + " nodes (" + audit_pct1(d_nodes, rt_nodes)
+        + "% of its own graph) that the persistence owner does not report. Nodes "
+        + "that exist only in runtime memory do not survive a restart."
+    }
+    return audit_finding("owner_runtime_divergence",
+        "\"runtime_nodes\":" + int_to_str(rt_nodes)
+        + ",\"runtime_edges\":" + int_to_str(rt_edges)
+        + ",\"owner\":\"" + api_json_escape(url) + "\",\"owner_reachable\":true"
+        + ",\"owner_nodes\":" + int_to_str(ow_nodes)
+        + ",\"owner_edges\":" + int_to_str(ow_edges)
+        + ",\"node_delta\":" + int_to_str(d_nodes)
+        + ",\"edge_delta\":" + int_to_str(d_edges)
+        + ",\"node_delta_pct_of_runtime\":" + audit_pct1(d_nodes, rt_nodes)
+        + ",\"trend_vs_previous_audit\":\"" + trend + "\""
+        + ",\"previous_node_delta\":" + (if str_eq(prev_raw, "") { "null" } else { int_to_str(prev) }),
+        note_head + " Trend against the previous audit recorded in this soul's "
+        + "state: " + trend + ". This is the comparison whose absence let a "
+        + "~24,000-node loss run for weeks with every boot reporting green.")
+}
+
+// audit_edge_typing — FINDING 2. Density plus the typed distribution the patent
+// asks for, against the claim-10 relation vocabulary. Exact: str_count over the
+// emitted edge array, one linear pass per relation.
+fn audit_edge_typing(edges: String, total_edges: Int, node_total: Int) -> String {
+    let c_sup: Int = audit_rel_count(edges, "Supersedes")
+    let c_cau: Int = audit_rel_count(edges, "Causes")
+    let c_con: Int = audit_rel_count(edges, "Contains")
+    let c_ref: Int = audit_rel_count(edges, "References")
+    let c_ctr: Int = audit_rel_count(edges, "Contradicts")
+    let c_exe: Int = audit_rel_count(edges, "Exemplifies")
+    let c_act: Int = audit_rel_count(edges, "Activates")
+    let c_tmp: Int = audit_rel_count(edges, "TemporallyPrecedes")
+    let typed: Int = c_sup + c_cau + c_con + c_ref + c_ctr + c_exe + c_act + c_tmp
+
+    // Lowercase near-misses: the same eight concepts written by the ad-hoc write
+    // paths (linkEntities defaults to "associates", linkCausal to "causes").
+    // Counted separately because "the vocabulary is unused" and "the vocabulary
+    // is used in the wrong case" are different defects with different fixes.
+    let l_sup: Int = audit_rel_count(edges, "supersedes")
+    let l_cau: Int = audit_rel_count(edges, "causes")
+    let l_con: Int = audit_rel_count(edges, "contains")
+    let l_ref: Int = audit_rel_count(edges, "references")
+    let l_ctr: Int = audit_rel_count(edges, "contradicts")
+    let l_exe: Int = audit_rel_count(edges, "exemplifies")
+    let l_act: Int = audit_rel_count(edges, "activates")
+    let l_tmp: Int = audit_rel_count(edges, "temporallyPrecedes")
+    let near: Int = l_sup + l_cau + l_con + l_ref + l_ctr + l_exe + l_act + l_tmp
+
+    let untyped: Int = total_edges - typed
+    return audit_finding("typed_edge_distribution",
+        "\"total_edges\":" + int_to_str(total_edges)
+        + ",\"total_nodes\":" + int_to_str(node_total)
+        // Density per 100 nodes, not per node: EL has no fixed-precision float
+        // formatter, and "0.3 edges per node" rounded to an integer is a lie.
+        + ",\"edges_per_100_nodes\":" + audit_pct1(total_edges, node_total)
+        + ",\"claim10_typed\":" + int_to_str(typed)
+        + ",\"claim10_typed_pct\":" + audit_pct1(typed, total_edges)
+        + ",\"outside_claim10_vocabulary\":" + int_to_str(untyped)
+        + ",\"lowercase_near_miss\":" + int_to_str(near)
+        + ",\"by_relation\":{"
+        + "\"Supersedes\":" + int_to_str(c_sup)
+        + ",\"Causes\":" + int_to_str(c_cau)
+        + ",\"Contains\":" + int_to_str(c_con)
+        + ",\"References\":" + int_to_str(c_ref)
+        + ",\"Contradicts\":" + int_to_str(c_ctr)
+        + ",\"Exemplifies\":" + int_to_str(c_exe)
+        + ",\"Activates\":" + int_to_str(c_act)
+        + ",\"TemporallyPrecedes\":" + int_to_str(c_tmp) + "}",
+        "Only " + int_to_str(typed) + " of " + int_to_str(total_edges)
+        + " edges use the claim-10 causal vocabulary; the remainder are ad-hoc "
+        + "relation strings, which is why the graph's causal claims cannot yet "
+        + "be checked for internal consistency — an untyped edge asserts "
+        + "association, not causation. " + int_to_str(near) + " edges use a "
+        + "lowercase spelling of a claim-10 relation: those are near-misses the "
+        + "write paths could be corrected to emit, not genuinely foreign types.")
+}
+
+// audit_orphans_dangling — FINDING 3. Both figures are SAMPLED; see the header
+// for why exhaustive is O(nodes x edges) on this runtime.
+//
+// An "orphan" here is a node with zero RESOLVABLE edges: engram_neighbors_json
+// drops any edge whose other endpoint does not resolve to a node, so a node
+// whose only edges are dangling reads as an orphan. That is the right reading —
+// such a node is unreachable by traversal — but it is stated rather than hidden.
+fn audit_orphans_dangling(edges: String, total_edges: Int, node_total: Int,
+                          edge_cap: Int, node_cap: Int) -> String {
+    // ── orphan sample: uniform stride over the node store ──
+    let n_take: Int = if node_total < node_cap { node_total } else { node_cap }
+    let n_stride: Int = if n_take > 0 { node_total / n_take } else { 1 }
+    let n_stride = if n_stride < 1 { 1 } else { n_stride }
+    let orphans: Int = 0
+    let n_checked: Int = 0
+    let j: Int = 0
+    while j < n_take {
+        let one: String = engram_scan_nodes_json(1, j * n_stride)
+        let nid: String = json_get(json_array_get(one, 0), "id")
+        if !str_eq(nid, "") {
+            let nbrs: String = engram_neighbors_json(nid, 1, "both")
+            let deg: Int = json_array_len(nbrs)
+            let orphans = if deg == 0 { orphans + 1 } else { orphans }
+            let n_checked = n_checked + 1
+        }
+        let j = j + 1
+    }
+
+    // ── dangling sample: uniform stride over the edge array ──
+    // str_index_of_all gives every edge's field offsets in ONE linear pass, so
+    // any index can be read in O(1). json_array_get would have been O(i) per
+    // element and O(n^2) over the array.
+    let from_pos: [Int] = str_index_of_all(edges, "\"from_id\":\"")
+    let to_pos: [Int] = str_index_of_all(edges, "\"to_id\":\"")
+    let nf: Int = len(from_pos)
+    let nt: Int = len(to_pos)
+    let ne: Int = if nf < nt { nf } else { nt }
+    let e_take: Int = if ne < edge_cap { ne } else { edge_cap }
+    let e_stride: Int = if e_take > 0 { ne / e_take } else { 1 }
+    let e_stride = if e_stride < 1 { 1 } else { e_stride }
+    let dangling: Int = 0
+    let e_checked: Int = 0
+    let i: Int = 0
+    while i < ne && e_checked < e_take {
+        let fid: String = audit_str_at(edges, get(from_pos, i) + 11, 96)
+        let tid: String = audit_str_at(edges, get(to_pos, i) + 9, 96)
+        let f_gone: Bool = str_eq(engram_get_node_json(fid), "{}")
+        let t_gone: Bool = if f_gone { true } else { str_eq(engram_get_node_json(tid), "{}") }
+        let dangling = if f_gone || t_gone { dangling + 1 } else { dangling }
+        let e_checked = e_checked + 1
+        let i = i + e_stride
+    }
+
+    let orphan_est: Int = if n_checked > 0 { (orphans * node_total) / n_checked } else { 0 }
+    let dangle_est: Int = if e_checked > 0 { (dangling * total_edges) / e_checked } else { 0 }
+    let exhaustive_n: String = if n_checked >= node_total { "true" } else { "false" }
+    let exhaustive_e: String = if e_checked >= ne { "true" } else { "false" }
+
+    return audit_finding("orphans_and_dangling_edges",
+        "\"nodes_population\":" + int_to_str(node_total)
+        + ",\"nodes_sampled\":" + int_to_str(n_checked)
+        + ",\"nodes_sample_exhaustive\":" + exhaustive_n
+        + ",\"orphans_in_sample\":" + int_to_str(orphans)
+        + ",\"orphan_rate_pct\":" + audit_pct1(orphans, n_checked)
+        + ",\"orphans_extrapolated\":" + int_to_str(orphan_est)
+        + ",\"edges_population\":" + int_to_str(total_edges)
+        + ",\"edges_sampled\":" + int_to_str(e_checked)
+        + ",\"edges_sample_exhaustive\":" + exhaustive_e
+        + ",\"dangling_in_sample\":" + int_to_str(dangling)
+        + ",\"dangling_rate_pct\":" + audit_pct1(dangling, e_checked)
+        + ",\"dangling_extrapolated\":" + int_to_str(dangle_est),
+        "Orphan = zero RESOLVABLE edges, so a node whose only edges dangle counts "
+        + "as an orphan; either way it is unreachable by traversal. Dangling = an "
+        + "edge with an endpoint id that resolves to no node. Both are uniform "
+        + "stride samples over the whole population, not the head of the list; "
+        + "the extrapolations are estimates and are labelled as such. Pass "
+        + "?node_sample= / ?edge_sample= at or above the population size to run "
+        + "either check exhaustively. A high orphan rate is a characterization, "
+        + "not a verdict: an accumulating store legitimately holds unlinked "
+        + "material. It becomes a defect when the write paths were SUPPOSED to "
+        + "link and did not.")
+}
+
+// audit_pillar — one self-model pillar: present, how much content, how connected.
+fn audit_pillar(key: String, id: String) -> String {
+    let node: String = engram_get_node_json(id)
+    let present: Bool = !str_eq(node, "{}") && !str_eq(node, "")
+    if !present {
+        return "\"" + key + "\":{\"id\":\"" + id + "\",\"present\":false"
+            + ",\"content_length\":0,\"degree\":0}"
+    }
+    let content: String = json_get(node, "content")
+    let deg: Int = json_array_len(engram_neighbors_json(id, 1, "both"))
+    return "\"" + key + "\":{\"id\":\"" + id + "\",\"present\":true"
+        + ",\"label\":\"" + api_json_escape(json_get(node, "label")) + "\""
+        + ",\"tier\":\"" + api_json_escape(json_get(node, "tier")) + "\""
+        + ",\"content_length\":" + int_to_str(str_len(content))
+        + ",\"degree\":" + int_to_str(deg) + "}"
+}
+
+// audit_self_model — FINDING 4. "the richness and connectivity of the
+// self-model ... is it connected to behavioral evidence?"
+//
+// This finding RETIRES the Claude-side vitals identity block. That check lived
+// outside the system it was checking — a shell script grepping a snapshot — so
+// it could only ever report on a file, and it went on reporting green while the
+// memory-philosophy pillar was absent from the live graph for about three weeks.
+// Asking the running soul about its own three pillars is the designed mechanism;
+// a shell probe was the fourth patch on the same hole.
+fn audit_self_model() -> String {
+    let dna: String = audit_pillar("intellectual_dna", "kn-5adecd7e-d6db-4576-87fe-6ef8a935cea6")
+    let val: String = audit_pillar("values_hub", "kn-5b606390-a52d-4ca2-8e0e-eba141d13440")
+    let phi: String = audit_pillar("memory_philosophy", "kn-dcfe04b3-3702-4cac-b6f0-ecb4db837eee")
+    let root: String = audit_pillar("self_root", "kn-efeb4a5b-5aff-4759-8a97-7233099be6ee")
+    return audit_finding("self_model_connectivity",
+        "\"pillars\":{" + dna + "," + val + "," + phi + "," + root + "}",
+        "The three identity pillars plus the self root. `degree` counts nodes "
+        + "reachable in one hop in either direction — the self-model's connection "
+        + "to the rest of the graph. present:false on any pillar is the condition "
+        + "that ran undetected for weeks; content_length distinguishes a pillar "
+        + "that is present from one that is present but hollowed out. The patent "
+        + "also asks whether the self-model makes ACCURATE PREDICTIONS about the "
+        + "system's own behavior; that half needs Prediction nodes and is deferred "
+        + "with the rest of stage 1b below.")
+}
+
+// audit_deferred — what stage 1 does NOT yet evaluate, with the measured reason.
+// Emitted as data, not as a comment, so a reader of the assessment sees the gap
+// and its evidence rather than inferring completeness from silence.
+fn audit_deferred() -> String {
+    let preds: Int = json_array_len(api_or_empty(engram_scan_nodes_by_type_json("Prediction", 50, 0)))
+    let wonders: Int = json_array_len(api_or_empty(engram_scan_nodes_by_type_json("WonderQuestion", 50, 0)))
+    return "[{\"deferred\":\"value_execution_record_consistency\""
+        + ",\"stage\":\"1b\""
+        + ",\"measured\":{\"prediction_nodes_found\":" + int_to_str(preds) + "}"
+        + ",\"reason\":\"" + api_json_escape(
+            "The patent asks whether the execution history SUPPORTS the stated "
+            + "values or shows systematic conflict. That requires execution "
+            + "records tied to value nodes and predictions to score them against. "
+            + "Prediction nodes found (capped at 50): " + int_to_str(preds)
+            + ". Asserting value/execution coherence on that population would be "
+            + "a fabricated result, which is worse than a stated gap.") + "\"}"
+        + ",{\"deferred\":\"wonder_manifest_authenticity\""
+        + ",\"stage\":\"1b\""
+        + ",\"measured\":{\"wonder_question_nodes_found\":" + int_to_str(wonders) + "}"
+        + ",\"reason\":\"" + api_json_escape(
+            "The patent asks whether pull weights CORRELATE WITH GENUINE "
+            + "PREDICTION UNCERTAINTY or are uniform/externally assigned — a "
+            + "correlation between two populations. WonderQuestion nodes readable "
+            + "by type (capped at 50): " + int_to_str(wonders) + ", against "
+            + int_to_str(preds) + " Prediction nodes. There is a known write/read "
+            + "node-type mismatch on the wonder path; until that is fixed and both "
+            + "populations exist, any correlation reported here would be noise.") + "\"}]"
+}
+
+// handle_api_structural_audit — Stage 1. Returns the coherence assessment 432:
+// an annotated characterization, explicitly NOT a score.
+//
+// COST NOTE: the edge findings need the relation labels, and the runtime exposes
+// no edge-enumeration builtin. The only way to see them is the same one
+// GET /api/graph/edges already uses — engram_save to a SCRATCH path (never the
+// owner's canonical file; see routes.el, neuron#117) and read the array back.
+// On a large graph that is a multi-hundred-MB write, so this is a manual audit
+// route, not something to put on a timer. Pass ?edges=0 to skip both edge
+// findings and get the divergence + self-model readings cheaply.
+fn handle_api_structural_audit(method: String, path: String, body: String) -> String {
+    let node_total: Int = engram_node_count()
+    let edge_total: Int = engram_edge_count()
+    let want_edges: Bool = !str_eq(api_query_param(path, "edges"), "0")
+    let edge_cap: Int = api_query_int(path, "edge_sample", 3000)
+    let node_cap: Int = api_query_int(path, "node_sample", 300)
+
+    let divergence: String = audit_divergence()
+    let self_model: String = audit_self_model()
+
+    let edge_part: String = if want_edges {
+        // Scratch export only. state_get("soul_snapshot_path") is deliberately
+        // NOT used: in HTTP-engram mode the soul is not the persistence owner and
+        // must never write the canonical file, not even on a read path.
+        let scratch_dir: String = env("TMPDIR")
+        let scratch_base: String = if str_eq(scratch_dir, "") { "/tmp" } else { scratch_dir }
+        let snap_path: String = scratch_base + "/soul-audit-export-" + state_get("soul_cgi_id") + ".json"
+        // engram_save returns Int (1 ok / 0 fail); str_eq on it SIGSEGVs (#150).
+        let saved: Int = engram_save(snap_path)
+        if saved == 0 {
+            "," + audit_finding("typed_edge_distribution", "\"available\":false",
+                "Could not export the graph to " + snap_path + " for edge analysis, "
+                + "so edge typing and the dangling-edge sample were not run. "
+                + "Reported as a gap, not as zero findings.")
+        } else {
+            // wt_read, not fs_read: fs_read leaves a thread-local length hint that
+            // the NEXT HTTP response would use as its Content-Length, appending
+            // adjacent heap bytes to the reply (see persist.el wt_read).
+            let snap: String = wt_read(snap_path)
+            let edges_raw: String = json_get_raw(snap, "edges")
+            let edges: String = if str_eq(edges_raw, "") { "[]" } else { edges_raw }
+            "," + audit_edge_typing(edges, edge_total, node_total)
+            + "," + audit_orphans_dangling(edges, edge_total, node_total, edge_cap, node_cap)
+        }
+    } else {
+        ""
+    }
+
+    return "{\"audit\":\"structural\",\"stage\":1"
+        + ",\"spec\":\"CGI provisional 05-detailed-description.md, Stage 1: Structural audit 430\""
+        + ",\"assessment\":\"coherence_assessment_432\""
+        + ",\"assessment_kind\":\"annotated_characterization\""
+        + ",\"score\":null"
+        + ",\"score_note\":\"By design. The specification calls for an annotated characterization of the graph's structural properties, not a binary score. Read the findings.\""
+        + ",\"cgi_id\":\"" + api_json_escape(state_get("soul_cgi_id")) + "\""
+        + ",\"ts_ms\":" + int_to_str(time_now())
+        + ",\"findings\":[" + divergence + "," + self_model + edge_part + "]"
+        + ",\"deferred\":" + audit_deferred() + "}"
+}

neuron-api.elh

@@ -1,53 +0,0 @@
-// 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_num_or_zero(obj: String, key: String) -> String
-extern fn api_utf8_trunc(s: String, n: Int) -> String
-extern fn api_compact_node(node: String, snip: Int) -> String
-extern fn api_compact_node_array(raw: String, max_items: Int, snip: Int) -> String
-extern fn api_compact_activated(raw: String, max_items: Int, snip: Int) -> String
-extern fn api_float_or(obj: String, key: String, dflt: Float) -> Float
-extern fn api_neigh_better(a: String, b: String) -> Bool
-extern fn api_neigh_rank(raw: String, n: Int, i: Int) -> Int
-extern fn api_neigh_full(node: String, edge: String, el: String, snip: Int) -> String
-extern fn api_neigh_pointer(node: String, edge: String, el: String) -> String
-extern fn api_compact_neighbors(raw: String, k_content: Int, snip: Int) -> String
-extern fn api_persisted(id: String) -> Bool
-extern fn api_not_persisted(id: String) -> String
-extern fn tombstone_node(id: String) -> String
-extern fn tombstoned_id_set() -> String
-extern fn memory_hide_tombstoned(raw: String, path: String) -> String
-extern fn handle_api_begin_session(body: String) -> String
-extern fn handle_api_compile_ctx(body: String) -> String
-extern fn handle_api_remember(body: String) -> String
-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

neuron-dev-setup/README.md

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

neuron-dev-setup/config.env.example

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

neuron-dev-setup/install.sh

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

neuron-dev-setup/uninstall.sh

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

persist.el

@@ -0,0 +1,426 @@
+// persist.el — the soul→engram WRITE-THROUGH boundary (neuron#117).
+//
+// WHY THIS FILE EXISTS
+//   soul.el:571-573 states the ownership rule: "when ENGRAM_URL is set the HTTP
+//   Engram owns persistence — the soul must NEVER write to the local snapshot
+//   (not the persistence owner)." The soul obeys the NEGATIVE half. The POSITIVE
+//   half — how a write made inside the soul actually REACHES the owner — was
+//   never built. Sync is pull-only (awareness.el `/api/sync` -> engram_load_merge),
+//   so every node the soul creates lives in its process RAM and is shed on
+//   restart. Measured live 2026-08-07: soul node_count=102184, engram
+//   node_count=79197 — ~23k nodes existing nowhere but RAM.
+//
+// SCOPE NOTE ON THE PATENT (corrects an earlier internal reading)
+//   Engram provisional claims 15-18 describe a delta-sync protocol "with peer
+//   Engram instances"; claim 17's pull-then-push sequence is PEER-ENGRAM to
+//   PEER-ENGRAM. The soul is NOT a peer Engram — it is a CALLER of the database
+//   system API (cf. claim 27, "invoked explicitly by a caller of the database
+//   system API"). So claim 17 does not specify a soul↔engram contract and is not
+//   cited as authority here. This design is derived from the ownership rule
+//   alone: the owner owns the writes, therefore the soul must HAND writes to the
+//   owner and must never write the owner's file itself.
+//
+// THE MECHANISM, AND WHY NOT `POST /api/nodes`
+//   The obvious route is the one the persona/boot-counter write-backs already
+//   use, POST /api/nodes. It is the wrong instrument here, verified against the
+//   live engram binary in a sandbox:
+//     - it mints a NEW server-side id (engram_node), so the soul's id and the
+//       owner's id diverge — the next /api/sync pull re-imports the node as a
+//       DUPLICATE, and any edge referencing the soul's id never resolves;
+//     - it accepts only {content, node_type, salience} and drops label, tier,
+//       tags, importance, confidence, metadata. A probe posted with tier
+//       "Canonical" came back tier "Working", importance 0.5.
+//   POST /api/load-merge (Will's own route, el `dc39a61`) is the right one:
+//     - engram_load_merge PRESERVES the id and every field;
+//     - it dedups nodes by id and edges by (from_id,to_id,relation), so a
+//       re-submitted delta is a NO-OP — retry safety is free, and it is the same
+//       local-wins semantics the graph already uses;
+//     - it calls persist_canonical() — THE OWNER writes its own canonical file.
+//       The soul never touches it. The ownership rule is honoured in its
+//       strongest form rather than worked around;
+//     - it returns real counts {ok, nodes_added, edges_added, node_count},
+//       so a receipt can be a MEASUREMENT instead of a fixed success shape.
+//
+// SPOOL-AND-DRAIN, AND WHY IT IS NOT JUST A DIRECT POST
+//   Measured in a sandbox against a 79k-node / 176MB graph (live scale): one
+//   load-merge costs ~0.38s, essentially all of it the owner's persist_canonical.
+//   A chat turn writes 5-7 nodes; pushing each separately would add ~2.7s per
+//   turn. So writes are STAGED and pushed in one coalesced batch.
+//   The staging buffer is the FILESYSTEM, not process state, because the soul
+//   serves each HTTP connection on its own pthread (el_runtime http_serve_async)
+//   and a shared in-process buffer would lose entries to a read-modify-write
+//   race — silently, which is the one failure mode this file exists to end.
+//   One file per write, named with uuid_v4, is race-free by construction and
+//   buys a property a memory buffer cannot: writes that could not be pushed
+//   SURVIVE A SOUL CRASH and are drained on the next boot.
+//
+// WHAT IS DELIBERATELY NOT PUSHED
+//   - InternalStateEvent / heartbeat telemetry. Will's own carve-out, stated in
+//     engram server.el 8f8ccc9: "48h-pruned, loss-tolerant, ~2/min; snapshotting
+//     28MB per heartbeat is waste."
+//   NOTE (ours, flagged for Will): we do NOT additionally exclude Working-tier
+//   nodes. That exclusion exists in `fb0bb55` to stop the boot counter leaking
+//   through the /api/sync PULL; it is about sync backflow, not durability.
+//   Applying it here would exclude mem_store — which writes tier "Working" — and
+//   mem_store is the single most important durable write path in the soul. Boot
+//   seeding reads the canonical file wholesale, so a pushed Working-tier node
+//   does survive restart. This is the one classification call this file makes
+//   that Will has not ruled on.
+//
+// WHAT THIS BOUNDARY CANNOT EXPRESS (by construction, not by omission)
+//   - engram_strengthen (salience/activation drift): load-merge SKIPS ids that
+//     already exist, so it cannot update an existing node. There is no owner-side
+//     update/upsert route. Not pushable through any current route; left as a
+//     follow-up that needs a change in the engram repo.
+//   - engram_forget (hard delete): load-merge is additive and has no delete verb.
+//     Propagating deletes would mean DELETE /api/nodes/<id>, a HARD delete at the
+//     owner — which scripts/verify-soul-contract.sh section B explicitly fails the
+//     build for ("to delete is to supersede/tombstone, never hard-remove"). Local
+//     deletes therefore stay local; the TOMBSTONE NODE and its "tombstones" edge
+//     (mem_tombstone) are pushed, and that is the sanctioned representation of a
+//     deletion in this graph.
+
+// ── Configuration ─────────────────────────────────────────────────────────────
+
+// wt_engram_url — same resolution order as ise_post: env, then the state key
+// stashed at boot. NO hardcoded localhost fallback: unlike telemetry, inventing
+// a destination for durable data would risk pushing a user's memories at whatever
+// happens to be listening on 8742. Empty means "no HTTP owner" -> file mode.
+fn wt_engram_url() -> String {
+    let env_url: String = env("ENGRAM_URL")
+    if !str_eq(env_url, "") { return env_url }
+    return state_get("soul_engram_url")
+}
+
+fn wt_api_key() -> String {
+    let env_key: String = env("ENGRAM_API_KEY")
+    if !str_eq(env_key, "") { return env_key }
+    return state_get("soul_engram_api_key")
+}
+
+// wt_enabled — true only in HTTP-engram mode. In file mode the soul IS the
+// persistence owner and every path below is a no-op, so this whole feature is
+// inert for genesis/local deployments. That is also what makes it reversible.
+fn wt_enabled() -> Bool {
+    return !str_eq(wt_engram_url(), "")
+}
+
+// wt_spool_dir — where staged deltas live. MUST be readable by the engram
+// process: /api/load-merge takes a PATH and the owner opens it itself. Both
+// processes are same-host by construction (dev-stack LaunchAgents; the GKE
+// image starts engram and soul in one container per entrypoint.sh).
+fn wt_spool_dir() -> String {
+    let raw: String = env("SOUL_OUTBOX_DIR")
+    let dir: String = if str_eq(raw, "") { env("HOME") + "/.neuron/soul-outbox" } else { raw }
+    fs_mkdir(dir)
+    return dir
+}
+
+// ── Helpers ───────────────────────────────────────────────────────────────────
+
+// wt_esc — minimal JSON string escape. Deliberately local rather than reusing
+// chat.el's json_safe: persist.el is imported BY memory.el, which is imported by
+// chat.el, so depending on chat.el here would be an import cycle.
+fn wt_esc(s: String) -> String {
+    let s1: String = str_replace(s, "\\", "\\\\")
+    let s2: String = str_replace(s1, "\"", "\\\"")
+    let s3: String = str_replace(s2, "\n", "\\n")
+    let s4: String = str_replace(s3, "\r", "\\r")
+    let s5: String = str_replace(s4, "\t", "\\t")
+    return s5
+}
+
+// wt_durable_class — Will's telemetry carve-out, by node_type. See header.
+fn wt_durable_class(node_type: String) -> Bool {
+    if str_eq(node_type, "InternalStateEvent") { return false }
+    return true
+}
+
+// wt_inner — strip the surrounding brackets off a JSON array so several arrays
+// can be concatenated into one. Returns "" for "[]" / "" / anything too short.
+fn wt_inner(arr: String) -> String {
+    let n: Int = str_len(arr)
+    if n < 3 { return "" }
+    if !str_starts_with(arr, "[") { return "" }
+    return str_slice(arr, 1, n - 1)
+}
+
+// wt_read — fs_read, plus a MANDATORY reset of the runtime's binary-length hint.
+//
+// THIS IS NOT OPTIONAL AND MUST NOT BE "SIMPLIFIED" BACK TO A BARE fs_read.
+// The pinned runtime (vendor/el-runtime/v1.0.0-20260501) keeps a thread-local
+// `_tl_fs_read_len` that fs_read SETS to the file's byte count (so binary files
+// can be served with a correct Content-Length) and that http_send_response
+// CONSUMES as the Content-Length of the next reply. Nothing else clears it
+// except json_get_raw. So any fs_read during request handling that is not
+// followed by a json_get_raw makes the NEXT HTTP response advertise the FILE's
+// length instead of the body's — and the runtime then sends that many bytes,
+// appending whatever adjacent heap memory follows the reply.
+//
+// Caught here, measured: a /api/neuron/memory reply that should be 86 bytes went
+// out as 497, with 411 bytes of this module's own spool paths and log strings
+// trailing the JSON. The drain reads spool files mid-request, so this boundary
+// is exactly where the landmine gets stepped on.
+//
+// Upstream el fixed the class in `43636ae` ("pair fs_read length hint with its
+// buffer"); that runtime is NOT the one vendored here, and re-pinning the
+// runtime is deliberately out of scope for this change. Clearing the hint at
+// our own boundary fixes our exposure without touching the pinned C.
+// json_get_raw is used as the reset because it is the only builtin in this
+// runtime that zeroes the hint, and it does so before any early return.
+fn wt_clear_binlen() -> Void {
+    let discard: String = json_get_raw("{}", "_wt_reset")
+}
+
+fn wt_read(path: String) -> String {
+    let data: String = fs_read(path)
+    wt_clear_binlen()
+    return data
+}
+
+// wt_sweep — best-effort removal of the zero-byte husks left by truncation.
+// The runtime exposes no unlink builtin, so a drained delta is emptied rather
+// than deleted; this reclaims the directory entries.
+//
+// `-empty` is the safety property, not an optimisation: the command is
+// STRUCTURALLY INCAPABLE of removing a delta that still has content, so it can
+// never destroy a pending write even if it runs concurrently with a stage.
+// Only the directory path is interpolated (never a filename), and it is quoted.
+// The exit code is ignored — an un-swept husk costs one directory entry.
+fn wt_sweep(dir: String) -> Void {
+    if str_eq(dir, "") { return }
+    if str_contains(dir, "'") { return }
+    exec_command("find '" + dir + "' -maxdepth 1 -name 'wt*.json' -empty -delete 2>/dev/null")
+}
+
+// ── Staging ───────────────────────────────────────────────────────────────────
+
+// wt_stage — write ONE delta file. uuid_v4 in the name makes concurrent stagers
+// collision-free without any lock. Returns true if the delta is on disk.
+fn wt_stage(nodes_json: String, edges_json: String) -> Bool {
+    let dir: String = wt_spool_dir()
+    if str_eq(dir, "") { return false }
+    let payload: String = "{\"nodes\":" + nodes_json + ",\"edges\":" + edges_json + "}"
+    let path: String = dir + "/wt-" + uuid_v4() + ".json"
+    fs_write(path, payload)
+    // Read-back-verify the stage itself. A stage that did not land is a write we
+    // would otherwise believe was queued — exactly the hallucinated-save class.
+    if str_eq(wt_read(path), "") {
+        println("[persist] wt_stage: FAILED to write spool file " + path + " — delta not queued")
+        return false
+    }
+    return true
+}
+
+// ── The write boundary ────────────────────────────────────────────────────────
+
+// wt_node — create a node locally AND queue it for the persistence owner.
+// Same signature and same return contract as engram_node_full ("" on failure),
+// so converting a call site is a rename and nothing else.
+fn wt_node(content: String, node_type: String, label: String,
+           salience: Float, importance: Float, confidence: Float,
+           tier: String, tags: String) -> String {
+    let id: String = engram_node_full(content, node_type, label,
+                                      salience, importance, confidence,
+                                      tier, tags)
+    if str_eq(id, "") { return "" }
+    // engram_get_node_json emits the SAME record shape engram_save writes (minus
+    // the embedding vector, which the owner backfills lazily), so the read-back
+    // doubles as the delta payload — no second serialization to drift.
+    let rec: String = engram_get_node_json(id)
+    if str_eq(rec, "") || str_eq(rec, "{}") {
+        println("[persist] wt_node: local write did not read back, id=" + id + " label=" + label)
+        return ""
+    }
+    if wt_enabled() && wt_durable_class(node_type) {
+        wt_stage("[" + rec + "]", "[]")
+    }
+    return id
+}
+
+// wt_edge — create an edge locally AND queue it. Mirrors engram_connect.
+//
+// The edge id is freshly generated rather than read back: the runtime exposes no
+// "id of the edge I just created" accessor, and the owner dedups edges by
+// (from_id,to_id,relation), never by id — so the id is not load-bearing. The
+// consequence, stated plainly: the soul's copy and the owner's copy of the same
+// edge carry different edge ids. Nothing in either codebase looks an edge up by
+// id (neighbors traversal scans from_id/to_id), so this is cosmetic.
+fn wt_edge(from_id: String, to_id: String, weight: Float, relation: String) -> Void {
+    engram_connect(from_id, to_id, weight, relation)
+    if !wt_enabled() { return }
+    if str_eq(from_id, "") || str_eq(to_id, "") { return }
+    let ts: Int = time_now()
+    let rec: String = "{\"id\":\"" + uuid_v4() + "\""
+        + ",\"from_id\":\"" + wt_esc(from_id) + "\""
+        + ",\"to_id\":\"" + wt_esc(to_id) + "\""
+        + ",\"relation\":\"" + wt_esc(relation) + "\""
+        + ",\"metadata\":\"{}\""
+        + ",\"weight\":" + float_to_str(weight)
+        + ",\"confidence\":1"
+        + ",\"created_at\":" + int_to_str(ts)
+        + ",\"updated_at\":" + int_to_str(ts)
+        + ",\"last_fired\":0,\"inhibitory\":0,\"layer_id\":1}"
+    wt_stage("[]", "[" + rec + "]")
+}
+
+// ── The drain ─────────────────────────────────────────────────────────────────
+
+// wt_drain — coalesce every staged delta into ONE load-merge against the owner.
+//
+// Returns: nodes_added on success (>= 0), 0 when there was nothing to do, and
+// -1 when the push FAILED. -1 is load-bearing: on failure the spool files are
+// left untouched, so nothing is lost and the next drain retries them. A caller
+// must never read a non-negative return as "my particular node is durable" —
+// use wt_durable(id) for that.
+//
+// Concurrency: several threads may drain at once. Each builds its own batch file
+// (uuid-named), and overlapping batches are harmless because load-merge dedups.
+// Files are truncated ONLY after a confirmed ok:true, so a lost race costs a
+// redundant push, never a dropped write.
+fn wt_drain() -> Int {
+    if !wt_enabled() { return 0 }
+    let dir: String = wt_spool_dir()
+    if str_eq(dir, "") { return 0 }
+
+    // el_list_len/el_list_get, NOT json_stringify(fs_list(...)): fs_list builds
+    // a native list via el_list_append, and json_stringify does not serialize
+    // that type — it renders the raw pointer value. (Verified in isolation; the
+    // same latent defect is live in studio.el's /api/tools/file/list route,
+    // which returns e.g. {"entries":4386409744}. Noted, not fixed here.)
+    let listing = fs_list(dir)
+    let count: Int = el_list_len(listing)
+    if count == 0 { return 0 }
+
+    let nodes_acc: String = ""
+    let edges_acc: String = ""
+    let drained: String = ""
+    let found: Int = 0
+    let i: Int = 0
+    // No `continue` / `break`: elc lists them as keywords but not one line of
+    // the shipped soul uses either, so they are unexercised on this build path.
+    // Guard conditions are expressed as nested ifs instead, and every rebind is
+    // at the loop-body top level where `let x = ...` is assignment (the idiom
+    // memory.el's boot-counter loop relies on) — never inside a nested block,
+    // where it would shadow instead.
+    while i < count {
+        let name: String = el_list_get(listing, i)
+        // A delta is only usable when it ends with the closing "]}" that
+        // wt_stage writes last. fs_write is not atomic, so a file being written
+        // right now can be observed half-formed; requiring the terminator means
+        // it is picked up whole on the next drain instead of merged as garbage.
+        // An empty read means "already drained and truncated" — not an error.
+        let p: String = if str_starts_with(name, "wt-") { dir + "/" + name } else { "" }
+        let raw: String = if str_eq(p, "") { "" } else { wt_read(p) }
+        let usable: Bool = !str_eq(raw, "") && str_ends_with(raw, "]}")
+        let nj: String = if usable { wt_inner(json_get_raw(raw, "nodes")) } else { "" }
+        let ej: String = if usable { wt_inner(json_get_raw(raw, "edges")) } else { "" }
+        let nodes_acc = if str_eq(nj, "") { nodes_acc } else if str_eq(nodes_acc, "") { nj } else { nodes_acc + "," + nj }
+        let edges_acc = if str_eq(ej, "") { edges_acc } else if str_eq(edges_acc, "") { ej } else { edges_acc + "," + ej }
+        let drained = if !usable { drained } else if str_eq(drained, "") { p } else { drained + "\n" + p }
+        let found = if usable { found + 1 } else { found }
+        let i = i + 1
+    }
+
+    if found == 0 { return 0 }
+
+    let combined: String = "{\"nodes\":[" + nodes_acc + "],\"edges\":[" + edges_acc + "]}"
+    let batch: String = dir + "/wtb-" + uuid_v4() + ".json"
+    fs_write(batch, combined)
+    if str_eq(wt_read(batch), "") {
+        println("[persist] wt_drain: could not write batch file " + batch + " — " + int_to_str(found) + " deltas stay queued")
+        return -1
+    }
+
+    let url: String = wt_engram_url()
+    let key: String = wt_api_key()
+    let body: String = "{\"path\":\"" + wt_esc(batch) + "\",\"_auth\":\"" + wt_esc(key) + "\"}"
+    let resp: String = http_post_json(url + "/api/load-merge", body)
+
+    // The batch file is pure scratch — the retry is rebuilt from the SPOOL, not
+    // from it. Truncate it unconditionally, before branching on the outcome, so
+    // a persistently unreachable owner cannot accumulate one husk per attempt.
+    fs_write(batch, "")
+
+    // Distinguish the two failures rather than collapsing them: "cannot reach
+    // the owner" and "the owner refused this delta" need different human
+    // responses, and a log line that says the wrong one costs a debugging hour.
+    // curl surfaces transport errors as a JSON body, so an empty response is not
+    // the only unreachable signal.
+    // (str_contains rather than a strict parse on purpose — the engram's HTTP
+    //  responses have been observed carrying trailing bytes past the JSON.)
+    let unreachable: Bool = str_eq(resp, "")
+        || str_contains(resp, "Couldn't connect")
+        || str_contains(resp, "Failed to connect")
+        || str_contains(resp, "Could not resolve")
+        || str_contains(resp, "timed out")
+    if unreachable {
+        wt_sweep(dir)
+        println("[persist] wt_drain: owner UNREACHABLE at " + url + " — " + int_to_str(found)
+            + " deltas stay queued in " + dir + " (will retry): " + resp)
+        return -1
+    }
+    if !str_contains(resp, "\"ok\":true") {
+        wt_sweep(dir)
+        println("[persist] wt_drain: owner REJECTED the delta — " + int_to_str(found)
+            + " stay queued in " + dir + ": " + resp)
+        return -1
+    }
+
+    let added: Int = json_get_int(resp, "nodes_added")
+    let added_e: Int = json_get_int(resp, "edges_added")
+
+    // Confirmed. Truncate the drained spool files so they are not re-pushed.
+    // Truncation (not deletion) because the runtime exposes no unlink builtin;
+    // an emptied file is inert to the loop above. The zero-byte husks are then
+    // swept below.
+    let paths = str_split(drained, "\n")
+    let pn: Int = el_list_len(paths)
+    let k: Int = 0
+    while k < pn {
+        let one: String = el_list_get(paths, k)
+        if !str_eq(one, "") { fs_write(one, "") }
+        let k = k + 1
+    }
+    wt_sweep(dir)
+
+    println("[persist] wt_drain: pushed " + int_to_str(found) + " deltas -> owner added "
+        + int_to_str(added) + " nodes, " + int_to_str(added_e) + " edges")
+    return added
+}
+
+// wt_durable — is this id present AT THE OWNER? The only honest answer to
+// "did my write persist" in HTTP mode.
+//
+// In file mode the soul IS the owner, so the local read-back is the owner-side
+// read-back and this collapses to the pre-existing check.
+//
+// nodes_added from wt_drain is NOT a substitute: a concurrent drain may have
+// already pushed this node, making our own added count 0 while the node is
+// perfectly durable. Presence at the owner is the fact; counts are telemetry.
+fn wt_durable(id: String) -> Bool {
+    if str_eq(id, "") { return false }
+    if !wt_enabled() {
+        let local: String = engram_get_node_json(id)
+        return !str_eq(local, "") && !str_eq(local, "null") && !str_eq(local, "{}")
+    }
+    let url: String = wt_engram_url()
+    let resp: String = http_get(url + "/api/nodes/" + id)
+    if str_eq(resp, "") { return false }
+    if str_eq(resp, "{}") { return false }
+    return str_contains(resp, "\"id\"")
+}
+
+// wt_commit — flush, then assert at the owner. The receipt callers should use.
+// Deliberately NOT a fixed success shape: it can and does return false while the
+// local write is perfectly fine in RAM, which is the true state of affairs when
+// the owner is unreachable.
+fn wt_commit(id: String) -> Bool {
+    if str_eq(id, "") { return false }
+    if !wt_enabled() {
+        let local: String = engram_get_node_json(id)
+        return !str_eq(local, "") && !str_eq(local, "null") && !str_eq(local, "{}")
+    }
+    let pushed: Int = wt_drain()
+    return wt_durable(id)
+}

routes.elh

@@ -1,16 +0,0 @@
-// 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

safety.el

@@ -204,7 +204,7 @@ fn safety_log_bell(level: String, reason: String, input_summary: String) -> Stri
     // Emit a fallback println so the bell event leaves at least a log trace even
     // when engram is degraded. This does not replace engram persistence -- it is a
     // last-resort audit trail when the primary write cannot be confirmed.
-    let node_id: String = engram_node_full(
+    let node_id: String = wt_node(
         content,
         "BellEvent",
         "bell:" + level,

safety.elh

@@ -1,29 +0,0 @@
-// 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

scripts/run-el-test.sh

@@ -0,0 +1,108 @@
+#!/usr/bin/env bash
+# run-el-test.sh — compile and run one El test program from tests/.
+#
+# WHY THIS EXISTS (2026-08-07, issue #129):
+#   tests/ has held 14 test programs for months with no way to run them. CI does
+#   not run them. The convention printed in their own headers
+#   (`elc soul.el && ./soul --test tests/x.el`) refers to a --test flag the El
+#   runtime does not implement. So the tests were documentation, not gates —
+#   which is how a P0 safety regression shipped with a test directory present.
+#
+# THE RECIPE, AND WHY IT IS THIS SHAPE:
+#   Same discovery as gen-soul-amalgam.sh — `elc --target=c` emits only an extern
+#   prototype for any module that has a .elh header next to it, and inlines the
+#   module's bodies when it does not. A test that imports ../chat.el therefore
+#   compiles to a 18 KB unit full of unresolved externs unless the headers are
+#   out of the way. So: copy the sources into a scratch tree, delete every .elh
+#   on the import chain, and compile the test there.
+#
+#   Scratch copy on purpose: the worktree is shared with other terminals and
+#   deleting headers in place would be a shared-tree mutation with no owner.
+#
+# EXIT STATUS IS THE GATE: non-zero if the binary fails to build, crashes, or if
+# its output contains a FAIL line or reports a non-zero failed count. Do not
+# "improve" this into something that only checks the exit code of the test
+# binary — these El tests print failures and still exit 0.
+#
+# usage: scripts/run-el-test.sh tests/test_history_amplification.el
+set -euo pipefail
+
+TEST_REL="${1:?usage: run-el-test.sh tests/<test>.el}"
+SRC="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+TEST_NAME="$(basename "$TEST_REL" .el)"
+
+ELC="${ELC:-$HOME/neuron-dev-stack/src/el/lang/dist/platform/elc}"
+[ -x "$ELC" ] || ELC="$HOME/el-sdk/elc"
+[ -x "$ELC" ] || { echo "[run-el-test] FAIL: no elc found (set ELC=)"; exit 1; }
+
+RTC="${RTC:-$SRC/vendor/el-runtime/v1.0.0-20260501/el_runtime.c}"
+[ -f "$RTC" ] || RTC="$HOME/el-sdk/el_runtime.c"
+[ -f "$RTC" ] || { echo "[run-el-test] FAIL: no el_runtime.c found (set RTC=)"; exit 1; }
+RTDIR="$(dirname "$RTC")"
+
+EL_REPO="${EL_REPO:-$HOME/Development/neuron-technologies/el}"
+SSL="${SSL_PREFIX:-/opt/homebrew/opt/openssl@3}"
+
+GEN="$(mktemp -d "${TMPDIR:-/tmp}/el-test.XXXXXX")"
+trap 'rm -rf "$GEN"' EXIT
+
+mkdir -p "$GEN/neuron/tests" "$GEN/foundation/el/elp/src"
+cp "$SRC"/*.el "$GEN/neuron/"
+cp "$SRC"/tests/*.el "$GEN/neuron/tests/" 2>/dev/null || true
+[ -d "$EL_REPO/elp/src" ] && cp "$EL_REPO"/elp/src/*.el "$GEN/foundation/el/elp/src/" 2>/dev/null || true
+# The whole recipe depends on there being no headers to short-circuit inlining.
+find "$GEN" -name '*.elh' -delete
+
+echo "[run-el-test] compiling $TEST_REL"
+( cd "$GEN/neuron" && "$ELC" --target=c "tests/${TEST_NAME}.el" ) > "$GEN/${TEST_NAME}.c"
+
+BODIES=$(grep -c '^el_val_t .*) {$' "$GEN/${TEST_NAME}.c" || true)
+echo "[run-el-test] $(wc -c < "$GEN/${TEST_NAME}.c" | tr -d ' ') bytes, ${BODIES} inlined function bodies"
+# A test that imports ../chat.el pulls in the bulk of the engine. A tiny body
+# count means an import was read from a header instead of inlined, and the test
+# would be exercising extern stubs rather than the real code.
+if [ "$BODIES" -lt 100 ]; then
+  echo "[run-el-test] FAIL: only $BODIES inlined bodies — an import was not inlined"
+  exit 1
+fi
+
+cc -O2 -DHAVE_CURL \
+   -I"$RTDIR" -I"$SSL/include" -L"$SSL/lib" \
+   "$GEN/${TEST_NAME}.c" "$RTC" \
+   -lssl -lcrypto -lcurl -lpthread -lm \
+   -o "$GEN/${TEST_NAME}" 2> "$GEN/cc.log" || {
+     echo "[run-el-test] FAIL: compile error"; tail -30 "$GEN/cc.log"; exit 1; }
+
+# arm64 pointer-truncation guard (cc-brain.sh's rule): an implicit declaration of
+# a runtime symbol truncates its returned pointer to 32 bits.
+if grep -E 'implicit.*(engram_|el_)' "$GEN/cc.log"; then
+  echo "[run-el-test] FAIL: implicit declarations of runtime symbols"; exit 1; fi
+
+# Throwaway HOME so a test can never read or write the live engram at ~/.neuron.
+TEST_HOME="$GEN/home"
+mkdir -p "$TEST_HOME"
+
+echo "[run-el-test] running $TEST_NAME"
+set +e
+HOME="$TEST_HOME" NEURON_HOME="$TEST_HOME/.neuron" "$GEN/${TEST_NAME}" 2>&1 | tee "$GEN/out.txt"
+RC=${PIPESTATUS[0]}
+set -e
+
+if [ "$RC" -ne 0 ]; then
+  echo "[run-el-test] FAIL: $TEST_NAME exited $RC (crash or abort)"
+  exit 1
+fi
+if grep -q "  FAIL:" "$GEN/out.txt"; then
+  echo "[run-el-test] FAIL: $TEST_NAME reported failing assertions"
+  exit 1
+fi
+if grep -qE '[1-9][0-9]* failed' "$GEN/out.txt"; then
+  echo "[run-el-test] FAIL: $TEST_NAME reported a non-zero failed count"
+  exit 1
+fi
+if ! grep -q "PASS:" "$GEN/out.txt"; then
+  echo "[run-el-test] FAIL: $TEST_NAME produced no assertions at all"
+  exit 1
+fi
+
+echo "[run-el-test] PASS: $TEST_NAME"

scripts/state-key-audit.py

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

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

@@ -0,0 +1,16 @@
+# 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-soul-contract.sh

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

scripts/verify-state-keys.sh

@@ -0,0 +1,118 @@
+#!/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.el

@@ -87,7 +87,7 @@ fn session_create(body: String) -> String {
     let folder: String = json_get(body, "folder")
     let content: String = session_make_content(id, title, ts, ts, folder)
     let tags: String = "[\"session\",\"session:meta\",\"Conversation\"]"
-    let node_id: String = engram_node_full(
+    let node_id: String = wt_node(
         content, "Conversation", "session:meta",
         el_from_float(0.7), el_from_float(0.7), el_from_float(0.9),
         "Episodic", tags
@@ -358,7 +358,7 @@ fn session_update_patch(session_id: String, body: String) -> String {
     let created_int: Int = str_to_int(old_created)
     let new_content: String = session_make_content(session_id, eff_title, created_int, ts, eff_folder)
     let tags: String = "[\"session\",\"session:meta\",\"Conversation\"]"
-    let new_node_id: String = engram_node_full(
+    let new_node_id: String = wt_node(
         new_content, "Conversation", "session:meta",
         el_from_float(0.7), el_from_float(0.7), el_from_float(0.9),
         "Episodic", tags
@@ -456,7 +456,7 @@ fn session_hist_save(session_id: String, hist: String) -> Void {
     // TODO(reliability #7): delete-then-insert is not atomic — concurrent saves for the
     // same session can produce orphan history nodes. State is primary truth; engram fallback.
     let tags: String = "[\"session\",\"session-history\",\"Conversation\"]"
-    let discard: String = engram_node_full(
+    let discard: String = wt_node(
         hist, "Conversation", "session:messages:" + session_id,
         el_from_float(0.6), el_from_float(0.6), el_from_float(0.9),
         "Episodic", tags
@@ -488,7 +488,7 @@ fn session_hist_save(session_id: String, hist: String) -> Void {
                 + " | ts:" + int_to_str(ts_now)
             let summary_tags: String = "[\"session-emotional-summary\",\"affective\",\"bell:" + eff_level + "\",\"BellEvent\"]"
             let summary_sal: String = if str_eq(eff_level, "hard") { el_from_float(0.95) } else { el_from_float(0.85) }
-            let sum_discard: String = engram_node_full(
+            let sum_discard: String = wt_node(
                 summary_content,
                 "BellEvent",
                 "session:emotional-summary",
@@ -529,7 +529,7 @@ fn session_hist_save(session_id: String, hist: String) -> Void {
             if !str_eq(ot_id, "") { engram_forget(ot_id) }
             let oti = oti + 1
         }
-        let discard_topic: String = engram_node_full(
+        let discard_topic: String = wt_node(
             topic_content, "Conversation", topic_label,
             el_from_float(0.7), el_from_float(0.7), el_from_float(0.9),
             "Episodic", topic_tags
@@ -582,7 +582,7 @@ fn session_update_meta_timestamp(session_id: String) -> Void {
     let created_int: Int = str_to_int(old_created)
     let new_content: String = session_make_content(session_id, old_title, created_int, ts, old_folder)
     let tags: String = "[\"session\",\"session:meta\",\"Conversation\"]"
-    let new_id: String = engram_node_full(
+    let new_id: String = wt_node(
         new_content, "Conversation", "session:meta",
         el_from_float(0.7), el_from_float(0.7), el_from_float(0.9),
         "Episodic", tags
@@ -629,7 +629,7 @@ fn session_auto_title(session_id: String, first_message: String) -> Void {
     let created_int: Int = str_to_int(old_created)
     let new_content: String = session_make_content(session_id, new_title, created_int, ts, old_folder)
     let tags: String = "[\"session\",\"session:meta\",\"Conversation\"]"
-    let new_id: String = engram_node_full(
+    let new_id: String = wt_node(
         new_content, "Conversation", "session:meta",
         el_from_float(0.7), el_from_float(0.7), el_from_float(0.9),
         "Episodic", tags
@@ -677,6 +677,11 @@ fn handle_session_approve(session_id: String, body: String) -> String {
     // path for all sessions created through handle_chat_agentic / agentic_loop.
     let bridge_blob: String = state_get("mcp_bridge:" + session_id)
     if !str_eq(bridge_blob, "") {
+        // BUG-LEAK fix (2026-07-16): the approved tool executes below via dispatch_tool,
+        // whose path/command guards read the shared workspace-root key. Re-assert THIS
+        // session's own root first — an approval must never execute under whatever root
+        // the last unrelated request left behind.
+        state_set("agent_workspace_root", state_get("agent_workspace_root_" + session_id))
         // For "always": record tool_name in the always-allow list before resuming.
         // The tool_name is not stored in the bridge blob (only tool_use_id is).
         // Accept it from the body so the client can pass it along.
@@ -708,7 +713,13 @@ fn handle_session_approve(session_id: String, body: String) -> String {
         // For builtin tools with no client-provided content: fall back to
         // dispatch_tool so those tools still execute correctly.
         let client_content: String = json_get(body, "content")
-        let use_client_content: Bool = !str_eq(client_content, "")
+        // BUG-6 fix (2026-07-17): the naive json_get scanner matches "content" ANYWHERE
+        // in the body — including INSIDE tool_input — so every approved write_file (whose
+        // input always carries a content field) was mistaken for client-executed, never
+        // dispatched, and narrated as done: a false receipt with no file on disk. Builtin
+        // tools now ALWAYS dispatch server-side; client content is only honored for
+        // non-builtin (MCP/client-executed) tools. Stricter only.
+        let use_client_content: Bool = !str_eq(client_content, "") && !is_builtin_tool(approve_tool_name)
         let use_dispatch: Bool = is_builtin_tool(approve_tool_name) && !use_client_content
         let raw_input: String = json_get_raw(body, "tool_input")
         let eff_input: String = if str_eq(raw_input, "") { "{}" } else { raw_input }