Merge pull request 'ci(dev): make SDK publish fail loudly, decouple ci-base rebuild' (#72) from hotfix/ci-dev-publish-hardening into dev

The dev push build went green-then-red while nothing published: the
Publish step had no set -e, so an auth/upload failure exited 0 (silent
no-publish), while the ci-base rebuild (set -euo pipefail + Docker on the
host-mode runner) hard-failed the job. Add set -euo pipefail + an empty-key
guard + active-account echo to the Publish step so failures surface with a
retrievable log, and mark the ci-base cache rebuild continue-on-error so
the fragile Docker step can never block the actual SDK artifact publish.

.gitea/workflows/ci-dev.yaml

@@ -214,9 +214,18 @@ jobs:
         env:
           GCP_SA_KEY: ${{ secrets.GCP_SA_KEY }}
         run: |
+          # Fail loudly: previously this step had no `set -e`, so an auth or
+          # upload failure was swallowed (step exited 0 on the trailing echo)
+          # and the SDK silently never published. Surface failures now.
+          set -euo pipefail
+          if [ -z "${GCP_SA_KEY:-}" ]; then
+            echo "FATAL: GCP_SA_KEY secret is empty — cannot authenticate to publish" >&2
+            exit 1
+          fi
           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
+          echo "Publishing as active account: $(gcloud config get-value account 2>/dev/null)"
 
           VERSION="${GITHUB_SHA:0:8}"
 
@@ -268,6 +277,12 @@ jobs:
         # Patches ci-base:dev in-place: pulls the existing image (which has all
         # system deps — Node, Go, gcloud, Docker CLI, etc.) and overlays the freshly
         # built El SDK on top. Keeps the full ci-base rebuild fast and incremental.
+        #
+        # continue-on-error: this is a CI-cache optimization, NOT the release
+        # artifact. It runs Docker (pull/build/push ~600MB) on the host-mode GCE
+        # runner where DinD/Docker availability is fragile. A failure here must
+        # never block or redden the job — the SDK publish above is the deliverable.
+        continue-on-error: true
         if: github.event_name == 'push'
         env:
           GCP_SA_KEY: ${{ secrets.GCP_SA_KEY }}

engram/.gitea/workflows/ci-dev.yaml

@@ -81,7 +81,7 @@ jobs:
       # Link to produce the engram binary
       - name: Link engram binary
         run: |
-          cc -std=c11 -O2 \
+          cc -std=c11 -O2 -DHAVE_CURL \
             -I /usr/local/lib/el \
             -o dist/engram \
             dist/engram.c \

engram/.gitea/workflows/ci-stage.yaml

@@ -88,7 +88,7 @@ jobs:
       # Link to produce the engram binary
       - name: Link engram binary
         run: |
-          cc -std=c11 -O2 \
+          cc -std=c11 -O2 -DHAVE_CURL \
             -I /usr/local/lib/el \
             -o dist/engram \
             dist/engram.c \

engram/.gitea/workflows/engram-release.yaml

@@ -62,7 +62,7 @@ jobs:
       # Link to produce the engram binary
       - name: Link engram binary
         run: |
-          cc -std=c11 -O2 \
+          cc -std=c11 -O2 -DHAVE_CURL \
             -I /usr/local/lib/el \
             -o dist/engram \
             dist/engram.c \

engram/dist/engram.c

@@ -10,7 +10,6 @@ el_val_t query_param(el_val_t path, el_val_t key);
 el_val_t query_int(el_val_t path, el_val_t key, el_val_t default_val);
 el_val_t extract_id(el_val_t path, el_val_t prefix);
 el_val_t route_stats(el_val_t method, el_val_t path, el_val_t body);
-el_val_t persist_canonical(void);
 el_val_t route_create_node(el_val_t method, el_val_t path, el_val_t body);
 el_val_t route_get_node(el_val_t method, el_val_t path, el_val_t body);
 el_val_t route_scan_nodes(el_val_t method, el_val_t path, el_val_t body);
@@ -21,23 +20,18 @@ 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_create_ise(el_val_t method, el_val_t path, el_val_t body);
+el_val_t route_sync(el_val_t method, el_val_t path, el_val_t body);
 el_val_t route_save(el_val_t method, el_val_t path, el_val_t body);
 el_val_t route_load(el_val_t method, el_val_t path, el_val_t body);
 el_val_t route_health(el_val_t method, el_val_t path, el_val_t body);
-el_val_t route_sync(el_val_t method, el_val_t path, el_val_t body);
-el_val_t route_load_merge(el_val_t method, el_val_t path, el_val_t body);
-el_val_t route_emit_ise(el_val_t method, el_val_t path, el_val_t body);
-el_val_t route_capture_knowledge(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_raw;
 el_val_t bind_str;
 el_val_t port;
-el_val_t data_dir_raw;
 el_val_t data_dir;
 el_val_t snapshot_path;
-el_val_t boot_snap;
 
 el_val_t parse_port(el_val_t bind) {
   el_val_t colon = str_index_of(bind, EL_STR(":"));
@@ -116,22 +110,17 @@ el_val_t route_stats(el_val_t method, el_val_t path, el_val_t body) {
   return 0;
 }
 
-el_val_t persist_canonical(void) {
-  el_val_t dir_raw = env(EL_STR("ENGRAM_DATA_DIR"));
-  el_val_t dir = ({ el_val_t _if_result_1 = 0; if (str_eq(dir_raw, EL_STR(""))) { _if_result_1 = (EL_STR("/tmp/engram")); } else { _if_result_1 = (dir_raw); } _if_result_1; });
-  engram_save(el_str_concat(dir, EL_STR("/snapshot.json")));
-  return 1;
-  return 0;
-}
-
 el_val_t route_create_node(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 nt_raw = json_get_string(body, EL_STR("node_type"));
-  el_val_t node_type = ({ el_val_t _if_result_2 = 0; if (str_eq(nt_raw, EL_STR(""))) { _if_result_2 = (EL_STR("Memory")); } else { _if_result_2 = (nt_raw); } _if_result_2; });
-  el_val_t sal_raw = json_get_float(body, EL_STR("salience"));
-  el_val_t salience = ({ el_val_t _if_result_3 = 0; if ((sal_raw == el_from_float(0.0))) { _if_result_3 = (el_from_float(0.5)); } else { _if_result_3 = (sal_raw); } _if_result_3; });
+  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 salience = json_get_float(body, EL_STR("salience"));
+  if (salience == el_from_float(0.0)) {
+    salience = el_from_float(0.5);
+  }
   el_val_t id = engram_node(content, node_type, salience);
-  el_val_t saved = persist_canonical();
   return el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"id\":\""), id), EL_STR("\",\"content\":\"")), content), EL_STR("\",\"node_type\":\"")), node_type), EL_STR("\"}"));
   return 0;
 }
@@ -157,9 +146,11 @@ el_val_t route_scan_nodes(el_val_t method, el_val_t path, el_val_t body) {
 }
 
 el_val_t route_scan_edges(el_val_t method, el_val_t path, el_val_t body) {
-  el_val_t dir_raw = env(EL_STR("ENGRAM_DATA_DIR"));
-  el_val_t dir = ({ el_val_t _if_result_4 = 0; if (str_eq(dir_raw, EL_STR(""))) { _if_result_4 = (EL_STR("/tmp/engram")); } else { _if_result_4 = (dir_raw); } _if_result_4; });
-  el_val_t snap_path = el_str_concat(dir, EL_STR("/.scan-export.json"));
+  el_val_t dir = env(EL_STR("ENGRAM_DATA_DIR"));
+  if (str_eq(dir, EL_STR(""))) {
+    dir = EL_STR("/tmp/engram");
+  }
+  el_val_t snap_path = el_str_concat(dir, EL_STR("/snapshot.json"));
   engram_save(snap_path);
   el_val_t snap = fs_read(snap_path);
   if (str_eq(snap, EL_STR(""))) {
@@ -174,22 +165,36 @@ el_val_t route_scan_edges(el_val_t method, el_val_t path, el_val_t body) {
 }
 
 el_val_t route_search(el_val_t method, el_val_t path, el_val_t body) {
-  el_val_t q = ({ el_val_t _if_result_5 = 0; if (str_eq(method, EL_STR("GET"))) { _if_result_5 = (query_param(path, EL_STR("q"))); } else { _if_result_5 = (json_get_string(body, EL_STR("query"))); } _if_result_5; });
-  el_val_t lim_url = query_int(path, EL_STR("limit"), 0);
-  el_val_t lim_body = json_get_int(body, EL_STR("limit"));
-  el_val_t lim_either = ({ el_val_t _if_result_6 = 0; if ((lim_url > 0)) { _if_result_6 = (lim_url); } else { _if_result_6 = (lim_body); } _if_result_6; });
-  el_val_t limit = ({ el_val_t _if_result_7 = 0; if ((lim_either > 0)) { _if_result_7 = (lim_either); } else { _if_result_7 = (20); } _if_result_7; });
+  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"));
+  }
+  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 engram_search_json(q, limit);
   return 0;
 }
 
 el_val_t route_activate(el_val_t method, el_val_t path, el_val_t body) {
-  el_val_t q = ({ el_val_t _if_result_8 = 0; if (str_eq(method, EL_STR("GET"))) { _if_result_8 = (query_param(path, EL_STR("q"))); } else { _if_result_8 = (json_get_string(body, EL_STR("query"))); } _if_result_8; });
-  if (str_eq(q, EL_STR(""))) {
-    return err_json(EL_STR("missing query"));
+  el_val_t q = EL_STR("");
+  el_val_t depth = 3;
+  if (str_eq(method, EL_STR("GET"))) {
+    q = query_param(path, EL_STR("q"));
+    depth = query_int(path, EL_STR("depth"), 3);
+  } else {
+    q = json_get_string(body, EL_STR("query"));
+    el_val_t bd = json_get_int(body, EL_STR("depth"));
+    if (bd > 0) {
+      depth = bd;
+    }
   }
-  el_val_t d_raw = ({ el_val_t _if_result_9 = 0; if (str_eq(method, EL_STR("GET"))) { _if_result_9 = (query_int(path, EL_STR("depth"), 3)); } else { _if_result_9 = (json_get_int(body, EL_STR("depth"))); } _if_result_9; });
-  el_val_t depth = ({ el_val_t _if_result_10 = 0; if ((d_raw > 0)) { _if_result_10 = (d_raw); } else { _if_result_10 = (3); } _if_result_10; });
   return el_str_concat(el_str_concat(EL_STR("{\"results\":"), engram_activate_json(q, depth)), EL_STR("}"));
   return 0;
 }
@@ -197,12 +202,15 @@ el_val_t route_activate(el_val_t method, el_val_t path, el_val_t body) {
 el_val_t route_create_edge(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"));
-  el_val_t rel_raw = json_get_string(body, EL_STR("relation"));
-  el_val_t relation = ({ el_val_t _if_result_11 = 0; if (str_eq(rel_raw, EL_STR(""))) { _if_result_11 = (EL_STR("associates")); } else { _if_result_11 = (rel_raw); } _if_result_11; });
-  el_val_t w_raw = json_get_float(body, EL_STR("weight"));
-  el_val_t weight = ({ el_val_t _if_result_12 = 0; if ((w_raw == el_from_float(0.0))) { _if_result_12 = (el_from_float(0.5)); } else { _if_result_12 = (w_raw); } _if_result_12; });
+  el_val_t relation = json_get_string(body, EL_STR("relation"));
+  if (str_eq(relation, EL_STR(""))) {
+    relation = EL_STR("associates");
+  }
+  el_val_t weight = json_get_float(body, EL_STR("weight"));
+  if (weight == el_from_float(0.0)) {
+    weight = el_from_float(0.5);
+  }
   engram_connect(from_id, to_id, weight, relation);
-  el_val_t saved = persist_canonical();
   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;
 }
@@ -223,7 +231,6 @@ el_val_t route_strengthen(el_val_t method, el_val_t path, el_val_t body) {
     return err_json(EL_STR("missing node_id"));
   }
   engram_strengthen(id);
-  el_val_t saved = persist_canonical();
   return ok_json();
   return 0;
 }
@@ -234,40 +241,29 @@ el_val_t route_forget(el_val_t method, el_val_t path, el_val_t body) {
     return err_json(EL_STR("missing id"));
   }
   engram_forget(id);
-  el_val_t saved = persist_canonical();
   return ok_json();
   return 0;
 }
 
-el_val_t route_save(el_val_t method, el_val_t path, el_val_t body) {
-  el_val_t p_raw = json_get_string(body, EL_STR("path"));
-  el_val_t dir_raw = env(EL_STR("ENGRAM_DATA_DIR"));
-  el_val_t dir = ({ el_val_t _if_result_13 = 0; if (str_eq(dir_raw, EL_STR(""))) { _if_result_13 = (EL_STR("/tmp/engram")); } else { _if_result_13 = (dir_raw); } _if_result_13; });
-  el_val_t p = ({ el_val_t _if_result_14 = 0; if (str_eq(p_raw, EL_STR(""))) { _if_result_14 = (el_str_concat(dir, EL_STR("/snapshot.json"))); } else { _if_result_14 = (p_raw); } _if_result_14; });
-  engram_save(p);
-  return el_str_concat(el_str_concat(EL_STR("{\"ok\":true,\"path\":\""), p), EL_STR("\"}"));
-  return 0;
-}
-
-el_val_t route_load(el_val_t method, el_val_t path, el_val_t body) {
-  el_val_t p_raw = json_get_string(body, EL_STR("path"));
-  el_val_t dir_raw = env(EL_STR("ENGRAM_DATA_DIR"));
-  el_val_t dir = ({ el_val_t _if_result_15 = 0; if (str_eq(dir_raw, EL_STR(""))) { _if_result_15 = (EL_STR("/tmp/engram")); } else { _if_result_15 = (dir_raw); } _if_result_15; });
-  el_val_t p = ({ el_val_t _if_result_16 = 0; if (str_eq(p_raw, EL_STR(""))) { _if_result_16 = (el_str_concat(dir, EL_STR("/snapshot.json"))); } else { _if_result_16 = (p_raw); } _if_result_16; });
-  engram_load(p);
-  return ok_json();
-  return 0;
-}
-
-el_val_t route_health(el_val_t method, el_val_t path, el_val_t body) {
-  return EL_STR("{\"status\":\"ok\",\"engine\":\"engram-runtime-native\"}");
+el_val_t route_create_ise(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 err_json(EL_STR("missing content"));
+  }
+  el_val_t sal = el_from_float(0.3);
+  el_val_t imp = el_from_float(0.3);
+  el_val_t conf = el_from_float(0.8);
+  el_val_t id = engram_node_full(content, EL_STR("InternalStateEvent"), EL_STR("state-event"), sal, imp, conf, EL_STR("Episodic"), EL_STR("[\"internal-state\",\"InternalStateEvent\"]"));
+  return el_str_concat(el_str_concat(EL_STR("{\"ok\":true,\"id\":\""), id), EL_STR("\"}"));
   return 0;
 }
 
 el_val_t route_sync(el_val_t method, el_val_t path, el_val_t body) {
-  el_val_t dir_raw = env(EL_STR("ENGRAM_DATA_DIR"));
-  el_val_t dir = ({ el_val_t _if_result_17 = 0; if (str_eq(dir_raw, EL_STR(""))) { _if_result_17 = (EL_STR("/tmp/engram")); } else { _if_result_17 = (dir_raw); } _if_result_17; });
-  el_val_t snap_path = el_str_concat(dir, EL_STR("/.sync-export.json"));
+  el_val_t dir = env(EL_STR("ENGRAM_DATA_DIR"));
+  if (str_eq(dir, EL_STR(""))) {
+    dir = EL_STR("/tmp/engram");
+  }
+  el_val_t snap_path = el_str_concat(dir, EL_STR("/sync-export.json"));
   engram_save(snap_path);
   el_val_t snap = fs_read(snap_path);
   if (str_eq(snap, EL_STR(""))) {
@@ -277,68 +273,36 @@ el_val_t route_sync(el_val_t method, el_val_t path, el_val_t body) {
   return 0;
 }
 
-el_val_t route_load_merge(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 p = json_get_string(body, EL_STR("path"));
   if (str_eq(p, EL_STR(""))) {
-    return err_json(EL_STR("path is required"));
+    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"));
   }
-  if (str_eq(fs_read(p), EL_STR(""))) {
-    return err_json(EL_STR("file missing or empty"));
-  }
-  el_val_t before_n = engram_node_count();
-  el_val_t before_e = engram_edge_count();
-  engram_load_merge(p);
-  el_val_t added_n = (engram_node_count() - before_n);
-  el_val_t added_e = (engram_edge_count() - before_e);
-  el_val_t saved = persist_canonical();
-  return el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"ok\":true,\"nodes_added\":"), int_to_str(added_n)), EL_STR(",\"edges_added\":")), int_to_str(added_e)), EL_STR(",\"node_count\":")), int_to_str(engram_node_count())), EL_STR("}"));
+  engram_save(p);
+  return el_str_concat(el_str_concat(EL_STR("{\"ok\":true,\"path\":\""), p), EL_STR("\"}"));
   return 0;
 }
 
-el_val_t route_emit_ise(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 err_json(EL_STR("missing content"));
+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"));
+  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"));
   }
-  el_val_t sal = el_from_float(0.3);
-  el_val_t imp = el_from_float(0.3);
-  el_val_t conf = el_from_float(0.8);
-  el_val_t id = engram_node_full(content, EL_STR("InternalStateEvent"), EL_STR("state-event"), sal, imp, conf, EL_STR("Episodic"), EL_STR("[\"internal-state\",\"InternalStateEvent\"]"));
-  el_val_t ret_raw = env(EL_STR("ENGRAM_ISE_RETENTION_MS"));
-  el_val_t ret_ms = ({ el_val_t _if_result_18 = 0; if (str_eq(ret_raw, EL_STR(""))) { _if_result_18 = (172800000); } else { _if_result_18 = (str_to_int(ret_raw)); } _if_result_18; });
-  el_val_t pruned = engram_prune_telemetry(ret_ms);
-  return el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"ok\":true,\"id\":\""), id), EL_STR("\",\"pruned\":")), int_to_str(pruned)), EL_STR("}"));
+  engram_load(p);
+  return ok_json();
   return 0;
 }
 
-el_val_t route_capture_knowledge(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 err_json(EL_STR("missing content"));
-  }
-  el_val_t title = json_get_string(body, EL_STR("title"));
-  el_val_t label = ({ el_val_t _if_result_19 = 0; if (str_eq(title, EL_STR(""))) { _if_result_19 = (str_slice(content, 0, 60)); } else { _if_result_19 = (title); } _if_result_19; });
-  el_val_t category_raw = json_get_string(body, EL_STR("category"));
-  el_val_t category = ({ el_val_t _if_result_20 = 0; if (str_eq(category_raw, EL_STR(""))) { _if_result_20 = (EL_STR("other")); } else { _if_result_20 = (category_raw); } _if_result_20; });
-  el_val_t ktier_raw = json_get_string(body, EL_STR("tier"));
-  el_val_t ktier = ({ el_val_t _if_result_21 = 0; if (str_eq(ktier_raw, EL_STR(""))) { _if_result_21 = (EL_STR("note")); } else { _if_result_21 = (ktier_raw); } _if_result_21; });
-  el_val_t project = json_get_string(body, EL_STR("project"));
-  el_val_t tags_raw = json_get_raw(body, EL_STR("tags"));
-  el_val_t tags_base = ({ el_val_t _if_result_22 = 0; if (str_eq(tags_raw, EL_STR(""))) { _if_result_22 = (EL_STR("[]")); } else { _if_result_22 = (tags_raw); } _if_result_22; });
-  el_val_t base_len = str_len(tags_base);
-  el_val_t head = str_slice(tags_base, 0, (base_len - 1));
-  el_val_t sep = ({ el_val_t _if_result_23 = 0; if (str_eq(head, EL_STR("["))) { _if_result_23 = (EL_STR("")); } else { _if_result_23 = (EL_STR(",")); } _if_result_23; });
-  el_val_t safe_cat = str_replace(category, EL_STR("\""), EL_STR("'"));
-  el_val_t safe_tier = str_replace(ktier, EL_STR("\""), EL_STR("'"));
-  el_val_t safe_proj = str_replace(project, EL_STR("\""), EL_STR("'"));
-  el_val_t proj_tag = ({ el_val_t _if_result_24 = 0; if (str_eq(safe_proj, EL_STR(""))) { _if_result_24 = (EL_STR("")); } else { _if_result_24 = (el_str_concat(el_str_concat(EL_STR(",\"project:"), safe_proj), EL_STR("\""))); } _if_result_24; });
-  el_val_t tags = el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(head, sep), EL_STR("\"category:")), safe_cat), EL_STR("\",\"tier:")), safe_tier), EL_STR("\"")), proj_tag), EL_STR("]"));
-  el_val_t sal = el_from_float(0.5);
-  el_val_t imp = el_from_float(0.5);
-  el_val_t conf = el_from_float(0.9);
-  el_val_t id = engram_node_full(content, EL_STR("Knowledge"), label, sal, imp, conf, EL_STR("Semantic"), tags);
-  el_val_t saved = persist_canonical();
-  return el_str_concat(el_str_concat(EL_STR("{\"ok\":true,\"id\":\""), id), EL_STR("\"}"));
+el_val_t route_health(el_val_t method, el_val_t path, el_val_t body) {
+  return EL_STR("{\"status\":\"ok\",\"engine\":\"engram-runtime-native\"}");
   return 0;
 }
 
@@ -365,15 +329,12 @@ 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_eq(method, EL_STR("POST")) && str_eq(clean, EL_STR("/api/neuron/state-events"))) {
-    return route_emit_ise(method, path, body);
+  if (str_eq(method, EL_STR("POST")) && str_starts_with(clean, EL_STR("/api/neuron/state-events"))) {
+    return route_create_ise(method, path, body);
   }
   if (!check_auth_ok(method, body)) {
     return err_json(EL_STR("unauthorized"));
   }
-  if (str_eq(method, EL_STR("POST")) && str_eq(clean, EL_STR("/api/neuron/knowledge/capture"))) {
-    return route_capture_knowledge(method, path, body);
-  }
   if (str_eq(method, EL_STR("GET")) && (str_eq(clean, EL_STR("/api/stats")) || str_eq(clean, EL_STR("/stats")))) {
     return route_stats(method, path, body);
   }
@@ -413,40 +374,32 @@ el_val_t handle_request(el_val_t method, el_val_t path, el_val_t 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("GET")) && (str_eq(clean, EL_STR("/api/sync")) || str_eq(clean, EL_STR("/sync")))) {
+    return route_sync(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);
   }
   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/load-merge")) || str_eq(clean, EL_STR("/load-merge")))) {
-    return route_load_merge(method, path, body);
-  }
-  if (str_eq(method, EL_STR("GET")) && str_eq(clean, EL_STR("/api/sync"))) {
-    return route_sync(method, path, body);
-  }
   return el_str_concat(el_str_concat(EL_STR("{\"error\":\"not found\",\"path\":\""), clean), EL_STR("\"}"));
   return 0;
 }
 
 int main(int _argc, char** _argv) {
   el_runtime_init_args(_argc, _argv);
-  bind_raw = env(EL_STR("ENGRAM_BIND"));
-  bind_str = ({ el_val_t _if_result_25 = 0; if (str_eq(bind_raw, EL_STR(""))) { _if_result_25 = (EL_STR(":8742")); } else { _if_result_25 = (bind_raw); } _if_result_25; });
+  bind_str = env(EL_STR("ENGRAM_BIND"));
+  if (str_eq(bind_str, EL_STR(""))) {
+    bind_str = EL_STR(":8742");
+  }
   port = parse_port(bind_str);
-  data_dir_raw = env(EL_STR("ENGRAM_DATA_DIR"));
-  data_dir = ({ el_val_t _if_result_26 = 0; if (str_eq(data_dir_raw, EL_STR(""))) { _if_result_26 = (EL_STR("/tmp/engram")); } else { _if_result_26 = (data_dir_raw); } _if_result_26; });
+  data_dir = env(EL_STR("ENGRAM_DATA_DIR"));
+  if (str_eq(data_dir, EL_STR(""))) {
+    data_dir = EL_STR("/tmp/engram");
+  }
   snapshot_path = el_str_concat(data_dir, EL_STR("/snapshot.json"));
   engram_load(snapshot_path);
-  boot_snap = fs_read(snapshot_path);
-  if (!str_eq(boot_snap, EL_STR(""))) {
-    if (engram_node_count() == 0) {
-      println(EL_STR("[engram] WARNING: snapshot.json is non-empty but load produced 0 nodes \xe2\x80\x94 preserving copy at snapshot.failed-load.json"));
-      fs_write(el_str_concat(data_dir, EL_STR("/snapshot.failed-load.json")), boot_snap);
-    } else {
-      fs_write(el_str_concat(data_dir, EL_STR("/snapshot.boot-backup.json")), boot_snap);
-    }
-  }
   println(EL_STR("[engram] runtime-native graph engine"));
   println(el_str_concat(EL_STR("[engram] data_dir="), data_dir));
   println(el_str_concat(EL_STR("[engram] node_count="), int_to_str(engram_node_count())));

engram/src/server.el

@@ -76,43 +76,13 @@ fn route_stats(method: String, path: String, body: String) -> String {
     engram_stats_json()
 }
 
-// (2026-07-18 self-review) Scoping sweep: `let` inside an if-block creates an
-// inner scope only — it does NOT mutate the outer binding (documented with
-// evidence in awareness.el, 2026-05-25). Every default/reassignment below used
-// that broken pattern, so defaults never applied: nodes were created with
-// node_type="" and salience=0.0, /api/search and /api/activate ALWAYS ran with
-// q="" regardless of input, edges defaulted to relation=""/weight=0.0, and
-// save/load with no "path" hit engram_save(""). Rewritten to the
-// `let x = if cond { a } else { b }` expression form (the pattern the newer
-// routes route_emit_ise/route_capture_knowledge already use correctly).
-// persist_canonical — save the canonical snapshot after a durable write.
-//
-// WHY (2026-07-22 self-review): the 2026-07-21 fix correctly stopped READ
-// routes from writing the canonical snapshot.json — but nothing was left
-// that saved it on WRITE. Every mutation (node create, edge create,
-// knowledge capture, forget, merge) lived only in RAM until someone POSTed
-// /api/save manually; a process restart silently discarded everything since
-// the last manual save. Observed live: two engram restarts during the
-// 2026-07-22 review reverted the store to a ~17h-old snapshot, destroying
-// same-day writes. Reads must never write the canonical; writes must always
-// persist it. ISE telemetry is deliberately excluded (48h-pruned, loss-
-// tolerant, ~2/min — snapshotting the whole store per heartbeat is waste;
-// any durable write that follows persists the pruning too).
-fn persist_canonical() -> Int {
-    let dir_raw: String = env("ENGRAM_DATA_DIR")
-    let dir: String = if str_eq(dir_raw, "") { "/tmp/engram" } else { dir_raw }
-    engram_save(dir + "/snapshot.json")
-    return 1
-}
-
 fn route_create_node(method: String, path: String, body: String) -> String {
     let content: String = json_get_string(body, "content")
-    let nt_raw: String = json_get_string(body, "node_type")
-    let node_type: String = if str_eq(nt_raw, "") { "Memory" } else { nt_raw }
-    let sal_raw: Float = json_get_float(body, "salience")
-    let salience: Float = if sal_raw == 0.0 { 0.5 } else { sal_raw }
+    let node_type: String = json_get_string(body, "node_type")
+    if str_eq(node_type, "") { let node_type = "Memory" }
+    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)
-    let saved: Int = persist_canonical()
     "{\"id\":\"" + id + "\",\"content\":\"" + content + "\",\"node_type\":\"" + node_type + "\"}"
 }
 
@@ -133,14 +103,13 @@ fn route_scan_nodes(method: String, path: String, body: String) -> String {
 }
 
 // route_scan_edges — bulk export of all edges as a JSON array. Implemented
-// via engram_save → fs_read of a SCRATCH export path. (2026-07-21 self-review:
-// previously this saved over the canonical snapshot.json on every GET — if the
-// process ever booted with a partial/empty store, the first read request
-// clobbered the good snapshot. Read routes must never write the canonical path.)
+// via engram_save → fs_read of the canonical on-disk snapshot, which the
+// runtime keeps in lockstep with the in-memory graph. Live against the
+// running graph, not a stale export.
 fn route_scan_edges(method: String, path: String, body: String) -> String {
-    let dir_raw: String = env("ENGRAM_DATA_DIR")
-    let dir: String = if str_eq(dir_raw, "") { "/tmp/engram" } else { dir_raw }
-    let snap_path: String = dir + "/.scan-export.json"
+    let dir: String = env("ENGRAM_DATA_DIR")
+    if str_eq(dir, "") { let dir = "/tmp/engram" }
+    let snap_path: String = dir + "/snapshot.json"
     engram_save(snap_path)
     let snap: String = fs_read(snap_path)
     if str_eq(snap, "") { return "[]" }
@@ -153,34 +122,40 @@ fn route_scan_edges(method: String, path: String, body: String) -> String {
 }
 
 fn route_search(method: String, path: String, body: String) -> String {
-    let q: String = if str_eq(method, "GET") { query_param(path, "q") } else { json_get_string(body, "query") }
-    let lim_url: Int = query_int(path, "limit", 0)
-    let lim_body: Int = json_get_int(body, "limit")
-    let lim_either: Int = if lim_url > 0 { lim_url } else { lim_body }
-    let limit: Int = if lim_either > 0 { lim_either } else { 20 }
+    let q: String = ""
+    if str_eq(method, "GET") {
+        let q = query_param(path, "q")
+    } else {
+        let q = json_get_string(body, "query")
+    }
+    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)
 }
 
 fn route_activate(method: String, path: String, body: String) -> String {
-    let q: String = if str_eq(method, "GET") { query_param(path, "q") } else { json_get_string(body, "query") }
-    // Guard: engram_activate with an empty query matches zero seeds, which
-    // zeroes ALL carried working-memory weights (documented in awareness.el
-    // perceive()). Never let an empty activation through to wipe WM.
-    if str_eq(q, "") { return err_json("missing query") }
-    let d_raw: Int = if str_eq(method, "GET") { query_int(path, "depth", 3) } else { json_get_int(body, "depth") }
-    let depth: Int = if d_raw > 0 { d_raw } else { 3 }
+    let q: String = ""
+    let depth: Int = 3
+    if str_eq(method, "GET") {
+        let q = query_param(path, "q")
+        let depth = query_int(path, "depth", 3)
+    } else {
+        let q = json_get_string(body, "query")
+        let bd: Int = json_get_int(body, "depth")
+        if bd > 0 { let depth = bd }
+    }
     return "{\"results\":" + engram_activate_json(q, depth) + "}"
 }
 
 fn route_create_edge(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")
-    let rel_raw: String = json_get_string(body, "relation")
-    let relation: String = if str_eq(rel_raw, "") { "associates" } else { rel_raw }
-    let w_raw: Float = json_get_float(body, "weight")
-    let weight: Float = if w_raw == 0.0 { 0.5 } else { w_raw }
+    let relation: String = json_get_string(body, "relation")
+    if str_eq(relation, "") { let relation = "associates" }
+    let weight: Float = json_get_float(body, "weight")
+    if weight == 0.0 { let weight = 0.5 }
     engram_connect(from_id, to_id, weight, relation)
-    let saved: Int = persist_canonical()
     "{\"ok\":true,\"from_id\":\"" + from_id + "\",\"to_id\":\"" + to_id + "\",\"relation\":\"" + relation + "\"}"
 }
 
@@ -195,7 +170,6 @@ fn route_strengthen(method: String, path: String, body: String) -> String {
     let id: String = json_get_string(body, "node_id")
     if str_eq(id, "") { return err_json("missing node_id") }
     engram_strengthen(id)
-    let saved: Int = persist_canonical()
     ok_json()
 }
 
@@ -203,24 +177,27 @@ fn route_forget(method: String, path: String, body: String) -> String {
     let id: String = extract_id(path, "/api/nodes/")
     if str_eq(id, "") { return err_json("missing id") }
     engram_forget(id)
-    let saved: Int = persist_canonical()
     ok_json()
 }
 
 fn route_save(method: String, path: String, body: String) -> String {
-    let p_raw: String = json_get_string(body, "path")
-    let dir_raw: String = env("ENGRAM_DATA_DIR")
-    let dir: String = if str_eq(dir_raw, "") { "/tmp/engram" } else { dir_raw }
-    let p: String = if str_eq(p_raw, "") { dir + "/snapshot.json" } else { p_raw }
+    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 + "\"}"
 }
 
 fn route_load(method: String, path: String, body: String) -> String {
-    let p_raw: String = json_get_string(body, "path")
-    let dir_raw: String = env("ENGRAM_DATA_DIR")
-    let dir: String = if str_eq(dir_raw, "") { "/tmp/engram" } else { dir_raw }
-    let p: String = if str_eq(p_raw, "") { dir + "/snapshot.json" } else { p_raw }
+    let p: String = json_get_string(body, "path")
+    if str_eq(p, "") {
+        let dir: String = env("ENGRAM_DATA_DIR")
+        if str_eq(dir, "") { let dir = "/tmp/engram" }
+        let p = dir + "/snapshot.json"
+    }
     engram_load(p)
     ok_json()
 }
@@ -242,36 +219,15 @@ fn route_health(method: String, path: String, body: String) -> String {
 // (it skips nodes already present by ID). Auth-exempt: same-host internal call.
 // (2026-06-27 self-review: added this route to fix silent 10-min sync failures)
 fn route_sync(method: String, path: String, body: String) -> String {
-    let dir_raw: String = env("ENGRAM_DATA_DIR")
-    let dir: String = if str_eq(dir_raw, "") { "/tmp/engram" } else { dir_raw }
-    // 2026-07-21 self-review: export to a scratch path, never the canonical
-    // snapshot.json — read routes must not be able to clobber the good snapshot.
-    let snap_path: String = dir + "/.sync-export.json"
+    let dir: String = env("ENGRAM_DATA_DIR")
+    if str_eq(dir, "") { let dir = "/tmp/engram" }
+    let snap_path: String = dir + "/snapshot.json"
     engram_save(snap_path)
     let snap: String = fs_read(snap_path)
     if str_eq(snap, "") { return "{\"nodes\":[],\"edges\":[]}" }
     return snap
 }
 
-// route_load_merge — POST /api/load-merge {"path": "..."} — merge a snapshot
-// file into the live store WITHOUT resetting it (engram_load_merge skips nodes
-// already present by id). Added 2026-07-21 self-review to restore the 244 kn-
-// identity Knowledge nodes lost from the snapshot lineage between 05-13 and
-// 07-13. Requires an explicit path: refuses to run without one so it can never
-// be triggered accidentally against a default.
-fn route_load_merge(method: String, path: String, body: String) -> String {
-    let p: String = json_get_string(body, "path")
-    if str_eq(p, "") { return err_json("path is required") }
-    if str_eq(fs_read(p), "") { return err_json("file missing or empty") }
-    let before_n: Int = engram_node_count()
-    let before_e: Int = engram_edge_count()
-    engram_load_merge(p)
-    let added_n: Int = engram_node_count() - before_n
-    let added_e: Int = engram_edge_count() - before_e
-    let saved: Int = persist_canonical()
-    "{\"ok\":true,\"nodes_added\":" + int_to_str(added_n) + ",\"edges_added\":" + int_to_str(added_e) + ",\"node_count\":" + int_to_str(engram_node_count()) + "}"
-}
-
 // route_emit_ise — write an InternalStateEvent node from the soul daemon.
 //
 // Endpoint: POST /api/neuron/state-events
@@ -285,20 +241,10 @@ fn route_load_merge(method: String, path: String, body: String) -> String {
 //
 // Salience/importance set to match engram_node_full ISE defaults used by the
 // in-process fallback path in awareness.el (salience=0.3, importance=0.3,
-// confidence=0.8, tier=Episodic).
+// confidence=0.8, tier=Episodic). High temporal_decay_rate (1.617) — ISEs
+// are inherently transient; they should decay faster than structural knowledge.
 // (2026-06-26 self-review: added this route after discovering ise_post was
 // silently failing — the soul posts here but the endpoint didn't exist.)
-//
-// Retention (2026-07-16 self-review): an earlier comment here claimed ISEs
-// got temporal_decay_rate=1.617 — that was never implemented (engram_node_full
-// hardcodes 0.0), and per-node decay only dampens activation anyway; it never
-// removes nodes. By 2026-07-16 ISEs were 75% of the store (10,175 of 13,522
-// nodes, ~4,300/day, unbounded). ISEs are already WM-excluded in
-// engram_activate, so the fix is retention, not decay: every insert calls
-// engram_prune_telemetry(), a single O(nodes+edges) compaction pass that
-// removes ISEs older than ENGRAM_ISE_RETENTION_MS (default 48h), protecting
-// "session-start" labels and self_review events as durable history. At
-// ~3 ISEs/min this bounds telemetry at ~8.6k nodes instead of growing forever.
 fn route_emit_ise(method: String, path: String, body: String) -> String {
     let content: String = json_get_string(body, "content")
     if str_eq(content, "") { return err_json("missing content") }
@@ -310,64 +256,6 @@ fn route_emit_ise(method: String, path: String, body: String) -> String {
         sal, imp, conf,
         "Episodic", "[\"internal-state\",\"InternalStateEvent\"]"
     )
-    let ret_raw: String = env("ENGRAM_ISE_RETENTION_MS")
-    let ret_ms: Int = if str_eq(ret_raw, "") { 172800000 } else { str_to_int(ret_raw) }
-    let pruned: Int = engram_prune_telemetry(ret_ms)
-    "{\"ok\":true,\"id\":\"" + id + "\",\"pruned\":" + int_to_str(pruned) + "}"
-}
-
-// ── Knowledge capture ─────────────────────────────────────────────────────────
-//
-// route_capture_knowledge — direct Knowledge-node capture over HTTP.
-//
-// Endpoint: POST /api/neuron/knowledge/capture   (auth required: "_auth" in body)
-// Body:     {"content": "...", "title": "...", "category": "...",
-//            "tier": "note|lesson|canonical", "tags": [...], "project": "...",
-//            "_auth": "<key>"}
-//
-// WHY (2026-07-15 self-review): the world-ingestor integrator was designed
-// against this endpoint (its MCP-unavailable fallback), but the route never
-// existed — every direct push 404'd, and because the auth gate ran before
-// routing, the failure surfaced as {"error":"unauthorized"} and was
-// misdiagnosed for two weeks while world knowledge silently dropped.
-// POST /api/nodes was no substitute: it discards label/tags/tier, which
-// makes captured knowledge invisible to tag-scoped search and curiosity.
-//
-// The incoming knowledge tier (note/lesson/canonical) is preserved as a
-// "tier:<x>" tag rather than mapped onto Engram's cognitive tiers — Knowledge
-// nodes land in Semantic (stable reference), and the epistemic tier stays
-// queryable without inventing a lossy mapping.
-fn route_capture_knowledge(method: String, path: String, body: String) -> String {
-    let content: String = json_get_string(body, "content")
-    if str_eq(content, "") { return err_json("missing content") }
-    let title: String = json_get_string(body, "title")
-    let label: String = if str_eq(title, "") { str_slice(content, 0, 60) } else { title }
-    let category_raw: String = json_get_string(body, "category")
-    let category: String = if str_eq(category_raw, "") { "other" } else { category_raw }
-    let ktier_raw: String = json_get_string(body, "tier")
-    let ktier: String = if str_eq(ktier_raw, "") { "note" } else { ktier_raw }
-    let project: String = json_get_string(body, "project")
-    let tags_raw: String = json_get_raw(body, "tags")
-    let tags_base: String = if str_eq(tags_raw, "") { "[]" } else { tags_raw }
-    // Merge category/tier/project markers into the tag array. Search matches
-    // against the tags string, so these make captures findable by facet.
-    let base_len: Int = str_len(tags_base)
-    let head: String = str_slice(tags_base, 0, base_len - 1)
-    let sep: String = if str_eq(head, "[") { "" } else { "," }
-    let safe_cat: String = str_replace(category, "\"", "'")
-    let safe_tier: String = str_replace(ktier, "\"", "'")
-    let safe_proj: String = str_replace(project, "\"", "'")
-    let proj_tag: String = if str_eq(safe_proj, "") { "" } else { ",\"project:" + safe_proj + "\"" }
-    let tags: String = head + sep + "\"category:" + safe_cat + "\",\"tier:" + safe_tier + "\"" + proj_tag + "]"
-    let sal: Float = 0.5
-    let imp: Float = 0.5
-    let conf: Float = 0.9
-    let id: String = engram_node_full(
-        content, "Knowledge", label,
-        sal, imp, conf,
-        "Semantic", tags
-    )
-    let saved: Int = persist_canonical()
     "{\"ok\":true,\"id\":\"" + id + "\"}"
 }
 
@@ -407,12 +295,6 @@ fn handle_request(method: String, path: String, body: String) -> String {
         return err_json("unauthorized")
     }
 
-    // Knowledge capture (auth enforced above; the world-ingestor integrator
-    // and any headless session without MCP push knowledge through this)
-    if str_eq(method, "POST") && str_eq(clean, "/api/neuron/knowledge/capture") {
-        return route_capture_knowledge(method, path, body)
-    }
-
     // Stats
     if str_eq(method, "GET") && (str_eq(clean, "/api/stats") || str_eq(clean, "/stats")) {
         return route_stats(method, path, body)
@@ -469,9 +351,6 @@ fn handle_request(method: String, path: String, body: String) -> String {
     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/load-merge") || str_eq(clean, "/load-merge")) {
-        return route_load_merge(method, path, body)
-    }
 
     // Sync — soul daemon periodic pull of non-ISE knowledge into in-process graph
     if str_eq(method, "GET") && str_eq(clean, "/api/sync") {
@@ -483,31 +362,16 @@ fn handle_request(method: String, path: String, body: String) -> String {
 
 // ── Entry ─────────────────────────────────────────────────────────────────────
 
-let bind_raw: String = env("ENGRAM_BIND")
-let bind_str: String = if str_eq(bind_raw, "") { ":8742" } else { bind_raw }
+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).
-let data_dir_raw: String = env("ENGRAM_DATA_DIR")
-let data_dir: String = if str_eq(data_dir_raw, "") { "/tmp/engram" } else { data_dir_raw }
+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"
 engram_load(snapshot_path)
 
-// 2026-07-21 self-review boot guard: if the snapshot file has content but the
-// load produced 0 nodes, something is wrong (corrupt file / parse failure).
-// Preserve the evidence and warn loudly — and since read routes no longer write
-// the canonical path, a bad boot can no longer clobber the good snapshot.
-let boot_snap: String = fs_read(snapshot_path)
-if !str_eq(boot_snap, "") {
-    if engram_node_count() == 0 {
-        println("[engram] WARNING: snapshot.json is non-empty but load produced 0 nodes — preserving copy at snapshot.failed-load.json")
-        fs_write(data_dir + "/snapshot.failed-load.json", boot_snap)
-    } else {
-        // Good load: keep a boot-time backup of the snapshot as loaded.
-        fs_write(data_dir + "/snapshot.boot-backup.json", boot_snap)
-    }
-}
-
 println("[engram] runtime-native graph engine")
 println("[engram] data_dir=" + data_dir)
 println("[engram] node_count=" + int_to_str(engram_node_count()))

epm/src/install.el

@@ -17,6 +17,16 @@
 //   4. Append dep to order after all its transitive deps
 //   5. Deduplicate: skip already-ordered vessels
 
+// ── Cross-module forward declarations ─────────────────────────────────────────
+// Defined in sibling epm modules; resolved at link time. The `extern fn` decls
+// give elc the C prototypes so generated install.c compiles cleanly under strict
+// compilers (gcc>=14 / clang) that reject implicit function declarations.
+extern fn manifest_name(src: String) -> String                        // manifest.el
+extern fn manifest_deps(src: String) -> String                        // manifest.el
+extern fn registry_token() -> String                                  // registry.el
+extern fn registry_find(name: String, version: String) -> String     // registry.el
+extern fn registry_latest_version(name: String) -> String            // registry.el
+
 // ── Install paths ─────────────────────────────────────────────────────────────
 
 // packages_dir returns the root directory for installed vessels.

epm/src/registry.el

@@ -14,6 +14,15 @@
 //   EPM_REGISTRY_ORG — org name that hosts vessel repos (default: neuron-technologies)
 //   EPM_TOKEN      — Gitea personal access token (required for publish)
 
+// ── Cross-module forward declarations ─────────────────────────────────────────
+// These symbols are defined in sibling epm modules or the El runtime and are
+// resolved at link time. The `extern fn` decls give elc the C prototype so the
+// generated registry.c compiles cleanly under strict compilers (gcc>=14 / clang)
+// that reject implicit function declarations. Signature arity must match the
+// definition; return/param types are informational (all lower to el_val_t).
+extern fn config(key: String) -> String          // El runtime builtin
+extern fn read_installed() -> String              // install.el
+
 // ── Config helpers ────────────────────────────────────────────────────────────
 
 // registry_api_url returns the Gitea API base URL with no trailing slash.

epm/src/update.el

@@ -6,6 +6,15 @@
 // Depends on: registry.el (registry_latest_version, registry_find),
 //             install.el  (read_installed, install_vessel, installed_version)
 
+// ── Cross-module forward declarations ─────────────────────────────────────────
+// Defined in sibling epm modules; resolved at link time. The `extern fn` decls
+// give elc the C prototypes so generated update.c compiles cleanly under strict
+// compilers (gcc>=14 / clang) that reject implicit function declarations.
+extern fn read_installed() -> String                                  // install.el
+extern fn installed_version(name: String) -> String                   // install.el
+extern fn install_vessel(name: String, version: String) -> Bool      // install.el
+extern fn registry_latest_version(name: String) -> String            // registry.el
+
 // ── Semver helpers ────────────────────────────────────────────────────────────
 
 // semver_part extracts the Nth dot-separated component from a semver string.

lang/el-compiler/runtime/el_platform_win.h

@@ -75,6 +75,7 @@ static inline void* el_win_dlsym(void* handle, const char* name) {
 #include <direct.h>            /* _mkdir */
 #define mkdir(path, mode) _mkdir(path)     /* POSIX mkdir(path,mode) → _mkdir(path) */
 #define timegm _mkgmtime                   /* UTC tm → time_t */
+#define fsync(fd) _commit(fd)              /* no fsync() on Windows; _commit() (<io.h>) is the equiv */
 
 /* setenv/unsetenv: not in the Windows CRT; map to _putenv_s / SetEnvironmentVariable. */
 static inline int setenv(const char* name, const char* value, int overwrite) {

lang/el-compiler/runtime/el_runtime.c

@@ -1963,8 +1963,9 @@ void http_serve_async(el_val_t port, el_val_t handler) {
     int sock = socket(AF_INET6, SOCK_STREAM, 0);
     if (sock < 0) { perror("socket"); return; }
     int yes = 1; int no = 0;
-    setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(yes));
-    setsockopt(sock, IPPROTO_IPV6, IPV6_V6ONLY, &no, sizeof(no));
+    /* Win32/mingw setsockopt takes optval as (const char*); the cast is portable on POSIX too. */
+    setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (const char*)&yes, sizeof(yes));
+    setsockopt(sock, IPPROTO_IPV6, IPV6_V6ONLY, (const char*)&no, sizeof(no));
     struct sockaddr_in6 addr;
     memset(&addr, 0, sizeof(addr));
     addr.sin6_family = AF_INET6;
@@ -6895,6 +6896,243 @@ static int engram_rank_cmp(const void* a, const void* b) {
     return 0;
 }
 
+/* ══════════════════════════════════════════════════════════════════════════
+ * SEMANTIC SEARCH LAYER — nomic-embed-text via Ollama /api/embeddings
+ * ──────────────────────────────────────────────────────────────────────────
+ * Augments the lexical (istr_contains) matcher with dense-vector retrieval.
+ * Node content and the query are embedded through a local Ollama server;
+ * nodes are ranked by cosine similarity and UNIONED with lexical hits. This
+ * lets a paraphrase query surface a node whose words never appear in it.
+ *
+ * DEGRADABLE BY DESIGN. The whole layer is gated on HAVE_CURL plus a one-shot
+ * runtime probe of the embedding endpoint. If curl is not compiled in, or
+ * Ollama is unreachable, or ENGRAM_SEMANTIC=0, every entry point returns
+ * "no semantic signal" and callers fall back to pure lexical behaviour —
+ * byte-for-byte the pre-existing search.
+ *
+ * CACHE. Node embeddings are computed lazily on first use and cached in
+ * process memory keyed by node id, with an FNV-1a content hash for
+ * invalidation (edited content re-embeds). The query is embedded once per
+ * search call. This is what "avoid re-embedding the whole graph every query"
+ * buys us: a warm cache serves cosine from RAM. (A cold process still pays
+ * O(N) embed calls the first time each node is scanned — persisting the cache
+ * to a snapshot sidecar is the documented next step, not done here.)
+ *
+ * nomic task prefixes ("search_query:" / "search_document:") are applied
+ * because nomic-embed-text is trained with them; they materially improve
+ * retrieval separation (empirically: paraphrase 0.72 vs distractors <0.48).
+ *
+ * ENV:
+ *   ENGRAM_SEMANTIC       "0" disables; unset/other = auto-probe
+ *   ENGRAM_EMBED_URL      default http://localhost:11434/api/embeddings
+ *   ENGRAM_EMBED_MODEL    default nomic-embed-text
+ *   ENGRAM_SEMANTIC_MIN   cosine threshold for a pure-semantic match (def 0.6)
+ * ════════════════════════════════════════════════════════════════════════ */
+
+static double engram_semantic_min(void) {
+    static double v = -1.0;
+    if (v >= 0.0) return v;
+    const char* s = getenv("ENGRAM_SEMANTIC_MIN");
+    double d = 0.6;
+    if (s && *s) { char* e = NULL; double t = strtod(s, &e);
+                   if (e != s && t >= 0.0 && t <= 1.0) d = t; }
+    v = d; return v;
+}
+
+#ifdef HAVE_CURL
+
+typedef struct { char* id; uint64_t hash; float* vec; int dim; } EngramEmbEntry;
+static EngramEmbEntry* g_emb_items = NULL;
+static int64_t g_emb_count = 0, g_emb_cap = 0;
+static int g_emb_state = 0;   /* 0=unprobed, 1=available, -1=disabled */
+
+static uint64_t engram_fnv1a(const char* s) {
+    uint64_t h = 1469598103934665603ULL;
+    if (s) for (const unsigned char* p = (const unsigned char*)s; *p; p++) {
+        h ^= *p; h *= 1099511628211ULL;
+    }
+    return h;
+}
+
+/* Parse "embedding":[f,f,...] from an Ollama response. malloc'd vec, or NULL. */
+static float* engram_parse_embedding(const char* json, int* out_dim) {
+    if (!json) return NULL;
+    const char* p = strstr(json, "\"embedding\"");
+    if (!p) return NULL;
+    p = strchr(p, '[');
+    if (!p) return NULL;
+    p++;
+    int cap = 1024, n = 0;
+    float* v = malloc((size_t)cap * sizeof(float));
+    if (!v) return NULL;
+    while (*p && *p != ']') {
+        while (*p == ' ' || *p == '\t' || *p == '\n' || *p == '\r' || *p == ',') p++;
+        if (*p == ']' || !*p) break;
+        char* e = NULL;
+        double d = strtod(p, &e);
+        if (e == p) break;
+        if (n >= cap) { cap *= 2; float* nv = realloc(v, (size_t)cap * sizeof(float));
+                        if (!nv) { free(v); return NULL; } v = nv; }
+        v[n++] = (float)d;
+        p = e;
+    }
+    if (n == 0) { free(v); return NULL; }
+    *out_dim = n;
+    return v;
+}
+
+/* JSON-escape src into a malloc'd buffer (no surrounding quotes). */
+static char* engram_json_escape(const char* src) {
+    if (!src) src = "";
+    size_t n = strlen(src);
+    char* out = malloc(n * 2 + 1);
+    if (!out) return NULL;
+    size_t j = 0;
+    for (size_t i = 0; i < n; i++) {
+        unsigned char c = (unsigned char)src[i];
+        if      (c == '"')  { out[j++] = '\\'; out[j++] = '"'; }
+        else if (c == '\\') { out[j++] = '\\'; out[j++] = '\\'; }
+        else if (c == '\n') { out[j++] = '\\'; out[j++] = 'n'; }
+        else if (c == '\r') { out[j++] = '\\'; out[j++] = 'r'; }
+        else if (c == '\t') { out[j++] = '\\'; out[j++] = 't'; }
+        else if (c < 0x20)  { /* drop other control bytes */ }
+        else                { out[j++] = (char)c; }
+    }
+    out[j] = '\0';
+    return out;
+}
+
+/* Embed `prefix+text` via Ollama. Returns malloc'd vec (caller frees), or NULL. */
+static float* engram_embed_raw(const char* prefix, const char* text, int* out_dim) {
+    if (!text) return NULL;
+    const char* url = getenv("ENGRAM_EMBED_URL");
+    if (!url || !*url) url = "http://localhost:11434/api/embeddings";
+    const char* model = getenv("ENGRAM_EMBED_MODEL");
+    if (!model || !*model) model = "nomic-embed-text";
+    /* Bound content length to keep latency/memory sane on huge nodes. */
+    char* trunc = NULL;
+    size_t maxlen = 8192;
+    if (strlen(text) > maxlen) {
+        trunc = malloc(maxlen + 1);
+        if (trunc) { memcpy(trunc, text, maxlen); trunc[maxlen] = '\0'; text = trunc; }
+    }
+    char* esc_prefix = engram_json_escape(prefix ? prefix : "");
+    char* esc = engram_json_escape(text);
+    free(trunc);
+    if (!esc || !esc_prefix) { free(esc); free(esc_prefix); return NULL; }
+    size_t blen = strlen(esc) + strlen(esc_prefix) + strlen(model) + 64;
+    char* body = malloc(blen);
+    if (!body) { free(esc); free(esc_prefix); return NULL; }
+    snprintf(body, blen, "{\"model\":\"%s\",\"prompt\":\"%s%s\"}", model, esc_prefix, esc);
+    free(esc); free(esc_prefix);
+
+    CURL* c = curl_easy_init();
+    if (!c) { free(body); return NULL; }
+    HttpBuf rb; httpbuf_init(&rb);
+    struct curl_slist* h = curl_slist_append(NULL, "Content-Type: application/json");
+    char errbuf[CURL_ERROR_SIZE]; errbuf[0] = '\0';
+    curl_easy_setopt(c, CURLOPT_URL, url);
+    curl_easy_setopt(c, CURLOPT_WRITEFUNCTION, http_write_cb);
+    curl_easy_setopt(c, CURLOPT_WRITEDATA, &rb);
+    curl_easy_setopt(c, CURLOPT_POST, 1L);
+    curl_easy_setopt(c, CURLOPT_POSTFIELDS, body);
+    curl_easy_setopt(c, CURLOPT_POSTFIELDSIZE, (long)strlen(body));
+    curl_easy_setopt(c, CURLOPT_HTTPHEADER, h);
+    curl_easy_setopt(c, CURLOPT_TIMEOUT_MS, el_http_timeout_ms());
+    curl_easy_setopt(c, CURLOPT_NOSIGNAL, 1L);
+    curl_easy_setopt(c, CURLOPT_ERRORBUFFER, errbuf);
+    CURLcode rc = curl_easy_perform(c);
+    curl_slist_free_all(h);
+    curl_easy_cleanup(c);
+    free(body);
+    if (rc != CURLE_OK) { free(rb.data); return NULL; }
+    float* v = engram_parse_embedding(rb.data, out_dim);
+    free(rb.data);
+    return v;
+}
+
+/* One-shot probe: is semantic search available? Caches the verdict. */
+static int engram_semantic_enabled(void) {
+    if (g_emb_state != 0) return g_emb_state == 1;
+    const char* s = getenv("ENGRAM_SEMANTIC");
+    if (s && strcmp(s, "0") == 0) { g_emb_state = -1; return 0; }
+    int dim = 0;
+    float* v = engram_embed_raw("search_query: ", "probe", &dim);
+    if (v && dim > 0) { free(v); g_emb_state = 1; return 1; }
+    free(v);
+    g_emb_state = -1; return 0;
+}
+
+/* Embed the query. Returns malloc'd vec (caller frees), or NULL if semantic off. */
+static float* engram_embed_query(const char* q, int* dim) {
+    if (!engram_semantic_enabled()) return NULL;
+    if (!q || !*q) return NULL;
+    return engram_embed_raw("search_query: ", q, dim);
+}
+
+/* Cached node embedding. Returns a pointer OWNED BY THE CACHE — do not free. */
+static const float* engram_node_vec(EngramNode* n, int* out_dim) {
+    if (!n || !n->id) return NULL;
+    uint64_t h = engram_fnv1a(n->content);
+    for (int64_t i = 0; i < g_emb_count; i++) {
+        if (g_emb_items[i].id && strcmp(g_emb_items[i].id, n->id) == 0) {
+            if (g_emb_items[i].hash == h && g_emb_items[i].vec) {
+                *out_dim = g_emb_items[i].dim; return g_emb_items[i].vec;
+            }
+            /* content changed → re-embed in place */
+            int dim = 0;
+            float* v = engram_embed_raw("search_document: ", n->content ? n->content : "", &dim);
+            if (!v) return NULL;
+            free(g_emb_items[i].vec);
+            g_emb_items[i].vec = v; g_emb_items[i].dim = dim; g_emb_items[i].hash = h;
+            *out_dim = dim; return v;
+        }
+    }
+    int dim = 0;
+    float* v = engram_embed_raw("search_document: ", n->content ? n->content : "", &dim);
+    if (!v) return NULL;
+    if (g_emb_count >= g_emb_cap) {
+        int64_t nc = g_emb_cap ? g_emb_cap * 2 : 256;
+        EngramEmbEntry* ni = realloc(g_emb_items, (size_t)nc * sizeof(EngramEmbEntry));
+        if (!ni) { free(v); return NULL; }
+        g_emb_items = ni; g_emb_cap = nc;
+    }
+    g_emb_items[g_emb_count].id   = strdup(n->id);
+    g_emb_items[g_emb_count].hash = h;
+    g_emb_items[g_emb_count].vec  = v;
+    g_emb_items[g_emb_count].dim  = dim;
+    g_emb_count++;
+    *out_dim = dim; return v;
+}
+
+static double engram_cosine(const float* a, const float* b, int dim) {
+    double dot = 0, na = 0, nb = 0;
+    for (int i = 0; i < dim; i++) { dot += (double)a[i] * b[i];
+                                    na  += (double)a[i] * a[i];
+                                    nb  += (double)b[i] * b[i]; }
+    if (na <= 0 || nb <= 0) return 0.0;
+    return dot / (sqrt(na) * sqrt(nb));
+}
+
+/* Cosine of node n against the query vector; 0 if unavailable / dim mismatch. */
+static double engram_node_cosine(EngramNode* n, const float* qvec, int qdim) {
+    if (!qvec || qdim <= 0) return 0.0;
+    int ndim = 0;
+    const float* nv = engram_node_vec(n, &ndim);
+    if (!nv || ndim != qdim) return 0.0;
+    return engram_cosine(qvec, nv, qdim);
+}
+
+#else  /* !HAVE_CURL — semantic layer compiled out; callers stay pure-lexical.
+        * Only the two boundary functions the always-compiled search/activate
+        * code calls are stubbed; the query embed always yields NULL so every
+        * cosine is 0 and every caller collapses to lexical-only. */
+static float* engram_embed_query(const char* q, int* dim) { (void)q; (void)dim; return NULL; }
+static double engram_node_cosine(EngramNode* n, const float* qvec, int qdim) {
+    (void)n; (void)qvec; (void)qdim; return 0.0;
+}
+#endif /* HAVE_CURL */
+
 el_val_t engram_search(el_val_t query, el_val_t limit) {
     EngramStore* g = engram_get();
     const char* q = EL_CSTR(query);
@@ -6905,8 +7143,15 @@ el_val_t engram_search(el_val_t query, el_val_t limit) {
     char toks[ENGRAM_MAX_QTOKENS][ENGRAM_QTOK_LEN];
     int ntok = engram_tokenize_query(q, toks, ENGRAM_MAX_QTOKENS);
     if (ntok == 0) return lst;
+    /* Semantic augmentation: embed the query once; a node is a hit if it covers
+     * >=1 query token (tokenized-lexical, #66) OR its cosine clears the
+     * threshold (#67). qvec is NULL (cosine 0) when semantic is unavailable →
+     * pure tokenized-lexical, byte-identical to the lexical-only behaviour. */
+    int qdim = 0;
+    float* qvec = engram_embed_query(q, &qdim);
+    double sem_min = engram_semantic_min();
     EngramRankEntry* hits = malloc((size_t)g->node_count * sizeof(EngramRankEntry));
-    if (!hits) return lst;
+    if (!hits) { free(qvec); return lst; }
     int64_t nhits = 0;
     for (int64_t i = 0; i < g->node_count; i++) {
         EngramNode* n = &g->nodes[i];
@@ -6916,20 +7161,24 @@ el_val_t engram_search(el_val_t query, el_val_t limit) {
          * + engram_compile_layered_json — that's the legitimate path. */
         if (engram_layer_is_transparent(n->layer_id)) continue;
         int sc = engram_node_match_score(n, toks, ntok);
-        if (sc > 0) {
+        double sem = qvec ? engram_node_cosine(n, qvec, qdim) : 0.0;
+        if (sc > 0 || sem >= sem_min) {
             hits[nhits].idx      = i;
             hits[nhits].score    = sc;
             hits[nhits].salience = n->salience;
             nhits++;
         }
     }
-    /* Rank by distinct tokens matched (desc) then salience (desc), then cap. */
+    /* Rank by distinct tokens matched (desc) then salience (desc), then cap.
+     * Pure-semantic hits (token score 0) sort after every lexical hit — a
+     * lexical ∪ semantic union with lexical precedence. */
     qsort(hits, (size_t)nhits, sizeof(EngramRankEntry), engram_rank_cmp);
     int64_t end = nhits < lim ? nhits : lim;
     for (int64_t k = 0; k < end; k++) {
         lst = el_list_append(lst, engram_node_to_map(&g->nodes[hits[k].idx]));
     }
     free(hits);
+    free(qvec);
     return lst;
 }
 
@@ -7279,21 +7528,31 @@ el_val_t engram_activate(el_val_t query, el_val_t depth) {
     if (!seeds) {
         free(best_bg); free(best_hops); free(reached); return out;
     }
-    /* Tokenize once: a node seeds if it matches ANY query token, and its seed
-     * activation is scaled by token coverage (fraction of distinct query
-     * tokens it contains) so a node matching all words seeds more strongly
-     * than one matching a single word. Single-word queries → coverage 1.0,
-     * identical to the prior whole-query behavior. */
+    /* Tokenized + semantic seeding: a node seeds if it covers >=1 query token
+     * (tokenized-lexical, #66) OR its cosine clears the threshold (#67). A
+     * lexical seed's activation is scaled by token coverage (fraction of
+     * distinct query tokens covered) so a node matching all words seeds more
+     * strongly than one matching a single word; single-word queries → coverage
+     * 1.0. A pure-semantic seed (no token match) is instead down-weighted by
+     * its cosine so paraphrase matches spread without overpowering exact seeds.
+     * q_vec is NULL (cosine 0) when semantic is unavailable → the seed set is
+     * exactly the tokenized-lexical one. q_vec is freed right after this loop
+     * so the many downstream early-returns need no cleanup change. */
     char toks[ENGRAM_MAX_QTOKENS][ENGRAM_QTOK_LEN];
     int ntok = engram_tokenize_query(q, toks, ENGRAM_MAX_QTOKENS);
+    int q_dim = 0;
+    float* q_vec = engram_embed_query(q, &q_dim);
+    double q_sem_min = engram_semantic_min();
     for (int64_t i = 0; i < g->node_count; i++) {
         EngramNode* n = &g->nodes[i];
         int sc = engram_node_match_score(n, toks, ntok);
-        if (sc > 0) {
+        double sem = q_vec ? engram_node_cosine(n, q_vec, q_dim) : 0.0;
+        if (sc > 0 || sem >= q_sem_min) {
             double tdecay = engram_temporal_decay(n, now_ms);
             double dampen = engram_activation_dampen(n);
-            double cover  = ntok > 0 ? (double)sc / (double)ntok : 1.0;
-            double act    = n->salience * tdecay * dampen * cover;
+            double act    = n->salience * tdecay * dampen;
+            if (sc > 0) act *= (ntok > 0 ? (double)sc / (double)ntok : 1.0);
+            else        act *= sem;  /* pure-semantic seed: down-weight by cosine */
             seeds[seed_count].idx        = i;
             seeds[seed_count].act        = act;
             seeds[seed_count].created_at = n->created_at;
@@ -7303,6 +7562,7 @@ el_val_t engram_activate(el_val_t query, el_val_t depth) {
             reached[i]   = 1;
         }
     }
+    free(q_vec);
     /* Compute mean seed created_at for temporal proximity bonus. */
     int64_t seed_epoch = 0;
     if (seed_count > 0) {
@@ -7854,6 +8114,35 @@ el_val_t engram_get_node_json(el_val_t id) {
     return el_wrap_str(jb_finish(&b));
 }
 
+/* engram_get_node_by_label — find the first node whose label field exactly
+ * matches the given string. Returns the node as a JSON object string, or "{}"
+ * if no match is found.
+ *
+ * Used by chat.el to retrieve well-known nodes (e.g. "conv:history",
+ * "session:summary") by their stable label rather than by ID, which is immune
+ * to vector index drift across restarts.
+ *
+ * Exact match (strcmp, not istr_contains) because labels like "conv:history"
+ * must not collide with nodes whose content happens to contain that substring.
+ *
+ * Backported verbatim (idiom-adapted to jb_finish) from release runtime
+ * v1.0.0-20260501 to unblock the soul regen link: chat.el references this
+ * native but the current runtime lacked its definition. */
+el_val_t engram_get_node_by_label(el_val_t label) {
+    const char* lbl = EL_CSTR(label);
+    if (!lbl || !*lbl) return el_wrap_str(el_strdup("{}"));
+    EngramStore* g = engram_get();
+    for (int64_t i = 0; i < g->node_count; i++) {
+        EngramNode* n = &g->nodes[i];
+        if (n->label && strcmp(n->label, lbl) == 0) {
+            JsonBuf b; jb_init(&b);
+            engram_emit_node_json(&b, n);
+            return el_wrap_str(jb_finish(&b));
+        }
+    }
+    return el_wrap_str(el_strdup("{}"));
+}
+
 el_val_t engram_search_json(el_val_t query, el_val_t limit) {
     EngramStore* g = engram_get();
     const char* q = EL_CSTR(query);
@@ -7861,39 +8150,50 @@ el_val_t engram_search_json(el_val_t query, el_val_t limit) {
     if (lim <= 0) lim = 100;
     JsonBuf b; jb_init(&b);
     jb_putc(&b, '[');
-    int first = 1;
-    if (q && *q) {
+    if (q && *q && g->node_count > 0) {
+        /* Collect candidates from the UNION of tokenized-lexical and semantic
+         * matches, score each, rank by score, emit the top `lim`. A node is a
+         * candidate if it covers >=1 query token (tokenized-lexical, #66) OR its
+         * query cosine clears the threshold (#67). Lexical score is the distinct
+         * token count (>=1), so any lexical hit outranks a pure-semantic hit
+         * (cosine < 1); pure-semantic hits are scored by cosine alone. When
+         * semantic is unavailable qvec is NULL, sem is 0, only tokenized-lexical
+         * hits are collected, and the stable insertion sort preserves order. */
         char toks[ENGRAM_MAX_QTOKENS][ENGRAM_QTOK_LEN];
         int ntok = engram_tokenize_query(q, toks, ENGRAM_MAX_QTOKENS);
-        if (ntok > 0) {
-            EngramRankEntry* hits =
-                malloc((size_t)g->node_count * sizeof(EngramRankEntry));
-            if (hits) {
-                int64_t nhits = 0;
-                for (int64_t i = 0; i < g->node_count; i++) {
-                    EngramNode* n = &g->nodes[i];
-                    /* Filter transparent layers — same as engram_search. */
-                    if (engram_layer_is_transparent(n->layer_id)) continue;
-                    int sc = engram_node_match_score(n, toks, ntok);
-                    if (sc > 0) {
-                        hits[nhits].idx      = i;
-                        hits[nhits].score    = sc;
-                        hits[nhits].salience = n->salience;
-                        nhits++;
-                    }
+        int qdim = 0;
+        float* qvec = engram_embed_query(q, &qdim);
+        double sem_min = engram_semantic_min();
+        typedef struct { int64_t idx; double score; } Cand;
+        Cand* cand = malloc((size_t)g->node_count * sizeof(Cand));
+        if (cand) {
+            int64_t nc = 0;
+            for (int64_t i = 0; i < g->node_count; i++) {
+                EngramNode* n = &g->nodes[i];
+                if (engram_layer_is_transparent(n->layer_id)) continue;
+                int sc = engram_node_match_score(n, toks, ntok);
+                double sem = qvec ? engram_node_cosine(n, qvec, qdim) : 0.0;
+                if (sc > 0 || sem >= sem_min) {
+                    cand[nc].idx   = i;
+                    cand[nc].score = (double)sc + sem;
+                    nc++;
                 }
-                /* Rank by distinct tokens matched (desc) then salience (desc). */
-                qsort(hits, (size_t)nhits, sizeof(EngramRankEntry),
-                      engram_rank_cmp);
-                int64_t end = nhits < lim ? nhits : lim;
-                for (int64_t k = 0; k < end; k++) {
-                    if (!first) jb_putc(&b, ',');
-                    engram_emit_node_json(&b, &g->nodes[hits[k].idx]);
-                    first = 0;
-                }
-                free(hits);
             }
+            /* Insertion sort by score desc; stable for equal scores. */
+            for (int64_t i = 1; i < nc; i++) {
+                Cand k = cand[i]; int64_t j = i - 1;
+                while (j >= 0 && cand[j].score < k.score) { cand[j + 1] = cand[j]; j--; }
+                cand[j + 1] = k;
+            }
+            int first = 1;
+            for (int64_t i = 0; i < nc && i < lim; i++) {
+                if (!first) jb_putc(&b, ',');
+                engram_emit_node_json(&b, &g->nodes[cand[i].idx]);
+                first = 0;
+            }
+            free(cand);
         }
+        free(qvec);
     }
     jb_putc(&b, ']');
     return el_wrap_str(jb_finish(&b));

lang/el-compiler/runtime/el_runtime.h

@@ -632,6 +632,7 @@ el_val_t  engram_load(el_val_t path);
  * can pass results straight through without round-tripping ElList/ElMap
  * through json_stringify. */
 el_val_t  engram_get_node_json(el_val_t id);
+el_val_t  engram_get_node_by_label(el_val_t label);
 el_val_t  engram_search_json(el_val_t query, el_val_t limit);
 el_val_t  engram_scan_nodes_json(el_val_t limit, el_val_t offset);
 el_val_t  engram_scan_nodes_by_type_json(el_val_t node_type, el_val_t limit, el_val_t offset);

lang/el-compiler/runtime/el_seed.c

@@ -1072,6 +1072,7 @@ el_val_t __engram_save(el_val_t path)                       { return engram_save
 el_val_t __engram_load(el_val_t path)                       { return engram_load(path); }
 
 el_val_t __engram_get_node_json(el_val_t id)               { return engram_get_node_json(id); }
+el_val_t __engram_get_node_by_label(el_val_t label)        { return engram_get_node_by_label(label); }
 
 el_val_t __engram_search_json(el_val_t query, el_val_t limit) {
     return engram_search_json(query, limit);

lang/el-compiler/runtime/el_seed.h

@@ -226,6 +226,7 @@ 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_get_node_json(el_val_t id);
+el_val_t  __engram_get_node_by_label(el_val_t label);
 el_val_t  __engram_search_json(el_val_t query, el_val_t limit);
 el_val_t  __engram_scan_nodes_json(el_val_t limit, el_val_t offset);
 el_val_t  __engram_scan_nodes_by_type_json(el_val_t node_type, el_val_t limit, el_val_t offset);

lang/el-compiler/src/codegen.el

@@ -2670,6 +2670,7 @@ fn builtin_arity(name: String) -> Int {
     if str_eq(name, "engram_save") { return 1 }
     if str_eq(name, "engram_load") { return 1 }
     if str_eq(name, "engram_get_node_json") { return 1 }
+    if str_eq(name, "engram_get_node_by_label") { return 1 }
     if str_eq(name, "engram_search_json") { return 2 }
     if str_eq(name, "engram_scan_nodes_json") { return 2 }
     if str_eq(name, "engram_neighbors_json") { return 3 }