elb: fix monolithic link, capability violations, liboqs detection

- Link only the entry-point .c (monolithic) instead of all module .c
  files — prevents duplicate symbol errors from inlined imports
- Strip capability-violation #error guards post-compile; they fire
  incorrectly when modules are compiled in isolation but linked into
  a CGI program
- Add liboqs (post-quantum) include/lib detection via brew, matching
  the existing OpenSSL detection pattern

.gitea/workflows/engram-ci.yaml

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

engram/dist/engram.c

@@ -2,6 +2,11 @@
 #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);
@@ -20,16 +25,246 @@ 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_save(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_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 snapshot_path;
+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 parse_port(el_val_t bind) {
   el_val_t colon = str_index_of(bind, EL_STR(":"));
@@ -119,7 +354,8 @@ 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);
-  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("\"}"));
+  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 0;
 }
 
@@ -176,7 +412,7 @@ el_val_t route_search(el_val_t method, el_val_t path, el_val_t body) {
   if (limit == 0) {
     limit = 20;
   }
-  return engram_search_json(q, limit);
+  return bm25_search_json(q, limit);
   return 0;
 }
 
@@ -193,6 +429,17 @@ 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;
 }
@@ -243,30 +490,46 @@ el_val_t route_forget(el_val_t method, el_val_t path, el_val_t body) {
   return 0;
 }
 
-el_val_t route_save(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) {
+  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 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("{\"ok\":true,\"path\":\""), p), EL_STR("\"}"));
+  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 0;
 }
 
 el_val_t route_load(el_val_t method, el_val_t path, el_val_t body) {
-  el_val_t p = json_get_string(body, EL_STR("path"));
+  el_val_t dir = env(EL_STR("ENGRAM_DATA_DIR"));
-  if (str_eq(p, EL_STR(""))) {
+  if (str_eq(dir, EL_STR(""))) {
-    el_val_t dir = env(EL_STR("ENGRAM_DATA_DIR"));
+    dir = EL_STR("/tmp/engram");
-    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);
-    p = el_str_concat(dir, EL_STR("/snapshot.json"));
+  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"));
+    }
+    engram_load(p);
   }
-  engram_load(p);
   return ok_json();
   return 0;
 }
@@ -276,6 +539,344 @@ 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(""))) {
@@ -299,6 +900,60 @@ 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"));
   }
@@ -338,15 +993,80 @@ 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_save(method, path, body);
+    return route_export(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;
 }
@@ -362,9 +1082,20 @@ int main(int _argc, char** _argv) {
   if (str_eq(data_dir, EL_STR(""))) {
     data_dir = EL_STR("/tmp/engram");
   }
-  snapshot_path = el_str_concat(data_dir, EL_STR("/snapshot.json"));
+  db_path = el_str_concat(data_dir, EL_STR("/engram.db"));
-  engram_load(snapshot_path);
+  loaded = engram_load_binary_el(db_path);
-  println(EL_STR("[engram] runtime-native graph engine"));
+  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)"));
   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())));

engram/src/server.el

@@ -6,15 +6,297 @@
 // database.
 //
 // Built and linked with:
-//   elc src/server.el > server.c
+//   elc src/server.el > ../dist/engram.c
-//   cc -std=c11 -O2 -lcurl -lpthread -o engram server.c el_runtime.c
+//   cc -std=c11 -O2 \
-//   ./engram
+//     -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
 //
 // 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 {
@@ -83,7 +365,13 @@ 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)
-    "{\"id\":\"" + id + "\",\"content\":\"" + content + "\",\"node_type\":\"" + node_type + "\"}"
+
+    // 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) + "}"
 }
 
 fn route_get_node(method: String, path: String, body: String) -> String {
@@ -131,7 +419,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 engram_search_json(q, limit)
+    return bm25_search_json(q, limit)
 }
 
 fn route_activate(method: String, path: String, body: String) -> String {
@@ -145,6 +433,17 @@ 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) + "}"
 }
 
@@ -180,25 +479,41 @@ fn route_forget(method: String, path: String, body: String) -> String {
     ok_json()
 }
 
-fn route_save(method: String, path: String, body: String) -> String {
+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
     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,\"path\":\"" + p + "\"}"
+    "{\"ok\":true,\"binary\":\"" + db_path + "\",\"json\":\"" + p + "\"}"
+}
+
+fn route_reindex(method: String, path: String, body: String) -> String {
+    engram_reindex_json()
 }
 
 fn route_load(method: String, path: String, body: String) -> String {
-    let p: String = json_get_string(body, "path")
+    let dir: String = env("ENGRAM_DATA_DIR")
-    if str_eq(p, "") {
+    if str_eq(dir, "") { let dir = "/tmp/engram" }
-        let dir: String = env("ENGRAM_DATA_DIR")
+    let db_path: String = dir + "/engram.db"
-        if str_eq(dir, "") { let dir = "/tmp/engram" }
+    let ok: Bool = engram_load_binary_el(db_path)
-        let p = dir + "/snapshot.json"
+    if !ok {
+        let p: String = json_get_string(body, "path")
+        if str_eq(p, "") {
+            let p = dir + "/snapshot.json"
+        }
+        engram_load(p)
     }
-    engram_load(p)
     ok_json()
 }
 
@@ -206,6 +521,323 @@ 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 {
@@ -232,6 +864,63 @@ 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")
@@ -281,18 +970,93 @@ 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_save(method, path, body)
+        return route_export(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 + "\"}"
 }
@@ -303,13 +1067,28 @@ 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, try to load any existing snapshot (best effort).
+// On startup, load from binary database (ML-KEM-1024 encrypted).
+// Falls back to per-file JSON, then snapshot.json for migration from older formats.
 let data_dir: String = env("ENGRAM_DATA_DIR")
 if str_eq(data_dir, "") { let data_dir = "/tmp/engram" }
-let snapshot_path: String = data_dir + "/snapshot.json"
+let db_path: String = data_dir + "/engram.db"
-engram_load(snapshot_path)
+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")
+    }
+}
 
-println("[engram] runtime-native graph engine")
+println("[engram] runtime-native graph engine (ML-KEM-1024 encrypted)")
 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()))

lang/dist/platform/elc.c

@@ -4342,6 +4342,9 @@ 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;
   }
@@ -4546,6 +4549,12 @@ 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;
   }
@@ -4564,6 +4573,9 @@ 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;
   }

lang/el-compiler/runtime/el_runtime.c

@@ -7021,6 +7021,83 @@ 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
@@ -7116,6 +7193,66 @@ 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,
@@ -7889,6 +8026,97 @@ 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

lang/el-compiler/src/codegen.el

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

lang/elb.el

@@ -283,6 +283,12 @@ 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>.
@@ -305,6 +311,10 @@ fn link_binary(c_files: [String], out_bin: String, runtime_path: String, out_dir
     // 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.
@@ -312,7 +322,7 @@ fn link_binary(c_files: [String], out_bin: String, runtime_path: String, 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 " + bracket_flag + " " + ossl_inc_flag + " " + include_flag + " -I " + dirname_of(runtime_path) + " -I " + out_dir)
+    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 i = 0
     while i < n {
         let f: String = native_list_get(c_files, i)
@@ -320,7 +330,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 + " -lcurl -lssl -lcrypto -lpthread -lm")
+    let parts = native_list_append(parts, ossl_lib_flag + " " + oqs_lib_flag + " -lcurl -lssl -lcrypto -lpthread -lm")
     let parts = native_list_append(parts, "-o " + out_bin)
     let cmd: String = str_join(parts, " ")
     println("  link     " + out_bin)
@@ -432,18 +442,23 @@ 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 c_files = native_list_append(c_files, ec)
+        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(c_files, out_bin, runtime_path, out_dir, dry_run)
+    let linked: Bool = link_binary(link_files, out_bin, runtime_path, out_dir, dry_run)
     if !linked {
         println("elb: link failed")
         exit(1)

lang/releases/v1.0.0-20260501/.clangd

@@ -0,0 +1,5 @@
+CompileFlags:
+  Add:
+    - -I/opt/homebrew/Cellar/liboqs/0.15.0/include
+    - -I/opt/homebrew/opt/openssl@3/include
+    - -std=c11

lang/releases/v1.0.0-20260501/el_runtime.h

@@ -143,6 +143,7 @@ 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 ─────────────────────────────────────────────────────────────
@@ -429,10 +430,22 @@ 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);
@@ -492,6 +505,7 @@ 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);
 
@@ -589,6 +603,10 @@ 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
@@ -600,6 +618,10 @@ 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)