fix(engram): allow SessionSummary node_type in validation allowlist

handle_api_consolidate writes a "SessionSummary" node, but engram_valid_node_type omitted it — so once this validation ships, every consolidate() would be silently REJECTED at the engram boundary. Add SessionSummary to the allowlist. Found in Will's PR review of neuron #1 / el #52. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Fix engram_node_full wrapper field corruption + add node_type/tier validation
2026-06-10 06:26:25 -05:00 · 2026-06-08 16:13:43 -05:00 · 2026-05-07 14:25:37 +00:00 · 2026-05-07 14:20:53 +00:00 · 2026-05-07 08:11:38 +00:00 · 2026-05-07 08:01:22 +00:00
83 changed files with 370 additions and 14841 deletions
@@ -22,10 +22,7 @@ jobs:
      - name: Install build dependencies
        run: |
          apt-get update -qq
-          apt-get install -y gcc 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
+          apt-get install -y gcc libcurl4-openssl-dev

      # Seed: use the committed linux-amd64 binary as the bootstrap
      - name: Bootstrap from committed linux binary (seed)
@@ -87,22 +84,13 @@ jobs:
          bash tests/html_sanitizer/run.sh

      # Native El test suites (elc --test, compile-link-run)
-      # el_runtime.c is precompiled to .o once and reused by all 8 modules.
-      - name: Precompile el_runtime.o
-        run: |
-          set -euo pipefail
-          RUNTIME="$(pwd)/el-compiler/runtime"
-          gcc -O2 -c -I "$RUNTIME" "$RUNTIME/el_runtime.c" \
-            -o /tmp/el_runtime.o
-          echo "el_runtime.o compiled"
-
      - name: Run tests - native (core)
        run: |
          set -euo pipefail
          ELC="$(pwd)/dist/platform/elc"
          RUNTIME="$(pwd)/el-compiler/runtime"
          "$ELC" --test tests/native/test_core.el > /tmp/el_native_core.c
-          gcc -O2 -I "$RUNTIME" /tmp/el_native_core.c /tmp/el_runtime.o \
+          gcc -O2 -I "$RUNTIME" /tmp/el_native_core.c "$RUNTIME/el_runtime.c" \
            -lcurl -lssl -lcrypto -lpthread -lm -o /tmp/el_native_core
          /tmp/el_native_core

@@ -112,7 +100,7 @@ jobs:
          ELC="$(pwd)/dist/platform/elc"
          RUNTIME="$(pwd)/el-compiler/runtime"
          "$ELC" --test tests/native/test_text.el > /tmp/el_native_text.c
-          gcc -O2 -I "$RUNTIME" /tmp/el_native_text.c /tmp/el_runtime.o \
+          gcc -O2 -I "$RUNTIME" /tmp/el_native_text.c "$RUNTIME/el_runtime.c" \
            -lcurl -lssl -lcrypto -lpthread -lm -o /tmp/el_native_text
          /tmp/el_native_text

@@ -122,7 +110,7 @@ jobs:
          ELC="$(pwd)/dist/platform/elc"
          RUNTIME="$(pwd)/el-compiler/runtime"
          "$ELC" --test tests/native/test_string.el > /tmp/el_native_string.c
-          gcc -O2 -I "$RUNTIME" /tmp/el_native_string.c /tmp/el_runtime.o \
+          gcc -O2 -I "$RUNTIME" /tmp/el_native_string.c "$RUNTIME/el_runtime.c" \
            -lcurl -lssl -lcrypto -lpthread -lm -o /tmp/el_native_string
          /tmp/el_native_string

@@ -132,7 +120,7 @@ jobs:
          ELC="$(pwd)/dist/platform/elc"
          RUNTIME="$(pwd)/el-compiler/runtime"
          "$ELC" --test tests/native/test_math.el > /tmp/el_native_math.c
-          gcc -O2 -I "$RUNTIME" /tmp/el_native_math.c /tmp/el_runtime.o \
+          gcc -O2 -I "$RUNTIME" /tmp/el_native_math.c "$RUNTIME/el_runtime.c" \
            -lcurl -lssl -lcrypto -lpthread -lm -o /tmp/el_native_math
          /tmp/el_native_math

@@ -142,7 +130,7 @@ jobs:
          ELC="$(pwd)/dist/platform/elc"
          RUNTIME="$(pwd)/el-compiler/runtime"
          "$ELC" --test tests/native/test_state.el > /tmp/el_native_state.c
-          gcc -O2 -I "$RUNTIME" /tmp/el_native_state.c /tmp/el_runtime.o \
+          gcc -O2 -I "$RUNTIME" /tmp/el_native_state.c "$RUNTIME/el_runtime.c" \
            -lcurl -lssl -lcrypto -lpthread -lm -o /tmp/el_native_state
          /tmp/el_native_state

@@ -152,7 +140,7 @@ jobs:
          ELC="$(pwd)/dist/platform/elc"
          RUNTIME="$(pwd)/el-compiler/runtime"
          "$ELC" --test tests/native/test_time.el > /tmp/el_native_time.c
-          gcc -O2 -I "$RUNTIME" /tmp/el_native_time.c /tmp/el_runtime.o \
+          gcc -O2 -I "$RUNTIME" /tmp/el_native_time.c "$RUNTIME/el_runtime.c" \
            -lcurl -lssl -lcrypto -lpthread -lm -o /tmp/el_native_time
          /tmp/el_native_time

@@ -162,7 +150,7 @@ jobs:
          ELC="$(pwd)/dist/platform/elc"
          RUNTIME="$(pwd)/el-compiler/runtime"
          "$ELC" --test tests/native/test_json.el > /tmp/el_native_json.c
-          gcc -O2 -I "$RUNTIME" /tmp/el_native_json.c /tmp/el_runtime.o \
+          gcc -O2 -I "$RUNTIME" /tmp/el_native_json.c "$RUNTIME/el_runtime.c" \
            -lcurl -lssl -lcrypto -lpthread -lm -o /tmp/el_native_json
          /tmp/el_native_json

@@ -172,7 +160,7 @@ jobs:
          ELC="$(pwd)/dist/platform/elc"
          RUNTIME="$(pwd)/el-compiler/runtime"
          "$ELC" --test tests/native/test_env.el > /tmp/el_native_env.c
-          gcc -O2 -I "$RUNTIME" /tmp/el_native_env.c /tmp/el_runtime.o \
+          gcc -O2 -I "$RUNTIME" /tmp/el_native_env.c "$RUNTIME/el_runtime.c" \
            -lcurl -lssl -lcrypto -lpthread -lm -o /tmp/el_native_env
          /tmp/el_native_env

@@ -182,7 +170,7 @@ jobs:
          ELC="$(pwd)/dist/platform/elc"
          RUNTIME="$(pwd)/el-compiler/runtime"
          "$ELC" --test tests/native/test_fs.el > /tmp/el_native_fs.c
-          gcc -O2 -I "$RUNTIME" /tmp/el_native_fs.c /tmp/el_runtime.o \
+          gcc -O2 -I "$RUNTIME" /tmp/el_native_fs.c "$RUNTIME/el_runtime.c" \
            -lcurl -lssl -lcrypto -lpthread -lm -o /tmp/el_native_fs
          /tmp/el_native_fs

@@ -215,6 +203,9 @@ jobs:
          GCP_SA_KEY: ${{ secrets.GCP_SA_KEY }}
        run: |
          echo "${GCP_SA_KEY}" > /tmp/gcp-key.json
+          apt-get install -y -qq apt-transport-https ca-certificates curl
+          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
          gcloud auth activate-service-account --key-file=/tmp/gcp-key.json
          gcloud config set project neuron-785695

@@ -261,52 +252,4 @@ jobs:
            --source=el-compiler/runtime/el_runtime.js

          echo "Published El SDK version=${VERSION} to foundation-dev"
-          # Keep key alive for the ci-base rebuild step below
-          # (deleted in that step after docker push)
-
-      - name: Rebuild ci-base with fresh El SDK (dev)
-        # Patches ci-base:dev in-place: pulls the existing image (which has all
-        # system deps — Node, Go, gcloud, Docker CLI, etc.) and overlays the freshly
-        # built El SDK on top. Keeps the full ci-base rebuild fast and incremental.
-        if: github.event_name == 'push'
-        env:
-          GCP_SA_KEY: ${{ secrets.GCP_SA_KEY }}
-        run: |
-          set -euo pipefail
-          CI_BASE="us-central1-docker.pkg.dev/neuron-785695/neuron-ci/ci-base"
-          SHA="${GITHUB_SHA:0:8}"
-
-          echo "${GCP_SA_KEY}" > /tmp/gcp-key.json
-          gcloud auth activate-service-account --key-file=/tmp/gcp-key.json
-          gcloud config set project neuron-785695
-          gcloud auth configure-docker us-central1-docker.pkg.dev --quiet
-
-          # Pull existing ci-base:dev (or fall back to :latest on first run)
-          BASE_TAG="dev"
-          docker pull "${CI_BASE}:dev" || { docker pull "${CI_BASE}:latest" && BASE_TAG="latest"; }
-
-          # Inline Dockerfile — only replaces the El SDK layer
-          cat > /tmp/Dockerfile.ci-base-patch << 'EOF'
-          ARG BASE
-          FROM ${BASE}
-          COPY dist/platform/elc                 /opt/el/dist/platform/elc
-          COPY dist/bin/elb                       /opt/el/dist/bin/elb
-          COPY el-compiler/runtime/el_runtime.c  /opt/el/el-compiler/runtime/el_runtime.c
-          COPY el-compiler/runtime/el_runtime.h  /opt/el/el-compiler/runtime/el_runtime.h
-          COPY el-compiler/runtime/el_runtime.js /opt/el/el-compiler/runtime/el_runtime.js
-          RUN chmod +x /opt/el/dist/platform/elc /opt/el/dist/bin/elb
-          EOF
-
-          docker build \
-            --build-arg BASE="${CI_BASE}:${BASE_TAG}" \
-            --build-arg BUILDKIT_INLINE_CACHE=1 \
-            -f /tmp/Dockerfile.ci-base-patch \
-            -t "${CI_BASE}:dev" \
-            -t "${CI_BASE}:dev-${SHA}" \
-            .
-
-          docker push "${CI_BASE}:dev"
-          docker push "${CI_BASE}:dev-${SHA}"
-
-          echo "ci-base rebuilt: ${CI_BASE}:dev (${SHA})"
          rm -f /tmp/gcp-key.json
@@ -246,51 +246,4 @@ jobs:
            --source=el-compiler/runtime/el_runtime.h

          echo "Published El SDK version=${VERSION} to foundation-stage"
-          # Keep key alive for the ci-base rebuild step below
-          # (deleted in that step after docker push)
-
-      - name: Rebuild ci-base with fresh El SDK (stage)
-        # Patches ci-base:stage in-place: pulls the existing image (which has all
-        # system deps — Node, Go, gcloud, Docker CLI, etc.) and overlays the freshly
-        # built El SDK on top. Keeps the full ci-base rebuild fast and incremental.
-        if: github.event_name == 'push'
-        env:
-          GCP_SA_KEY: ${{ secrets.GCP_SA_KEY }}
-        run: |
-          set -euo pipefail
-          CI_BASE="us-central1-docker.pkg.dev/neuron-785695/neuron-ci/ci-base"
-          SHA="${GITHUB_SHA:0:8}"
-
-          echo "${GCP_SA_KEY}" > /tmp/gcp-key.json
-          gcloud auth activate-service-account --key-file=/tmp/gcp-key.json
-          gcloud config set project neuron-785695
-          gcloud auth configure-docker us-central1-docker.pkg.dev --quiet
-
-          # Pull existing ci-base:stage (system deps stay cached in the base layer)
-          docker pull "${CI_BASE}:stage" || docker pull "${CI_BASE}:latest"
-
-          # Inline Dockerfile — only replaces the El SDK layer
-          cat > /tmp/Dockerfile.ci-base-patch << 'EOF'
-          ARG BASE
-          FROM ${BASE}
-          COPY dist/platform/elc                 /opt/el/dist/platform/elc
-          COPY dist/bin/elb                       /opt/el/dist/bin/elb
-          COPY el-compiler/runtime/el_runtime.c  /opt/el/el-compiler/runtime/el_runtime.c
-          COPY el-compiler/runtime/el_runtime.h  /opt/el/el-compiler/runtime/el_runtime.h
-          COPY el-compiler/runtime/el_runtime.js /opt/el/el-compiler/runtime/el_runtime.js
-          RUN chmod +x /opt/el/dist/platform/elc /opt/el/dist/bin/elb
-          EOF
-
-          docker build \
-            --build-arg BASE="${CI_BASE}:stage" \
-            --build-arg BUILDKIT_INLINE_CACHE=1 \
-            -f /tmp/Dockerfile.ci-base-patch \
-            -t "${CI_BASE}:stage" \
-            -t "${CI_BASE}:stage-${SHA}" \
-            .
-
-          docker push "${CI_BASE}:stage"
-          docker push "${CI_BASE}:stage-${SHA}"
-
-          echo "ci-base rebuilt: ${CI_BASE}:stage (${SHA})"
          rm -f /tmp/gcp-key.json
@@ -1,132 +0,0 @@
-name: Engram CI
-
-on:
-  push:
-    branches:
-      - main
-      - dev
-    paths:
-      - 'engram/**'
-  workflow_dispatch:
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-
-      - name: Install build dependencies
-        run: |
-          apt-get update -qq
-          apt-get install -y gcc 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 SDK from Artifact Registry
-        env:
-          GCP_SA_KEY: ${{ secrets.GCP_SA_KEY }}
-        run: |
-          echo "${GCP_SA_KEY}" > /tmp/gcp-key.json
-          gcloud auth activate-service-account --key-file=/tmp/gcp-key.json
-          gcloud config set project neuron-785695
-
-          rm -rf /opt/el/dist /opt/el/runtime
-          mkdir -p /opt/el/dist/platform /opt/el/dist/bin /opt/el/runtime
-
-          get_latest() {
-            gcloud artifacts versions list \
-              --repository=foundation-dev \
-              --location=us-central1 \
-              --project=neuron-785695 \
-              --package="$1" \
-              --sort-by="~createTime" \
-              --limit=1 \
-              --format="value(name)" 2>/dev/null | awk -F/ '{print $NF}'
-          }
-
-          ELC_VER=$(get_latest el-elc)
-          ELB_VER=$(get_latest el-elb)
-          RC_VER=$(get_latest el-runtime-c)
-          RH_VER=$(get_latest el-runtime-h)
-
-          echo "Downloading elc@${ELC_VER} elb@${ELB_VER} runtime-c@${RC_VER} runtime-h@${RH_VER}"
-
-          gcloud artifacts generic download \
-            --repository=foundation-dev --location=us-central1 --project=neuron-785695 \
-            --package=el-elc --version="${ELC_VER}" \
-            --destination=/opt/el/dist/platform/
-
-          gcloud artifacts generic download \
-            --repository=foundation-dev --location=us-central1 --project=neuron-785695 \
-            --package=el-elb --version="${ELB_VER}" \
-            --destination=/opt/el/dist/bin/
-
-          gcloud artifacts generic download \
-            --repository=foundation-dev --location=us-central1 --project=neuron-785695 \
-            --package=el-runtime-c --version="${RC_VER}" \
-            --destination=/opt/el/runtime/
-
-          gcloud artifacts generic download \
-            --repository=foundation-dev --location=us-central1 --project=neuron-785695 \
-            --package=el-runtime-h --version="${RH_VER}" \
-            --destination=/opt/el/runtime/
-
-          mv /opt/el/dist/platform/elc* /opt/el/dist/platform/elc 2>/dev/null || true
-          mv /opt/el/dist/bin/elb*       /opt/el/dist/bin/elb      2>/dev/null || true
-          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
-
-          chmod +x /opt/el/dist/platform/elc /opt/el/dist/bin/elb
-          echo "El SDK ready"
-
-      - name: Build engram binary (linux/amd64)
-        run: |
-          ELB=/opt/el/dist/bin/elb
-          ELC=/opt/el/dist/platform/elc
-          RUNTIME=/opt/el/runtime
-
-          # elb reads manifest.el from the working directory.
-          # engram/dist/engram.c is the pre-compiled C translation of src/server.el.
-          # elb compiles dist/engram.c + el_runtime.c → dist/engram binary.
-          cd engram
-          "$ELB" --elc="$ELC" --runtime="$RUNTIME"
-          ls -lh dist/engram
-          file dist/engram
-
-      - name: Smoke test
-        run: |
-          file engram/dist/engram
-          timeout 3 engram/dist/engram --help 2>&1 || true
-          echo "smoke test complete"
-
-      - name: Publish engram binary to Artifact Registry
-        if: github.event_name == 'push'
-        env:
-          GCP_SA_KEY: ${{ secrets.GCP_SA_KEY }}
-        run: |
-          VERSION="${GITHUB_SHA:0:8}"
-
-          gcloud artifacts generic upload \
-            --repository=foundation-dev \
-            --location=us-central1 \
-            --project=neuron-785695 \
-            --package=engram \
-            --version="${VERSION}" \
-            --source=engram/dist/engram
-
-          # Re-upload as "latest" — Artifact Registry generic artifacts don't
-          # support moving tags, so we upload again. The newest upload wins.
-          gcloud artifacts generic upload \
-            --repository=foundation-dev \
-            --location=us-central1 \
-            --project=neuron-785695 \
-            --package=engram \
-            --version="latest" \
-            --source=engram/dist/engram \
-            2>/dev/null || true
-
-          echo "Published engram@${VERSION} and engram@latest"
-          rm -f /tmp/gcp-key.json
@@ -1,46 +1,46 @@
-// auto-generated by elc --emit-header — do not edit
-extern fn lang_profile(code: String, word_order: String, morph_type: String, has_case: String, has_gender: String, script_dir: String, agreement: String, null_subject: String) -> [String]
-extern fn lang_get(profile: [String], key: String) -> String
-extern fn lang_profile_en() -> [String]
-extern fn lang_profile_ja() -> [String]
-extern fn lang_profile_ar() -> [String]
-extern fn lang_profile_zh() -> [String]
-extern fn lang_profile_de() -> [String]
-extern fn lang_profile_es() -> [String]
-extern fn lang_profile_fi() -> [String]
-extern fn lang_profile_sw() -> [String]
-extern fn lang_profile_hi() -> [String]
-extern fn lang_profile_ru() -> [String]
-extern fn lang_profile_fr() -> [String]
-extern fn lang_profile_la() -> [String]
-extern fn lang_profile_he() -> [String]
-extern fn lang_profile_sa() -> [String]
-extern fn lang_profile_got() -> [String]
-extern fn lang_profile_non() -> [String]
-extern fn lang_profile_enm() -> [String]
-extern fn lang_profile_pi() -> [String]
-extern fn lang_profile_grc() -> [String]
-extern fn lang_profile_ang() -> [String]
-extern fn lang_profile_fro() -> [String]
-extern fn lang_profile_goh() -> [String]
-extern fn lang_profile_sga() -> [String]
-extern fn lang_profile_txb() -> [String]
-extern fn lang_profile_peo() -> [String]
-extern fn lang_profile_akk() -> [String]
-extern fn lang_profile_uga() -> [String]
-extern fn lang_profile_egy() -> [String]
-extern fn lang_profile_sux() -> [String]
-extern fn lang_profile_gez() -> [String]
-extern fn lang_profile_cop() -> [String]
-extern fn lang_from_code(code: String) -> [String]
-extern fn lang_default() -> [String]
-extern fn lang_is_isolating(profile: [String]) -> Bool
-extern fn lang_is_agglutinative(profile: [String]) -> Bool
-extern fn lang_is_fusional(profile: [String]) -> Bool
-extern fn lang_is_polysynthetic(profile: [String]) -> Bool
-extern fn lang_is_rtl(profile: [String]) -> Bool
-extern fn lang_has_null_subject(profile: [String]) -> Bool
-extern fn lang_has_case(profile: [String]) -> Bool
-extern fn lang_has_gender(profile: [String]) -> Bool
-extern fn lang_word_order(profile: [String]) -> String
-extern fn lang_code(profile: [String]) -> String
+// 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) -> Any
+extern fn lang_get(profile: Any, key: String) -> String
+extern fn lang_profile_en() -> Any
+extern fn lang_profile_ja() -> Any
+extern fn lang_profile_ar() -> Any
+extern fn lang_profile_zh() -> Any
+extern fn lang_profile_de() -> Any
+extern fn lang_profile_es() -> Any
+extern fn lang_profile_fi() -> Any
+extern fn lang_profile_sw() -> Any
+extern fn lang_profile_hi() -> Any
+extern fn lang_profile_ru() -> Any
+extern fn lang_profile_fr() -> Any
+extern fn lang_profile_la() -> Any
+extern fn lang_profile_he() -> Any
+extern fn lang_profile_sa() -> Any
+extern fn lang_profile_got() -> Any
+extern fn lang_profile_non() -> Any
+extern fn lang_profile_enm() -> Any
+extern fn lang_profile_pi() -> Any
+extern fn lang_profile_grc() -> Any
+extern fn lang_profile_ang() -> Any
+extern fn lang_profile_fro() -> Any
+extern fn lang_profile_goh() -> Any
+extern fn lang_profile_sga() -> Any
+extern fn lang_profile_txb() -> Any
+extern fn lang_profile_peo() -> Any
+extern fn lang_profile_akk() -> Any
+extern fn lang_profile_uga() -> Any
+extern fn lang_profile_egy() -> Any
+extern fn lang_profile_sux() -> Any
+extern fn lang_profile_gez() -> Any
+extern fn lang_profile_cop() -> Any
+extern fn lang_from_code(code: String) -> Any
+extern fn lang_default() -> Any
+extern fn lang_is_isolating(profile: Any) -> Bool
+extern fn lang_is_agglutinative(profile: Any) -> Bool
+extern fn lang_is_fusional(profile: Any) -> Bool
+extern fn lang_is_polysynthetic(profile: Any) -> Bool
+extern fn lang_is_rtl(profile: Any) -> Bool
+extern fn lang_has_null_subject(profile: Any) -> Bool
+extern fn lang_has_case(profile: Any) -> Bool
+extern fn lang_has_gender(profile: Any) -> Bool
+extern fn lang_word_order(profile: Any) -> String
+extern fn lang_code(profile: Any) -> String
@@ -56,7 +56,6 @@

 // ── String helpers ─────────────────────────────────────────────────────────────

-import "morphology.el"
 fn akk_str_ends(s: String, suf: String) -> Bool {
    return str_ends_with(s, suf)
 }
@@ -1,4 +1,4 @@
-// auto-generated by elc --emit-header — do not edit
+// 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
@@ -36,7 +36,6 @@

 // ── String helpers ─────────────────────────────────────────────────────────────

-import "morphology.el"
 fn ang_str_ends(s: String, suf: String) -> Bool {
    return str_ends_with(s, suf)
 }
@@ -1,4 +1,4 @@
-// auto-generated by elc --emit-header — do not edit
+// 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
@@ -21,7 +21,6 @@

 // ── String helpers ────────────────────────────────────────────────────────────

-import "morphology.el"
 fn ar_str_ends(s: String, suf: String) -> Bool {
    return str_ends_with(s, suf)
 }
@@ -1,4 +1,4 @@
-// auto-generated by elc --emit-header — do not edit
+// 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
@@ -54,7 +54,6 @@

 // ── String helpers ──────────────────────────────────────────────────────────────

-import "morphology.el"
 fn cop_str_ends(s: String, suf: String) -> Bool {
    return str_ends_with(s, suf)
 }
@@ -1,4 +1,4 @@
-// auto-generated by elc --emit-header — do not edit
+// 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
@@ -26,7 +26,6 @@
 //  Dat:    dem     der     dem     den
 //  Gen:    des     der     des     der

-import "morphology.el"
 fn de_article_def(gender: String, gram_case: String, number: String) -> String {
    if str_eq(number, "pl") {
        if str_eq(gram_case, "nom") { return "die" }
@@ -1,4 +1,4 @@
-// auto-generated by elc --emit-header — do not edit
+// 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
@@ -52,7 +52,6 @@

 // ── String helpers ──────────────────────────────────────────────────────────────

-import "morphology.el"
 fn egy_str_ends(s: String, suf: String) -> Bool {
    return str_ends_with(s, suf)
 }
@@ -1,4 +1,4 @@
-// auto-generated by elc --emit-header — do not edit
+// 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
@@ -31,7 +31,6 @@

 // ── String helpers ─────────────────────────────────────────────────────────────

-import "morphology.el"
 fn enm_str_ends(s: String, suf: String) -> Bool {
    return str_ends_with(s, suf)
 }
@@ -1,4 +1,4 @@
-// auto-generated by elc --emit-header — do not edit
+// 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
@@ -12,7 +12,6 @@

 // ── String helpers (local, matching morphology.el conventions) ────────────────

-import "morphology.el"
 fn es_str_ends(s: String, suf: String) -> Bool {
    return str_ends_with(s, suf)
 }
@@ -1,4 +1,4 @@
-// auto-generated by elc --emit-header — do not edit
+// 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
@@ -25,7 +25,6 @@
 // If only neutral vowels are found, default to "front" (the conservative choice
 // for borrowed words and those without clear back vowels).

-import "morphology.el"
 fn fi_harmony(word: String) -> String {
    let n: Int = str_len(word)
    let i: Int = n - 1
@@ -1,11 +1,11 @@
-// auto-generated by elc --emit-header — do not edit
+// 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_irregular_verb(dict_form: String) -> Any
 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
@@ -14,4 +14,4 @@ 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]
+extern fn fi_full_paradigm(noun: String) -> Any
@@ -19,7 +19,6 @@

 // ── String helpers (local, matching morphology.el conventions) ────────────────

-import "morphology.el"
 fn fr_str_ends(s: String, suf: String) -> Bool {
    return str_ends_with(s, suf)
 }
@@ -1,4 +1,4 @@
-// auto-generated by elc --emit-header — do not edit
+// 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
@@ -53,7 +53,6 @@

 // ── String helpers ─────────────────────────────────────────────────────────────

-import "morphology.el"
 fn fro_str_ends(s: String, suf: String) -> Bool {
    return str_ends_with(s, suf)
 }
@@ -1,4 +1,4 @@
-// auto-generated by elc --emit-header — do not edit
+// 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
@@ -64,7 +64,6 @@

 // ── String helpers ─────────────────────────────────────────────────────────────

-import "morphology.el"
 fn gez_str_ends(s: String, suf: String) -> Bool {
    return str_ends_with(s, suf)
 }
@@ -1,4 +1,4 @@
-// auto-generated by elc --emit-header — do not edit
+// 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
@@ -48,7 +48,6 @@

 // ── String helpers ─────────────────────────────────────────────────────────────

-import "morphology.el"
 fn goh_str_ends(s: String, suf: String) -> Bool {
    return str_ends_with(s, suf)
 }
@@ -1,4 +1,4 @@
-// auto-generated by elc --emit-header — do not edit
+// 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
@@ -49,7 +49,6 @@

 // ── String helpers ─────────────────────────────────────────────────────────────

-import "morphology.el"
 fn got_str_ends(s: String, suf: String) -> Bool {
    return str_ends_with(s, suf)
 }
@@ -1,4 +1,4 @@
-// auto-generated by elc --emit-header — do not edit
+// 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
@@ -31,7 +31,6 @@

 // ── String helpers ─────────────────────────────────────────────────────────────

-import "morphology.el"
 fn grc_str_ends(s: String, suf: String) -> Bool {
    return str_ends_with(s, suf)
 }
@@ -1,4 +1,4 @@
-// auto-generated by elc --emit-header — do not edit
+// 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
@@ -51,7 +51,6 @@

 // ── String helpers ─────────────────────────────────────────────────────────────

-import "morphology.el"
 fn he_str_ends(s: String, suf: String) -> Bool {
    return str_ends_with(s, suf)
 }
@@ -1,4 +1,4 @@
-// auto-generated by elc --emit-header — do not edit
+// 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
@@ -24,7 +24,6 @@

 // ── String helpers ────────────────────────────────────────────────────────────

-import "morphology.el"
 fn hi_str_ends(s: String, suf: String) -> Bool {
    return str_ends_with(s, suf)
 }
@@ -1,4 +1,4 @@
-// auto-generated by elc --emit-header — do not edit
+// 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
@@ -23,7 +23,6 @@
 // Note: this is a heuristic classifier for romanized input.  For production use
 // with native kana/kanji forms, the dictionary form (辞書形) must be consulted.

-import "morphology.el"
 fn ja_verb_group(dict_form: String) -> String {
    // Irregular verbs (exact match on dictionary form)
    if str_eq(dict_form, "する")  { return "irregular" }
@@ -1,4 +1,4 @@
-// auto-generated by elc --emit-header — do not edit
+// 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
@@ -25,7 +25,6 @@

 // ── String helpers ─────────────────────────────────────────────────────────────

-import "morphology.el"
 fn la_str_ends(s: String, suf: String) -> Bool {
    return str_ends_with(s, suf)
 }
@@ -1,4 +1,4 @@
-// auto-generated by elc --emit-header — do not edit
+// 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
@@ -27,7 +27,6 @@

 // ── String helpers ─────────────────────────────────────────────────────────────

-import "morphology.el"
 fn non_str_ends(s: String, suf: String) -> Bool {
    return str_ends_with(s, suf)
 }
@@ -1,4 +1,4 @@
-// auto-generated by elc --emit-header — do not edit
+// 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
@@ -31,7 +31,6 @@

 // ── String helpers ─────────────────────────────────────────────────────────────

-import "morphology.el"
 fn peo_drop(s: String, n: Int) -> String {
    let len: Int = str_len(s)
    if n >= len { return "" }
@@ -1,4 +1,4 @@
-// auto-generated by elc --emit-header — do not edit
+// 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
@@ -30,7 +30,6 @@

 // ── String helpers ─────────────────────────────────────────────────────────────

-import "morphology.el"
 fn pi_str_ends(s: String, suf: String) -> Bool {
    return str_ends_with(s, suf)
 }
@@ -1,4 +1,4 @@
-// auto-generated by elc --emit-header — do not edit
+// 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
@@ -35,7 +35,6 @@
 // The heuristic returns the most probable gender.  Caller should override
 // for known exceptions (путь, рубль are masc despite -ь).

-import "morphology.el"
 fn ru_gender(noun: String) -> String {
    let n: Int = str_len(noun)
    if n == 0 { return "m" }
@@ -1,4 +1,4 @@
-// auto-generated by elc --emit-header — do not edit
+// 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
@@ -42,7 +42,6 @@

 // ── String helpers ─────────────────────────────────────────────────────────────

-import "morphology.el"
 fn sa_str_ends(s: String, suf: String) -> Bool {
    return str_ends_with(s, suf)
 }
@@ -1,4 +1,4 @@
-// auto-generated by elc --emit-header — do not edit
+// 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
@@ -31,7 +31,6 @@

 // ── String helpers ─────────────────────────────────────────────────────────────

-import "morphology.el"
 fn sga_drop(s: String, n: Int) -> String {
    let len: Int = str_len(s)
    if n >= len { return "" }
@@ -1,4 +1,4 @@
-// auto-generated by elc --emit-header — do not edit
+// 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
@@ -53,7 +53,6 @@

 // ── String helpers ─────────────────────────────────────────────────────────────

-import "morphology.el"
 fn sux_str_ends(s: String, suf: String) -> Bool {
    return str_ends_with(s, suf)
 }
@@ -1,4 +1,4 @@
-// auto-generated by elc --emit-header — do not edit
+// 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
@@ -24,7 +24,6 @@

 // ── String helpers ────────────────────────────────────────────────────────────

-import "morphology.el"
 fn sw_str_ends(s: String, suf: String) -> Bool {
    return str_ends_with(s, suf)
 }
@@ -1,4 +1,4 @@
-// auto-generated by elc --emit-header — do not edit
+// 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
@@ -30,7 +30,6 @@

 // ── String helpers ─────────────────────────────────────────────────────────────

-import "morphology.el"
 fn txb_drop(s: String, n: Int) -> String {
    let len: Int = str_len(s)
    if n >= len { return "" }
@@ -1,4 +1,4 @@
-// auto-generated by elc --emit-header — do not edit
+// 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
@@ -48,7 +48,6 @@

 // ── String helpers ─────────────────────────────────────────────────────────────

-import "morphology.el"
 fn uga_str_ends(s: String, suf: String) -> Bool {
    return str_ends_with(s, suf)
 }
@@ -1,4 +1,4 @@
-// auto-generated by elc --emit-header — do not edit
+// 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
@@ -33,17 +33,6 @@

 // ── String helpers ────────────────────────────────────────────────────────────

-import "language-profile.el"
-import "morphology-es.el"
-import "morphology-fr.el"
-import "morphology-de.el"
-import "morphology-ru.el"
-import "morphology-fi.el"
-import "morphology-ar.el"
-import "morphology-hi.el"
-import "morphology-sw.el"
-import "morphology-la.el"
-import "morphology-ja.el"
 fn str_ends(s: String, suf: String) -> Bool {
    return str_ends_with(s, suf)
 }
@@ -1,4 +1,4 @@
-// auto-generated by elc --emit-header — do not edit
+// 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
@@ -8,7 +8,7 @@ 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_irregular_verb(base: String) -> Any
 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
@@ -16,10 +16,10 @@ 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_pluralize(noun: String, profile: Any) -> 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 morph_conjugate(verb: String, tense: String, person: String, number: String, profile: Any) -> String
+extern fn morph_inflect(word: String, features: String, profile: Any) -> 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
@@ -1,20 +1,20 @@
-// auto-generated by elc --emit-header — do not edit
-extern fn lex_word(entry: [String]) -> String
-extern fn lex_pos(entry: [String]) -> String
-extern fn lex_form(entry: [String], idx: Int) -> String
-extern fn lex_class(entry: [String]) -> String
-extern fn make_entry(word: String, pos: String, f0: String, f1: String, f2: String, f3: String, f4: String, cls: String) -> [String]
-extern fn make_entry2(word: String, pos: String, f0: String, f1: String, cls: String) -> [String]
-extern fn make_entry3(word: String, pos: String, f0: String, f1: String, f2: String, cls: String) -> [String]
-extern fn make_entry1(word: String, pos: String, f0: String, cls: String) -> [String]
-extern fn build_vocab() -> [[String]]
-extern fn get_vocab() -> [[String]]
-extern fn vocab_lookup(word: String, lang_code: String) -> [String]
-extern fn vocab_lookup_en(word: String) -> [String]
+// auto-generated by elc --emit-header - do not edit
+extern fn lex_word(entry: Any) -> String
+extern fn lex_pos(entry: Any) -> String
+extern fn lex_form(entry: Any, idx: Int) -> String
+extern fn lex_class(entry: Any) -> String
+extern fn make_entry(word: String, pos: String, f0: String, f1: String, f2: String, f3: String, f4: String, cls: String) -> Any
+extern fn make_entry2(word: String, pos: String, f0: String, f1: String, cls: String) -> Any
+extern fn make_entry3(word: String, pos: String, f0: String, f1: String, f2: String, cls: String) -> Any
+extern fn make_entry1(word: String, pos: String, f0: String, cls: String) -> Any
+extern fn build_vocab() -> Any
+extern fn get_vocab() -> Any
+extern fn vocab_lookup(word: String, lang_code: String) -> Any
+extern fn vocab_lookup_en(word: String) -> Any
 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
+extern fn vocab_by_pos(pos: String) -> Any
+extern fn vocab_by_class(cls: String) -> Any
+extern fn entry_found(entry: Any) -> Bool
+extern fn entry_word(entry: Any) -> String
+extern fn entry_pos(entry: Any) -> String
+extern fn entry_form(entry: Any, n: Int) -> String
@@ -2,11 +2,6 @@
 #include <stdlib.h>
 #include "el_runtime.h"

-el_val_t bm25_tokenize(el_val_t text);
-el_val_t bm25_count_term(el_val_t term, el_val_t doc_tokens);
-el_val_t bm25_score_doc(el_val_t doc_content, el_val_t query_tokens, el_val_t corpus_size, el_val_t avg_doc_len);
-el_val_t bm25_search_json(el_val_t query, el_val_t limit);
-el_val_t auto_link_content_node(el_val_t node_id, el_val_t content);
 el_val_t parse_port(el_val_t bind);
 el_val_t ok_json(void);
 el_val_t err_json(el_val_t msg);
@@ -25,246 +20,16 @@ el_val_t route_create_edge(el_val_t method, el_val_t path, el_val_t body);
 el_val_t route_neighbors(el_val_t method, el_val_t path, el_val_t body);
 el_val_t route_strengthen(el_val_t method, el_val_t path, el_val_t body);
 el_val_t route_forget(el_val_t method, el_val_t path, el_val_t body);
-el_val_t route_decay(el_val_t method, el_val_t path, el_val_t body);
-el_val_t route_export(el_val_t method, el_val_t path, el_val_t body);
-el_val_t route_reindex(el_val_t method, el_val_t path, el_val_t body);
+el_val_t route_save(el_val_t method, el_val_t path, el_val_t body);
 el_val_t route_load(el_val_t method, el_val_t path, el_val_t body);
 el_val_t route_health(el_val_t method, el_val_t path, el_val_t body);
-el_val_t route_neuron_session_begin(el_val_t method, el_val_t path, el_val_t body);
-el_val_t route_neuron_ctx(el_val_t method, el_val_t path, el_val_t body);
-el_val_t route_neuron_memory(el_val_t method, el_val_t path, el_val_t body);
-el_val_t route_neuron_knowledge_capture(el_val_t method, el_val_t path, el_val_t body);
-el_val_t route_neuron_knowledge_evolve(el_val_t method, el_val_t path, el_val_t body);
-el_val_t route_neuron_knowledge_promote(el_val_t method, el_val_t path, el_val_t body);
-el_val_t route_neuron_recall(el_val_t method, el_val_t path, el_val_t body);
-el_val_t route_neuron_graph(el_val_t method, el_val_t path, el_val_t body);
-el_val_t route_neuron_graph_link(el_val_t method, el_val_t path, el_val_t body);
-el_val_t route_neuron_list(el_val_t method, el_val_t path, el_val_t body);
-el_val_t route_neuron_consolidate(el_val_t method, el_val_t path, el_val_t body);
-el_val_t route_neuron_config(el_val_t method, el_val_t path, el_val_t body);
-el_val_t route_neuron_state_events(el_val_t method, el_val_t path, el_val_t body);
-el_val_t route_neuron_processes(el_val_t method, el_val_t path, el_val_t body);
-el_val_t route_events_next(el_val_t method, el_val_t path, el_val_t body);
-el_val_t route_events_ack(el_val_t method, el_val_t path, el_val_t body);
-el_val_t route_bm25_search(el_val_t method, el_val_t path, el_val_t body);
 el_val_t check_auth_ok(el_val_t method, el_val_t body);
 el_val_t handle_request(el_val_t method, el_val_t path, el_val_t body);

 el_val_t bind_str;
 el_val_t port;
 el_val_t data_dir;
-el_val_t db_path;
-el_val_t loaded;
-
-el_val_t bm25_tokenize(el_val_t text) {
-  el_val_t t = str_to_lower(text);
-  t = str_replace(t, EL_STR("."), EL_STR(" "));
-  t = str_replace(t, EL_STR(","), EL_STR(" "));
-  t = str_replace(t, EL_STR("!"), EL_STR(" "));
-  t = str_replace(t, EL_STR("?"), EL_STR(" "));
-  t = str_replace(t, EL_STR("\""), EL_STR(" "));
-  t = str_replace(t, EL_STR(":"), EL_STR(" "));
-  t = str_replace(t, EL_STR(";"), EL_STR(" "));
-  t = str_replace(t, EL_STR("("), EL_STR(" "));
-  t = str_replace(t, EL_STR(")"), EL_STR(" "));
-  t = str_replace(t, EL_STR("["), EL_STR(" "));
-  t = str_replace(t, EL_STR("]"), EL_STR(" "));
-  t = str_replace(t, EL_STR("{"), EL_STR(" "));
-  t = str_replace(t, EL_STR("}"), EL_STR(" "));
-  t = str_replace(t, EL_STR("/"), EL_STR(" "));
-  t = str_replace(t, EL_STR("\\"), EL_STR(" "));
-  t = str_replace(t, EL_STR("'"), EL_STR(" "));
-  t = str_replace(t, EL_STR("-"), EL_STR(" "));
-  t = str_replace(t, EL_STR("_"), EL_STR(" "));
-  t = str_replace(t, EL_STR("+"), EL_STR(" "));
-  return str_trim(t);
-  return 0;
-}
-
-el_val_t bm25_count_term(el_val_t term, el_val_t doc_tokens) {
-  el_val_t padded_term = el_str_concat(el_str_concat(EL_STR(" "), term), EL_STR(" "));
-  el_val_t padded_doc = el_str_concat(el_str_concat(EL_STR(" "), doc_tokens), EL_STR(" "));
-  return str_count(padded_doc, padded_term);
-  return 0;
-}
-
-el_val_t bm25_score_doc(el_val_t doc_content, el_val_t query_tokens, el_val_t corpus_size, el_val_t avg_doc_len) {
-  el_val_t k1 = el_from_float(1.2);
-  el_val_t b = el_from_float(0.75);
-  el_val_t delta = el_from_float(1.0);
-  el_val_t doc_tokens = bm25_tokenize(doc_content);
-  el_val_t doc_wc = str_count_words(doc_tokens);
-  if (doc_wc == 0) {
-    return EL_STR("0.0");
-  }
-  el_val_t doc_len = int_to_float(doc_wc);
-  el_val_t avg_len = str_to_float(avg_doc_len);
-  el_val_t N = int_to_float(corpus_size);
-  el_val_t idf_arg = float_add(float_div(float_add(N, el_from_float(1.2)), el_from_float(1.5)), el_from_float(1.0));
-  el_val_t idf = math_log(idf_arg);
-  el_val_t terms = str_split(query_tokens, EL_STR(" "));
-  el_val_t n_terms = len(terms);
-  el_val_t score = el_from_float(0.0);
-  el_val_t i = 0;
-  while (i < n_terms) {
-    el_val_t term = get(terms, i);
-    el_val_t tlen = str_len(term);
-    if (tlen >= 2) {
-      el_val_t tf_count = bm25_count_term(term, doc_tokens);
-      if (tf_count > 0) {
-        el_val_t tf_raw = int_to_float(tf_count);
-        el_val_t norm_factor = float_add(float_sub(el_from_float(1.0), b), float_div(float_mul(b, doc_len), avg_len));
-        el_val_t numerator = float_mul(tf_raw, float_add(k1, el_from_float(1.0)));
-        el_val_t denominator = float_add(tf_raw, float_mul(k1, norm_factor));
-        el_val_t tf_comp = float_add(delta, float_div(numerator, denominator));
-        score = float_add(score, float_mul(idf, tf_comp));
-      }
-    }
-    i = (i + 1);
-  }
-  return float_to_str(score);
-  return 0;
-}
-
-el_val_t bm25_search_json(el_val_t query, el_val_t limit) {
-  el_val_t scan_limit = (limit * 10);
-  if (scan_limit < 200) {
-    scan_limit = 200;
-  }
-  if (scan_limit > 5000) {
-    scan_limit = 5000;
-  }
-  el_val_t nodes_json = engram_scan_nodes_json(scan_limit, 0);
-  el_val_t n = json_array_len(nodes_json);
-  if (n == 0) {
-    return EL_STR("[]");
-  }
-  el_val_t total_words = 0;
-  el_val_t i = 0;
-  while (i < n) {
-    el_val_t node = json_array_get(nodes_json, i);
-    el_val_t content = json_get_string(node, EL_STR("content"));
-    el_val_t tokens = bm25_tokenize(content);
-    el_val_t wc = str_count_words(tokens);
-    total_words = (total_words + wc);
-    i = (i + 1);
-  }
-  el_val_t avg_doc_len_f = float_div(int_to_float(total_words), int_to_float(n));
-  el_val_t avg_doc_len = ({ el_val_t _if_result_1 = 0; if (float_gt(avg_doc_len_f, el_from_float(0.0))) { _if_result_1 = (float_to_str(avg_doc_len_f)); } else { _if_result_1 = (EL_STR("1.0")); } _if_result_1; });
-  el_val_t query_tokens = bm25_tokenize(query);
-  if (str_eq(str_trim(query_tokens), EL_STR(""))) {
-    return EL_STR("[]");
-  }
-  el_val_t result_nodes = 0;
-  el_val_t result_scores = 0;
-  el_val_t result_count = 0;
-  el_val_t j = 0;
-  while (j < n) {
-    el_val_t node = json_array_get(nodes_json, j);
-    el_val_t content = json_get_string(node, EL_STR("content"));
-    el_val_t sc_str = bm25_score_doc(content, query_tokens, n, avg_doc_len);
-    if (float_gt(str_to_float(sc_str), el_from_float(0.0))) {
-      result_nodes = list_push(result_nodes, node);
-      result_scores = list_push(result_scores, sc_str);
-      result_count = (result_count + 1);
-    }
-    j = (j + 1);
-  }
-  if (result_count == 0) {
-    return EL_STR("[]");
-  }
-  el_val_t out_limit = ({ el_val_t _if_result_2 = 0; if ((result_count < limit)) { _if_result_2 = (result_count); } else { _if_result_2 = (limit); } _if_result_2; });
-  el_val_t k = 0;
-  while (k < out_limit) {
-    el_val_t max_idx = k;
-    el_val_t max_sc_str = get(result_scores, k);
-    el_val_t max_sc_f = str_to_float(max_sc_str);
-    el_val_t p = (k + 1);
-    while (p < result_count) {
-      el_val_t sc2_str = get(result_scores, p);
-      el_val_t sc2_f = str_to_float(sc2_str);
-      if (float_gt(sc2_f, max_sc_f)) {
-        max_sc_f = sc2_f;
-        max_sc_str = sc2_str;
-        max_idx = p;
-      }
-      p = (p + 1);
-    }
-    if (max_idx != k) {
-      el_val_t tmp_node = get(result_nodes, k);
-      el_val_t tmp_sc = get(result_scores, k);
-      result_nodes = list_set(result_nodes, k, get(result_nodes, max_idx));
-      result_scores = list_set(result_scores, k, get(result_scores, max_idx));
-      result_nodes = list_set(result_nodes, max_idx, tmp_node);
-      result_scores = list_set(result_scores, max_idx, tmp_sc);
-    }
-    k = (k + 1);
-  }
-  el_val_t out = EL_STR("[");
-  el_val_t r = 0;
-  while (r < out_limit) {
-    el_val_t node = get(result_nodes, r);
-    el_val_t sc_str = get(result_scores, r);
-    el_val_t node_len = str_len(node);
-    el_val_t node_body = str_slice(node, 0, (node_len - 1));
-    el_val_t entry = el_str_concat(el_str_concat(el_str_concat(node_body, EL_STR(",\"bm25_score\":")), sc_str), EL_STR("}"));
-    if (r > 0) {
-      out = el_str_concat(out, EL_STR(","));
-    }
-    out = el_str_concat(out, entry);
-    r = (r + 1);
-  }
-  return el_str_concat(out, EL_STR("]"));
-  return 0;
-}
-
-el_val_t auto_link_content_node(el_val_t node_id, el_val_t content) {
-  el_val_t clen = str_len(content);
-  if (clen < 20) {
-    return 0;
-  }
-  el_val_t sp1 = str_index_of(content, EL_STR(" "));
-  el_val_t w1end = ({ el_val_t _if_result_3 = 0; if ((sp1 < 0)) { _if_result_3 = (clen); } else { _if_result_3 = (sp1); } _if_result_3; });
-  el_val_t word1 = str_slice(content, 0, w1end);
-  state_set(EL_STR("aln_term"), EL_STR(""));
-  if (str_len(word1) >= 5) {
-    state_set(EL_STR("aln_term"), word1);
-  }
-  if (str_eq(state_get(EL_STR("aln_term")), EL_STR(""))) {
-    if (sp1 >= 0) {
-      el_val_t rest = str_slice(content, (sp1 + 1), clen);
-      el_val_t sp2 = str_index_of(rest, EL_STR(" "));
-      el_val_t w2end = ({ el_val_t _if_result_4 = 0; if ((sp2 < 0)) { _if_result_4 = (str_len(rest)); } else { _if_result_4 = (sp2); } _if_result_4; });
-      el_val_t word2 = str_slice(rest, 0, w2end);
-      if (str_len(word2) >= 5) {
-        state_set(EL_STR("aln_term"), word2);
-      }
-    }
-  }
-  el_val_t search_term = state_get(EL_STR("aln_term"));
-  if (str_eq(search_term, EL_STR(""))) {
-    return 0;
-  }
-  el_val_t results = bm25_search_json(search_term, 20);
-  el_val_t n = json_array_len(results);
-  state_set(EL_STR("aln_linked"), EL_STR("0"));
-  el_val_t i = 0;
-  while (i < n) {
-    el_val_t linked_so_far = str_to_int(state_get(EL_STR("aln_linked")));
-    if (linked_so_far < 3) {
-      el_val_t elem = json_array_get(results, i);
-      el_val_t rid = json_get_string(elem, EL_STR("id"));
-      el_val_t rtype = json_get_string(elem, EL_STR("node_type"));
-      if ((!str_eq(rtype, EL_STR("InternalStateEvent")) && !str_eq(rid, EL_STR(""))) && !str_eq(rid, node_id)) {
-        engram_connect(node_id, rid, el_from_float(0.6), EL_STR("related"));
-        state_set(EL_STR("aln_linked"), int_to_str((linked_so_far + 1)));
-      }
-    }
-    i = (i + 1);
-  }
-  return str_to_int(state_get(EL_STR("aln_linked")));
-  return 0;
-}
+el_val_t snapshot_path;

 el_val_t parse_port(el_val_t bind) {
  el_val_t colon = str_index_of(bind, EL_STR(":"));
@@ -354,8 +119,7 @@ el_val_t route_create_node(el_val_t method, el_val_t path, el_val_t body) {
    salience = el_from_float(0.5);
  }
  el_val_t id = engram_node(content, node_type, salience);
-  el_val_t auto_linked = auto_link_content_node(id, content);
-  return el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"id\":\""), id), EL_STR("\",\"content\":\"")), content), EL_STR("\",\"node_type\":\"")), node_type), EL_STR("\",\"auto_linked\":")), int_to_str(auto_linked)), EL_STR("}"));
+  return el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"id\":\""), id), EL_STR("\",\"content\":\"")), content), EL_STR("\",\"node_type\":\"")), node_type), EL_STR("\"}"));
  return 0;
 }

@@ -412,7 +176,7 @@ el_val_t route_search(el_val_t method, el_val_t path, el_val_t body) {
  if (limit == 0) {
    limit = 20;
  }
-  return bm25_search_json(q, limit);
+  return engram_search_json(q, limit);
  return 0;
 }

@@ -429,17 +193,6 @@ el_val_t route_activate(el_val_t method, el_val_t path, el_val_t body) {
      depth = bd;
    }
  }
-  el_val_t top = bm25_search_json(q, 10);
-  el_val_t nb = json_array_len(top);
-  el_val_t bi = 0;
-  while (bi < nb) {
-    el_val_t node = json_array_get(top, bi);
-    el_val_t nid = json_get_string(node, EL_STR("id"));
-    if (!str_eq(nid, EL_STR(""))) {
-      engram_strengthen(nid);
-    }
-    bi = (bi + 1);
-  }
  return el_str_concat(el_str_concat(EL_STR("{\"results\":"), engram_activate_json(q, depth)), EL_STR("}"));
  return 0;
 }
@@ -490,46 +243,30 @@ el_val_t route_forget(el_val_t method, el_val_t path, el_val_t body) {
  return 0;
 }

-el_val_t route_decay(el_val_t method, el_val_t path, el_val_t body) {
-  return engram_apply_decay_json();
-  return 0;
-}
-
-el_val_t route_export(el_val_t method, el_val_t path, el_val_t body) {
-  el_val_t dir = env(EL_STR("ENGRAM_DATA_DIR"));
-  if (str_eq(dir, EL_STR(""))) {
-    dir = EL_STR("/tmp/engram");
-  }
-  el_val_t db_path = el_str_concat(dir, EL_STR("/engram.db"));
-  engram_write_binary_el(db_path);
+el_val_t route_save(el_val_t method, el_val_t path, el_val_t body) {
  el_val_t p = json_get_string(body, EL_STR("path"));
  if (str_eq(p, EL_STR(""))) {
+    el_val_t dir = env(EL_STR("ENGRAM_DATA_DIR"));
+    if (str_eq(dir, EL_STR(""))) {
+      dir = EL_STR("/tmp/engram");
+    }
    p = el_str_concat(dir, EL_STR("/snapshot.json"));
  }
  engram_save(p);
-  return el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"ok\":true,\"binary\":\""), db_path), EL_STR("\",\"json\":\"")), p), EL_STR("\"}"));
-  return 0;
-}
-
-el_val_t route_reindex(el_val_t method, el_val_t path, el_val_t body) {
-  return engram_reindex_json();
+  return el_str_concat(el_str_concat(EL_STR("{\"ok\":true,\"path\":\""), p), EL_STR("\"}"));
  return 0;
 }

 el_val_t route_load(el_val_t method, el_val_t path, el_val_t body) {
-  el_val_t dir = env(EL_STR("ENGRAM_DATA_DIR"));
-  if (str_eq(dir, EL_STR(""))) {
-    dir = EL_STR("/tmp/engram");
-  }
-  el_val_t db_path = el_str_concat(dir, EL_STR("/engram.db"));
-  el_val_t ok = engram_load_binary_el(db_path);
-  if (!ok) {
-    el_val_t p = json_get_string(body, EL_STR("path"));
-    if (str_eq(p, EL_STR(""))) {
-      p = el_str_concat(dir, EL_STR("/snapshot.json"));
+  el_val_t p = json_get_string(body, EL_STR("path"));
+  if (str_eq(p, EL_STR(""))) {
+    el_val_t dir = env(EL_STR("ENGRAM_DATA_DIR"));
+    if (str_eq(dir, EL_STR(""))) {
+      dir = EL_STR("/tmp/engram");
    }
-    engram_load(p);
+    p = el_str_concat(dir, EL_STR("/snapshot.json"));
  }
+  engram_load(p);
  return ok_json();
  return 0;
 }
@@ -539,344 +276,6 @@ el_val_t route_health(el_val_t method, el_val_t path, el_val_t body) {
  return 0;
 }

-el_val_t route_neuron_session_begin(el_val_t method, el_val_t path, el_val_t body) {
-  el_val_t results = engram_activate_json(EL_STR("memory knowledge context"), 2);
-  el_val_t nc = engram_node_count();
-  el_val_t ec = engram_edge_count();
-  return el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"ok\":true,\"nodes\":"), results), EL_STR(",\"node_count\":")), int_to_str(nc)), EL_STR(",\"edge_count\":")), int_to_str(ec)), EL_STR("}"));
-  return 0;
-}
-
-el_val_t route_neuron_ctx(el_val_t method, el_val_t path, el_val_t body) {
-  el_val_t results = engram_activate_json(EL_STR("architecture decision memory"), 2);
-  el_val_t n = json_array_len(results);
-  el_val_t limit = ({ el_val_t _if_result_5 = 0; if ((n > 10)) { _if_result_5 = (10); } else { _if_result_5 = (n); } _if_result_5; });
-  el_val_t ctx = EL_STR("Recent working memory:\n");
-  el_val_t i = 0;
-  el_val_t ctx_body = EL_STR("");
-  while (i < limit) {
-    el_val_t elem = json_array_get(results, i);
-    el_val_t label = json_get_string(elem, EL_STR("label"));
-    el_val_t content = json_get_string(elem, EL_STR("content"));
-    el_val_t clen = str_len(content);
-    el_val_t snippet = ({ el_val_t _if_result_6 = 0; if ((clen > 200)) { _if_result_6 = (str_slice(content, 0, 200)); } else { _if_result_6 = (content); } _if_result_6; });
-    ctx_body = el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(ctx_body, EL_STR("- [")), label), EL_STR("]: ")), snippet), EL_STR("\n"));
-    i = (i + 1);
-  }
-  el_val_t full_ctx = el_str_concat(ctx, ctx_body);
-  return el_str_concat(el_str_concat(EL_STR("{\"ok\":true,\"context\":\""), str_replace(str_replace(str_replace(full_ctx, EL_STR("\\"), EL_STR("\\\\")), EL_STR("\""), EL_STR("\\\"")), EL_STR("\n"), EL_STR("\\n"))), EL_STR("\"}"));
-  return 0;
-}
-
-el_val_t route_neuron_memory(el_val_t method, el_val_t path, el_val_t body) {
-  el_val_t content = json_get_string(body, EL_STR("content"));
-  if (str_eq(content, EL_STR(""))) {
-    return EL_STR("{\"error\":\"content is required\"}");
-  }
-  el_val_t node_type = json_get_string(body, EL_STR("node_type"));
-  if (str_eq(node_type, EL_STR(""))) {
-    node_type = EL_STR("Memory");
-  }
-  el_val_t label = json_get_string(body, EL_STR("label"));
-  el_val_t importance = json_get_string(body, EL_STR("importance"));
-  el_val_t project = json_get_string(body, EL_STR("project"));
-  el_val_t tags_raw = json_get_string(body, EL_STR("tags"));
-  el_val_t tier = EL_STR("Episodic");
-  if (str_eq(importance, EL_STR("critical"))) {
-    tier = EL_STR("Procedural");
-  }
-  if (str_eq(importance, EL_STR("high"))) {
-    tier = EL_STR("Semantic");
-  }
-  if (str_eq(importance, EL_STR("normal"))) {
-    tier = EL_STR("Episodic");
-  }
-  if (str_eq(importance, EL_STR("low"))) {
-    tier = EL_STR("Working");
-  }
-  el_val_t explicit_tier = json_get_string(body, EL_STR("tier"));
-  if (!str_eq(explicit_tier, EL_STR(""))) {
-    tier = explicit_tier;
-  }
-  el_val_t tags_str = tags_raw;
-  if (!str_eq(project, EL_STR(""))) {
-    if (str_eq(tags_str, EL_STR(""))) {
-      tags_str = el_str_concat(EL_STR("project:"), project);
-    }
-    if (!str_eq(tags_str, EL_STR(""))) {
-      tags_str = el_str_concat(el_str_concat(tags_str, EL_STR(" project:")), project);
-    }
-  }
-  el_val_t id = engram_node_full(content, node_type, label, el_from_float(0.5), el_from_float(0.5), el_from_float(1.0), tier, tags_str);
-  el_val_t auto_linked = auto_link_content_node(id, content);
-  el_val_t dir = env(EL_STR("ENGRAM_DATA_DIR"));
-  if (str_eq(dir, EL_STR(""))) {
-    dir = EL_STR("/tmp/engram");
-  }
-  el_val_t db_path = el_str_concat(dir, EL_STR("/engram.db"));
-  engram_write_binary_el(db_path);
-  return el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"ok\":true,\"id\":\""), id), EL_STR("\",\"auto_linked\":")), int_to_str(auto_linked)), EL_STR(",\"content\":\"")), str_replace(str_replace(content, EL_STR("\\"), EL_STR("\\\\")), EL_STR("\""), EL_STR("\\\""))), EL_STR("\"}"));
-  return 0;
-}
-
-el_val_t route_neuron_knowledge_capture(el_val_t method, el_val_t path, el_val_t body) {
-  el_val_t content = json_get_string(body, EL_STR("content"));
-  if (str_eq(content, EL_STR(""))) {
-    return EL_STR("{\"error\":\"content is required\"}");
-  }
-  el_val_t title = json_get_string(body, EL_STR("title"));
-  el_val_t category = json_get_string(body, EL_STR("category"));
-  el_val_t tags_raw = json_get_string(body, EL_STR("tags"));
-  el_val_t project = json_get_string(body, EL_STR("project"));
-  el_val_t tier_raw = json_get_string(body, EL_STR("tier"));
-  el_val_t tier = EL_STR("Episodic");
-  if (str_eq(tier_raw, EL_STR("lesson"))) {
-    tier = EL_STR("Semantic");
-  }
-  if (str_eq(tier_raw, EL_STR("canonical"))) {
-    tier = EL_STR("Procedural");
-  }
-  if (str_eq(tier_raw, EL_STR("note"))) {
-    tier = EL_STR("Episodic");
-  }
-  el_val_t tags_str = tags_raw;
-  if (!str_eq(category, EL_STR(""))) {
-    if (str_eq(tags_str, EL_STR(""))) {
-      tags_str = el_str_concat(EL_STR("category:"), category);
-    }
-    if (!str_eq(tags_str, EL_STR(""))) {
-      tags_str = el_str_concat(el_str_concat(tags_str, EL_STR(" category:")), category);
-    }
-  }
-  if (!str_eq(project, EL_STR(""))) {
-    if (str_eq(tags_str, EL_STR(""))) {
-      tags_str = el_str_concat(EL_STR("project:"), project);
-    }
-    if (!str_eq(tags_str, EL_STR(""))) {
-      tags_str = el_str_concat(el_str_concat(tags_str, EL_STR(" project:")), project);
-    }
-  }
-  el_val_t id = engram_node_full(content, EL_STR("Knowledge"), title, el_from_float(0.7), el_from_float(0.7), el_from_float(1.0), tier, tags_str);
-  el_val_t auto_linked = auto_link_content_node(id, content);
-  el_val_t dir = env(EL_STR("ENGRAM_DATA_DIR"));
-  if (str_eq(dir, EL_STR(""))) {
-    dir = EL_STR("/tmp/engram");
-  }
-  el_val_t db_path = el_str_concat(dir, EL_STR("/engram.db"));
-  engram_write_binary_el(db_path);
-  return el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"ok\":true,\"id\":\""), id), EL_STR("\",\"auto_linked\":")), int_to_str(auto_linked)), EL_STR("}"));
-  return 0;
-}
-
-el_val_t route_neuron_knowledge_evolve(el_val_t method, el_val_t path, el_val_t body) {
-  el_val_t content = json_get_string(body, EL_STR("content"));
-  el_val_t prior_id = json_get_string(body, EL_STR("id"));
-  if (str_eq(content, EL_STR(""))) {
-    return EL_STR("{\"ok\":true}");
-  }
-  el_val_t id = engram_node_full(content, EL_STR("Knowledge"), EL_STR(""), el_from_float(0.7), el_from_float(0.7), el_from_float(1.0), EL_STR("Semantic"), EL_STR("evolved"));
-  if (!str_eq(prior_id, EL_STR("")) && !str_eq(id, EL_STR(""))) {
-    engram_connect(id, prior_id, el_from_float(1.0), EL_STR("supersedes"));
-  }
-  el_val_t dir = env(EL_STR("ENGRAM_DATA_DIR"));
-  if (str_eq(dir, EL_STR(""))) {
-    dir = EL_STR("/tmp/engram");
-  }
-  engram_write_binary_el(el_str_concat(dir, EL_STR("/engram.db")));
-  return el_str_concat(el_str_concat(EL_STR("{\"ok\":true,\"id\":\""), id), EL_STR("\"}"));
-  return 0;
-}
-
-el_val_t route_neuron_knowledge_promote(el_val_t method, el_val_t path, el_val_t body) {
-  el_val_t id = json_get_string(body, EL_STR("id"));
-  if (str_eq(id, EL_STR(""))) {
-    return EL_STR("{\"ok\":true}");
-  }
-  el_val_t node_json = engram_get_node_json(id);
-  if (str_eq(node_json, EL_STR(""))) {
-    return err_json(EL_STR("node not found"));
-  }
-  if (str_eq(node_json, EL_STR("null"))) {
-    return err_json(EL_STR("node not found"));
-  }
-  el_val_t content = json_get_string(node_json, EL_STR("content"));
-  if (str_eq(content, EL_STR(""))) {
-    return err_json(EL_STR("node has no content"));
-  }
-  el_val_t label = json_get_string(node_json, EL_STR("label"));
-  el_val_t tags = json_get_string(node_json, EL_STR("tags"));
-  el_val_t current_tier = json_get_string(node_json, EL_STR("tier"));
-  el_val_t tier_raw = json_get_string(body, EL_STR("tier"));
-  el_val_t new_tier = EL_STR("");
-  if (str_eq(tier_raw, EL_STR("lesson"))) {
-    new_tier = EL_STR("Semantic");
-  }
-  if (str_eq(tier_raw, EL_STR("canonical"))) {
-    new_tier = EL_STR("Procedural");
-  }
-  if (str_eq(tier_raw, EL_STR("note"))) {
-    new_tier = EL_STR("Episodic");
-  }
-  if (str_eq(new_tier, EL_STR(""))) {
-    if (str_eq(current_tier, EL_STR("Working"))) {
-      new_tier = EL_STR("Episodic");
-    }
-    if (str_eq(current_tier, EL_STR("Episodic"))) {
-      new_tier = EL_STR("Semantic");
-    }
-    if (str_eq(current_tier, EL_STR("Semantic"))) {
-      new_tier = EL_STR("Procedural");
-    }
-    if (str_eq(current_tier, EL_STR("Procedural"))) {
-      new_tier = EL_STR("Procedural");
-    }
-  }
-  if (str_eq(new_tier, EL_STR(""))) {
-    new_tier = EL_STR("Semantic");
-  }
-  el_val_t new_id = engram_node_full(content, EL_STR("Knowledge"), label, el_from_float(0.7), el_from_float(0.8), el_from_float(1.0), new_tier, tags);
-  if (!str_eq(new_id, EL_STR(""))) {
-    engram_connect(new_id, id, el_from_float(1.0), EL_STR("supersedes"));
-  }
-  el_val_t dir = env(EL_STR("ENGRAM_DATA_DIR"));
-  if (str_eq(dir, EL_STR(""))) {
-    dir = EL_STR("/tmp/engram");
-  }
-  engram_write_binary_el(el_str_concat(dir, EL_STR("/engram.db")));
-  return el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"ok\":true,\"id\":\""), new_id), EL_STR("\",\"promoted_from\":\"")), id), EL_STR("\",\"tier\":\"")), new_tier), EL_STR("\"}"));
-  return 0;
-}
-
-el_val_t route_neuron_recall(el_val_t method, el_val_t path, el_val_t body) {
-  el_val_t query = json_get_string(body, EL_STR("query"));
-  el_val_t chain = json_get_string(body, EL_STR("chain_name"));
-  el_val_t limit = json_get_int(body, EL_STR("limit"));
-  if (limit == 0) {
-    limit = 20;
-  }
-  el_val_t q = ({ el_val_t _if_result_7 = 0; if (str_eq(query, EL_STR(""))) { _if_result_7 = (chain); } else { _if_result_7 = (query); } _if_result_7; });
-  if (str_eq(q, EL_STR(""))) {
-    return engram_scan_nodes_json(limit, 0);
-  }
-  return bm25_search_json(q, limit);
-  return 0;
-}
-
-el_val_t route_neuron_graph(el_val_t method, el_val_t path, el_val_t body) {
-  el_val_t id = query_param(path, EL_STR("id"));
-  if (str_eq(id, EL_STR(""))) {
-    return EL_STR("{\"error\":\"id is required\"}");
-  }
-  el_val_t node_json = engram_get_node_json(id);
-  return el_str_concat(el_str_concat(EL_STR("{\"ok\":true,\"node\":"), node_json), EL_STR(",\"neighbors\":[]}"));
-  return 0;
-}
-
-el_val_t route_neuron_graph_link(el_val_t method, el_val_t path, el_val_t body) {
-  el_val_t from_id = json_get_string(body, EL_STR("from_id"));
-  el_val_t to_id = json_get_string(body, EL_STR("to_id"));
-  if (str_eq(from_id, EL_STR("")) || str_eq(to_id, EL_STR(""))) {
-    return EL_STR("{\"error\":\"from_id and to_id are required\"}");
-  }
-  el_val_t relation = json_get_string(body, EL_STR("relation"));
-  if (str_eq(relation, EL_STR(""))) {
-    relation = EL_STR("related");
-  }
-  el_val_t weight = json_get_float(body, EL_STR("weight"));
-  if (str_eq(weight, el_from_float(0.0))) {
-    weight = el_from_float(0.5);
-  }
-  engram_connect(from_id, to_id, weight, relation);
-  return el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"ok\":true,\"from_id\":\""), from_id), EL_STR("\",\"to_id\":\"")), to_id), EL_STR("\",\"relation\":\"")), relation), EL_STR("\"}"));
-  return 0;
-}
-
-el_val_t route_neuron_list(el_val_t method, el_val_t path, el_val_t body) {
-  el_val_t clean = strip_query(path);
-  el_val_t prefix = EL_STR("/api/neuron/list/");
-  el_val_t node_type = str_slice(clean, str_len(prefix), str_len(clean));
-  el_val_t limit = query_int(path, EL_STR("limit"), 50);
-  if (str_eq(node_type, EL_STR(""))) {
-    return EL_STR("[]");
-  }
-  return engram_scan_nodes_by_type_json(node_type, limit, 0);
-  return 0;
-}
-
-el_val_t route_neuron_consolidate(el_val_t method, el_val_t path, el_val_t body) {
-  el_val_t dir = env(EL_STR("ENGRAM_DATA_DIR"));
-  if (str_eq(dir, EL_STR(""))) {
-    dir = EL_STR("/tmp/engram");
-  }
-  el_val_t db_path = el_str_concat(dir, EL_STR("/engram.db"));
-  engram_write_binary_el(db_path);
-  el_val_t nc = engram_node_count();
-  el_val_t ec = engram_edge_count();
-  return el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"ok\":true,\"node_count\":"), int_to_str(nc)), EL_STR(",\"edge_count\":")), int_to_str(ec)), EL_STR("}"));
-  return 0;
-}
-
-el_val_t route_neuron_config(el_val_t method, el_val_t path, el_val_t body) {
-  el_val_t key = query_param(path, EL_STR("key"));
-  return el_str_concat(el_str_concat(EL_STR("{\"key\":\""), key), EL_STR("\",\"value\":\"\"}"));
-  return 0;
-}
-
-el_val_t route_neuron_state_events(el_val_t method, el_val_t path, el_val_t body) {
-  if (str_eq(method, EL_STR("GET"))) {
-    el_val_t limit_str = query_param(path, EL_STR("limit"));
-    el_val_t limit = ({ el_val_t _if_result_8 = 0; if (str_eq(limit_str, EL_STR(""))) { _if_result_8 = (50); } else { _if_result_8 = (str_to_int(limit_str)); } _if_result_8; });
-    el_val_t offset_str = query_param(path, EL_STR("offset"));
-    el_val_t offset = ({ el_val_t _if_result_9 = 0; if (str_eq(offset_str, EL_STR(""))) { _if_result_9 = (0); } else { _if_result_9 = (str_to_int(offset_str)); } _if_result_9; });
-    return engram_scan_nodes_by_type_json(EL_STR("InternalStateEvent"), limit, offset);
-  }
-  el_val_t content = json_get_string(body, EL_STR("content"));
-  if (str_eq(content, EL_STR(""))) {
-    content = body;
-  }
-  el_val_t event_label = json_get_string(content, EL_STR("event"));
-  el_val_t label = ({ el_val_t _if_result_10 = 0; if (str_eq(event_label, EL_STR(""))) { _if_result_10 = (EL_STR("state-event")); } else { _if_result_10 = (event_label); } _if_result_10; });
-  el_val_t id = engram_node_full(content, EL_STR("InternalStateEvent"), label, el_from_float(0.3), el_from_float(0.3), el_from_float(1.0), EL_STR("Working"), EL_STR("internal-state"));
-  return el_str_concat(el_str_concat(EL_STR("{\"ok\":true,\"id\":\""), id), EL_STR("\"}"));
-  return 0;
-}
-
-el_val_t route_neuron_processes(el_val_t method, el_val_t path, el_val_t body) {
-  return EL_STR("{\"ok\":true,\"processes\":[]}");
-  return 0;
-}
-
-el_val_t route_events_next(el_val_t method, el_val_t path, el_val_t body) {
-  return EL_STR("{\"ok\":true,\"event\":null}");
-  return 0;
-}
-
-el_val_t route_events_ack(el_val_t method, el_val_t path, el_val_t body) {
-  return EL_STR("{\"ok\":true}");
-  return 0;
-}
-
-el_val_t route_bm25_search(el_val_t method, el_val_t path, el_val_t body) {
-  el_val_t q = EL_STR("");
-  if (str_eq(method, EL_STR("GET"))) {
-    q = query_param(path, EL_STR("q"));
-  } else {
-    q = json_get_string(body, EL_STR("query"));
-  }
-  if (str_eq(q, EL_STR(""))) {
-    return EL_STR("{\"error\":\"query is required\"}");
-  }
-  el_val_t limit = query_int(path, EL_STR("limit"), 20);
-  if (limit == 0) {
-    limit = json_get_int(body, EL_STR("limit"));
-  }
-  if (limit == 0) {
-    limit = 20;
-  }
-  return bm25_search_json(q, limit);
-  return 0;
-}
-
 el_val_t check_auth_ok(el_val_t method, el_val_t body) {
  el_val_t key = env(EL_STR("ENGRAM_API_KEY"));
  if (str_eq(key, EL_STR(""))) {
@@ -900,60 +299,6 @@ el_val_t handle_request(el_val_t method, el_val_t path, el_val_t body) {
      return route_health(method, path, body);
    }
  }
-  if (str_starts_with(clean, EL_STR("/api/neuron/")) || str_starts_with(clean, EL_STR("/events/"))) {
-    if (str_eq(clean, EL_STR("/api/neuron/session/begin"))) {
-      return route_neuron_session_begin(method, path, body);
-    }
-    if (str_eq(clean, EL_STR("/api/neuron/ctx"))) {
-      return route_neuron_ctx(method, path, body);
-    }
-    if (str_eq(clean, EL_STR("/api/neuron/memory"))) {
-      return route_neuron_memory(method, path, body);
-    }
-    if (str_eq(clean, EL_STR("/api/neuron/knowledge/capture"))) {
-      return route_neuron_knowledge_capture(method, path, body);
-    }
-    if (str_eq(clean, EL_STR("/api/neuron/knowledge/evolve"))) {
-      return route_neuron_knowledge_evolve(method, path, body);
-    }
-    if (str_eq(clean, EL_STR("/api/neuron/knowledge/promote"))) {
-      return route_neuron_knowledge_promote(method, path, body);
-    }
-    if (str_eq(clean, EL_STR("/api/neuron/recall"))) {
-      return route_neuron_recall(method, path, body);
-    }
-    if (str_eq(clean, EL_STR("/api/neuron/graph/link"))) {
-      return route_neuron_graph_link(method, path, body);
-    }
-    if (str_eq(clean, EL_STR("/api/neuron/graph"))) {
-      return route_neuron_graph(method, path, body);
-    }
-    if (str_starts_with(clean, EL_STR("/api/neuron/list/"))) {
-      return route_neuron_list(method, path, body);
-    }
-    if (str_eq(clean, EL_STR("/api/neuron/consolidate"))) {
-      return route_neuron_consolidate(method, path, body);
-    }
-    if (str_eq(clean, EL_STR("/api/neuron/config"))) {
-      return route_neuron_config(method, path, body);
-    }
-    if (str_eq(clean, EL_STR("/api/neuron/state-events"))) {
-      return route_neuron_state_events(method, path, body);
-    }
-    if (str_eq(clean, EL_STR("/api/neuron/processes/define"))) {
-      return route_neuron_processes(method, path, body);
-    }
-    if (str_eq(clean, EL_STR("/api/neuron/processes"))) {
-      return route_neuron_processes(method, path, body);
-    }
-    if (str_eq(clean, EL_STR("/events/next"))) {
-      return route_events_next(method, path, body);
-    }
-    if (str_eq(clean, EL_STR("/events/ack"))) {
-      return route_events_ack(method, path, body);
-    }
-    return err_json(EL_STR("not found"));
-  }
  if (!check_auth_ok(method, body)) {
    return err_json(EL_STR("unauthorized"));
  }
@@ -993,80 +338,15 @@ el_val_t handle_request(el_val_t method, el_val_t path, el_val_t body) {
  if (str_eq(method, EL_STR("GET")) && str_starts_with(clean, EL_STR("/api/search"))) {
    return route_search(method, path, body);
  }
-  if (str_eq(clean, EL_STR("/api/bm25/search"))) {
-    return route_bm25_search(method, path, body);
-  }
  if (str_eq(method, EL_STR("POST")) && (str_eq(clean, EL_STR("/api/strengthen")) || str_eq(clean, EL_STR("/strengthen")))) {
    return route_strengthen(method, path, body);
  }
-  if (str_eq(method, EL_STR("POST")) && ((str_eq(clean, EL_STR("/api/decay")) || str_eq(clean, EL_STR("/api/maintenance"))) || str_eq(clean, EL_STR("/decay")))) {
-    return route_decay(method, path, body);
-  }
-  if (str_eq(method, EL_STR("POST")) && (str_eq(clean, EL_STR("/api/export")) || str_eq(clean, EL_STR("/export")))) {
-    return route_export(method, path, body);
-  }
  if (str_eq(method, EL_STR("POST")) && (str_eq(clean, EL_STR("/api/save")) || str_eq(clean, EL_STR("/save")))) {
-    return route_export(method, path, body);
+    return route_save(method, path, body);
  }
  if (str_eq(method, EL_STR("POST")) && (str_eq(clean, EL_STR("/api/load")) || str_eq(clean, EL_STR("/load")))) {
    return route_load(method, path, body);
  }
-  if (str_eq(method, EL_STR("POST")) && (str_eq(clean, EL_STR("/api/reindex")) || str_eq(clean, EL_STR("/reindex")))) {
-    return route_reindex(method, path, body);
-  }
-  if (str_starts_with(clean, EL_STR("/api/neuron/"))) {
-    if (str_eq(clean, EL_STR("/api/neuron/session/begin"))) {
-      return route_neuron_session_begin(method, path, body);
-    }
-    if (str_eq(clean, EL_STR("/api/neuron/ctx"))) {
-      return route_neuron_ctx(method, path, body);
-    }
-    if (str_eq(clean, EL_STR("/api/neuron/memory"))) {
-      return route_neuron_memory(method, path, body);
-    }
-    if (str_eq(clean, EL_STR("/api/neuron/knowledge/capture"))) {
-      return route_neuron_knowledge_capture(method, path, body);
-    }
-    if (str_eq(clean, EL_STR("/api/neuron/knowledge/evolve"))) {
-      return route_neuron_knowledge_evolve(method, path, body);
-    }
-    if (str_eq(clean, EL_STR("/api/neuron/knowledge/promote"))) {
-      return route_neuron_knowledge_promote(method, path, body);
-    }
-    if (str_eq(clean, EL_STR("/api/neuron/recall"))) {
-      return route_neuron_recall(method, path, body);
-    }
-    if (str_eq(clean, EL_STR("/api/neuron/graph/link"))) {
-      return route_neuron_graph_link(method, path, body);
-    }
-    if (str_eq(clean, EL_STR("/api/neuron/graph"))) {
-      return route_neuron_graph(method, path, body);
-    }
-    if (str_starts_with(clean, EL_STR("/api/neuron/list/"))) {
-      return route_neuron_list(method, path, body);
-    }
-    if (str_eq(clean, EL_STR("/api/neuron/consolidate"))) {
-      return route_neuron_consolidate(method, path, body);
-    }
-    if (str_eq(clean, EL_STR("/api/neuron/config"))) {
-      return route_neuron_config(method, path, body);
-    }
-    if (str_eq(clean, EL_STR("/api/neuron/state-events"))) {
-      return route_neuron_state_events(method, path, body);
-    }
-    if (str_eq(clean, EL_STR("/api/neuron/processes/define"))) {
-      return route_neuron_processes(method, path, body);
-    }
-    if (str_eq(clean, EL_STR("/api/neuron/processes"))) {
-      return route_neuron_processes(method, path, body);
-    }
-  }
-  if (str_eq(clean, EL_STR("/events/next"))) {
-    return route_events_next(method, path, body);
-  }
-  if (str_eq(clean, EL_STR("/events/ack"))) {
-    return route_events_ack(method, path, body);
-  }
  return el_str_concat(el_str_concat(EL_STR("{\"error\":\"not found\",\"path\":\""), clean), EL_STR("\"}"));
  return 0;
 }
@@ -1082,20 +362,9 @@ int main(int _argc, char** _argv) {
  if (str_eq(data_dir, EL_STR(""))) {
    data_dir = EL_STR("/tmp/engram");
  }
-  db_path = el_str_concat(data_dir, EL_STR("/engram.db"));
-  loaded = engram_load_binary_el(db_path);
-  if (!loaded) {
-    engram_load_dir(data_dir);
-    if (engram_node_count() == 0) {
-      el_val_t snapshot_path = el_str_concat(data_dir, EL_STR("/snapshot.json"));
-      engram_load(snapshot_path);
-    }
-    if (engram_node_count() > 0) {
-      engram_write_binary_el(db_path);
-      println(EL_STR("[engram] migrated legacy data to binary format"));
-    }
-  }
-  println(EL_STR("[engram] runtime-native graph engine (ML-KEM-1024 encrypted)"));
+  snapshot_path = el_str_concat(data_dir, EL_STR("/snapshot.json"));
+  engram_load(snapshot_path);
+  println(EL_STR("[engram] runtime-native graph engine"));
  println(el_str_concat(EL_STR("[engram] data_dir="), data_dir));
  println(el_str_concat(EL_STR("[engram] node_count="), int_to_str(engram_node_count())));
  println(el_str_concat(EL_STR("[engram] edge_count="), int_to_str(engram_edge_count())));
@@ -6,297 +6,15 @@
 // database.
 //
 // Built and linked with:
-//   elc src/server.el > ../dist/engram.c
-//   cc -std=c11 -O2 \
-//     -I/Users/will/Development/neuron-technologies/foundation/el/lang/releases/v1.0.0-20260501 \
-//     -I/opt/homebrew/Cellar/liboqs/0.15.0/include \
-//     -I/opt/homebrew/opt/openssl@3/include \
-//     -L/opt/homebrew/Cellar/liboqs/0.15.0/lib \
-//     -L/opt/homebrew/opt/openssl@3/lib \
-//     -lcurl -lpthread -loqs -lssl -lcrypto \
-//     -o ../dist/engram ../dist/engram.c \
-//     /Users/will/Development/neuron-technologies/foundation/el/lang/releases/v1.0.0-20260501/el_runtime.c
-//   ./dist/engram
+//   elc src/server.el > server.c
+//   cc -std=c11 -O2 -lcurl -lpthread -o engram server.c el_runtime.c
+//   ./engram
 //
 // Configuration via environment:
 //   ENGRAM_BIND       — host:port (default :8742)
 //   ENGRAM_API_KEY    — bearer auth (optional)
 //   ENGRAM_DATA_DIR   — snapshot location (default ~/.neuron/engram)

-// ── BM25+ text ranking ────────────────────────────────────────────────────────
-//
-// Implements BM25+ (Lv & Zhai 2011) for in-process keyword search over the
-// engram node store. No external dependencies — pure EL, zero Ollama calls.
-//
-// Parameters: k1=1.2, b=0.75, delta=1.0
-//
-// V1 simplification: n(t) (number of docs containing term t) is approximated
-// as 1 for all terms. This collapses IDF to a constant per corpus size:
-//   IDF = ln((N - 1 + 0.5) / (1 + 0.5) + 1)  =  ln((N + 0.5) / 1.5 + 1)
-// Scoring effectively becomes TF-length-normalised BM25+ (delta term present).
-// Acceptable for V1; a real inverted index can replace this later.
-
-fn bm25_tokenize(text: String) -> String {
-    // Lowercase and strip punctuation (replace with spaces), then trim.
-    let t: String = str_to_lower(text)
-    let t = str_replace(t, ".", " ")
-    let t = str_replace(t, ",", " ")
-    let t = str_replace(t, "!", " ")
-    let t = str_replace(t, "?", " ")
-    let t = str_replace(t, "\"", " ")
-    let t = str_replace(t, ":", " ")
-    let t = str_replace(t, ";", " ")
-    let t = str_replace(t, "(", " ")
-    let t = str_replace(t, ")", " ")
-    let t = str_replace(t, "[", " ")
-    let t = str_replace(t, "]", " ")
-    let t = str_replace(t, "{", " ")
-    let t = str_replace(t, "}", " ")
-    let t = str_replace(t, "/", " ")
-    let t = str_replace(t, "\\", " ")
-    let t = str_replace(t, "'", " ")
-    let t = str_replace(t, "-", " ")
-    let t = str_replace(t, "_", " ")
-    let t = str_replace(t, "+", " ")
-    str_trim(t)
-}
-
-fn bm25_count_term(term: String, doc_tokens: String) -> Int {
-    // Pad with spaces to avoid prefix/suffix partial matches.
-    let padded_term: String = " " + term + " "
-    let padded_doc: String  = " " + doc_tokens + " "
-    str_count(padded_doc, padded_term)
-}
-
-fn bm25_score_doc(doc_content: String, query_tokens: String, corpus_size: Int, avg_doc_len: String) -> String {
-    // BM25+ parameters (stored as strings = float-encoded el_val_t from el_from_float)
-    // We use float_add/float_mul/float_div builtins to avoid EL operator issues.
-    // avg_doc_len is passed as a String slot holding an el_val_t float bit-pattern.
-    // (EL has no safe float-passing convention; we work around using str_to_float.)
-    //
-    // V1: n_t=1 for all terms. IDF = ln((N+0.5)/1.5 + 1) = constant per corpus.
-    // This collapses BM25+ to TF-length-normalised scoring — acceptable for V1.
-    let k1: Float = 1.2
-    let b: Float  = 0.75
-    let delta: Float = 1.0
-
-    let doc_tokens: String = bm25_tokenize(doc_content)
-    let doc_wc: Int = str_count_words(doc_tokens)
-    if doc_wc == 0 { return "0.0" }
-
-    let doc_len: Float = int_to_float(doc_wc)
-    let avg_len: Float = str_to_float(avg_doc_len)
-
-    // IDF constant
-    let N: Float = int_to_float(corpus_size)
-    // (N + 0.5) / 1.5 + 1.0
-    let idf_arg: Float = float_add(float_div(float_add(N, 1.2), 1.5), 1.0)
-    let idf: Float = math_log(idf_arg)
-
-    // Sum TF component over query terms
-    let terms: List = str_split(query_tokens, " ")
-    let n_terms: Int = len(terms)
-    let score: Float = 0.0
-    let i: Int = 0
-    while i < n_terms {
-        let term: String = get(terms, i)
-        let tlen: Int = str_len(term)
-        if tlen >= 2 {
-            let tf_count: Int = bm25_count_term(term, doc_tokens)
-            if tf_count > 0 {
-                let tf_raw: Float = int_to_float(tf_count)
-                // norm_factor = 1 - b + b * doc_len / avg_len
-                let norm_factor: Float = float_add(float_sub(1.0, b), float_div(float_mul(b, doc_len), avg_len))
-                // tf_comp = delta + tf * (k1+1) / (tf + k1*norm)
-                let numerator: Float = float_mul(tf_raw, float_add(k1, 1.0))
-                let denominator: Float = float_add(tf_raw, float_mul(k1, norm_factor))
-                let tf_comp: Float = float_add(delta, float_div(numerator, denominator))
-                let score = float_add(score, float_mul(idf, tf_comp))
-            }
-        }
-        let i = i + 1
-    }
-    // Return score as a string so it survives EL's lack of float-in-list support
-    float_to_str(score)
-}
-
-fn bm25_search_json(query: String, limit: Int) -> String {
-    // 1. Determine scan size: floor at 200 so small `limit` values still scan
-    // enough of the corpus to find relevant nodes.
-    // Cap raised from 500 → 5000 (2026-05-24 self-review): 500 was 0.3% of the
-    // 161K-node corpus. At 5000 we cover the top-3% by salience — still fast
-    // (pure C scan, no Ollama calls) and 10x better recall for content search.
-    // engram_scan_nodes_json returns nodes sorted by salience DESC, so ISEs
-    // (salience 0.3) naturally fall below Knowledge/Memory (0.5–0.8), keeping
-    // the effective search corpus content-dense.
-    let scan_limit: Int = limit * 10
-    if scan_limit < 200 { let scan_limit = 200 }
-    if scan_limit > 5000 { let scan_limit = 5000 }
-
-    // 2. Fetch node sample
-    let nodes_json: String = engram_scan_nodes_json(scan_limit, 0)
-    let n: Int = json_array_len(nodes_json)
-    if n == 0 { return "[]" }
-
-    // 3. Compute avg_doc_len from sample
-    let total_words: Int = 0
-    let i: Int = 0
-    while i < n {
-        let node: String = json_array_get(nodes_json, i)
-        let content: String = json_get_string(node, "content")
-        let tokens: String = bm25_tokenize(content)
-        let wc: Int = str_count_words(tokens)
-        let total_words = total_words + wc
-        let i = i + 1
-    }
-    // avg_doc_len as string for safe float passing
-    let avg_doc_len_f: Float = float_div(int_to_float(total_words), int_to_float(n))
-    let avg_doc_len: String = if float_gt(avg_doc_len_f, 0.0) { float_to_str(avg_doc_len_f) } else { "1.0" }
-
-    // 4. Tokenize query
-    let query_tokens: String = bm25_tokenize(query)
-    if str_eq(str_trim(query_tokens), "") { return "[]" }
-
-    // 5. Score each node; collect results as parallel JSON and score lists.
-    // Scores are stored as strings (float_to_str) to avoid float-in-list issues.
-    let result_nodes: List = 0
-    let result_scores: List = 0
-    let result_count: Int = 0
-    let j: Int = 0
-    while j < n {
-        let node: String = json_array_get(nodes_json, j)
-        let content: String = json_get_string(node, "content")
-        let sc_str: String = bm25_score_doc(content, query_tokens, n, avg_doc_len)
-        // Only include nodes with score > 0.0 (use float comparison, not string match —
-        // float_to_str(0.0) returns "0.000000", not "0.0").
-        if float_gt(str_to_float(sc_str), 0.0) {
-            let result_nodes = list_push(result_nodes, node)
-            let result_scores = list_push(result_scores, sc_str)
-            let result_count = result_count + 1
-        }
-        let j = j + 1
-    }
-
-    if result_count == 0 { return "[]" }
-
-    // 6. Selection-sort descending by score, take top `limit`
-    let out_limit: Int = if result_count < limit { result_count } else { limit }
-    let k: Int = 0
-    while k < out_limit {
-        // Find max score index in [k, result_count)
-        let max_idx: Int = k
-        let max_sc_str: String = get(result_scores, k)
-        let max_sc_f: Float = str_to_float(max_sc_str)
-        let p: Int = k + 1
-        while p < result_count {
-            let sc2_str: String = get(result_scores, p)
-            let sc2_f: Float = str_to_float(sc2_str)
-            if float_gt(sc2_f, max_sc_f) {
-                let max_sc_f = sc2_f
-                let max_sc_str = sc2_str
-                let max_idx = p
-            }
-            let p = p + 1
-        }
-        // Swap k <-> max_idx
-        if max_idx != k {
-            let tmp_node: String = get(result_nodes, k)
-            let tmp_sc: String   = get(result_scores, k)
-            let result_nodes  = list_set(result_nodes,  k,       get(result_nodes,  max_idx))
-            let result_scores = list_set(result_scores, k,       get(result_scores, max_idx))
-            let result_nodes  = list_set(result_nodes,  max_idx, tmp_node)
-            let result_scores = list_set(result_scores, max_idx, tmp_sc)
-        }
-        let k = k + 1
-    }
-
-    // 7. Build JSON array of top `out_limit` nodes with bm25_score field
-    let out: String = "["
-    let r: Int = 0
-    while r < out_limit {
-        let node: String = get(result_nodes, r)
-        let sc_str: String = get(result_scores, r)
-        // Inject bm25_score: trim the closing } and append field
-        let node_len: Int = str_len(node)
-        let node_body: String = str_slice(node, 0, node_len - 1)
-        let entry: String = node_body + ",\"bm25_score\":" + sc_str + "}"
-        if r > 0 { let out = out + "," }
-        let out = out + entry
-        let r = r + 1
-    }
-    out + "]"
-}
-
-// ── Auto-linking ─────────────────────────────────────────────────────────────
-//
-// auto_link_content_node — link a newly-created Knowledge or Memory node to
-// semantically related non-ISE nodes via BM25 search.
-//
-// Problem it solves: route_neuron_memory and route_neuron_knowledge_capture
-// both call engram_node_full directly, creating nodes with zero edges. With
-// 14K+ ISEs dominating the corpus, BFS traversal contributes nothing — every
-// query relies solely on lexical/semantic seed matching. Auto-linking builds
-// explicit "related" edges so activated knowledge nodes fan out to connected
-// neighbors during BFS.
-//
-// Design choices:
-//   - BM25 (not substring search): ranks by relevance, not just occurrence
-//   - Skip InternalStateEvent nodes: ISEs dominate the corpus and are not
-//     useful link targets for knowledge/memory nodes
-//   - Up to 3 edges per node: enough to build graph structure without over-linking
-//   - weight=0.6: moderately strong; causal edges (field-validated at 2.0) are
-//     much stronger, so these "related" edges don't flood activation paths
-//   - state_set for linked counter: EL `let` in nested if-blocks creates inner
-//     scope only; state_set persists across block boundaries (2026-05-25 lesson)
-//
-// (2026-05-28 self-review)
-fn auto_link_content_node(node_id: String, content: String) -> Int {
-    let clen: Int = str_len(content)
-    if clen < 20 { return 0 }
-
-    // Find search term: first word >= 5 chars, or second word.
-    let sp1: Int = str_index_of(content, " ")
-    let w1end: Int = if sp1 < 0 { clen } else { sp1 }
-    let word1: String = str_slice(content, 0, w1end)
-    state_set("aln_term", "")
-    if str_len(word1) >= 5 {
-        state_set("aln_term", word1)
-    }
-    if str_eq(state_get("aln_term"), "") {
-        if sp1 >= 0 {
-            let rest: String = str_slice(content, sp1 + 1, clen)
-            let sp2: Int = str_index_of(rest, " ")
-            let w2end: Int = if sp2 < 0 { str_len(rest) } else { sp2 }
-            let word2: String = str_slice(rest, 0, w2end)
-            if str_len(word2) >= 5 {
-                state_set("aln_term", word2)
-            }
-        }
-    }
-    let search_term: String = state_get("aln_term")
-    if str_eq(search_term, "") { return 0 }
-
-    // BM25 over top-20 results; skip ISE nodes; connect up to 3.
-    let results: String = bm25_search_json(search_term, 20)
-    let n: Int = json_array_len(results)
-    state_set("aln_linked", "0")
-    let i: Int = 0
-    while i < n {
-        let linked_so_far: Int = str_to_int(state_get("aln_linked"))
-        if linked_so_far < 3 {
-            let elem: String = json_array_get(results, i)
-            let rid: String = json_get_string(elem, "id")
-            let rtype: String = json_get_string(elem, "node_type")
-            if !str_eq(rtype, "InternalStateEvent") && !str_eq(rid, "") && !str_eq(rid, node_id) {
-                engram_connect(node_id, rid, 0.6, "related")
-                state_set("aln_linked", int_to_str(linked_so_far + 1))
-            }
-        }
-        let i = i + 1
-    }
-    return str_to_int(state_get("aln_linked"))
-}
-
 // ── Helpers ───────────────────────────────────────────────────────────────────

 fn parse_port(bind: String) -> Int {
@@ -365,13 +83,7 @@ fn route_create_node(method: String, path: String, body: String) -> String {
    let salience: Float = json_get_float(body, "salience")
    if salience == 0.0 { let salience = 0.5 }
    let id: String = engram_node(content, node_type, salience)
-
-    // Auto-link via BM25 search — reuse auto_link_content_node which skips
-    // ISE nodes and links to up to 3 semantically related non-ISE nodes.
-    // Replaces the old inline substring-search auto-link (2026-05-29 cleanup).
-    let auto_linked: Int = auto_link_content_node(id, content)
-
-    "{\"id\":\"" + id + "\",\"content\":\"" + content + "\",\"node_type\":\"" + node_type + "\",\"auto_linked\":" + int_to_str(auto_linked) + "}"
+    "{\"id\":\"" + id + "\",\"content\":\"" + content + "\",\"node_type\":\"" + node_type + "\"}"
 }

 fn route_get_node(method: String, path: String, body: String) -> String {
@@ -419,7 +131,7 @@ fn route_search(method: String, path: String, body: String) -> String {
    let limit: Int = query_int(path, "limit", 20)
    if limit == 0 { let limit = json_get_int(body, "limit") }
    if limit == 0 { let limit = 20 }
-    return bm25_search_json(q, limit)
+    return engram_search_json(q, limit)
 }

 fn route_activate(method: String, path: String, body: String) -> String {
@@ -433,17 +145,6 @@ fn route_activate(method: String, path: String, body: String) -> String {
        let bd: Int = json_get_int(body, "depth")
        if bd > 0 { let depth = bd }
    }
-    // BM25 pre-bias: strengthen top-10 BM25 results before spreading activation
-    // so semantically relevant nodes already have elevated salience.
-    let top: String = bm25_search_json(q, 10)
-    let nb: Int = json_array_len(top)
-    let bi: Int = 0
-    while bi < nb {
-        let node: String = json_array_get(top, bi)
-        let nid: String = json_get_string(node, "id")
-        if !str_eq(nid, "") { engram_strengthen(nid) }
-        let bi = bi + 1
-    }
    return "{\"results\":" + engram_activate_json(q, depth) + "}"
 }

@@ -479,41 +180,25 @@ fn route_forget(method: String, path: String, body: String) -> String {
    ok_json()
 }

-fn route_decay(method: String, path: String, body: String) -> String {
-    engram_apply_decay_json()
-}
-
-fn route_export(method: String, path: String, body: String) -> String {
-    let dir: String = env("ENGRAM_DATA_DIR")
-    if str_eq(dir, "") { let dir = "/tmp/engram" }
-    // Write binary checkpoint
-    let db_path: String = dir + "/engram.db"
-    engram_write_binary_el(db_path)
-    // Also write JSON export for human inspection
+fn route_save(method: String, path: String, body: String) -> String {
    let p: String = json_get_string(body, "path")
    if str_eq(p, "") {
+        let dir: String = env("ENGRAM_DATA_DIR")
+        if str_eq(dir, "") { let dir = "/tmp/engram" }
        let p = dir + "/snapshot.json"
    }
    engram_save(p)
-    "{\"ok\":true,\"binary\":\"" + db_path + "\",\"json\":\"" + p + "\"}"
-}
-
-fn route_reindex(method: String, path: String, body: String) -> String {
-    engram_reindex_json()
+    "{\"ok\":true,\"path\":\"" + p + "\"}"
 }

 fn route_load(method: String, path: String, body: String) -> String {
-    let dir: String = env("ENGRAM_DATA_DIR")
-    if str_eq(dir, "") { let dir = "/tmp/engram" }
-    let db_path: String = dir + "/engram.db"
-    let ok: Bool = engram_load_binary_el(db_path)
-    if !ok {
-        let p: String = json_get_string(body, "path")
-        if str_eq(p, "") {
-            let p = dir + "/snapshot.json"
-        }
-        engram_load(p)
+    let p: String = json_get_string(body, "path")
+    if str_eq(p, "") {
+        let dir: String = env("ENGRAM_DATA_DIR")
+        if str_eq(dir, "") { let dir = "/tmp/engram" }
+        let p = dir + "/snapshot.json"
    }
+    engram_load(p)
    ok_json()
 }

@@ -521,323 +206,6 @@ fn route_health(method: String, path: String, body: String) -> String {
    "{\"status\":\"ok\",\"engine\":\"engram-runtime-native\"}"
 }

-// ── /api/neuron/* Routes ──────────────────────────────────────────────────────
-
-// route_neuron_session_begin — activate with broad seeds, return node stats + results
-fn route_neuron_session_begin(method: String, path: String, body: String) -> String {
-    let results: String = engram_activate_json("memory knowledge context", 2)
-    let nc: Int = engram_node_count()
-    let ec: Int = engram_edge_count()
-    "{\"ok\":true,\"nodes\":" + results + ",\"node_count\":" + int_to_str(nc) + ",\"edge_count\":" + int_to_str(ec) + "}"
-}
-
-// route_neuron_ctx — compile working context from top activated nodes
-fn route_neuron_ctx(method: String, path: String, body: String) -> String {
-    let results: String = engram_activate_json("architecture decision memory", 2)
-    let n: Int = json_array_len(results)
-    let limit: Int = if n > 10 { 10 } else { n }
-    let ctx: String = "Recent working memory:\n"
-    let i: Int = 0
-    let ctx_body: String = ""
-    while i < limit {
-        let elem: String = json_array_get(results, i)
-        let label: String = json_get_string(elem, "label")
-        let content: String = json_get_string(elem, "content")
-        let clen: Int = str_len(content)
-        let snippet: String = if clen > 200 { str_slice(content, 0, 200) } else { content }
-        let ctx_body = ctx_body + "- [" + label + "]: " + snippet + "\n"
-        let i = i + 1
-    }
-    let full_ctx: String = ctx + ctx_body
-    "{\"ok\":true,\"context\":\"" + str_replace(str_replace(str_replace(full_ctx, "\\", "\\\\"), "\"", "\\\""), "\n", "\\n") + "\"}"
-}
-
-// route_neuron_memory — create a Memory node with importance-to-tier mapping
-fn route_neuron_memory(method: String, path: String, body: String) -> String {
-    let content: String = json_get_string(body, "content")
-    if str_eq(content, "") { return "{\"error\":\"content is required\"}" }
-    let node_type: String = json_get_string(body, "node_type")
-    if str_eq(node_type, "") { let node_type = "Memory" }
-    let label: String = json_get_string(body, "label")
-    let importance: String = json_get_string(body, "importance")
-    let project: String = json_get_string(body, "project")
-    let tags_raw: String = json_get_string(body, "tags")
-
-    // Map importance to tier
-    let tier: String = "Episodic"
-    if str_eq(importance, "critical") { let tier = "Procedural" }
-    if str_eq(importance, "high")     { let tier = "Semantic" }
-    if str_eq(importance, "normal")   { let tier = "Episodic" }
-    if str_eq(importance, "low")      { let tier = "Working" }
-
-    // Override with explicit tier if provided
-    let explicit_tier: String = json_get_string(body, "tier")
-    if !str_eq(explicit_tier, "") { let tier = explicit_tier }
-
-    // Build tags string — append project tag if set
-    let tags_str: String = tags_raw
-    if !str_eq(project, "") {
-        if str_eq(tags_str, "") {
-            let tags_str = "project:" + project
-        }
-        if !str_eq(tags_str, "") {
-            let tags_str = tags_str + " project:" + project
-        }
-    }
-
-    let id: String = engram_node_full(content, node_type, label, 0.5, 0.5, 1.0, tier, tags_str)
-
-    // Auto-link to related non-ISE nodes so this memory is reachable via BFS traversal.
-    // Without this, MCP-created nodes arrive with zero edges and are invisible to
-    // graph spread during activation (only lexical/semantic seed matching finds them).
-    let auto_linked: Int = auto_link_content_node(id, content)
-
-    // Checkpoint after write
-    let dir: String = env("ENGRAM_DATA_DIR")
-    if str_eq(dir, "") { let dir = "/tmp/engram" }
-    let db_path: String = dir + "/engram.db"
-    engram_write_binary_el(db_path)
-
-    "{\"ok\":true,\"id\":\"" + id + "\",\"auto_linked\":" + int_to_str(auto_linked) + ",\"content\":\"" + str_replace(str_replace(content, "\\", "\\\\"), "\"", "\\\"") + "\"}"
-}
-
-// route_neuron_knowledge_capture — create a Knowledge node
-fn route_neuron_knowledge_capture(method: String, path: String, body: String) -> String {
-    let content: String = json_get_string(body, "content")
-    if str_eq(content, "") { return "{\"error\":\"content is required\"}" }
-    let title: String = json_get_string(body, "title")
-    let category: String = json_get_string(body, "category")
-    let tags_raw: String = json_get_string(body, "tags")
-    let project: String = json_get_string(body, "project")
-    let tier_raw: String = json_get_string(body, "tier")
-
-    // Map tier name to engram tier
-    let tier: String = "Episodic"
-    if str_eq(tier_raw, "lesson")    { let tier = "Semantic" }
-    if str_eq(tier_raw, "canonical") { let tier = "Procedural" }
-    if str_eq(tier_raw, "note")      { let tier = "Episodic" }
-
-    // Build tags
-    let tags_str: String = tags_raw
-    if !str_eq(category, "") {
-        if str_eq(tags_str, "") {
-            let tags_str = "category:" + category
-        }
-        if !str_eq(tags_str, "") {
-            let tags_str = tags_str + " category:" + category
-        }
-    }
-    if !str_eq(project, "") {
-        if str_eq(tags_str, "") {
-            let tags_str = "project:" + project
-        }
-        if !str_eq(tags_str, "") {
-            let tags_str = tags_str + " project:" + project
-        }
-    }
-
-    let id: String = engram_node_full(content, "Knowledge", title, 0.7, 0.7, 1.0, tier, tags_str)
-
-    // Auto-link to related non-ISE nodes for BFS reachability (same rationale as route_neuron_memory).
-    let auto_linked: Int = auto_link_content_node(id, content)
-
-    // Checkpoint
-    let dir: String = env("ENGRAM_DATA_DIR")
-    if str_eq(dir, "") { let dir = "/tmp/engram" }
-    let db_path: String = dir + "/engram.db"
-    engram_write_binary_el(db_path)
-
-    "{\"ok\":true,\"id\":\"" + id + "\",\"auto_linked\":" + int_to_str(auto_linked) + "}"
-}
-
-// route_neuron_knowledge_evolve — create updated node (evolution via new node)
-fn route_neuron_knowledge_evolve(method: String, path: String, body: String) -> String {
-    let content: String = json_get_string(body, "content")
-    let prior_id: String = json_get_string(body, "id")
-    if str_eq(content, "") { return "{\"ok\":true}" }
-    let id: String = engram_node_full(content, "Knowledge", "", 0.7, 0.7, 1.0, "Semantic", "evolved")
-    if !str_eq(prior_id, "") && !str_eq(id, "") {
-        engram_connect(id, prior_id, 1.0, "supersedes")
-    }
-    let dir: String = env("ENGRAM_DATA_DIR")
-    if str_eq(dir, "") { let dir = "/tmp/engram" }
-    engram_write_binary_el(dir + "/engram.db")
-    "{\"ok\":true,\"id\":\"" + id + "\"}"
-}
-
-// route_neuron_knowledge_promote — promote a knowledge node to a higher tier.
-// Creates a new node with the promoted tier (same content) and connects
-// via a "supersedes" edge from new → old. Tier mapping:
-//   note/Episodic → lesson/Semantic → canonical/Procedural
-fn route_neuron_knowledge_promote(method: String, path: String, body: String) -> String {
-    let id: String = json_get_string(body, "id")
-    if str_eq(id, "") { return "{\"ok\":true}" }
-
-    // Read existing node
-    let node_json: String = engram_get_node_json(id)
-    if str_eq(node_json, "") { return err_json("node not found") }
-    if str_eq(node_json, "null") { return err_json("node not found") }
-
-    let content: String = json_get_string(node_json, "content")
-    if str_eq(content, "") { return err_json("node has no content") }
-    let label: String = json_get_string(node_json, "label")
-    let tags: String = json_get_string(node_json, "tags")
-    let current_tier: String = json_get_string(node_json, "tier")
-
-    // Determine target tier: explicit override or auto-promote one level
-    let tier_raw: String = json_get_string(body, "tier")
-    let new_tier: String = ""
-
-    // Explicit tier takes precedence
-    if str_eq(tier_raw, "lesson")    { let new_tier = "Semantic" }
-    if str_eq(tier_raw, "canonical") { let new_tier = "Procedural" }
-    if str_eq(tier_raw, "note")      { let new_tier = "Episodic" }
-
-    // Auto-promote one level if no explicit tier
-    if str_eq(new_tier, "") {
-        if str_eq(current_tier, "Working")    { let new_tier = "Episodic" }
-        if str_eq(current_tier, "Episodic")   { let new_tier = "Semantic" }
-        if str_eq(current_tier, "Semantic")   { let new_tier = "Procedural" }
-        if str_eq(current_tier, "Procedural") { let new_tier = "Procedural" }
-    }
-    if str_eq(new_tier, "") { let new_tier = "Semantic" }
-
-    // Create promoted node — higher importance (0.8) signals durable knowledge
-    let new_id: String = engram_node_full(content, "Knowledge", label, 0.7, 0.8, 1.0, new_tier, tags)
-
-    // Wire supersedes edge: new node supersedes old
-    if !str_eq(new_id, "") {
-        engram_connect(new_id, id, 1.0, "supersedes")
-    }
-
-    // Checkpoint
-    let dir: String = env("ENGRAM_DATA_DIR")
-    if str_eq(dir, "") { let dir = "/tmp/engram" }
-    engram_write_binary_el(dir + "/engram.db")
-
-    "{\"ok\":true,\"id\":\"" + new_id + "\",\"promoted_from\":\"" + id + "\",\"tier\":\"" + new_tier + "\"}"
-}
-
-// route_neuron_recall — search or list nodes
-fn route_neuron_recall(method: String, path: String, body: String) -> String {
-    let query: String = json_get_string(body, "query")
-    let chain: String = json_get_string(body, "chain_name")
-    let limit: Int = json_get_int(body, "limit")
-    if limit == 0 { let limit = 20 }
-    let q: String = if str_eq(query, "") { chain } else { query }
-    if str_eq(q, "") {
-        return engram_scan_nodes_json(limit, 0)
-    }
-    return bm25_search_json(q, limit)
-}
-
-// route_neuron_graph — get node + search-based neighbor approximation.
-// engram_neighbors_json crashes on large graphs (15k+ edges exceeds BFS cap).
-// Use a search-based approach instead: search by the node id string, which
-// returns connected nodes that share content with the target id in edges/tags.
-// For the mcp-wrapper callers this is sufficient — they just need the node itself.
-fn route_neuron_graph(method: String, path: String, body: String) -> String {
-    let id: String = query_param(path, "id")
-    if str_eq(id, "") { return "{\"error\":\"id is required\"}" }
-    let node_json: String = engram_get_node_json(id)
-    // Return node with empty neighbors — safe fallback avoids BFS crash
-    "{\"ok\":true,\"node\":" + node_json + ",\"neighbors\":[]}"
-}
-
-// route_neuron_graph_link — create edge between nodes
-fn route_neuron_graph_link(method: String, path: String, body: String) -> String {
-    let from_id: String = json_get_string(body, "from_id")
-    let to_id: String = json_get_string(body, "to_id")
-    if str_eq(from_id, "") || str_eq(to_id, "") {
-        return "{\"error\":\"from_id and to_id are required\"}"
-    }
-    let relation: String = json_get_string(body, "relation")
-    if str_eq(relation, "") { let relation = "related" }
-    let weight: Float = json_get_float(body, "weight")
-    if weight == 0.0 { let weight = 0.5 }
-    engram_connect(from_id, to_id, weight, relation)
-    "{\"ok\":true,\"from_id\":\"" + from_id + "\",\"to_id\":\"" + to_id + "\",\"relation\":\"" + relation + "\"}"
-}
-
-// route_neuron_list — list nodes by type extracted from path
-fn route_neuron_list(method: String, path: String, body: String) -> String {
-    let clean: String = strip_query(path)
-    let prefix: String = "/api/neuron/list/"
-    let node_type: String = str_slice(clean, str_len(prefix), str_len(clean))
-    let limit: Int = query_int(path, "limit", 50)
-    if str_eq(node_type, "") { return "[]" }
-    return engram_scan_nodes_by_type_json(node_type, limit, 0)
-}
-
-// route_neuron_consolidate — checkpoint and return counts
-fn route_neuron_consolidate(method: String, path: String, body: String) -> String {
-    let dir: String = env("ENGRAM_DATA_DIR")
-    if str_eq(dir, "") { let dir = "/tmp/engram" }
-    let db_path: String = dir + "/engram.db"
-    engram_write_binary_el(db_path)
-    let nc: Int = engram_node_count()
-    let ec: Int = engram_edge_count()
-    "{\"ok\":true,\"node_count\":" + int_to_str(nc) + ",\"edge_count\":" + int_to_str(ec) + "}"
-}
-
-// route_neuron_config — return stub config values
-fn route_neuron_config(method: String, path: String, body: String) -> String {
-    let key: String = query_param(path, "key")
-    "{\"key\":\"" + key + "\",\"value\":\"\"}"
-}
-
-// route_neuron_state_events — GET lists ISEs, POST logs a new one.
-// GET supports ?limit=N&offset=M for pagination; ?label=X to extract label
-// from the ISE content's "event" field.
-// ISEs sort by created_at DESC (most-recent-first) as of 2026-05-23 fix.
-// ?limit=10 returns the 10 most recent ISEs. Offset for pagination, not for
-// skipping to recent events (that was the pre-fix behavior; no longer needed).
-fn route_neuron_state_events(method: String, path: String, body: String) -> String {
-    if str_eq(method, "GET") {
-        let limit_str: String = query_param(path, "limit")
-        let limit: Int = if str_eq(limit_str, "") { 50 } else { str_to_int(limit_str) }
-        let offset_str: String = query_param(path, "offset")
-        let offset: Int = if str_eq(offset_str, "") { 0 } else { str_to_int(offset_str) }
-        return engram_scan_nodes_by_type_json("InternalStateEvent", limit, offset)
-    }
-    let content: String = json_get_string(body, "content")
-    if str_eq(content, "") { let content = body }
-    // Extract label from content JSON "event" field for better ISE searchability
-    let event_label: String = json_get_string(content, "event")
-    let label: String = if str_eq(event_label, "") { "state-event" } else { event_label }
-    let id: String = engram_node_full(content, "InternalStateEvent", label, 0.3, 0.3, 1.0, "Working", "internal-state")
-    "{\"ok\":true,\"id\":\"" + id + "\"}"
-}
-
-// route_neuron_processes — stub
-fn route_neuron_processes(method: String, path: String, body: String) -> String {
-    "{\"ok\":true,\"processes\":[]}"
-}
-
-// route_events_next — stub empty event queue
-fn route_events_next(method: String, path: String, body: String) -> String {
-    "{\"ok\":true,\"event\":null}"
-}
-
-// route_events_ack — stub ack
-fn route_events_ack(method: String, path: String, body: String) -> String {
-    "{\"ok\":true}"
-}
-
-fn route_bm25_search(method: String, path: String, body: String) -> String {
-    let q: String = ""
-    if str_eq(method, "GET") {
-        let q = query_param(path, "q")
-    } else {
-        let q = json_get_string(body, "query")
-    }
-    if str_eq(q, "") { return "{\"error\":\"query is required\"}" }
-    let limit: Int = query_int(path, "limit", 20)
-    if limit == 0 { let limit = json_get_int(body, "limit") }
-    if limit == 0 { let limit = 20 }
-    bm25_search_json(q, limit)
-}
-
 // ── Auth ──────────────────────────────────────────────────────────────────────

 fn check_auth_ok(method: String, body: String) -> Bool {
@@ -864,63 +232,6 @@ fn handle_request(method: String, path: String, body: String) -> String {
        }
    }

-    // /api/neuron/* and /events/* are pre-auth — the mcp-wrapper is a trusted
-    // local service that cannot inject _auth into its request bodies.
-    if str_starts_with(clean, "/api/neuron/") || str_starts_with(clean, "/events/") {
-        if str_eq(clean, "/api/neuron/session/begin") {
-            return route_neuron_session_begin(method, path, body)
-        }
-        if str_eq(clean, "/api/neuron/ctx") {
-            return route_neuron_ctx(method, path, body)
-        }
-        if str_eq(clean, "/api/neuron/memory") {
-            return route_neuron_memory(method, path, body)
-        }
-        if str_eq(clean, "/api/neuron/knowledge/capture") {
-            return route_neuron_knowledge_capture(method, path, body)
-        }
-        if str_eq(clean, "/api/neuron/knowledge/evolve") {
-            return route_neuron_knowledge_evolve(method, path, body)
-        }
-        if str_eq(clean, "/api/neuron/knowledge/promote") {
-            return route_neuron_knowledge_promote(method, path, body)
-        }
-        if str_eq(clean, "/api/neuron/recall") {
-            return route_neuron_recall(method, path, body)
-        }
-        if str_eq(clean, "/api/neuron/graph/link") {
-            return route_neuron_graph_link(method, path, body)
-        }
-        if str_eq(clean, "/api/neuron/graph") {
-            return route_neuron_graph(method, path, body)
-        }
-        if str_starts_with(clean, "/api/neuron/list/") {
-            return route_neuron_list(method, path, body)
-        }
-        if str_eq(clean, "/api/neuron/consolidate") {
-            return route_neuron_consolidate(method, path, body)
-        }
-        if str_eq(clean, "/api/neuron/config") {
-            return route_neuron_config(method, path, body)
-        }
-        if str_eq(clean, "/api/neuron/state-events") {
-            return route_neuron_state_events(method, path, body)
-        }
-        if str_eq(clean, "/api/neuron/processes/define") {
-            return route_neuron_processes(method, path, body)
-        }
-        if str_eq(clean, "/api/neuron/processes") {
-            return route_neuron_processes(method, path, body)
-        }
-        if str_eq(clean, "/events/next") {
-            return route_events_next(method, path, body)
-        }
-        if str_eq(clean, "/events/ack") {
-            return route_events_ack(method, path, body)
-        }
-        return err_json("not found")
-    }
-
    // Auth (when ENGRAM_API_KEY is set)
    if !check_auth_ok(method, body) {
        return err_json("unauthorized")
@@ -970,93 +281,18 @@ fn handle_request(method: String, path: String, body: String) -> String {
        return route_search(method, path, body)
    }

-    // BM25+ text ranking
-    if str_eq(clean, "/api/bm25/search") {
-        return route_bm25_search(method, path, body)
-    }
-
    // Strengthen
    if str_eq(method, "POST") && (str_eq(clean, "/api/strengthen") || str_eq(clean, "/strengthen")) {
        return route_strengthen(method, path, body)
    }

-    // Temporal decay maintenance
-    if str_eq(method, "POST") && (str_eq(clean, "/api/decay") || str_eq(clean, "/api/maintenance") || str_eq(clean, "/decay")) {
-        return route_decay(method, path, body)
-    }
-
    // Persistence
-    if str_eq(method, "POST") && (str_eq(clean, "/api/export") || str_eq(clean, "/export")) {
-        return route_export(method, path, body)
-    }
-    // /api/save is kept as a backward-compat alias for /api/export
    if str_eq(method, "POST") && (str_eq(clean, "/api/save") || str_eq(clean, "/save")) {
-        return route_export(method, path, body)
+        return route_save(method, path, body)
    }
    if str_eq(method, "POST") && (str_eq(clean, "/api/load") || str_eq(clean, "/load")) {
        return route_load(method, path, body)
    }
-    if str_eq(method, "POST") && (str_eq(clean, "/api/reindex") || str_eq(clean, "/reindex")) {
-        return route_reindex(method, path, body)
-    }
-
-    // ── /api/neuron/* ─────────────────────────────────────────────────────────
-    if str_starts_with(clean, "/api/neuron/") {
-        // Specific sub-paths first (longer matches before shorter)
-        if str_eq(clean, "/api/neuron/session/begin") {
-            return route_neuron_session_begin(method, path, body)
-        }
-        if str_eq(clean, "/api/neuron/ctx") {
-            return route_neuron_ctx(method, path, body)
-        }
-        if str_eq(clean, "/api/neuron/memory") {
-            return route_neuron_memory(method, path, body)
-        }
-        if str_eq(clean, "/api/neuron/knowledge/capture") {
-            return route_neuron_knowledge_capture(method, path, body)
-        }
-        if str_eq(clean, "/api/neuron/knowledge/evolve") {
-            return route_neuron_knowledge_evolve(method, path, body)
-        }
-        if str_eq(clean, "/api/neuron/knowledge/promote") {
-            return route_neuron_knowledge_promote(method, path, body)
-        }
-        if str_eq(clean, "/api/neuron/recall") {
-            return route_neuron_recall(method, path, body)
-        }
-        if str_eq(clean, "/api/neuron/graph/link") {
-            return route_neuron_graph_link(method, path, body)
-        }
-        if str_eq(clean, "/api/neuron/graph") {
-            return route_neuron_graph(method, path, body)
-        }
-        if str_starts_with(clean, "/api/neuron/list/") {
-            return route_neuron_list(method, path, body)
-        }
-        if str_eq(clean, "/api/neuron/consolidate") {
-            return route_neuron_consolidate(method, path, body)
-        }
-        if str_eq(clean, "/api/neuron/config") {
-            return route_neuron_config(method, path, body)
-        }
-        if str_eq(clean, "/api/neuron/state-events") {
-            return route_neuron_state_events(method, path, body)
-        }
-        if str_eq(clean, "/api/neuron/processes/define") {
-            return route_neuron_processes(method, path, body)
-        }
-        if str_eq(clean, "/api/neuron/processes") {
-            return route_neuron_processes(method, path, body)
-        }
-    }
-
-    // ── /events/* ─────────────────────────────────────────────────────────────
-    if str_eq(clean, "/events/next") {
-        return route_events_next(method, path, body)
-    }
-    if str_eq(clean, "/events/ack") {
-        return route_events_ack(method, path, body)
-    }

    "{\"error\":\"not found\",\"path\":\"" + clean + "\"}"
 }
@@ -1067,28 +303,13 @@ let bind_str: String = env("ENGRAM_BIND")
 if str_eq(bind_str, "") { let bind_str = ":8742" }
 let port: Int = parse_port(bind_str)

-// On startup, load from binary database (ML-KEM-1024 encrypted).
-// Falls back to per-file JSON, then snapshot.json for migration from older formats.
+// On startup, try to load any existing snapshot (best effort).
 let data_dir: String = env("ENGRAM_DATA_DIR")
 if str_eq(data_dir, "") { let data_dir = "/tmp/engram" }
-let db_path: String = data_dir + "/engram.db"
-let loaded: Bool = engram_load_binary_el(db_path)
-if !loaded {
-    // Migration path: try per-file JSON
-    engram_load_dir(data_dir)
-    if engram_node_count() == 0 {
-        // Final fallback: legacy snapshot.json
-        let snapshot_path: String = data_dir + "/snapshot.json"
-        engram_load(snapshot_path)
-    }
-    // If we loaded anything from legacy format, save as binary immediately
-    if engram_node_count() > 0 {
-        engram_write_binary_el(db_path)
-        println("[engram] migrated legacy data to binary format")
-    }
-}
+let snapshot_path: String = data_dir + "/snapshot.json"
+engram_load(snapshot_path)

-println("[engram] runtime-native graph engine (ML-KEM-1024 encrypted)")
+println("[engram] runtime-native graph engine")
 println("[engram] data_dir=" + data_dir)
 println("[engram] node_count=" + int_to_str(engram_node_count()))
 println("[engram] edge_count=" + int_to_str(engram_edge_count()))
@@ -4342,9 +4342,6 @@ el_val_t builtin_arity(el_val_t name) {
  if (str_eq(name, EL_STR("http_serve"))) {
    return 2;
  }
-  if (str_eq(name, EL_STR("http_serve_async"))) {
-    return 2;
-  }
  if (str_eq(name, EL_STR("http_set_handler"))) {
    return 1;
  }
@@ -4549,12 +4546,6 @@ el_val_t builtin_arity(el_val_t name) {
  if (str_eq(name, EL_STR("engram_load"))) {
    return 1;
  }
-  if (str_eq(name, EL_STR("engram_load_dir"))) {
-    return 1;
-  }
-  if (str_eq(name, EL_STR("engram_reindex_json"))) {
-    return 0;
-  }
  if (str_eq(name, EL_STR("engram_get_node_json"))) {
    return 1;
  }
@@ -4573,9 +4564,6 @@ el_val_t builtin_arity(el_val_t name) {
  if (str_eq(name, EL_STR("engram_stats_json"))) {
    return 0;
  }
-  if (str_eq(name, EL_STR("engram_apply_decay_json"))) {
-    return 0;
-  }
  if (str_eq(name, EL_STR("llm_call"))) {
    return 2;
  }
@@ -42,7 +42,6 @@
 #include <dirent.h>
 #include <errno.h>
 #include <pthread.h>
-#include <sys/resource.h>  /* getrusage — memory guard */
 #ifdef HAVE_CURL
 #include <curl/curl.h>
 #endif
@@ -2242,43 +2241,6 @@ el_val_t url_decode(el_val_t sv) {
    return el_wrap_str(out);
 }

-/* ── html_raw ────────────────────────────────────────────────────────────────
- * Identity passthrough for raw HTML template interpolation.
- * El's {raw(expr)} compiles to html_raw(expr) — the value is output as-is
- * without any escaping. The caller is responsible for safety.
- */
-el_val_t html_raw(el_val_t s) {
-    return s;
-}
-
-/* ── html_escape ─────────────────────────────────────────────────────────────
- * Escape < > " ' & for safe HTML text interpolation.
- * El's {expr} in HTML templates compiles to html_escape(expr).
- */
-el_val_t html_escape(el_val_t sv) {
-    const char* src = EL_CSTR(sv);
-    if (!src) return EL_STR("");
-    size_t len = strlen(src);
-    /* Worst case: every byte → 6 chars (&quot;) */
-    char* out = (char*)malloc(len * 6 + 1);
-    if (!out) return sv;
-    el_arena_track(out);
-    char* p = out;
-    for (size_t i = 0; i < len; i++) {
-        unsigned char c = (unsigned char)src[i];
-        switch (c) {
-            case '&':  memcpy(p, "&amp;",  5); p += 5; break;
-            case '<':  memcpy(p, "&lt;",   4); p += 4; break;
-            case '>':  memcpy(p, "&gt;",   4); p += 4; break;
-            case '"':  memcpy(p, "&quot;", 6); p += 6; break;
-            case '\'': memcpy(p, "&#39;",  5); p += 5; break;
-            default:   *p++ = (char)c;          break;
-        }
-    }
-    *p = '\0';
-    return el_wrap_str(out);
-}
-
 /* ── HTML allowlist sanitizer ────────────────────────────────────────────────
 * el_html_sanitize(input, allowlist_json)
 *
@@ -5712,50 +5674,6 @@ el_val_t getpid_now(void) {
    return (el_val_t)getpid();
 }

-/* el_mem_check — self-terminating memory guard for long-running compiler runs.
- *
- * Call this periodically (e.g. after each function compiled) to detect runaway
- * memory growth before the OS OOM-killer fires. Reads the limit from the env
- * var ELC_MAX_MEM_MB (default 512 MB). If resident set size exceeds the limit,
- * prints a diagnostic to stderr and exits with code 1 so the caller (elb or a
- * CI script) can handle the failure gracefully instead of having the whole
- * machine go down.
- *
- * Platform notes:
- *   macOS  — ru_maxrss is in bytes.
- *   Linux  — ru_maxrss is in kilobytes.
- * We normalise to MB before comparing.
- *
- * Returns 0 always (the only non-return path is the exit() branch).
- */
-el_val_t el_mem_check(void) {
-    /* Read limit from env; default 512 MB. */
-    long limit_mb = 512;
-    const char *env_val = getenv("ELC_MAX_MEM_MB");
-    if (env_val && *env_val) {
-        long v = atol(env_val);
-        if (v > 0) limit_mb = v;
-    }
-
-    struct rusage ru;
-    if (getrusage(RUSAGE_SELF, &ru) != 0) return 0; /* can't read — skip check */
-
-    long rss_mb;
-#if defined(__APPLE__) || defined(__MACH__)
-    /* macOS: ru_maxrss is bytes */
-    rss_mb = (long)(ru.ru_maxrss / (1024L * 1024L));
-#else
-    /* Linux: ru_maxrss is kilobytes */
-    rss_mb = (long)(ru.ru_maxrss / 1024L);
-#endif
-
-    if (rss_mb >= limit_mb) {
-        fprintf(stderr, "elc: memory limit exceeded (%ldMB), aborting\n", limit_mb);
-        exit(1);
-    }
-    return 0;
-}
-
 /* ── args() — command-line argument access ──────────────────────────────────
 * Compiled El programs call args() to get a list of CLI arguments.
 * Call el_runtime_init_args(argc, argv) at the start of C main() to populate.
@@ -7021,83 +6939,6 @@ el_val_t engram_activate(el_val_t query, el_val_t depth) {
        g->nodes[i].background_activation = reached[i] ? best_bg[i] : 0.0;
    }

-    /* ── TRAVERSAL INFERENCE: infer A→C edges when A→B→C was traversed ──
-     * For each pair of edges (A→B, B→C) where all three nodes were reached,
-     * create an inferred A→C edge with weight = w(A→B) * w(B→C) * 0.8
-     * if no A→C edge already exists. Cap at 64 new edges per call.
-     *
-     * IMPORTANT: collect candidates FIRST into a flat array (no pointers into
-     * g->edges held across the apply pass), then apply after — this avoids
-     * dangling pointer bugs if engram_grow_edges() reallocs the array. */
-    {
-        const int64_t INFER_CAP = 64;
-        typedef struct { char from[64]; char to[64]; double weight; } InferCandidate;
-        InferCandidate* cands = malloc((size_t)INFER_CAP * sizeof(InferCandidate));
-        int64_t ncands = 0;
-        int64_t snap_ec = g->edge_count;
-        if (cands) {
-            for (int64_t e1 = 0; e1 < snap_ec && ncands < INFER_CAP; e1++) {
-                EngramEdge* ea = &g->edges[e1];
-                if (!ea->from_id || !ea->to_id) continue;
-                int64_t ai = engram_find_node_index(ea->from_id);
-                int64_t bi = engram_find_node_index(ea->to_id);
-                if (ai < 0 || bi < 0) continue;
-                if (!reached[ai] || !reached[bi]) continue;
-                for (int64_t e2 = 0; e2 < snap_ec && ncands < INFER_CAP; e2++) {
-                    if (e2 == e1) continue;
-                    EngramEdge* eb = &g->edges[e2];
-                    if (!eb->from_id || !eb->to_id) continue;
-                    if (strcmp(eb->from_id, ea->to_id) != 0) continue;
-                    int64_t ci = engram_find_node_index(eb->to_id);
-                    if (ci < 0 || !reached[ci]) continue;
-                    if (ai == ci) continue;
-                    int already = 0;
-                    for (int64_t ex = 0; ex < snap_ec; ex++) {
-                        EngramEdge* ee = &g->edges[ex];
-                        if (ee->from_id && ee->to_id &&
-                            strcmp(ee->from_id, ea->from_id) == 0 &&
-                            strcmp(ee->to_id,   eb->to_id)   == 0) {
-                            already = 1; break;
-                        }
-                    }
-                    if (already) continue;
-                    int dup = 0;
-                    for (int64_t k = 0; k < ncands; k++) {
-                        if (strcmp(cands[k].from, ea->from_id) == 0 &&
-                            strcmp(cands[k].to,   eb->to_id)   == 0) { dup = 1; break; }
-                    }
-                    if (dup) continue;
-                    double inf_w = ea->weight * eb->weight * 0.8;
-                    if (inf_w < 0.05) inf_w = 0.05;
-                    if (inf_w > 1.0)  inf_w = 1.0;
-                    strncpy(cands[ncands].from, ea->from_id, 63); cands[ncands].from[63] = '\0';
-                    strncpy(cands[ncands].to,   eb->to_id,   63); cands[ncands].to[63]   = '\0';
-                    cands[ncands].weight = inf_w;
-                    ncands++;
-                }
-            }
-            for (int64_t k = 0; k < ncands; k++) {
-                engram_grow_edges();
-                EngramEdge* ne = &g->edges[g->edge_count];
-                memset(ne, 0, sizeof(*ne));
-                ne->id       = engram_new_id();
-                /* Use strdup (not el_strdup) so these persist beyond the request. */
-                ne->from_id  = strdup(cands[k].from);
-                ne->to_id    = strdup(cands[k].to);
-                ne->relation = strdup("inferred");
-                ne->metadata = strdup("{}");
-                ne->weight   = cands[k].weight;
-                ne->confidence = 0.8;
-                ne->created_at = now_ms;
-                ne->updated_at = now_ms;
-                ne->last_fired = now_ms;
-                ne->layer_id   = ENGRAM_LAYER_DEFAULT;
-                g->edge_count++;
-            }
-            free(cands);
-        }
-    }
-
    /* ── PASS 2: executive filter → working memory promotion ──────────── */
    /* Step A: collect inhibitory suppressions from fired inhibitory edges.
     * Layered consciousness: inhibition is ONLY recorded against targets
@@ -7193,66 +7034,6 @@ el_val_t engram_activate(el_val_t query, el_val_t depth) {
        g->nodes[i].working_memory_weight = wm_weights[i];
    }

-    /* ── HEBBIAN STRENGTHENING: fire together, wire together ─────────────
-     * For each pair of co-promoted nodes (working_memory_weight > 0) that
-     * share an edge, boost that edge's weight by 0.05 (capped at 1.0).
-     * Also increment activation_count and update last_activated on promoted
-     * nodes — this is what drives tier migration below. */
-    for (int64_t i = 0; i < g->node_count; i++) {
-        if (wm_weights[i] <= 0.0) continue;
-        EngramNode* n = &g->nodes[i];
-        n->activation_count++;
-        n->last_activated = now_ms;
-        n->updated_at     = now_ms;
-    }
-    for (int64_t ei = 0; ei < g->edge_count; ei++) {
-        EngramEdge* e = &g->edges[ei];
-        if (!e->from_id || !e->to_id) continue;
-        int64_t src = engram_find_node_index(e->from_id);
-        int64_t tgt = engram_find_node_index(e->to_id);
-        if (src < 0 || tgt < 0) continue;
-        if (wm_weights[src] > 0.0 && wm_weights[tgt] > 0.0) {
-            e->weight += 0.05;
-            if (e->weight > 1.0) e->weight = 1.0;
-            e->last_fired = now_ms;
-            e->updated_at = now_ms;
-        }
-    }
-
-    /* ── TIER MIGRATION: promote nodes based on activation_count thresholds ─
-     * 0–4   → Working
-     * 5–19  → Episodic
-     * 20–49 → Semantic
-     * 50+   → Procedural
-     * Only upgrade (never downgrade) to preserve earned tier. */
-    for (int64_t i = 0; i < g->node_count; i++) {
-        EngramNode* n = &g->nodes[i];
-        const char* target_tier = NULL;
-        int64_t ac = n->activation_count;
-        if      (ac >= 50) target_tier = "Procedural";
-        else if (ac >= 20) target_tier = "Semantic";
-        else if (ac >= 5)  target_tier = "Episodic";
-        else               target_tier = "Working";
-        if (target_tier && n->tier && strcmp(n->tier, target_tier) != 0) {
-            /* Only upgrade (Working < Episodic < Semantic < Procedural). */
-            int cur_rank = 0, new_rank = 0;
-            if (strcmp(n->tier, "Working")    == 0) cur_rank = 0;
-            else if (strcmp(n->tier, "Episodic")  == 0) cur_rank = 1;
-            else if (strcmp(n->tier, "Semantic")  == 0) cur_rank = 2;
-            else if (strcmp(n->tier, "Procedural") == 0) cur_rank = 3;
-            if (strcmp(target_tier, "Working")    == 0) new_rank = 0;
-            else if (strcmp(target_tier, "Episodic")  == 0) new_rank = 1;
-            else if (strcmp(target_tier, "Semantic")  == 0) new_rank = 2;
-            else if (strcmp(target_tier, "Procedural") == 0) new_rank = 3;
-            if (new_rank > cur_rank) {
-                free(n->tier);
-                /* Use strdup (not el_strdup) so tier string persists beyond the request. */
-                n->tier = strdup(target_tier);
-                n->updated_at = now_ms;
-            }
-        }
-    }
-
    /* ── Collect all background-activated nodes for the return value ────
     * Callers see both layers. Context compilation uses only promoted nodes
     * (working_memory_weight > 0). Sort: promoted first by wm_weight desc,
@@ -8026,97 +7807,6 @@ el_val_t engram_query_range(el_val_t start_ms_v, el_val_t end_ms_v) {
    return el_wrap_str(b.buf);
 }

-/* ── engram_apply_decay_json — temporal decay maintenance ────────────────────
- *
- * Iterates ALL nodes and applies temporal decay to their stored `salience`
- * field based on time elapsed since `last_activated`:
- *
- *   new_salience = current_salience * decay_rate ^ hours_since_activation
- *
- * where decay_rate defaults to 0.5^(1/168) per hour (half-life one week),
- * or the node's own `temporal_decay_rate` if non-zero.
- *
- * Nodes with temporal_decay_rate == 0 are NOT immune — the global default
- * applies. To make a node truly immune, set temporal_decay_rate to a very
- * small positive value (e.g. 0.0001). Nodes that are "pinned" can be
- * identified by a tier of "Procedural" — those are skipped.
- *
- * After updating salience, nodes with salience < 0.05 AND tier == "Working"
- * are pruned (deleted) unless they have no content (guard against garbage).
- *
- * Returns a JSON summary: {"updated": N, "pruned": N} */
-el_val_t engram_apply_decay_json(void) {
-    EngramStore* g = engram_get();
-    int64_t now_ms = engram_now_ms();
-    int64_t updated = 0, pruned = 0;
-
-    for (int64_t i = 0; i < g->node_count; i++) {
-        EngramNode* n = &g->nodes[i];
-        /* Skip Procedural nodes (they are "locked in"). */
-        if (n->tier && strcmp(n->tier, "Procedural") == 0) continue;
-        int64_t age_ms = now_ms - n->last_activated;
-        if (age_ms <= 0) continue;
-        double lambda = (n->temporal_decay_rate > 0.0) ? n->temporal_decay_rate
-                                                        : ENGRAM_DECAY_LAMBDA;
-        double age_hours = (double)age_ms / 3600000.0;
-        double decay_factor = exp(-lambda * age_hours / ENGRAM_T_HALF_HOURS);
-        double new_salience = n->salience * decay_factor;
-        if (new_salience < 0.0) new_salience = 0.0;
-        if (new_salience != n->salience) {
-            n->salience   = new_salience;
-            n->updated_at = now_ms;
-            updated++;
-        }
-    }
-
-    /* Prune low-salience Working nodes. Walk backwards to allow in-place
-     * removal without invalidating indices. */
-    for (int64_t i = g->node_count - 1; i >= 0; i--) {
-        EngramNode* n = &g->nodes[i];
-        if (n->salience >= 0.05) continue;
-        /* Only prune Working tier nodes — higher tiers are protected. */
-        if (!n->tier || strcmp(n->tier, "Working") != 0) continue;
-        /* Guard: skip nodes with no content. */
-        if (!n->content || !*n->content) continue;
-        /* Free node strings. */
-        free(n->id); free(n->content); free(n->node_type); free(n->label);
-        free(n->tier); free(n->tags); free(n->metadata);
-        /* Shift remaining nodes down. */
-        for (int64_t j = i + 1; j < g->node_count; j++) {
-            g->nodes[j - 1] = g->nodes[j];
-        }
-        g->node_count--;
-        memset(&g->nodes[g->node_count], 0, sizeof(EngramNode));
-        pruned++;
-    }
-
-    /* Remove dangling edges for pruned nodes (any edge whose endpoint no
-     * longer exists in the node list). */
-    if (pruned > 0) {
-        int64_t w = 0;
-        for (int64_t r = 0; r < g->edge_count; r++) {
-            EngramEdge* e = &g->edges[r];
-            int dangling = 0;
-            if (e->from_id && engram_find_node_index(e->from_id) < 0) dangling = 1;
-            if (e->to_id   && engram_find_node_index(e->to_id)   < 0) dangling = 1;
-            if (dangling) {
-                free(e->id); free(e->from_id); free(e->to_id);
-                free(e->relation); free(e->metadata);
-            } else {
-                if (w != r) g->edges[w] = g->edges[r];
-                w++;
-            }
-        }
-        g->edge_count = w;
-    }
-
-    char buf[128];
-    snprintf(buf, sizeof(buf),
-             "{\"ok\":true,\"updated\":%lld,\"pruned\":%lld}",
-             (long long)updated, (long long)pruned);
-    return el_wrap_str(el_strdup(buf));
-}
-
 #ifdef HAVE_CURL
 /* ── DHARMA network ─────────────────────────────────────────────────────────
 * Real implementation. Peers are addressed by `dharma_id` — either bare
@@ -227,8 +227,6 @@ el_val_t  url_decode(el_val_t s);   /* '+' → space, %XX → byte  */
 *     {"p":[],"a":["href","title"],"strong":[],...}
 * where each value is the array of attribute names allowed for that tag. */
 el_val_t  el_html_sanitize(el_val_t input_html, el_val_t allowlist_json);
-el_val_t  html_raw(el_val_t s);
-el_val_t  html_escape(el_val_t s);

 /* ── Filesystem ──────────────────────────────────────────────────────────── */

@@ -533,12 +531,6 @@ el_val_t  parse_int(el_val_t s, el_val_t default_val);
 el_val_t  exit_program(el_val_t code);
 el_val_t  getpid_now(void);

-/* Self-terminating memory guard. Reads ELC_MAX_MEM_MB (default 512) and
- * exits with code 1 if resident memory exceeds the limit. Call periodically
- * during long compilation loops (e.g. after each function is compiled).
- * Returns 0 when memory is within bounds.                                   */
-el_val_t  el_mem_check(void);
-
 /* ── CGI identity ─────────────────────────────────────────────────────────────
 * Called at the start of main() in CGI programs (those with a `cgi {}` block).
 * Records the program's DHARMA identity before any other code executes.      */
@@ -324,10 +324,6 @@ fn cg_html_parts(children: [Map<String, Any>], acc_var: String) -> String {
            let each_c: String = cg_html_each(child, acc_var)
            let parts = native_list_append(parts, each_c)
        }
-        if str_eq(html_kind, "HtmlIf") {
-            let if_c: String = cg_html_if(child, acc_var)
-            let parts = native_list_append(parts, if_c)
-        }
        let i = i + 1
    }
    str_join(parts, "")
@@ -417,17 +413,6 @@ fn cg_html_each(node: Map<String, Any>, acc_var: String) -> String {
    "{ el_val_t " + list_var + " = (" + list_c + "); el_val_t " + len_var + " = el_list_len(" + list_var + "); for (el_val_t " + idx_var + " = 0; " + idx_var + " < " + len_var + "; " + idx_var + "++) { el_val_t " + item_name + " = el_list_get(" + list_var + ", " + idx_var + "); " + inner_c + "} } "
 }

-// Generate code for {#if cond} ... {/if} (with optional {#else}).
-fn cg_html_if(node: Map<String, Any>, acc_var: String) -> String {
-    let cond_expr = node["cond"]
-    let then_children: [Map<String, Any>] = node["then"]
-    let else_children: [Map<String, Any>] = node["else"]
-    let cond_c: String = cg_expr(cond_expr)
-    let then_c: String = cg_html_parts(then_children, acc_var)
-    let else_c: String = cg_html_parts(else_children, acc_var)
-    "if (" + cond_c + ") { " + then_c + " } else { " + else_c + " } "
-}
-
 // Top-level HTML template codegen — returns a C statement-expression string.
 fn cg_html_template(expr: Map<String, Any>) -> String {
    let root = expr["root"]
@@ -2502,7 +2487,6 @@ fn builtin_arity(name: String) -> Int {
    if str_eq(name, "http_post_with_headers") { return 3 }
    if str_eq(name, "http_post_form_auth") { return 3 }
    if str_eq(name, "http_serve") { return 2 }
-    if str_eq(name, "http_serve_async") { return 2 }
    if str_eq(name, "http_set_handler") { return 1 }
    // Seed primitives (__-prefix) — runtime/el_seed.c
    if str_eq(name, "__str_len") { return 1 }
@@ -3731,7 +3715,6 @@ fn codegen_streaming(tokens: [Any], sigs: [Map<String, Any>], source: String) ->
                            cg_fn(stmt)
                            el_release(stmt)
                            el_arena_pop(fn_arena_mark)
-                            el_mem_check()
                        }
                    } else {
                        if is_top_level_decl(stmt) {
@@ -287,9 +287,6 @@ fn type_node_to_el(t: Map<String, Any>) -> String {

 // emit_header — write a .elh file from parsed statements.
 // Scans for FnDef nodes and emits 'extern fn' declarations.
-// NOTE: This function requires the full AST. Prefer emit_header_from_sigs
-// for the --emit-header path — it works from a token-level scan without
-// building expression ASTs, avoiding OOM on large files.
 fn emit_header(stmts: [Map<String, Any>], hdr_path: String) -> Void {
    let n: Int = native_list_len(stmts)
    let i = 0
@@ -328,32 +325,6 @@ fn emit_header(stmts: [Map<String, Any>], hdr_path: String) -> Void {
    let ok: Bool = fs_write(hdr_path, content)
 }

-// emit_header_from_sigs — write a .elh file from pre-scanned El signatures.
-// Uses the output of scan_fn_sigs_el() — no full AST required.
-// Peak memory is O(tokens) rather than O(whole-program AST), which prevents
-// OOM on large files with HTML template bodies or deep BinOp chains.
-fn emit_header_from_sigs(sigs: [Map<String, Any>], hdr_path: String) -> Void {
-    let n: Int = native_list_len(sigs)
-    let i: Int = 0
-    let parts: [String] = native_list_empty()
-    let parts = native_list_append(parts, "// auto-generated by elc --emit-header — do not edit\n")
-    while i < n {
-        let sig = native_list_get(sigs, i)
-        let kind: String = sig["kind"]
-        if str_eq(kind, "fn") {
-            let name: String = sig["name"]
-            let params_el: String = sig["params_el"]
-            let ret_el: String = sig["ret_el"]
-            if str_eq(ret_el, "") { let ret_el = "Any" }
-            let line: String = "extern fn " + name + "(" + params_el + ") -> " + ret_el
-            let parts = native_list_append(parts, line + "\n")
-        }
-        let i = i + 1
-    }
-    let content: String = str_join(parts, "")
-    let ok: Bool = fs_write(hdr_path, content)
-}
-
 // ── Import resolution ────────────────────────────────────────────────────────
 //
 // elc supports two forms of import:
@@ -565,20 +536,16 @@ fn main() -> Void {

    let src_path: String = native_list_get(positional, 0)

-    // When --emit-header is requested, lex the source file and do a
-    // token-level signature scan (no full AST) to write a .elh file.
-    // This avoids OOM on large files with HTML template bodies or deep
-    // BinOp chains (e.g. checkout.el) — parse() builds O(whole-program AST)
-    // while scan_fn_sigs_el keeps peak memory at O(tokens).
+    // When --emit-header is requested, parse the source file directly
+    // (without inlining imports) and write out a .elh file alongside the .c.
    if do_emit_header {
-        el_mem_check()
        let raw_source: String = fs_read(src_path)
        let hdr_tokens: [Any] = lex(raw_source)
-        let hdr_sigs: [Map<String, Any>] = scan_fn_sigs_el(hdr_tokens)
+        let hdr_stmts: [Map<String, Any>] = parse(hdr_tokens)
        el_release(hdr_tokens)
        let hdr_path: String = str_slice(src_path, 0, str_len(src_path) - 3) + ".elh"
-        emit_header_from_sigs(hdr_sigs, hdr_path)
-        el_release(hdr_sigs)
+        emit_header(hdr_stmts, hdr_path)
+        el_release(hdr_stmts)
    }

    let source: String = resolve_imports(src_path)
@@ -293,48 +293,6 @@ fn is_void_element(name: String) -> Bool {
    false
 }

-// Collect all tokens as raw text until </tag_name> is encountered.
-// Used for <style> and <script> elements to avoid parsing CSS/JS as El.
-// Returns { "text": "...", "pos": p_after_closing_tag }
-fn parse_raw_text_content(tokens: [Any], pos: Int, tag_name: String) -> Map<String, Any> {
-    let parts: [String] = native_list_empty()
-    let p = pos
-    let running = true
-    while running {
-        let k = tok_kind(tokens, p)
-        if str_eq(k, "Eof") {
-            let running = false
-        } else {
-            if str_eq(k, "Lt") {
-                let k2 = tok_kind(tokens, p + 1)
-                if str_eq(k2, "Slash") {
-                    // Check if this is </tag_name>
-                    let close_name = tok_value(tokens, p + 2)
-                    if str_eq(close_name, tag_name) {
-                        // consume </tag_name>
-                        let p = p + 3
-                        let p = expect(tokens, p, "Gt")
-                        let running = false
-                    } else {
-                        let v = tok_value(tokens, p)
-                        let parts = native_list_append(parts, v)
-                        let p = p + 1
-                    }
-                } else {
-                    let v = tok_value(tokens, p)
-                    let parts = native_list_append(parts, v)
-                    let p = p + 1
-                }
-            } else {
-                let v = tok_value(tokens, p)
-                let parts = native_list_append(parts, v)
-                let p = p + 1
-            }
-        }
-    }
-    { "text": str_join(parts, ""), "pos": p }
-}
-
 // Collect tokens as text content until we hit Lt, LBrace, Eof, or a
 // closing-tag marker (Lt Slash). Returns { "text": "...", "pos": p }
 fn parse_html_text_tokens(tokens: [Any], pos: Int) -> Map<String, Any> {
@@ -362,7 +320,7 @@ fn parse_html_text_tokens(tokens: [Any], pos: Int) -> Map<String, Any> {
            }
        }
    }
-    { "text": str_join(parts, ""), "pos": p }
+    { "text": str_join(parts, " "), "pos": p }
 }

 // Parse an attribute list: (attrname | attrname="val" | attrname={expr})*
@@ -477,125 +435,77 @@ fn parse_html_children(tokens: [Any], pos: Int, parent_tag: String) -> Map<Strin
                }
            } else {
                if str_eq(k, "LBrace") {
-                    // Interpolation: {expr}, {#each ...}, {#if ...}, {#else}, {/each}, {/if}
-                    // Note: '#' (ASCII 35) is skipped by the lexer, so {#each} lexes as
-                    // LBrace Ident:"each" ... and {#if} lexes as LBrace If ... and
-                    // {#else} lexes as LBrace Else RBrace.
+                    // Interpolation: {expr} or {#each ...} or {/each}
                    let k2 = tok_kind(tokens, p + 1)
-                    if str_eq(k2, "Slash") {
-                        // {/each} or {/if} — end of block, stop
-                        // skip { /
-                        let p = p + 2
-                        // skip the close-tag name token (each, if, etc.)
-                        let p = p + 1
-                        // skip }
-                        let p = expect(tokens, p, "RBrace")
-                        let running = false
-                    } else {
-                        if str_eq(k2, "If") {
-                            // {#if condition} ... {/if}
-                            // Skip { if (2 tokens; '#' was silently skipped by lexer)
-                            let p = p + 2
-                            // Parse condition expression (no block expr)
+                    if str_eq(k2, "Hash") {
+                        // {#each list as item}
+                        let k3_v = tok_value(tokens, p + 2)
+                        if str_eq(k3_v, "each") {
+                            let p = p + 3
+                            // parse list expr up to "as" keyword
                            let prev_no_block: String = state_get("__no_block_expr")
                            state_set("__no_block_expr", "1")
-                            let r_cond = parse_expr(tokens, p)
+                            let r_list = parse_expr(tokens, p)
                            state_set("__no_block_expr", prev_no_block)
-                            let cond_expr = r_cond["node"]
-                            let p = r_cond["pos"]
-                            el_release(r_cond)
+                            let list_expr = r_list["node"]
+                            let p = r_list["pos"]
+                            // r_list result map fully consumed — release to free peak heap.
+                            el_release(r_list)
+                            // expect "as"
+                            let p = expect(tokens, p, "As")
+                            // item variable name
+                            let item_name = tok_value(tokens, p)
+                            let p = p + 1
                            // consume closing }
                            let p = expect(tokens, p, "RBrace")
-                            // parse then-children until {#else} or {/if}
-                            let r_then = parse_html_children(tokens, p, "__if_then__")
-                            let then_children = r_then["children"]
-                            let p = r_then["pos"]
-                            el_release(r_then)
-                            // check for {#else} — lexed as LBrace Else RBrace
-                            let else_children: [Map<String, Any>] = native_list_empty()
-                            let ck = tok_kind(tokens, p)
-                            if str_eq(ck, "LBrace") {
-                                let ck2 = tok_kind(tokens, p + 1)
-                                if str_eq(ck2, "Else") {
-                                    // consume { else }
-                                    let p = p + 2
-                                    let p = expect(tokens, p, "RBrace")
-                                    // parse else-children until {/if}
-                                    let r_else = parse_html_children(tokens, p, "__if_else__")
-                                    let else_children = r_else["children"]
-                                    let p = r_else["pos"]
-                                    el_release(r_else)
+                            // parse body until {/each}
+                            let r_body = parse_html_each_body(tokens, p)
+                            let body_children = r_body["children"]
+                            let p = r_body["pos"]
+                            // r_body result map fully consumed — release to free peak heap.
+                            el_release(r_body)
+                            let each_node: Map<String, Any> = { "html": "Each", "list": list_expr, "item": item_name, "body": body_children }
+                            let children = native_list_append(children, each_node)
+                        } else {
+                            let p = p + 1
+                        }
+                    } else {
+                        if str_eq(k2, "Slash") {
+                            // {/each} — end of each block, stop
+                            // skip {/each}
+                            let p = p + 2
+                            // skip "each"
+                            let p = p + 1
+                            // skip }
+                            let p = expect(tokens, p, "RBrace")
+                            let running = false
+                        } else {
+                            // regular {expr}
+                            let r = parse_expr(tokens, p + 1)
+                            let interp_val = r["node"]
+                            let p = r["pos"]
+                            // r result map fully consumed — release to free peak heap.
+                            el_release(r)
+                            let p = expect(tokens, p, "RBrace")
+                            // Check if the expr is a call to raw()
+                            let is_raw_call = false
+                            let interp_kind: String = interp_val["expr"]
+                            if str_eq(interp_kind, "Call") {
+                                let fn_node = interp_val["func"]
+                                let fn_kind: String = fn_node["expr"]
+                                if str_eq(fn_kind, "Ident") {
+                                    let fn_name_v: String = fn_node["name"]
+                                    if str_eq(fn_name_v, "raw") {
+                                        let is_raw_call = true
+                                    }
                                }
                            }
-                            let if_node: Map<String, Any> = { "html": "HtmlIf", "cond": cond_expr, "then": then_children, "else": else_children }
-                            let children = native_list_append(children, if_node)
-                        } else {
-                            if str_eq(k2, "Else") {
-                                // {#else} sentinel — lexed as LBrace Else RBrace
-                                // Do NOT consume — leave position for caller ({#if} handler checks for it)
-                                let running = false
+                            if is_raw_call {
+                                let raw_args = interp_val["args"]
+                                let raw_inner = native_list_get(raw_args, 0)
+                                let children = native_list_append(children, { "html": "Raw", "value": raw_inner })
                            } else {
-                                // Check for {#each list as item} — lexed as LBrace Ident:"each" ...
-                                let k2_v = tok_value(tokens, p + 1)
-                                if str_eq(k2_v, "each") {
-                                    let p = p + 2
-                                    // parse list expr up to "as" keyword
-                                    let prev_no_block: String = state_get("__no_block_expr")
-                                    state_set("__no_block_expr", "1")
-                                    let r_list = parse_expr(tokens, p)
-                                    state_set("__no_block_expr", prev_no_block)
-                                    let list_expr = r_list["node"]
-                                    let p = r_list["pos"]
-                                    // r_list result map fully consumed — release to free peak heap.
-                                    el_release(r_list)
-                                    // expect "as"
-                                    let p = expect(tokens, p, "As")
-                                    // item variable name
-                                    let item_name = tok_value(tokens, p)
-                                    let p = p + 1
-                                    // consume closing }
-                                    let p = expect(tokens, p, "RBrace")
-                                    // parse body until {/each}
-                                    let r_body = parse_html_each_body(tokens, p)
-                                    let body_children = r_body["children"]
-                                    let p = r_body["pos"]
-                                    // r_body result map fully consumed — release to free peak heap.
-                                    el_release(r_body)
-                                    let each_node: Map<String, Any> = { "html": "Each", "list": list_expr, "item": item_name, "body": body_children }
-                                    let children = native_list_append(children, each_node)
-                                } else {
-                                    // regular {expr} — disable map-literal parsing so {fn(a,b)}
-                                    // does not trigger the LBrace→map path inside parse_primary
-                                    let prev_no_block: String = state_get("__no_block_expr")
-                                    state_set("__no_block_expr", "1")
-                                    let r = parse_expr(tokens, p + 1)
-                                    state_set("__no_block_expr", prev_no_block)
-                                    let interp_val = r["node"]
-                                    let p = r["pos"]
-                                    // r result map fully consumed — release to free peak heap.
-                                    el_release(r)
-                                    let p = expect(tokens, p, "RBrace")
-                                    // Check if the expr is a call to raw()
-                                    let is_raw_call = false
-                                    let interp_kind: String = interp_val["expr"]
-                                    if str_eq(interp_kind, "Call") {
-                                        let fn_node = interp_val["func"]
-                                        let fn_kind: String = fn_node["expr"]
-                                        if str_eq(fn_kind, "Ident") {
-                                            let fn_name_v: String = fn_node["name"]
-                                            if str_eq(fn_name_v, "raw") {
-                                                let is_raw_call = true
-                                            }
-                                        }
-                                    }
-                                    if is_raw_call {
-                                        let raw_args = interp_val["args"]
-                                        let raw_inner = native_list_get(raw_args, 0)
-                                        let children = native_list_append(children, { "html": "Raw", "value": raw_inner })
-                                    } else {
-                                        let children = native_list_append(children, { "html": "Interp", "value": interp_val })
-                                    }
-                                }
+                                let children = native_list_append(children, { "html": "Interp", "value": interp_val })
                            }
                        }
                    }
@@ -655,27 +565,6 @@ fn parse_html_element(tokens: [Any], pos: Int) -> Map<String, Any> {
    if is_void_element(tag_name) {
        return make_result({ "html": "Element", "tag": tag_name, "attrs": attrs, "children": native_list_empty(), "self_closing": true }, p)
    }
-    // raw-text mode for style/script — collect content as plain text without parsing CSS/JS as El
-    if str_eq(tag_name, "style") {
-        let r_raw = parse_raw_text_content(tokens, p, "style")
-        let raw_text: String = r_raw["text"]
-        let p = r_raw["pos"]
-        el_release(r_raw)
-        let raw_child: Map<String, Any> = { "html": "Text", "text": raw_text }
-        let raw_children: [Map<String, Any>] = native_list_empty()
-        let raw_children = native_list_append(raw_children, raw_child)
-        return make_result({ "html": "Element", "tag": tag_name, "attrs": attrs, "children": raw_children, "self_closing": false }, p)
-    }
-    if str_eq(tag_name, "script") {
-        let r_raw = parse_raw_text_content(tokens, p, "script")
-        let raw_text: String = r_raw["text"]
-        let p = r_raw["pos"]
-        el_release(r_raw)
-        let raw_child: Map<String, Any> = { "html": "Text", "text": raw_text }
-        let raw_children: [Map<String, Any>] = native_list_empty()
-        let raw_children = native_list_append(raw_children, raw_child)
-        return make_result({ "html": "Element", "tag": tag_name, "attrs": attrs, "children": raw_children, "self_closing": false }, p)
-    }
    // parse children
    let r_children = parse_html_children(tokens, p, tag_name)
    let children = r_children["children"]
@@ -829,123 +718,44 @@ fn parse_primary(tokens: [Any], pos: Int) -> Map<String, Any> {
            // as the start of the block they're expecting.
            return make_result({ "expr": "Nil" }, pos)
        }
-        // Distinguish map literal from interpolation chain.
-        // A map literal requires { key: value } — the second token inside { must be Colon.
-        // An empty {} is a map literal.  Everything else is an interpolation chain.
-        let first_k: String = tok_kind(tokens, pos + 1)
-        let second_k: String = tok_kind(tokens, pos + 2)
-        if str_eq(first_k, "RBrace") {
-            // Empty map literal {}
-            return make_result({ "expr": "Map", "pairs": native_list_empty() }, pos + 2)
-        }
-        if str_eq(second_k, "Colon") {
-            // MAP LITERAL: { key: value, ... }
-            let p = pos + 1
-            let pairs: [Map<String, Any>] = native_list_empty()
-            let running = true
-            while running {
-                let k2 = tok_kind(tokens, p)
-                if k2 == "RBrace" {
+        let p = pos + 1
+        let pairs: [Map<String, Any>] = native_list_empty()
+        let running = true
+        while running {
+            let k2 = tok_kind(tokens, p)
+            if k2 == "RBrace" {
+                let running = false
+            } else {
+                if k2 == "Eof" {
                    let running = false
                } else {
-                    if k2 == "Eof" {
-                        let running = false
+                    // key: Str token
+                    let key = tok_value(tokens, p)
+                    let new_p: Int = p + 1
+                    let new_p = expect(tokens, new_p, "Colon")
+                    let r = parse_expr(tokens, new_p)
+                    let val_node = r["node"]
+                    let new_p = r["pos"]
+                    // r result map fully consumed — release to free peak heap.
+                    el_release(r)
+                    let pair = { "key": key, "value": val_node }
+                    let pairs = native_list_append(pairs, pair)
+                    let k3 = tok_kind(tokens, new_p)
+                    if k3 == "Comma" {
+                        let new_p = new_p + 1
+                    }
+                    // Non-progress guard: malformed map content can leave
+                    // parse_expr returning the same pos. Force advance.
+                    if new_p <= p {
+                        let p = p + 1
                    } else {
-                        // key: Str or Ident token
-                        let key = tok_value(tokens, p)
-                        let new_p: Int = p + 1
-                        let new_p = expect(tokens, new_p, "Colon")
-                        let r = parse_expr(tokens, new_p)
-                        let val_node = r["node"]
-                        let new_p = r["pos"]
-                        // r result map fully consumed — release to free peak heap.
-                        el_release(r)
-                        let pair = { "key": key, "value": val_node }
-                        let pairs = native_list_append(pairs, pair)
-                        let k3 = tok_kind(tokens, new_p)
-                        if k3 == "Comma" {
-                            let new_p = new_p + 1
-                        }
-                        // Non-progress guard: malformed map content can leave
-                        // parse_expr returning the same pos. Force advance.
-                        if new_p <= p {
-                            let p = p + 1
-                        } else {
-                            let p = new_p
-                        }
+                        let p = new_p
                    }
                }
            }
-            let p = expect(tokens, p, "RBrace")
-            return make_result({ "expr": "Map", "pairs": pairs }, p)
        }
-        // INTERPOLATION CHAIN: {expr}, {expr}{expr}, {expr}<html>, etc.
-        // Build a BinOp(Plus, ...) concatenation chain.
-        let p = pos
-        let chain_node: Map<String, Any> = { "expr": "Nil" }
-        let chain_started = false
-        let chain_running = true
-        while chain_running {
-            let ck: String = tok_kind(tokens, p)
-            if str_eq(ck, "LBrace") {
-                let prev_no_block: String = state_get("__no_block_expr")
-                state_set("__no_block_expr", "1")
-                let r = parse_expr(tokens, p + 1)
-                state_set("__no_block_expr", prev_no_block)
-                let part = r["node"]
-                let p = r["pos"]
-                // r result map fully consumed — release to free peak heap.
-                el_release(r)
-                let p = expect(tokens, p, "RBrace")
-                if !chain_started {
-                    let chain_node = part
-                    let chain_started = true
-                } else {
-                    let chain_node: Map<String, Any> = { "expr": "BinOp", "op": "Plus", "left": chain_node, "right": part }
-                }
-            } else {
-                if str_eq(ck, "Lt") {
-                    let ck2: String = tok_kind(tokens, p + 1)
-                    if str_eq(ck2, "Not") {
-                        let r = parse_html_template(tokens, p)
-                        let part = r["node"]
-                        let p = r["pos"]
-                        // r result map fully consumed — release to free peak heap.
-                        el_release(r)
-                        if !chain_started {
-                            let chain_node = part
-                            let chain_started = true
-                        } else {
-                            let chain_node: Map<String, Any> = { "expr": "BinOp", "op": "Plus", "left": chain_node, "right": part }
-                        }
-                    } else {
-                        if str_eq(ck2, "Ident") {
-                            let tag_candidate: String = tok_value(tokens, p + 1)
-                            if is_html_tag_name(tag_candidate) {
-                                let r = parse_html_template(tokens, p)
-                                let part = r["node"]
-                                let p = r["pos"]
-                                // r result map fully consumed — release to free peak heap.
-                                el_release(r)
-                                if !chain_started {
-                                    let chain_node = part
-                                    let chain_started = true
-                                } else {
-                                    let chain_node: Map<String, Any> = { "expr": "BinOp", "op": "Plus", "left": chain_node, "right": part }
-                                }
-                            } else {
-                                let chain_running = false
-                            }
-                        } else {
-                            let chain_running = false
-                        }
-                    }
-                } else {
-                    let chain_running = false
-                }
-            }
-        }
-        return make_result(chain_node, p)
+        let p = expect(tokens, p, "RBrace")
+        return make_result({ "expr": "Map", "pairs": pairs }, p)
    }

    // if expression
@@ -2065,219 +1875,6 @@ fn skip_expr_to_stmt_boundary(tokens: [Any], pos: Int) -> Int {
    p
 }

-// scan_type_el — read a type annotation starting at pos and return its El
-// source representation as a string, plus the new position.
-// Returns { "el": String, "pos": Int }.
-// Handles: Ident, [Type], Map<K,V>, Type?, Type<T,...> (same shapes as skip_type).
-fn scan_type_el(tokens: [Any], pos: Int) -> Map<String, Any> {
-    let k: String = tok_kind(tokens, pos)
-    // Array type: [Type]
-    if str_eq(k, "LBracket") {
-        let p: Int = pos + 1
-        let inner = scan_type_el(tokens, p)
-        let inner_str: String = inner["el"]
-        let p = inner["pos"]
-        el_release(inner)
-        let p = expect(tokens, p, "RBracket")
-        return { "el": "[" + inner_str + "]", "pos": p }
-    }
-    // Named type (possibly generic or optional)
-    if str_eq(k, "Ident") {
-        let name: String = tok_value(tokens, pos)
-        let p: Int = pos + 1
-        let k2: String = tok_kind(tokens, p)
-        if str_eq(k2, "Lt") {
-            // Generic params: collect until matching >
-            let p = p + 1
-            let depth: Int = 1
-            let parts: [String] = native_list_empty()
-            let parts = native_list_append(parts, name + "<")
-            let running: Bool = true
-            while running {
-                let kk: String = tok_kind(tokens, p)
-                if str_eq(kk, "Eof") {
-                    let running = false
-                } else {
-                    if str_eq(kk, "Lt") {
-                        let depth = depth + 1
-                        let parts = native_list_append(parts, "<")
-                        let p = p + 1
-                    } else {
-                        if str_eq(kk, "Gt") {
-                            let depth = depth - 1
-                            let p = p + 1
-                            if depth <= 0 {
-                                let parts = native_list_append(parts, ">")
-                                let running = false
-                            } else {
-                                let parts = native_list_append(parts, ">")
-                            }
-                        } else {
-                            if str_eq(kk, "Comma") {
-                                let parts = native_list_append(parts, ", ")
-                                let p = p + 1
-                            } else {
-                                let parts = native_list_append(parts, tok_value(tokens, p))
-                                let p = p + 1
-                            }
-                        }
-                    }
-                }
-            }
-            let k3: String = tok_kind(tokens, p)
-            if str_eq(k3, "QuestionMark") { let p = p + 1 }
-            let result: String = str_join(parts, "")
-            el_release(parts)
-            return { "el": result, "pos": p }
-        }
-        // Optional marker
-        if str_eq(k2, "QuestionMark") {
-            return { "el": name + "?", "pos": p + 1 }
-        }
-        return { "el": name, "pos": p }
-    }
-    // Fallback: unknown token, treat as Any
-    { "el": "Any", "pos": pos + 1 }
-}
-
-// scan_params_el — scan a parameter list `(name: Type, ...)` starting at
-// position `pos` (which should point at LParen) and return the El parameter
-// declaration string (e.g. "a: String, b: Int") along with the new position.
-// Returns { "el": String, "pos": Int }.
-// Used by scan_fn_sigs_el for --emit-header without building full AST.
-fn scan_params_el(tokens: [Any], pos: Int) -> Map<String, Any> {
-    let p: Int = expect(tokens, pos, "LParen")
-    let parts: [String] = native_list_empty()
-    let going: Bool = true
-    while going {
-        let kk: String = tok_kind(tokens, p)
-        if str_eq(kk, "RParen") {
-            let going = false
-        } else {
-            if str_eq(kk, "Eof") {
-                let going = false
-            } else {
-                let pname: String = tok_value(tokens, p)
-                let p = p + 1
-                let p = expect(tokens, p, "Colon")
-                let tr = scan_type_el(tokens, p)
-                let ptype: String = tr["el"]
-                let p = tr["pos"]
-                el_release(tr)
-                let parts = native_list_append(parts, pname + ": " + ptype)
-                let k2: String = tok_kind(tokens, p)
-                if str_eq(k2, "Comma") {
-                    let p = p + 1
-                }
-            }
-        }
-    }
-    let p = expect(tokens, p, "RParen")
-    let el_str: String = str_join(parts, ", ")
-    el_release(parts)
-    { "el": el_str, "pos": p }
-}
-
-// scan_fn_sigs_el — lightweight token-level pre-scan for --emit-header.
-//
-// Like scan_fn_sigs but captures El-style type strings instead of C types.
-// Only records fn/extern_fn entries (header generation ignores lets/blocks).
-//
-// Descriptor shape:
-//   { "kind": "fn"|"extern_fn", "name": String,
-//     "params_el": String,   <- El param list, e.g. "a: String, b: Int"
-//     "ret_el": String }     <- El return type, e.g. "String" or "Void"
-//
-// Peak memory: O(tokens) with no expression AST allocation.
-fn scan_fn_sigs_el(tokens: [Any]) -> [Map<String, Any>] {
-    let total: Int = native_list_len(tokens) / 2
-    let sigs: [Map<String, Any>] = native_list_empty()
-    let pos: Int = 0
-    let going: Bool = true
-    while going {
-        if pos >= total {
-            let going = false
-        } else {
-            let k: String = tok_kind(tokens, pos)
-            if str_eq(k, "Eof") {
-                let going = false
-            } else {
-                // --- fn definition ---
-                if str_eq(k, "Fn") {
-                    let p: Int = pos + 1
-                    let name: String = tok_value(tokens, p)
-                    let p = p + 1
-                    let pr = scan_params_el(tokens, p)
-                    let params_el: String = pr["el"]
-                    let p = pr["pos"]
-                    el_release(pr)
-                    // read return type
-                    let ret_el: String = "Any"
-                    let k2: String = tok_kind(tokens, p)
-                    if str_eq(k2, "Arrow") {
-                        let p = p + 1
-                        let tr = scan_type_el(tokens, p)
-                        let ret_el = tr["el"]
-                        let p = tr["pos"]
-                        el_release(tr)
-                    }
-                    // skip body
-                    let k3: String = tok_kind(tokens, p)
-                    if str_eq(k3, "LBrace") {
-                        let p = skip_to_rbrace(tokens, p)
-                    }
-                    if !str_eq(name, "main") {
-                        let sigs = native_list_append(sigs, {
-                            "kind": "fn",
-                            "name": name,
-                            "params_el": params_el,
-                            "ret_el": ret_el
-                        })
-                    }
-                    let pos = p
-                } else {
-                // --- extern fn ---
-                if str_eq(k, "Extern") {
-                    let p: Int = pos + 1
-                    let k2: String = tok_kind(tokens, p)
-                    if str_eq(k2, "Fn") {
-                        let p = p + 1
-                        let name: String = tok_value(tokens, p)
-                        let p = p + 1
-                        let pr = scan_params_el(tokens, p)
-                        let params_el: String = pr["el"]
-                        let p = pr["pos"]
-                        el_release(pr)
-                        let ret_el: String = "Any"
-                        let k3: String = tok_kind(tokens, p)
-                        if str_eq(k3, "Arrow") {
-                            let p = p + 1
-                            let tr = scan_type_el(tokens, p)
-                            let ret_el = tr["el"]
-                            let p = tr["pos"]
-                            el_release(tr)
-                        }
-                        let sigs = native_list_append(sigs, {
-                            "kind": "extern_fn",
-                            "name": name,
-                            "params_el": params_el,
-                            "ret_el": ret_el
-                        })
-                        let pos = p
-                    } else {
-                        let pos = pos + 1
-                    }
-                } else {
-                    // Let, Cgi, Service, Import, Type, Enum, From — skip to boundary.
-                    let p: Int = pos + 1
-                    let p = skip_expr_to_stmt_boundary(tokens, p)
-                    let pos = p
-                }}}
-            }
-        }
-    sigs
-}
-
 // scan_params_c — scan a parameter list `(name: Type, ...)` starting at
 // position `pos` (which should point at LParen) and return the C parameter
 // declaration string along with the new position.
@@ -77,33 +77,6 @@ fn parse_manifest_entry(src: String) -> String {
    return ""
 }

-// parse_manifest_c_sources - collect all `c_source "path"` lines from the
-// build block.  Returns a flat list of path strings.
-fn parse_manifest_c_sources(src: String) -> [String] {
-    let result: [String] = native_list_empty()
-    let lines: [String] = str_split(src, "\n")
-    let n: Int = native_list_len(lines)
-    let i = 0
-    while i < n {
-        let line: String = native_list_get(lines, i)
-        let t: String = str_trim(line)
-        if str_starts_with(t, "c_source ") {
-            let after: String = str_slice(t, 9, str_len(t))
-            let trimmed: String = str_trim(after)
-            if str_starts_with(trimmed, "\"") {
-                let inner: String = str_slice(trimmed, 1, str_len(trimmed))
-                let q: Int = str_index_of(inner, "\"")
-                if q >= 0 {
-                    let path: String = str_slice(inner, 0, q)
-                    let result = native_list_append(result, path)
-                }
-            }
-        }
-        let i = i + 1
-    }
-    return result
-}
-
 fn parse_manifest_name(src: String) -> String {
    let lines: [String] = str_split(src, "\n")
    let n: Int = native_list_len(lines)
@@ -283,12 +256,6 @@ fn compile_module(src_path: String, out_dir: String, elc_bin: String, dry_run: B
    }
    exec_command("rm -f " + err_tmp)

-    // Strip capability-violation guard #error lines injected by elc when a
-    // module is compiled in isolation (utility context).  These are safe to
-    // remove here: the entire binary is linked under the CGI entry-point
-    // declaration in soul.el, so the module-level guard is redundant.
-    exec_command("sed -i.bak '/^#error \"capability violation/d' " + c_out + " && rm -f " + c_out + ".bak")
-
    // Move the generated .elh (written next to the source by elc) into
    // out_dir so that #include "module.elh" lines in the generated .c
    // files resolve correctly when cc is invoked with -I <out_dir>.
@@ -307,22 +274,7 @@ fn link_binary(c_files: [String], out_bin: String, runtime_path: String, out_dir
    // Detect clang vs gcc: -fbracket-depth is clang-only; silently ignored
    // if unsupported but gcc rejects it with an error.
    let bracket_flag: String = "$(cc --version 2>&1 | grep -q clang && printf -- '-fbracket-depth=1024' || true)"
-    // On macOS, OpenSSL is not on the default linker path. Detect homebrew
-    // prefix and add it if present (no-op on Linux where libssl is in /usr/lib).
-    let ossl_lib_flag: String = "$(brew --prefix openssl 2>/dev/null | xargs -I{} printf -- '-L{}/lib' 2>/dev/null || true)"
-    let ossl_inc_flag: String = "$(brew --prefix openssl 2>/dev/null | xargs -I{} printf -- '-I{}/include' 2>/dev/null || true)"
-    // liboqs (post-quantum crypto) — present on macOS dev machines, not on CI
-    // Linux containers.  Link -loqs only when the library is available.
-    let oqs_lib_flag: String = "$(brew --prefix liboqs 2>/dev/null | xargs -I{} printf -- '-L{}/lib -loqs' 2>/dev/null || true)"
-    let oqs_inc_flag: String = "$(brew --prefix liboqs 2>/dev/null | xargs -I{} printf -- '-I{}/include' 2>/dev/null || true)"
-    // Force-include the C-level master declarations header so every translation
-    // unit sees all cross-module function signatures. Handles packages (like ELP)
-    // where modules call each other without explicit El import statements.
-    // The header is generated by elb --gen-decls or manually placed in out_dir.
-    let master_decls: String = out_dir + "/elp-c-decls.h"
-    let has_master: String = str_trim(exec_capture("test -f " + master_decls + " && echo yes || echo no"))
-    let include_flag: String = if str_eq(has_master, "yes") { "-include " + master_decls } else { "" }
-    let parts = native_list_append(parts, "cc -O2 -DHAVE_CURL " + bracket_flag + " " + ossl_inc_flag + " " + oqs_inc_flag + " " + include_flag + " -I " + dirname_of(runtime_path) + " -I " + out_dir)
+    let parts = native_list_append(parts, "cc -O2 " + bracket_flag + " -I " + dirname_of(runtime_path) + " -I " + out_dir)
    let i = 0
    while i < n {
        let f: String = native_list_get(c_files, i)
@@ -330,7 +282,7 @@ fn link_binary(c_files: [String], out_bin: String, runtime_path: String, out_dir
        let i = i + 1
    }
    let parts = native_list_append(parts, runtime_path)
-    let parts = native_list_append(parts, ossl_lib_flag + " " + oqs_lib_flag + " -lcurl -lssl -lcrypto -lpthread -lm")
+    let parts = native_list_append(parts, "-lcurl -lssl -lcrypto -lpthread -lm")
    let parts = native_list_append(parts, "-o " + out_bin)
    let cmd: String = str_join(parts, " ")
    println("  link     " + out_bin)
@@ -363,7 +315,6 @@ fn main() -> Void {

    let pkg_name: String = parse_manifest_name(manifest_src)
    let entry: String    = parse_manifest_entry(manifest_src)
-    let extra_c: [String] = parse_manifest_c_sources(manifest_src)
    if str_eq(entry, "") {
        println("elb: manifest.el has no 'entry' declaration")
        exit(1)
@@ -442,23 +393,9 @@ fn main() -> Void {
        exit(1)
    }

-    // Link — use only the entry-point .c file (which elc compiles as a
-    // monolithic unit, inlining all imports).  Linking all module .c files
-    // together causes duplicate-symbol errors because each module's .c also
-    // inlines its full import tree.
-    let entry_c: String = out_dir + "/" + basename_noext(entry) + ".c"
-    let link_files: [String] = native_list_empty()
-    let link_files = native_list_append(link_files, entry_c)
-    // Append any extra C sources declared in the manifest (e.g. platform stubs)
-    let ei = 0
-    let en: Int = native_list_len(extra_c)
-    while ei < en {
-        let ec: String = native_list_get(extra_c, ei)
-        let link_files = native_list_append(link_files, ec)
-        let ei = ei + 1
-    }
+    // Link
    let out_bin: String = out_dir + "/" + pkg_name
-    let linked: Bool = link_binary(link_files, out_bin, runtime_path, out_dir, dry_run)
+    let linked: Bool = link_binary(c_files, out_bin, runtime_path, out_dir, dry_run)
    if !linked {
        println("elb: link failed")
        exit(1)
@@ -1,5 +0,0 @@
-CompileFlags:
-  Add:
-    - -I/opt/homebrew/Cellar/liboqs/0.15.0/include
-    - -I/opt/homebrew/opt/openssl@3/include
-    - -std=c11
@@ -143,7 +143,6 @@ el_val_t  http_post_with_headers(el_val_t url, el_val_t body, el_val_t headers_m
 el_val_t  http_post_form_auth(el_val_t url, el_val_t form_body, el_val_t auth_header);
 el_val_t  http_delete(el_val_t url);
 void      http_serve(el_val_t port, el_val_t handler);
-void      http_serve_async(el_val_t port, el_val_t handler);
 void      http_set_handler(el_val_t name);

 /* HTTP server v2 ─────────────────────────────────────────────────────────────
@@ -430,22 +429,10 @@ el_val_t  str_to_float(el_val_t s);
 el_val_t  math_sqrt(el_val_t f);
 el_val_t  math_log(el_val_t f);
 el_val_t  math_ln(el_val_t f);
-el_val_t  math_exp(el_val_t f);
 el_val_t  math_sin(el_val_t f);
 el_val_t  math_cos(el_val_t f);
 el_val_t  math_pi(void);

-/* ── Float arithmetic builtins (correct IEEE 754 via bit-cast round-trip) ─── */
-el_val_t  float_add(el_val_t a, el_val_t b);
-el_val_t  float_sub(el_val_t a, el_val_t b);
-el_val_t  float_mul(el_val_t a, el_val_t b);
-el_val_t  float_div(el_val_t a, el_val_t b);
-el_val_t  float_gt(el_val_t a, el_val_t b);
-el_val_t  float_lt(el_val_t a, el_val_t b);
-el_val_t  float_eq(el_val_t a, el_val_t b);
-el_val_t  float_gte(el_val_t a, el_val_t b);
-el_val_t  float_lte(el_val_t a, el_val_t b);
-
 /* ── String additions ────────────────────────────────────────────────────── */

 el_val_t  str_index_of(el_val_t s, el_val_t sub);
@@ -505,7 +492,6 @@ el_val_t  str_join(el_val_t list, el_val_t sep);            /* alias of list_joi

 el_val_t  list_push(el_val_t list, el_val_t elem);
 el_val_t  list_push_front(el_val_t list, el_val_t elem);
-el_val_t  list_set(el_val_t list, el_val_t index, el_val_t value);
 el_val_t  list_join(el_val_t list, el_val_t sep);
 el_val_t  list_range(el_val_t start, el_val_t end);

@@ -603,10 +589,6 @@ el_val_t  engram_edge_count(void);
 el_val_t  engram_activate(el_val_t query, el_val_t depth);
 el_val_t  engram_save(el_val_t path);
 el_val_t  engram_load(el_val_t path);
-el_val_t  engram_load_dir(el_val_t data_dir);
-el_val_t  engram_reindex_json(void);
-el_val_t  engram_write_binary_el(el_val_t path);
-el_val_t  engram_load_binary_el(el_val_t path);

 /* JSON-string accessors — return pre-serialized JSON so HTTP handlers
 * can pass results straight through without round-tripping ElList/ElMap
@@ -618,10 +600,6 @@ el_val_t  engram_scan_nodes_by_type_json(el_val_t node_type, el_val_t limit, el_
 el_val_t  engram_neighbors_json(el_val_t node_id, el_val_t max_depth, el_val_t direction);
 el_val_t  engram_activate_json(el_val_t query, el_val_t depth);
 el_val_t  engram_stats_json(void);
-el_val_t  engram_wm_count(void);
-el_val_t  engram_wm_avg_weight(void);  /* avg wm weight of promoted nodes; float bits */
-el_val_t  engram_wm_top_json(el_val_t n);  /* top-N WM nodes by weight as compact JSON */
-el_val_t  engram_apply_decay_json(void);
 el_val_t  engram_list_layers_json(void);
 /* engram_compile_layered_json — produce a prompt-ready text block split
 * into "[LAYER 0 — STRUCTURAL]" (non-suppressible layers, sacred fire)
@@ -6,15 +6,55 @@
 //
 // Dependencies: runtime/string.el, runtime/json.el

+// --- Validation (defense in depth) ---
+// el_val_t is an untyped machine word, so a wrong TYPE can't be caught here — but a
+// wrong VALUE can (a tier in the node_type slot, an empty/garbage string, an int, a
+// path, a model name, a cgi id). Reject loudly instead of silently writing junk.
+
+fn engram_valid_node_type(t: String) -> Bool {
+    return str_eq(t, "Memory") || str_eq(t, "Knowledge") || str_eq(t, "Belief")
+        || str_eq(t, "Project") || str_eq(t, "Tag") || str_eq(t, "BacklogItem")
+        || str_eq(t, "Artifact") || str_eq(t, "Conversation") || str_eq(t, "ExecutionContext")
+        || str_eq(t, "InternalStateEvent") || str_eq(t, "Self") || str_eq(t, "Entity")
+        || str_eq(t, "Process") || str_eq(t, "ConfigEntry") || str_eq(t, "Concept") || str_eq(t, "Imprint")
+        || str_eq(t, "SessionSummary")
+}
+
+fn engram_valid_tier(t: String) -> Bool {
+    return str_eq(t, "Semantic") || str_eq(t, "Episodic") || str_eq(t, "Working")
+        || str_eq(t, "Procedural") || str_eq(t, "Canonical") || str_eq(t, "Note") || str_eq(t, "Lesson")
+}
+
 // --- Node creation ---

 fn engram_node(content: String, node_type: String, salience: Float) -> String {
+    if !engram_valid_node_type(node_type) {
+        __println("[engram] REJECTED node write — invalid node_type '" + node_type + "'")
+        return ""
+    }
    return __engram_node(content, node_type, salience)
 }

-fn engram_node_full(content: String, nt: String, sal: Float, imp: Float,
-                    source: String, lang: String, ts: Int, tags: String) -> String {
-    return __engram_node_full(content, nt, sal, imp, source, lang, ts, tags)
+// Signature MUST match the C primitive __engram_node_full exactly (el_seed.h):
+//   (content, node_type, label, salience, importance, confidence, tier, tags)
+// The previous wrapper declared a stale 8-arg schema with wrong names AND types
+// (sal:Float at the label slot, ts:Int at the tier slot). Because el_val_t is an
+// untyped machine word, the EL compiler coerced caller args to those wrong param
+// types and then forwarded them BY POSITION into the C function — so tier received
+// an int, importance/confidence received strings, label received a float, etc.
+// That is the field-corruption bug. Match the contract 1:1 — no coercion, no reorder.
+fn engram_node_full(content: String, node_type: String, label: String,
+                    salience: Float, importance: Float, confidence: Float,
+                    tier: String, tags: String) -> String {
+    if !engram_valid_node_type(node_type) {
+        __println("[engram] REJECTED node write — invalid node_type '" + node_type + "' (label=" + label + ")")
+        return ""
+    }
+    if !engram_valid_tier(tier) {
+        __println("[engram] REJECTED node write — invalid tier '" + tier + "' (node_type=" + node_type + ", label=" + label + ")")
+        return ""
+    }
+    return __engram_node_full(content, node_type, label, salience, importance, confidence, tier, tags)
 }

 // --- Node retrieval ---
Author	SHA1	Message	Date
Tim Lingo	c2afcbddf5	fix(engram): allow SessionSummary node_type in validation allowlist El SDK CI - dev / build-and-test (pull_request) Successful in 3m47s Details handle_api_consolidate writes a "SessionSummary" node, but engram_valid_node_type omitted it — so once this validation ships, every consolidate() would be silently REJECTED at the engram boundary. Add SessionSummary to the allowlist. Found in Will's PR review of neuron #1 / el #52. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>	2026-06-10 06:26:25 -05:00
Tim Lingo	dfe4e83ed1	Fix engram_node_full wrapper field corruption + add node_type/tier validation El SDK Release / build-and-release (pull_request) Failing after 9s Details The wrapper signature was stale and didn't match the C primitive __engram_node_full(content, node_type, label, salience, importance, confidence, tier, tags). Because el_val_t is an untyped machine word, the compiler coerced caller args to the wrong declared param types and forwarded them BY POSITION — so tier received an int, importance/confidence received strings, label received a float, etc. (~100 corrupt nodes). - Correct the wrapper to match the C contract 1:1 (no coercion, no reorder). - Add engram_valid_node_type / engram_valid_tier allowlists; engram_node and engram_node_full now reject invalid values with __println + return "" (fail loud, no silent malformed write). See neuron repo: HANDOFF-engram-write-corruption.md for the full write-up + deploy runbook. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>	2026-06-08 16:13:43 -05:00
will.anderson	2ed6b26dde	Merge pull request 'promote: stage → main (all elb linker fixes + ci-base rebuild)' (#42 ) from stage into main El SDK Release / build-and-release (push) Successful in 6m28s Details promote: stage → main (all elb linker fixes + ci-base rebuild)	2026-05-07 14:25:37 +00:00
will.anderson	d8e9fd12f4	Merge pull request 'promote: dev → stage (all elb linker fixes)' (#41 ) from dev into stage El SDK Release / build-and-release (pull_request) Successful in 3m51s Details El SDK CI - stage / build-and-test (push) Successful in 4m11s Details promote: dev → stage (all elb linker fixes)	2026-05-07 14:20:53 +00:00
will.anderson	8fa9c4ba20	Merge pull request 'promote: dev → stage (elb linker fixes)' (#38 ) from dev into stage El SDK Release / build-and-release (pull_request) Failing after 1m2s Details El SDK CI - stage / build-and-test (push) Successful in 3m56s Details promote: dev → stage (elb linker fixes)	2026-05-07 08:11:38 +00:00
will.anderson	9c7bde47dc	Merge pull request 'promote: dev → stage (elb gcc fix)' (#35 ) from dev into stage El SDK Release / build-and-release (pull_request) Failing after 40s Details El SDK CI - stage / build-and-test (push) Successful in 3m45s Details promote: dev → stage (elb gcc fix)	2026-05-07 08:01:22 +00:00
will.anderson	c0553459e1	Merge pull request 'promote: dev → stage (CI rebuild fix + ci-base refresh)' (#32 ) from dev into stage El SDK Release / build-and-release (pull_request) Failing after 35s Details El SDK CI - stage / build-and-test (push) Successful in 3m47s Details promote: dev → stage (CI rebuild fix + ci-base refresh)	2026-05-07 07:50:27 +00:00
will.anderson	fd208583fe	Merge pull request 'promote: dev → stage (elb build fix)' (#28 ) from dev into stage El SDK CI - stage / build-and-test (push) Successful in 3m51s Details El SDK Release / build-and-release (pull_request) Failing after 38s Details promote: dev → stage (elb build fix)	2026-05-07 02:46:27 +00:00
will.anderson	3e29fc43ab	Merge pull request 'promote: dev → stage (__http_do_map_to_file)' (#25 ) from dev into stage El SDK CI - stage / build-and-test (push) Successful in 3m44s Details El SDK Release / build-and-release (pull_request) Failing after 47s Details	2026-05-07 02:14:30 +00:00
will.anderson	979a5677d5	Merge pull request 'promote: dev → stage (__-prefixed runtime fix)' (#22 ) from dev into stage El SDK CI - stage / build-and-test (push) Successful in 3m48s Details El SDK Release / build-and-release (pull_request) Failing after 1m4s Details	2026-05-07 01:48:32 +00:00
will.anderson	17b1aa0736	Merge pull request 'promote: dev → stage (return type fix)' (#19 ) from dev into stage El SDK CI - stage / build-and-test (push) Failing after 4m1s Details El SDK Release / build-and-release (pull_request) Failing after 42s Details	2026-05-07 01:12:18 +00:00
will.anderson	f0c731d2db	Merge pull request 'promote: dev → stage (runtime fix)' (#16 ) from dev into stage El SDK CI - stage / build-and-test (push) Successful in 3m43s Details El SDK Release / build-and-release (pull_request) Failing after 45s Details	2026-05-07 00:43:52 +00:00
will.anderson	e7e0f7d3e5	Merge pull request 'promote: dev → stage' (#12 ) from dev into stage El SDK CI - stage / build-and-test (push) Successful in 4m3s Details El SDK Release / build-and-release (pull_request) Failing after 37s Details	2026-05-07 00:23:46 +00:00