el: native @route dispatch + multi-decorator stacking in modular compiler

Port the @route decorator from the bootstrap prototype into the production
modular compiler (parser + streaming codegen), and generalize single
decorators to a stacked list so a handler can be both @route and a VBD role
(@manager/@engine/@accessor). The dispatcher is synthesized from a token
pre-scan (survives the streaming backend's per-fn AST discard, works for
library modules) and emitted specificity-sorted so overlapping prefixes never
shadow by source order. Supports method lists ("GET|POST"), "ANY", and
suffix/compound matchers. Inert on all non-@route code (byte-identical C).

engram/dist/engram.c

@@ -10,6 +10,9 @@ 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 route_act_stats(el_val_t method, el_val_t path, el_val_t body);
+el_val_t route_text_health(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);
@@ -17,21 +20,29 @@ 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 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 route_create_edges_batch(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_embed_backfill(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 route_similarity(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(":"));
@@ -110,17 +121,40 @@ el_val_t route_stats(el_val_t method, el_val_t path, el_val_t body) {
   return 0;
 }
 
+el_val_t route_act_stats(el_val_t method, el_val_t path, el_val_t body) {
+  return engram_act_stats_json();
+  return 0;
+}
+
+el_val_t route_text_health(el_val_t method, el_val_t path, el_val_t body) {
+  return engram_text_health_json();
+  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; });
+  return engram_save(el_str_concat(dir, EL_STR("/snapshot.json")));
+  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 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 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_present = json_get_raw(body, EL_STR("salience"));
+  el_val_t salience = ({ el_val_t _if_result_3 = 0; if (str_eq(sal_present, EL_STR(""))) { _if_result_3 = (el_from_float(0.5)); } else { _if_result_3 = (json_get_float(body, EL_STR("salience"))); } _if_result_3; });
+  el_val_t label_raw = json_get_string(body, EL_STR("label"));
+  el_val_t label = ({ el_val_t _if_result_4 = 0; if (str_eq(label_raw, EL_STR(""))) { _if_result_4 = (content); } else { _if_result_4 = (label_raw); } _if_result_4; });
+  el_val_t imp_present = json_get_raw(body, EL_STR("importance"));
+  el_val_t importance = ({ el_val_t _if_result_5 = 0; if (str_eq(imp_present, EL_STR(""))) { _if_result_5 = (el_from_float(0.5)); } else { _if_result_5 = (json_get_float(body, EL_STR("importance"))); } _if_result_5; });
+  el_val_t conf_present = json_get_raw(body, EL_STR("confidence"));
+  el_val_t confidence = ({ el_val_t _if_result_6 = 0; if (str_eq(conf_present, EL_STR(""))) { _if_result_6 = (el_from_float(1.0)); } else { _if_result_6 = (json_get_float(body, EL_STR("confidence"))); } _if_result_6; });
+  el_val_t tier_raw = json_get_string(body, EL_STR("tier"));
+  el_val_t tier = ({ el_val_t _if_result_7 = 0; if (str_eq(tier_raw, EL_STR(""))) { _if_result_7 = (EL_STR("Working")); } else { _if_result_7 = (tier_raw); } _if_result_7; });
+  el_val_t tags = json_get_string(body, EL_STR("tags"));
+  el_val_t id = engram_node_full(content, node_type, label, salience, importance, confidence, tier, tags);
+  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;
 }
@@ -146,11 +180,9 @@ 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 = 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"));
+  el_val_t dir_raw = env(EL_STR("ENGRAM_DATA_DIR"));
+  el_val_t dir = ({ el_val_t _if_result_8 = 0; if (str_eq(dir_raw, EL_STR(""))) { _if_result_8 = (EL_STR("/tmp/engram")); } else { _if_result_8 = (dir_raw); } _if_result_8; });
+  el_val_t snap_path = el_str_concat(dir, EL_STR("/.scan-export.json"));
   engram_save(snap_path);
   el_val_t snap = fs_read(snap_path);
   if (str_eq(snap, EL_STR(""))) {
@@ -165,36 +197,22 @@ 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_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;
-  }
+  el_val_t q = ({ el_val_t _if_result_9 = 0; if (str_eq(method, EL_STR("GET"))) { _if_result_9 = (query_param(path, EL_STR("q"))); } else { _if_result_9 = (json_get_string(body, EL_STR("query"))); } _if_result_9; });
+  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_10 = 0; if ((lim_url > 0)) { _if_result_10 = (lim_url); } else { _if_result_10 = (lim_body); } _if_result_10; });
+  el_val_t limit = ({ el_val_t _if_result_11 = 0; if ((lim_either > 0)) { _if_result_11 = (lim_either); } else { _if_result_11 = (20); } _if_result_11; });
   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_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 q = ({ el_val_t _if_result_12 = 0; if (str_eq(method, EL_STR("GET"))) { _if_result_12 = (query_param(path, EL_STR("q"))); } else { _if_result_12 = (json_get_string(body, EL_STR("query"))); } _if_result_12; });
+  if (str_eq(q, EL_STR(""))) {
+    return err_json(EL_STR("missing query"));
   }
+  el_val_t d_raw = ({ el_val_t _if_result_13 = 0; if (str_eq(method, EL_STR("GET"))) { _if_result_13 = (query_int(path, EL_STR("depth"), 3)); } else { _if_result_13 = (json_get_int(body, EL_STR("depth"))); } _if_result_13; });
+  el_val_t depth = ({ el_val_t _if_result_14 = 0; if ((d_raw > 0)) { _if_result_14 = (d_raw); } else { _if_result_14 = (3); } _if_result_14; });
   return el_str_concat(el_str_concat(EL_STR("{\"results\":"), engram_activate_json(q, depth)), EL_STR("}"));
   return 0;
 }
@@ -202,19 +220,51 @@ 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 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);
-  }
+  el_val_t rel_raw = json_get_string(body, EL_STR("relation"));
+  el_val_t relation = ({ el_val_t _if_result_15 = 0; if (str_eq(rel_raw, EL_STR(""))) { _if_result_15 = (EL_STR("associates")); } else { _if_result_15 = (rel_raw); } _if_result_15; });
+  el_val_t w_present = json_get_raw(body, EL_STR("weight"));
+  el_val_t weight = ({ el_val_t _if_result_16 = 0; if (str_eq(w_present, EL_STR(""))) { _if_result_16 = (el_from_float(0.5)); } else { _if_result_16 = (json_get_float(body, EL_STR("weight"))); } _if_result_16; });
   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;
 }
 
+el_val_t route_create_edges_batch(el_val_t method, el_val_t path, el_val_t body) {
+  el_val_t arr = json_get_raw(body, EL_STR("edges"));
+  if (str_eq(arr, EL_STR(""))) {
+    return err_json(EL_STR("missing edges array"));
+  }
+  el_val_t n = json_array_len(arr);
+  if (n == 0) {
+    return EL_STR("{\"ok\":true,\"accepted\":0,\"skipped\":0}");
+  }
+  el_val_t i = 0;
+  el_val_t accepted = 0;
+  el_val_t skipped = 0;
+  while (i < n) {
+    el_val_t item = json_array_get(arr, i);
+    el_val_t from_id = json_get_string(item, EL_STR("from_id"));
+    el_val_t to_id = json_get_string(item, EL_STR("to_id"));
+    if (str_eq(from_id, EL_STR("")) || str_eq(to_id, EL_STR(""))) {
+      skipped = (skipped + 1);
+    } else {
+      el_val_t rel_raw = json_get_string(item, EL_STR("relation"));
+      el_val_t relation = ({ el_val_t _if_result_17 = 0; if (str_eq(rel_raw, EL_STR(""))) { _if_result_17 = (EL_STR("associates")); } else { _if_result_17 = (rel_raw); } _if_result_17; });
+      el_val_t w_present = json_get_raw(item, EL_STR("weight"));
+      el_val_t weight = ({ el_val_t _if_result_18 = 0; if (str_eq(w_present, EL_STR(""))) { _if_result_18 = (el_from_float(0.5)); } else { _if_result_18 = (json_get_float(item, EL_STR("weight"))); } _if_result_18; });
+      engram_connect(from_id, to_id, weight, relation);
+      accepted = (accepted + 1);
+    }
+    i = (i + 1);
+  }
+  if (accepted > 0) {
+    el_val_t saved = persist_canonical();
+  }
+  return el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"ok\":true,\"accepted\":"), int_to_str(accepted)), EL_STR(",\"skipped\":")), int_to_str(skipped)), EL_STR("}"));
+  return 0;
+}
+
 el_val_t route_neighbors(el_val_t method, el_val_t path, el_val_t body) {
   el_val_t id = extract_id(path, EL_STR("/api/neighbors/"));
   if (str_eq(id, EL_STR(""))) {
@@ -231,6 +281,7 @@ 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;
 }
@@ -241,11 +292,83 @@ 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_create_ise(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_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_19 = 0; if (str_eq(dir_raw, EL_STR(""))) { _if_result_19 = (EL_STR("/tmp/engram")); } else { _if_result_19 = (dir_raw); } _if_result_19; });
+  el_val_t p = ({ el_val_t _if_result_20 = 0; if (str_eq(p_raw, EL_STR(""))) { _if_result_20 = (el_str_concat(dir, EL_STR("/snapshot.json"))); } else { _if_result_20 = (p_raw); } _if_result_20; });
+  el_val_t sv = engram_save(p);
+  el_val_t sv_ok = ({ el_val_t _if_result_21 = 0; if ((sv == 0)) { _if_result_21 = (EL_STR("false")); } else { _if_result_21 = (EL_STR("true")); } _if_result_21; });
+  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("{\"ok\":"), sv_ok), EL_STR(",\"path\":\"")), p), EL_STR("\",\"node_count\":")), int_to_str(engram_node_count())), EL_STR(",\"edge_count\":")), int_to_str(engram_edge_count())), 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_22 = 0; if (str_eq(dir_raw, EL_STR(""))) { _if_result_22 = (EL_STR("/tmp/engram")); } else { _if_result_22 = (dir_raw); } _if_result_22; });
+  el_val_t p = ({ el_val_t _if_result_23 = 0; if (str_eq(p_raw, EL_STR(""))) { _if_result_23 = (el_str_concat(dir, EL_STR("/snapshot.json"))); } else { _if_result_23 = (p_raw); } _if_result_23; });
+  el_val_t ld = engram_load(p);
+  el_val_t ld_ok = ({ el_val_t _if_result_24 = 0; if ((ld == 0)) { _if_result_24 = (EL_STR("false")); } else { _if_result_24 = (EL_STR("true")); } _if_result_24; });
+  el_val_t nc_after = engram_node_count();
+  el_val_t hollow = ({ el_val_t _if_result_25 = 0; if ((nc_after == 0)) { _if_result_25 = (EL_STR("true")); } else { _if_result_25 = (EL_STR("false")); } _if_result_25; });
+  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_concat(el_str_concat(EL_STR("{\"ok\":"), ld_ok), EL_STR(",\"path\":\"")), p), EL_STR("\",\"node_count\":")), int_to_str(nc_after)), EL_STR(",\"edge_count\":")), int_to_str(engram_edge_count())), EL_STR(",\"hollow\":")), hollow), EL_STR("}"));
+  return 0;
+}
+
+el_val_t route_health(el_val_t method, el_val_t path, el_val_t body) {
+  return el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"status\":\"ok\",\"engine\":\"engram-runtime-native\",\"node_count\":"), int_to_str(engram_node_count())), EL_STR(",\"edge_count\":")), int_to_str(engram_edge_count())), EL_STR("}"));
+  return 0;
+}
+
+el_val_t route_embed_backfill(el_val_t method, el_val_t path, el_val_t body) {
+  el_val_t n = query_int(path, EL_STR("n"), 32);
+  el_val_t result = engram_embed_backfill(n);
+  el_val_t done = json_get_float(result, EL_STR("embedded"));
+  if (done > el_from_float(0.0)) {
+    el_val_t saved = persist_canonical();
+  }
+  return result;
+  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_26 = 0; if (str_eq(dir_raw, EL_STR(""))) { _if_result_26 = (EL_STR("/tmp/engram")); } else { _if_result_26 = (dir_raw); } _if_result_26; });
+  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(""))) {
+    return err_json(EL_STR("sync export failed: snapshot unreadable"));
+  }
+  return snap;
+  return 0;
+}
+
+el_val_t route_load_merge(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"));
+  }
+  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("}"));
+  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"));
@@ -254,55 +377,55 @@ el_val_t route_create_ise(el_val_t method, el_val_t path, el_val_t body) {
   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_27 = 0; if (str_eq(ret_raw, EL_STR(""))) { _if_result_27 = (172800000); } else { _if_result_27 = (str_to_int(ret_raw)); } _if_result_27; });
+  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("}"));
+  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_28 = 0; if (str_eq(title, EL_STR(""))) { _if_result_28 = (str_slice(content, 0, 60)); } else { _if_result_28 = (title); } _if_result_28; });
+  el_val_t category_raw = json_get_string(body, EL_STR("category"));
+  el_val_t category = ({ el_val_t _if_result_29 = 0; if (str_eq(category_raw, EL_STR(""))) { _if_result_29 = (EL_STR("other")); } else { _if_result_29 = (category_raw); } _if_result_29; });
+  el_val_t ktier_raw = json_get_string(body, EL_STR("tier"));
+  el_val_t ktier = ({ el_val_t _if_result_30 = 0; if (str_eq(ktier_raw, EL_STR(""))) { _if_result_30 = (EL_STR("note")); } else { _if_result_30 = (ktier_raw); } _if_result_30; });
+  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_31 = 0; if (str_eq(tags_raw, EL_STR(""))) { _if_result_31 = (EL_STR("[]")); } else { _if_result_31 = (tags_raw); } _if_result_31; });
+  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_32 = 0; if (str_eq(head, EL_STR("["))) { _if_result_32 = (EL_STR("")); } else { _if_result_32 = (EL_STR(",")); } _if_result_32; });
+  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_33 = 0; if (str_eq(safe_proj, EL_STR(""))) { _if_result_33 = (EL_STR("")); } else { _if_result_33 = (el_str_concat(el_str_concat(EL_STR(",\"project:"), safe_proj), EL_STR("\""))); } _if_result_33; });
+  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("\"}"));
   return 0;
 }
 
-el_val_t route_sync(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 route_similarity(el_val_t method, el_val_t path, el_val_t body) {
+  el_val_t a = query_param(path, EL_STR("a"));
+  el_val_t b = query_param(path, EL_STR("b"));
+  if (str_eq(a, EL_STR(""))) {
+    return err_json(EL_STR("missing a"));
   }
-  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(""))) {
-    return EL_STR("{\"nodes\":[],\"edges\":[]}");
+  if (str_eq(b, EL_STR(""))) {
+    return err_json(EL_STR("missing b"));
   }
-  return snap;
-  return 0;
-}
-
-el_val_t route_save(el_val_t method, el_val_t path, el_val_t body) {
-  el_val_t p = json_get_string(body, EL_STR("path"));
-  if (str_eq(p, EL_STR(""))) {
-    el_val_t dir = env(EL_STR("ENGRAM_DATA_DIR"));
-    if (str_eq(dir, EL_STR(""))) {
-      dir = EL_STR("/tmp/engram");
-    }
-    p = el_str_concat(dir, EL_STR("/snapshot.json"));
-  }
-  engram_save(p);
-  return el_str_concat(el_str_concat(EL_STR("{\"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 = 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_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 sim = engram_cosine_sim(a, b);
+  return el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"a\":\""), a), EL_STR("\",\"b\":\"")), b), EL_STR("\",\"cosine\":")), float_to_str(sim)), EL_STR("}"));
   return 0;
 }
 
@@ -329,15 +452,24 @@ 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_starts_with(clean, EL_STR("/api/neuron/state-events"))) {
-    return route_create_ise(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 (!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);
   }
+  if (str_eq(method, EL_STR("GET")) && (str_eq(clean, EL_STR("/api/act-stats")) || str_eq(clean, EL_STR("/act-stats")))) {
+    return route_act_stats(method, path, body);
+  }
+  if (str_eq(method, EL_STR("GET")) && (str_eq(clean, EL_STR("/api/text-health")) || str_eq(clean, EL_STR("/text-health")))) {
+    return route_text_health(method, path, body);
+  }
   if (str_eq(method, EL_STR("POST")) && (str_eq(clean, EL_STR("/api/nodes")) || str_eq(clean, EL_STR("/nodes")))) {
     return route_create_node(method, path, body);
   }
@@ -356,6 +488,9 @@ 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/edges")) || str_eq(clean, EL_STR("/edges")))) {
     return route_create_edge(method, path, body);
   }
+  if (str_eq(method, EL_STR("POST")) && (str_eq(clean, EL_STR("/api/edges/batch")) || str_eq(clean, EL_STR("/edges/batch")))) {
+    return route_create_edges_batch(method, path, body);
+  }
   if (str_eq(method, EL_STR("GET")) && str_starts_with(clean, EL_STR("/api/neighbors/"))) {
     return route_neighbors(method, path, body);
   }
@@ -374,32 +509,46 @@ 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);
+  }
+  if (str_eq(clean, EL_STR("/api/embed-backfill"))) {
+    return route_embed_backfill(method, path, body);
+  }
+  if (str_eq(method, EL_STR("GET")) && str_starts_with(clean, EL_STR("/api/similarity"))) {
+    return route_similarity(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_str = env(EL_STR("ENGRAM_BIND"));
-  if (str_eq(bind_str, EL_STR(""))) {
-    bind_str = EL_STR(":8742");
-  }
+  bind_raw = env(EL_STR("ENGRAM_BIND"));
+  bind_str = ({ el_val_t _if_result_34 = 0; if (str_eq(bind_raw, EL_STR(""))) { _if_result_34 = (EL_STR(":8742")); } else { _if_result_34 = (bind_raw); } _if_result_34; });
   port = parse_port(bind_str);
-  data_dir = env(EL_STR("ENGRAM_DATA_DIR"));
-  if (str_eq(data_dir, EL_STR(""))) {
-    data_dir = EL_STR("/tmp/engram");
-  }
+  data_dir_raw = env(EL_STR("ENGRAM_DATA_DIR"));
+  data_dir = ({ el_val_t _if_result_35 = 0; if (str_eq(data_dir_raw, EL_STR(""))) { _if_result_35 = (EL_STR("/tmp/engram")); } else { _if_result_35 = (data_dir_raw); } _if_result_35; });
   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,13 +76,112 @@ fn route_stats(method: String, path: String, body: String) -> String {
     engram_stats_json()
 }
 
+// route_act_stats — GET /api/act-stats
+// (2026-08-04 self-review) engram_act_stats_json() has existed since the
+// 2026-07-27 review but was reachable ONLY through the soul daemon's heartbeat
+// binding. Every activation-layer gauge — WM evictions, breakthroughs, embedder
+// breaker state, context drift, and now the Hebbian counters — was therefore
+// invisible unless the soul happened to be running and its ISEs were read back
+// out of the store. Diagnosing the activation layer required a working soul,
+// which is exactly backwards: the lower layer should be observable on its own.
+// This review needed it to verify link formation and could not get at it. One
+// line of plumbing, and the whole activation layer becomes directly diagnosable.
+fn route_act_stats(method: String, path: String, body: String) -> String {
+    engram_act_stats_json()
+}
+
+// route_text_health — GET /api/text-health
+// (2026-08-08 self-review) The daily census half of the text-integrity gauge.
+// Today's review found that the JSON parser had been replacing every \uXXXX
+// escape with a literal '?' for at least two months: 3,119 of 4,081
+// non-telemetry nodes (76%) were damaged, including the self traversal root
+// and every values node, and NOTHING detected it — because every gauge in the
+// system measured whether the machinery was running, and none measured whether
+// the text it carried was intact. No snapshot on disk predates the damage, so
+// it cannot be undone; it can only be made impossible to repeat quietly.
+//
+// The parser is fixed. This route is the standing check: `damaged` should now
+// hold flat at its historical floor and never climb. `write_damaged` (also on
+// the heartbeat as txt_damaged) is the live regression signal — non-zero means
+// a write path is mangling text right now.
+fn route_text_health(method: String, path: String, body: String) -> String {
+    engram_text_health_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 }
+    // (2026-08-10 self-review) This returned a hardcoded 1, which made every
+    // caller's `let saved: Int = persist_canonical()` a dead variable — six
+    // durable write paths each believed they had confirmation of a successful
+    // canonical persist and none of them had any. Propagate the real result.
+    return engram_save(dir + "/snapshot.json")
+}
+
+// INCOMPLETE-ROUTE FIX (2026-07-24 self-review): this route silently dropped
+// label, importance, tier, and tags — engram_node() defaults label to content
+// and importance to 0.5, so every node created over HTTP lost its metadata.
+// Observed live: the soul's boot-counter write-back landed with
+// label="soul:boot_count:99" (content), importance 0.5, no tags. Honor the
+// full field set via engram_node_full when any of them is supplied.
+// PRESENCE-AWARE DEFAULTS (2026-08-01 self-review): the old pattern
+// `if x == 0.0 { default }` made a legitimate 0.0 unrepresentable — a caller
+// setting salience/importance/weight to zero silently got 0.5. json_get_raw
+// returns "" when the key is ABSENT and the raw token when present, so
+// absence and zero are now distinguishable. Also: confidence was hardcoded
+// to 1.0 regardless of input — every HTTP-created node claimed full
+// epistemic confidence. Now honored from the payload (default 1.0).
 fn route_create_node(method: String, path: String, body: String) -> String {
     let content: String = json_get_string(body, "content")
-    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 nt_raw: String = json_get_string(body, "node_type")
+    let node_type: String = if str_eq(nt_raw, "") { "Memory" } else { nt_raw }
+    let sal_present: String = json_get_raw(body, "salience")
+    let salience: Float = if str_eq(sal_present, "") { 0.5 } else { json_get_float(body, "salience") }
+    let label_raw: String = json_get_string(body, "label")
+    let label: String = if str_eq(label_raw, "") { content } else { label_raw }
+    let imp_present: String = json_get_raw(body, "importance")
+    let importance: Float = if str_eq(imp_present, "") { 0.5 } else { json_get_float(body, "importance") }
+    let conf_present: String = json_get_raw(body, "confidence")
+    let confidence: Float = if str_eq(conf_present, "") { 1.0 } else { json_get_float(body, "confidence") }
+    let tier_raw: String = json_get_string(body, "tier")
+    let tier: String = if str_eq(tier_raw, "") { "Working" } else { tier_raw }
+    let tags: String = json_get_string(body, "tags")
+    // NO el_from_float WRAPPER (2026-08-01 self-review): salience/importance/
+    // confidence are already Float (el_val_t) values — json_get_float and
+    // Float literals both encode. Wrapping them in el_from_float AGAIN
+    // reinterpreted the boxed bits as a raw double, producing garbage that
+    // failed engram_decode_score's range check and clamped every HTTP-created
+    // node to defaults (salience 0.9 in → 0.5 stored; confidence 0.6 in → 1.0
+    // stored — verified live). route_emit_ise always passed Floats bare and
+    // its 0.3/0.3/0.8 stored correctly; this call now does the same.
+    let id: String = engram_node_full(
+        content, node_type, label,
+        salience, importance, confidence,
+        tier, tags
+    )
+    let saved: Int = persist_canonical()
     "{\"id\":\"" + id + "\",\"content\":\"" + content + "\",\"node_type\":\"" + node_type + "\"}"
 }
 
@@ -103,13 +202,14 @@ 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 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.
+// 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.)
 fn route_scan_edges(method: String, path: String, body: String) -> String {
-    let dir: String = env("ENGRAM_DATA_DIR")
-    if str_eq(dir, "") { let dir = "/tmp/engram" }
-    let snap_path: String = dir + "/snapshot.json"
+    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"
     engram_save(snap_path)
     let snap: String = fs_read(snap_path)
     if str_eq(snap, "") { return "[]" }
@@ -122,43 +222,88 @@ 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") {
-        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 }
+    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 }
     return engram_search_json(q, limit)
 }
 
 fn route_activate(method: String, path: String, body: String) -> String {
-    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 }
-    }
+    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 }
     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 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 }
+    let rel_raw: String = json_get_string(body, "relation")
+    let relation: String = if str_eq(rel_raw, "") { "associates" } else { rel_raw }
+    // Presence-aware (2026-08-01): weight 0.0 is a legitimate edge weight
+    // (dormant association); only default when the key is absent.
+    let w_present: String = json_get_raw(body, "weight")
+    let weight: Float = if str_eq(w_present, "") { 0.5 } else { json_get_float(body, "weight") }
     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 + "\"}"
 }
 
+// route_create_edges_batch — POST /api/edges/batch {"edges":[{from_id,to_id,relation,weight}, ...]}
+//
+// WHY THIS EXISTS (2026-08-07 self-review). persist_canonical() writes the
+// FULL canonical snapshot — 60MB at current graph size — and route_create_edge
+// calls it once per edge. That is correct for the interactive one-edge case and
+// ruinous for any bulk write: the soul's Hebbian consolidation path delivers
+// ~14 associations per 8-minute heartbeat, which through the single-edge route
+// would be ~840MB of disk writes per beat, ~150GB/day, to persist 14 edges.
+//
+// The fix is not to weaken durability — it is to make the unit of durability
+// the BATCH. Connect every edge, then snapshot exactly once. Same guarantee
+// (nothing acknowledged is lost to a restart), 1/N the writes. Empty or
+// malformed entries are skipped rather than aborting the batch: a consolidation
+// payload is best-effort by design, and one bad id should not cost the other 13.
+//
+// Returns the accepted count so the caller can tell delivery from silence.
+fn route_create_edges_batch(method: String, path: String, body: String) -> String {
+    let arr: String = json_get_raw(body, "edges")
+    if str_eq(arr, "") { return err_json("missing edges array") }
+    let n: Int = json_array_len(arr)
+    if n == 0 { return "{\"ok\":true,\"accepted\":0,\"skipped\":0}" }
+    let i: Int = 0
+    let accepted: Int = 0
+    let skipped: Int = 0
+    while i < n {
+        let item: String = json_array_get(arr, i)
+        let from_id: String = json_get_string(item, "from_id")
+        let to_id: String = json_get_string(item, "to_id")
+        if str_eq(from_id, "") || str_eq(to_id, "") {
+            let skipped = skipped + 1
+        } else {
+            let rel_raw: String = json_get_string(item, "relation")
+            let relation: String = if str_eq(rel_raw, "") { "associates" } else { rel_raw }
+            let w_present: String = json_get_raw(item, "weight")
+            let weight: Float = if str_eq(w_present, "") { 0.5 } else { json_get_float(item, "weight") }
+            engram_connect(from_id, to_id, weight, relation)
+            let accepted = accepted + 1
+        }
+        let i = i + 1
+    }
+    // ONE snapshot for the whole batch — the entire point of this route.
+    // Skip it when nothing was accepted: an all-malformed payload must not
+    // trigger a 60MB write.
+    if accepted > 0 {
+        let saved: Int = persist_canonical()
+    }
+    return "{\"ok\":true,\"accepted\":" + int_to_str(accepted) + ",\"skipped\":" + int_to_str(skipped) + "}"
+}
+
 fn route_neighbors(method: String, path: String, body: String) -> String {
     let id: String = extract_id(path, "/api/neighbors/")
     if str_eq(id, "") { return err_json("missing id") }
@@ -170,6 +315,7 @@ 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()
 }
 
@@ -177,33 +323,84 @@ 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: 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 + "\"}"
+    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 }
+    // (2026-08-10 self-review) engram_save returns 0 on an empty path and the
+    // route discarded it, so the response was a literal "ok":true regardless
+    // of whether anything was written. Report the actual result AND the counts
+    // that were supposed to have been written — the same move that made
+    // route_health honest on 2026-08-01. A caller can now tell "saved 13k
+    // nodes" from "saved nothing and said ok".
+    let sv: Int = engram_save(p)
+    let sv_ok: String = if sv == 0 { "false" } else { "true" }
+    "{\"ok\":" + sv_ok + ",\"path\":\"" + p + "\",\"node_count\":" + int_to_str(engram_node_count()) + ",\"edge_count\":" + int_to_str(engram_edge_count()) + "}"
 }
 
 fn route_load(method: String, path: String, body: String) -> String {
-    let p: String = json_get_string(body, "path")
-    if str_eq(p, "") {
-        let dir: String = env("ENGRAM_DATA_DIR")
-        if str_eq(dir, "") { let dir = "/tmp/engram" }
-        let p = dir + "/snapshot.json"
-    }
-    engram_load(p)
-    ok_json()
+    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 }
+    // (2026-08-10 self-review) This was a stub response over the single most
+    // destructive operation in the server. engram_load returns 0 on an empty
+    // path, an unopenable file, a zero-length file, or malloc failure — and
+    // this route answered ok_json() in every one of those cases.
+    //
+    // Precise failure shape (el_runtime.c:9890): the fopen guard runs BEFORE
+    // the store reset, so a MISSING path is genuinely safe — it returns 0 with
+    // the graph intact. The dangerous case is a readable-but-malformed file:
+    // the reset loop frees every node and edge FIRST, then parses, so a
+    // truncated or non-snapshot JSON leaves a hollow store — and the caller
+    // was told "ok":true. With 37 GB of stale dated snapshots sitting in the
+    // data dir as tempting restore targets, "restore reported success and
+    // silently emptied the graph" is a live risk, not a hypothetical one.
+    //
+    // Fix: surface the return value AND the resulting counts. node_count=0
+    // after a load is the unambiguous hollow-store signal (same convention
+    // route_health adopted 2026-08-01). Callers can now verify a restore
+    // instead of trusting it.
+    let ld: Int = engram_load(p)
+    let ld_ok: String = if ld == 0 { "false" } else { "true" }
+    let nc_after: Int = engram_node_count()
+    let hollow: String = if nc_after == 0 { "true" } else { "false" }
+    "{\"ok\":" + ld_ok + ",\"path\":\"" + p + "\",\"node_count\":" + int_to_str(nc_after) + ",\"edge_count\":" + int_to_str(engram_edge_count()) + ",\"hollow\":" + hollow + "}"
 }
 
+// (2026-08-01 self-review) Health previously returned a hardcoded literal —
+// it reported "ok" even when the snapshot failed to load and the store was
+// empty. Now reports live counts so a monitor can distinguish "up and
+// loaded" from "up and hollow" (node_count=0 after boot = failed load).
 fn route_health(method: String, path: String, body: String) -> String {
-    "{\"status\":\"ok\",\"engine\":\"engram-runtime-native\"}"
+    "{\"status\":\"ok\",\"engine\":\"engram-runtime-native\",\"node_count\":" + int_to_str(engram_node_count()) + ",\"edge_count\":" + int_to_str(engram_edge_count()) + "}"
+}
+
+// route_embed_backfill — GET/POST /api/embed-backfill?n=48
+//
+// (2026-07-25 self-review) The lazy embedding backfill runs only inside
+// engram_activate, and nothing in production calls /api/activate on this
+// store — the soul's curiosity loop activates its own in-process graph.
+// After a restart from a snapshot without vectors, embedded_count stalled
+// at 93/12175 and would never recover. This route lets the soul's
+// heartbeat pump the backfill explicitly (48/min clears a 12k backlog in
+// ~4h). Persists the canonical snapshot whenever new vectors were
+// generated — the 2026-07-25 regression happened precisely because 3747
+// in-RAM embeddings were never snapshotted before a restart. Self-
+// limiting: once coverage is full, embedded=0 and no save occurs.
+fn route_embed_backfill(method: String, path: String, body: String) -> String {
+    let n: Int = query_int(path, "n", 32)
+    let result: String = engram_embed_backfill(n)
+    let done: Float = json_get_float(result, "embedded")
+    if done > 0.0 {
+        let saved: Int = persist_canonical()
+    }
+    return result
 }
 
 // route_sync — return a snapshot of non-ISE/non-Working nodes for the soul daemon
@@ -219,15 +416,45 @@ 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: String = env("ENGRAM_DATA_DIR")
-    if str_eq(dir, "") { let dir = "/tmp/engram" }
-    let snap_path: String = dir + "/snapshot.json"
+    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"
     engram_save(snap_path)
     let snap: String = fs_read(snap_path)
-    if str_eq(snap, "") { return "{\"nodes\":[],\"edges\":[]}" }
+    // 2026-08-02 self-review: this used to return {"nodes":[],"edges":[]} when
+    // the export/read failed. The soul's sync_ok test (awareness.el) only
+    // checks for "" and "{}", so that placeholder PASSED as a healthy sync:
+    // soul.last_sync_ok_ts got stamped, sync_age_ms stayed green, the
+    // sync_empty warn ISE never fired, and engram_sync reported added:0
+    // forever. A totally broken sync was indistinguishable from a quiet
+    // healthy one — the exact failure class this route was added to fix in
+    // the first place (see 2026-06-27 note above). Return a real error so the
+    // failure is loud on both sides.
+    if str_eq(snap, "") { return err_json("sync export failed: snapshot unreadable") }
     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
@@ -241,10 +468,20 @@ fn route_sync(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). High temporal_decay_rate (1.617) — ISEs
-// are inherently transient; they should decay faster than structural knowledge.
+// confidence=0.8, tier=Episodic).
 // (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") }
@@ -256,9 +493,86 @@ 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 + "\"}"
 }
 
+// route_similarity — GET /api/similarity?a=<id>&b=<id>
+//
+// (2026-08-01 self-review) engram_cosine_sim was added 2026-07-24
+// (bl-b2d1c944) with the stated purpose of exposing semantic distance to
+// "EL code and the introspection API" — but it had ZERO callers anywhere:
+// no route, no soul-daemon use. The activation path uses embeddings
+// internally (semantic seeding, Pass-2 additive term), but there was no way
+// to probe pairwise node similarity from outside. This closes that: cosine
+// in [-1,1], or -2 when either node is missing or not yet embedded (so
+// "not comparable" is distinguishable from "genuinely orthogonal" 0.0).
+fn route_similarity(method: String, path: String, body: String) -> String {
+    let a: String = query_param(path, "a")
+    let b: String = query_param(path, "b")
+    if str_eq(a, "") { return err_json("missing a") }
+    if str_eq(b, "") { return err_json("missing b") }
+    let sim: Float = engram_cosine_sim(a, b)
+    "{\"a\":\"" + a + "\",\"b\":\"" + b + "\",\"cosine\":" + float_to_str(sim) + "}"
+}
+
 // ── Auth ──────────────────────────────────────────────────────────────────────
 
 fn check_auth_ok(method: String, body: String) -> Bool {
@@ -295,10 +609,22 @@ 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)
     }
+    if str_eq(method, "GET") && (str_eq(clean, "/api/act-stats") || str_eq(clean, "/act-stats")) {
+        return route_act_stats(method, path, body)
+    }
+    if str_eq(method, "GET") && (str_eq(clean, "/api/text-health") || str_eq(clean, "/text-health")) {
+        return route_text_health(method, path, body)
+    }
 
     // Nodes
     if str_eq(method, "POST") && (str_eq(clean, "/api/nodes") || str_eq(clean, "/nodes")) {
@@ -321,6 +647,13 @@ fn handle_request(method: String, path: String, body: String) -> String {
     if str_eq(method, "POST") && (str_eq(clean, "/api/edges") || str_eq(clean, "/edges")) {
         return route_create_edge(method, path, body)
     }
+    // Batch edge write — one snapshot for the whole payload. Must be tested
+    // BEFORE nothing else claims it; the exact-match on "/api/edges" above
+    // does not catch "/api/edges/batch", so order is not load-bearing here,
+    // but keeping the two adjacent keeps them from drifting apart.
+    if str_eq(method, "POST") && (str_eq(clean, "/api/edges/batch") || str_eq(clean, "/edges/batch")) {
+        return route_create_edges_batch(method, path, body)
+    }
     if str_eq(method, "GET") && str_starts_with(clean, "/api/neighbors/") {
         return route_neighbors(method, path, body)
     }
@@ -351,27 +684,55 @@ 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") {
         return route_sync(method, path, body)
     }
 
+    // Embedding backfill — pumped by the soul heartbeat (2026-07-25)
+    if str_eq(clean, "/api/embed-backfill") {
+        return route_embed_backfill(method, path, body)
+    }
+
+    // Semantic similarity probe (2026-08-01)
+    if str_eq(method, "GET") && str_starts_with(clean, "/api/similarity") {
+        return route_similarity(method, path, body)
+    }
+
     "{\"error\":\"not found\",\"path\":\"" + clean + "\"}"
 }
 
 // ── Entry ─────────────────────────────────────────────────────────────────────
 
-let bind_str: String = env("ENGRAM_BIND")
-if str_eq(bind_str, "") { let bind_str = ":8742" }
+let bind_raw: String = env("ENGRAM_BIND")
+let bind_str: String = if str_eq(bind_raw, "") { ":8742" } else { bind_raw }
 let port: Int = parse_port(bind_str)
 
 // On startup, try to load any existing snapshot (best effort).
-let data_dir: String = env("ENGRAM_DATA_DIR")
-if str_eq(data_dir, "") { let data_dir = "/tmp/engram" }
+let 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 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()))

lang/el-compiler/runtime/el_runtime.c

@@ -1545,6 +1545,17 @@ typedef struct {
 #endif
 } HttpWorkerArg;
 
+/* Forward declarations for the loopback/API-key hardening helpers defined
+ * further down. Without these, http_worker's calls below were implicit
+ * declarations and the later `static` definitions conflicted with them — this
+ * file did not compile at all. (2026-08-08 self-review: the hardening work
+ * they belong to had been sitting uncommitted in the working tree since
+ * 2026-07-15 in exactly this non-building state, which is presumably why it
+ * was never committed. Adding the two prototypes is the whole fix.) */
+static int  el_http_request_authorized(const char* method, const char* path,
+                                       const char* hdr_block);
+static void el_http_send_401(int fd);
+
 static void* http_worker(void* arg) {
     HttpWorkerArg* a = (HttpWorkerArg*)arg;
 #ifdef _WIN32
@@ -1553,8 +1564,13 @@ static void* http_worker(void* arg) {
     int fd = a->fd;
 #endif
     free(a);
-    char *method = NULL, *path = NULL, *body = NULL;
-    if (http_read_request(fd, &method, &path, &body, NULL) == 0) {
+    char *method = NULL, *path = NULL, *body = NULL, *hdr_block = NULL;
+    if (http_read_request(fd, &method, &path, &body, &hdr_block) == 0
+        && !el_http_request_authorized(method, path, hdr_block)) {
+        /* Loopback hardening: EL_HTTP_AUTH_KEY is set and this request lacks the
+         * matching X-Neuron-Auth header — refuse before it reaches any handler. */
+        el_http_send_401(fd);
+    } else if (method != NULL) {
         http_handler_fn h = http_lookup_active();
         char* response = NULL;
         /* HEAD: dispatch as GET so existing handlers respond with the same
@@ -1582,7 +1598,7 @@ static void* http_worker(void* arg) {
         _tl_http_head_only = 0;
         free(response);
     }
-    free(method); free(path); free(body);
+    free(method); free(path); free(body); free(hdr_block);
     el_closesocket(fd);
     /* release a slot */
     pthread_mutex_lock(&_http_conn_mu);
@@ -1592,6 +1608,108 @@ static void* http_worker(void* arg) {
     return NULL;
 }
 
+/* ── loopback lock + local API-key auth (shipped desktop hardening) ────────
+ * Both controls are OFF by default (their env vars unset), so dev, self-host,
+ * and server builds behave exactly as before. The shipped macOS launcher
+ * neuron-daemons.sh sets them so a customer's soul is neither reachable from
+ * other machines on the LAN nor callable by other local users/processes
+ * without the per-install key held in the login Keychain:
+ *
+ *   EL_HTTP_BIND_HOST=127.0.0.1    -> bind loopback only (el_http_apply_bind_addr)
+ *   EL_HTTP_AUTH_KEY=<per-install> -> require "X-Neuron-Auth: <key>" per request
+ */
+
+/* Set the listen address on the dual-stack (AF_INET6, V6ONLY=0) socket. Default
+ * is in6addr_any (all interfaces) — unchanged. When EL_HTTP_BIND_HOST names a
+ * loopback ("127.0.0.1", "localhost", "loopback", or "::1") we bind the IPv4-
+ * mapped IPv6 loopback ::ffff:127.0.0.1: on a V6ONLY=0 socket this accepts IPv4
+ * 127.0.0.1 clients (the desktop app connects there) while refusing every
+ * off-machine address. */
+static void el_http_apply_bind_addr(struct sockaddr_in6* addr) {
+    const char* h = getenv("EL_HTTP_BIND_HOST");
+    int loopback = h && *h && (strcmp(h, "127.0.0.1") == 0
+                            || strcmp(h, "localhost") == 0
+                            || strcmp(h, "loopback")  == 0
+                            || strcmp(h, "::1")       == 0);
+    if (loopback) {
+        memset(&addr->sin6_addr, 0, sizeof(addr->sin6_addr));
+        addr->sin6_addr.s6_addr[10] = 0xff;   /* ::ffff:127.0.0.1 */
+        addr->sin6_addr.s6_addr[11] = 0xff;
+        addr->sin6_addr.s6_addr[12] = 127;
+        addr->sin6_addr.s6_addr[15] = 1;
+    } else {
+        addr->sin6_addr = in6addr_any;
+    }
+}
+
+/* Human-readable description of the active bind host, for the listen log line. */
+static const char* el_http_bind_desc(void) {
+    const char* h = getenv("EL_HTTP_BIND_HOST");
+    if (h && *h && (strcmp(h, "127.0.0.1") == 0 || strcmp(h, "localhost") == 0
+                 || strcmp(h, "loopback") == 0 || strcmp(h, "::1") == 0)) {
+        return "127.0.0.1 (loopback)";
+    }
+    return "[::] (dual-stack)";
+}
+
+/* Case-insensitive compare of the first n bytes of a and b. */
+static int el_ci_eq_n(const char* a, const char* b, size_t n) {
+    for (size_t i = 0; i < n; i++) {
+        unsigned char ca = (unsigned char)a[i], cb = (unsigned char)b[i];
+        if (tolower(ca) != tolower(cb)) return 0;
+    }
+    return 1;
+}
+
+/* Return 1 iff the raw header block carries a header named `name` (case-
+ * insensitive) whose trimmed value equals `want` exactly. */
+static int el_http_header_equals(const char* hdr_block, const char* name,
+                                 const char* want) {
+    if (!hdr_block || !name || !want) return 0;
+    size_t nlen = strlen(name), wlen = strlen(want);
+    const char* p = hdr_block;
+    while (*p) {
+        const char* line_end = strstr(p, "\r\n");
+        const char* end = line_end ? line_end : p + strlen(p);
+        const char* colon = memchr(p, ':', (size_t)(end - p));
+        if (colon && (size_t)(colon - p) == nlen && el_ci_eq_n(p, name, nlen)) {
+            const char* v = colon + 1;
+            while (v < end && (*v == ' ' || *v == '\t')) v++;
+            size_t vlen = (size_t)(end - v);
+            while (vlen > 0 && (v[vlen - 1] == ' ' || v[vlen - 1] == '\t')) vlen--;
+            if (vlen == wlen && memcmp(v, want, wlen) == 0) return 1;
+        }
+        if (!line_end) break;
+        p = line_end + 2;
+    }
+    return 0;
+}
+
+/* Authorize an inbound request. Enforcement is active only when EL_HTTP_AUTH_KEY
+ * is set; otherwise every request is allowed (dev default). GET/HEAD /health*
+ * are always allowed so launch-agent liveness probes work without the key. */
+static int el_http_request_authorized(const char* method, const char* path,
+                                      const char* hdr_block) {
+    const char* key = getenv("EL_HTTP_AUTH_KEY");
+    if (!key || !*key) return 1;
+    if (method && (strcmp(method, "GET") == 0 || strcmp(method, "HEAD") == 0)
+        && path && strncmp(path, "/health", 7) == 0) return 1;
+    return el_http_header_equals(hdr_block, "x-neuron-auth", key);
+}
+
+/* Minimal 401 for unauthorized requests — never reaches an EL handler. */
+static void el_http_send_401(int fd) {
+    static const char* body = "{\"error\":\"unauthorized\",\"code\":\"auth_required\"}";
+    char resp[256];
+    int n = snprintf(resp, sizeof(resp),
+                     "HTTP/1.1 401 Unauthorized\r\n"
+                     "Content-Type: application/json\r\n"
+                     "Content-Length: %zu\r\n"
+                     "Connection: close\r\n\r\n%s",
+                     strlen(body), body);
+    if (n > 0) http_send_all(fd, resp, (size_t)n);
+}
+
 el_val_t http_serve(el_val_t port, el_val_t handler) {
     /* If `handler` looks like a string name, register it as the active handler. */
     const char* hname = EL_CSTR(handler);
@@ -1610,13 +1728,13 @@ el_val_t http_serve(el_val_t port, el_val_t handler) {
     struct sockaddr_in6 addr;
     memset(&addr, 0, sizeof(addr));
     addr.sin6_family = AF_INET6;
-    addr.sin6_addr = in6addr_any;
+    el_http_apply_bind_addr(&addr);
     addr.sin6_port = htons((uint16_t)p);
     if (bind(sock, (struct sockaddr*)&addr, sizeof(addr)) < 0) {
         perror("bind"); el_closesocket(sock); return 0;
     }
     if (listen(sock, 64) < 0) { perror("listen"); el_closesocket(sock); return 0; }
-    fprintf(stderr, "[http] listening on [::]:%d (dual-stack)\n", p);
+    fprintf(stderr, "[http] listening on %s port %d\n", el_http_bind_desc(), p);
     while (1) {
         struct sockaddr_in6 cli;
         socklen_t clen = sizeof(cli);
@@ -1866,13 +1984,13 @@ el_val_t http_serve_v2(el_val_t port, el_val_t handler) {
     struct sockaddr_in6 addr;
     memset(&addr, 0, sizeof(addr));
     addr.sin6_family = AF_INET6;
-    addr.sin6_addr = in6addr_any;
+    el_http_apply_bind_addr(&addr);
     addr.sin6_port = htons((uint16_t)p);
     if (bind(sock, (struct sockaddr*)&addr, sizeof(addr)) < 0) {
         perror("bind"); el_closesocket(sock); return 0;
     }
     if (listen(sock, 64) < 0) { perror("listen"); el_closesocket(sock); return 0; }
-    fprintf(stderr, "[http v2] listening on [::]:%d (dual-stack)\n", p);
+    fprintf(stderr, "[http v2] listening on %s port %d\n", el_http_bind_desc(), p);
     while (1) {
         struct sockaddr_in6 cli;
         socklen_t clen = sizeof(cli);
@@ -1968,13 +2086,13 @@ void http_serve_async(el_val_t port, el_val_t handler) {
     struct sockaddr_in6 addr;
     memset(&addr, 0, sizeof(addr));
     addr.sin6_family = AF_INET6;
-    addr.sin6_addr = in6addr_any;
+    el_http_apply_bind_addr(&addr);
     addr.sin6_port = htons((uint16_t)p);
     if (bind(sock, (struct sockaddr*)&addr, sizeof(addr)) < 0) {
         perror("bind"); close(sock); return;
     }
     if (listen(sock, 64) < 0) { perror("listen"); close(sock); return; }
-    fprintf(stderr, "[http] async listening on [::]:%d (dual-stack)\n", p);
+    fprintf(stderr, "[http] async listening on %s port %d\n", el_http_bind_desc(), p);
     HttpServeAsyncArg* a = malloc(sizeof(HttpServeAsyncArg));
     if (!a) { close(sock); return; }
     a->sock = sock;
@@ -3139,10 +3257,72 @@ static char* jp_parse_string_raw(JsonParser* jp) {
                 case 'r':  c = '\r'; break;
                 case 't':  c = '\t'; break;
                 case 'u': {
-                    /* Skip 4 hex digits; emit '?' as a placeholder */
-                    for (int i = 0; i < 4 && jp->p < jp->end; i++) jp->p++;
-                    c = '?';
-                    break;
+                    /* Decode \uXXXX (with surrogate pairs) to UTF-8.
+                     * Ported from lang/releases/v1.0.0-20260501 (2026-08-08
+                     * self-review). This copy carried the identical defect:
+                     * the escape was skipped and a literal '?' emitted, which
+                     * silently destroyed every non-ASCII character in any JSON
+                     * string entering the runtime. Two copies of one parser
+                     * bug is exactly how this class of fault survives, so the
+                     * fix lands in both. See the release copy for the full
+                     * measurement and rationale. */
+                    unsigned cp = 0;
+                    int ok = 1;
+                    for (int i = 0; i < 4; i++) {
+                        if (jp->p >= jp->end) { ok = 0; break; }
+                        char h = *jp->p++;
+                        unsigned d;
+                        if      (h >= '0' && h <= '9') d = (unsigned)(h - '0');
+                        else if (h >= 'a' && h <= 'f') d = (unsigned)(h - 'a' + 10);
+                        else if (h >= 'A' && h <= 'F') d = (unsigned)(h - 'A' + 10);
+                        else { ok = 0; break; }
+                        cp = (cp << 4) | d;
+                    }
+                    if (!ok) { c = '?'; break; }
+                    if (cp >= 0xD800 && cp <= 0xDBFF &&
+                        (size_t)(jp->end - jp->p) >= 6 &&
+                        jp->p[0] == '\\' && jp->p[1] == 'u') {
+                        const char* save = jp->p;
+                        unsigned lo = 0; int ok2 = 1;
+                        jp->p += 2;
+                        for (int i = 0; i < 4; i++) {
+                            char h = *jp->p++;
+                            unsigned d;
+                            if      (h >= '0' && h <= '9') d = (unsigned)(h - '0');
+                            else if (h >= 'a' && h <= 'f') d = (unsigned)(h - 'a' + 10);
+                            else if (h >= 'A' && h <= 'F') d = (unsigned)(h - 'A' + 10);
+                            else { ok2 = 0; break; }
+                            lo = (lo << 4) | d;
+                        }
+                        if (ok2 && lo >= 0xDC00 && lo <= 0xDFFF)
+                            cp = 0x10000u + ((cp - 0xD800u) << 10) + (lo - 0xDC00u);
+                        else jp->p = save;
+                    }
+                    if (cp >= 0xD800 && cp <= 0xDFFF) cp = 0xFFFD;
+
+                    char ub[4]; int un;
+                    if (cp < 0x80) {
+                        ub[0] = (char)cp; un = 1;
+                    } else if (cp < 0x800) {
+                        ub[0] = (char)(0xC0 | (cp >> 6));
+                        ub[1] = (char)(0x80 | (cp & 0x3F)); un = 2;
+                    } else if (cp < 0x10000) {
+                        ub[0] = (char)(0xE0 | (cp >> 12));
+                        ub[1] = (char)(0x80 | ((cp >> 6) & 0x3F));
+                        ub[2] = (char)(0x80 | (cp & 0x3F)); un = 3;
+                    } else {
+                        ub[0] = (char)(0xF0 | (cp >> 18));
+                        ub[1] = (char)(0x80 | ((cp >> 12) & 0x3F));
+                        ub[2] = (char)(0x80 | ((cp >> 6) & 0x3F));
+                        ub[3] = (char)(0x80 | (cp & 0x3F)); un = 4;
+                    }
+                    while (len + (size_t)un >= cap) {
+                        cap *= 2;
+                        out = realloc(out, cap);
+                        if (!out) { fputs("el_runtime: out of memory\n", stderr); exit(1); }
+                    }
+                    for (int i = 0; i < un; i++) out[len++] = ub[i];
+                    continue; /* bytes already appended */
                 }
                 default: c = esc; break;
             }
@@ -6048,6 +6228,13 @@ void el_cgi_init(el_val_t name, el_val_t dharma_id, el_val_t principal,
 #define ENGRAM_SUPPRESSION_BREAKTHROUGH 5
 #define ENGRAM_BREAKTHROUGH_WEIGHT   0.25
 #define ENGRAM_INHIBITION_FACTOR     0.1
+/* ENGRAM_WM_CAP: hard global ceiling on nodes holding working_memory_weight
+ * > 0 at any time. Cowan (2001) puts human WM capacity at ~4 chunks; 24 gives
+ * the daemon generous headroom while preventing the unbounded growth observed
+ * in production (wm_active 288-778 per heartbeat — "working memory" that is
+ * really the whole recently-touched graph). Ported from release runtime
+ * v1.0.0-20260501 Pass 5 on 2026-07-15 self-review. */
+#define ENGRAM_WM_CAP                24
 
 /* ── Layered consciousness architecture ──────────────────────────────────────
  *
@@ -6826,6 +7013,75 @@ static int istr_contains(const char* hay, const char* needle) {
     return 0;
 }
 
+/* ── Tokenized query matching ───────────────────────────────────────────
+ * The engram query surface (search / activate / goal-bias) historically
+ * matched the ENTIRE raw query string as a single case-insensitive
+ * substring via istr_contains(field, q). That is Ctrl-F, not search:
+ * a multi-word query like "windows msi signing" only matched a node whose
+ * text contained that exact contiguous run, so real multi-word queries
+ * returned zero. istr_contains stays as the per-TOKEN primitive; these
+ * helpers split the query on whitespace and match ANY token, then rank by
+ * how many DISTINCT tokens a node covers. Single-token queries are a strict
+ * special case (score is 0 or 1) so single-word callers never regress. */
+#define ENGRAM_MAX_QTOKENS 32
+#define ENGRAM_QTOK_LEN    256
+
+/* Split q on whitespace into up to ENGRAM_MAX_QTOKENS distinct
+ * (case-insensitive) tokens. Returns the token count. Over-long tokens are
+ * truncated to ENGRAM_QTOK_LEN-1; over-count tokens are ignored. */
+static int engram_tokenize_query(const char* q,
+                                 char toks[][ENGRAM_QTOK_LEN], int maxtok) {
+    int n = 0;
+    if (!q) return 0;
+    const char* p = q;
+    while (*p && n < maxtok) {
+        while (*p && isspace((unsigned char)*p)) p++;
+        if (!*p) break;
+        char buf[ENGRAM_QTOK_LEN];
+        size_t tl = 0;
+        while (*p && !isspace((unsigned char)*p)) {
+            if (tl < sizeof(buf) - 1) buf[tl++] = *p;
+            p++;
+        }
+        buf[tl] = '\0';
+        if (tl == 0) continue;
+        int dup = 0;
+        for (int s = 0; s < n; s++) {
+            if (strcasecmp(toks[s], buf) == 0) { dup = 1; break; }
+        }
+        if (dup) continue;
+        memcpy(toks[n], buf, tl + 1);
+        n++;
+    }
+    return n;
+}
+
+/* Count how many of the ntok distinct query tokens appear (case-insensitive)
+ * in the node's content, label, or tags. 0 == no match. */
+static int engram_node_match_score(const EngramNode* n,
+                                   char toks[][ENGRAM_QTOK_LEN], int ntok) {
+    int score = 0;
+    for (int t = 0; t < ntok; t++) {
+        if (istr_contains(n->content, toks[t]) ||
+            istr_contains(n->label,   toks[t]) ||
+            istr_contains(n->tags,    toks[t]))
+            score++;
+    }
+    return score;
+}
+
+/* Rank entry: distinct-token match count (primary, desc) then salience
+ * (tiebreak, desc). */
+typedef struct { int64_t idx; int score; double salience; } EngramRankEntry;
+static int engram_rank_cmp(const void* a, const void* b) {
+    const EngramRankEntry* ea = (const EngramRankEntry*)a;
+    const EngramRankEntry* eb = (const EngramRankEntry*)b;
+    if (ea->score != eb->score) return eb->score - ea->score;      /* desc */
+    if (ea->salience < eb->salience) return 1;
+    if (ea->salience > eb->salience) return -1;
+    return 0;
+}
+
 el_val_t engram_search(el_val_t query, el_val_t limit) {
     EngramStore* g = engram_get();
     const char* q = EL_CSTR(query);
@@ -6833,21 +7089,34 @@ el_val_t engram_search(el_val_t query, el_val_t limit) {
     if (lim <= 0) lim = 100;
     el_val_t lst = el_list_empty();
     if (!q || !*q) return lst;
-    int64_t found = 0;
-    for (int64_t i = 0; i < g->node_count && found < lim; i++) {
+    char toks[ENGRAM_MAX_QTOKENS][ENGRAM_QTOK_LEN];
+    int ntok = engram_tokenize_query(q, toks, ENGRAM_MAX_QTOKENS);
+    if (ntok == 0) return lst;
+    EngramRankEntry* hits = malloc((size_t)g->node_count * sizeof(EngramRankEntry));
+    if (!hits) return lst;
+    int64_t nhits = 0;
+    for (int64_t i = 0; i < g->node_count; i++) {
         EngramNode* n = &g->nodes[i];
         /* Filter transparent layers: nodes whose layer is `transparent=1`
          * shape output but are invisible to introspection ("what do you
          * know about yourself"). They still surface via engram_activate
          * + engram_compile_layered_json — that's the legitimate path. */
         if (engram_layer_is_transparent(n->layer_id)) continue;
-        if (istr_contains(n->content, q) ||
-            istr_contains(n->label,   q) ||
-            istr_contains(n->tags,    q)) {
-            lst = el_list_append(lst, engram_node_to_map(n));
-            found++;
+        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++;
         }
     }
+    /* Rank by distinct tokens matched (desc) then salience (desc), then cap. */
+    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);
     return lst;
 }
 
@@ -7124,10 +7393,14 @@ static double engram_temporal_proximity_bonus(int64_t node_created,
 static double engram_goal_bias(const EngramNode* n, const char* query) {
     if (!query || !*query) return 1.0;
     double bias = 1.0;
-    /* Direct lexical overlap: node content/label/tags share text with query. */
-    if (istr_contains(n->content, query) || istr_contains(n->label, query) ||
-        istr_contains(n->tags, query)) {
-        bias += 0.5;
+    /* Direct lexical overlap, graded by token coverage: a node covering all
+     * query tokens gets the full +0.5; partial coverage gets a proportional
+     * share. Single-token queries → full +0.5 on match, identical to before. */
+    {
+        char toks[ENGRAM_MAX_QTOKENS][ENGRAM_QTOK_LEN];
+        int ntok = engram_tokenize_query(query, toks, ENGRAM_MAX_QTOKENS);
+        int sc   = engram_node_match_score(n, toks, ntok);
+        if (sc > 0 && ntok > 0) bias += 0.5 * ((double)sc / (double)ntok);
     }
     /* Node-type resonance with query intent. */
     int technical_query = istr_contains(query, "code")         ||
@@ -7166,6 +7439,48 @@ static double engram_goal_bias(const EngramNode* n, const char* query) {
     return bias;
 }
 
+/* eg_cmp_double_desc — qsort comparator, descending doubles. */
+static int eg_cmp_double_desc(const void* a, const void* b) {
+    double da = *(const double*)a, db = *(const double*)b;
+    if (da < db) return 1;
+    if (da > db) return -1;
+    return 0;
+}
+
+/* eg_enforce_wm_cap_global — clamp the store-wide working-memory population
+ * to ENGRAM_WM_CAP, keeping the top-K by current weight. Runs at every point
+ * that materializes WM: post-activation persist and snapshot load/merge.
+ * (Ported from release runtime v1.0.0-20260501 Pass 5, 2026-07-15.) */
+static void eg_enforce_wm_cap_global(EngramStore* g) {
+    int64_t wm_count = 0;
+    for (int64_t i = 0; i < g->node_count; i++) {
+        if (g->nodes[i].working_memory_weight > 0.0) wm_count++;
+    }
+    if (wm_count <= ENGRAM_WM_CAP) return;
+    double* vals = malloc((size_t)wm_count * sizeof(double));
+    if (!vals) return; /* OOM: over cap this call, no corruption */
+    int64_t vi = 0;
+    for (int64_t i = 0; i < g->node_count; i++) {
+        if (g->nodes[i].working_memory_weight > 0.0)
+            vals[vi++] = g->nodes[i].working_memory_weight;
+    }
+    qsort(vals, (size_t)wm_count, sizeof(double), eg_cmp_double_desc);
+    double cutoff = vals[ENGRAM_WM_CAP - 1];
+    free(vals);
+    int64_t above = 0;
+    for (int64_t i = 0; i < g->node_count; i++) {
+        if (g->nodes[i].working_memory_weight > cutoff) above++;
+    }
+    int64_t slots_at_cutoff = ENGRAM_WM_CAP - above;
+    for (int64_t i = 0; i < g->node_count; i++) {
+        EngramNode* n = &g->nodes[i];
+        if (n->working_memory_weight <= 0.0) continue;
+        if (n->working_memory_weight > cutoff) continue;
+        if (slots_at_cutoff > 0) { slots_at_cutoff--; continue; }
+        n->working_memory_weight = 0.0; /* evict: over global cap */
+    }
+}
+
 el_val_t engram_activate(el_val_t query, el_val_t depth) {
     EngramStore* g = engram_get();
     const char* q = EL_CSTR(query);
@@ -7193,14 +7508,21 @@ 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. */
+    char toks[ENGRAM_MAX_QTOKENS][ENGRAM_QTOK_LEN];
+    int ntok = engram_tokenize_query(q, toks, ENGRAM_MAX_QTOKENS);
     for (int64_t i = 0; i < g->node_count; i++) {
         EngramNode* n = &g->nodes[i];
-        if (istr_contains(n->content, q) ||
-            istr_contains(n->label,   q) ||
-            istr_contains(n->tags,    q)) {
+        int sc = engram_node_match_score(n, toks, ntok);
+        if (sc > 0) {
             double tdecay = engram_temporal_decay(n, now_ms);
             double dampen = engram_activation_dampen(n);
-            double act    = n->salience * tdecay * dampen;
+            double cover  = ntok > 0 ? (double)sc / (double)ntok : 1.0;
+            double act    = n->salience * tdecay * dampen * cover;
             seeds[seed_count].idx        = i;
             seeds[seed_count].act        = act;
             seeds[seed_count].created_at = n->created_at;
@@ -7364,6 +7686,12 @@ el_val_t engram_activate(el_val_t query, el_val_t depth) {
         g->nodes[i].working_memory_weight = wm_weights[i];
     }
 
+    /* Global WM cap: keep only the top ENGRAM_WM_CAP by weight across the
+     * whole store (see eg_enforce_wm_cap_global). Without this, repeated
+     * activation calls accumulate hundreds of "promoted" nodes and WM stops
+     * meaning anything (production heartbeats showed wm_active up to 778). */
+    eg_enforce_wm_cap_global(g);
+
     /* ── 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,
@@ -7741,6 +8069,9 @@ el_val_t engram_load(el_val_t path) {
             }
         }
     }
+    /* WM cap discipline applies to every entry point that materializes WM,
+     * including snapshot restore (see eg_enforce_wm_cap_global). */
+    eg_enforce_wm_cap_global(g);
     free(data);
     return 1;
 }
@@ -7765,16 +8096,14 @@ el_val_t engram_get_node_json(el_val_t id) {
  * 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 substring) because labels like "conv:history"
+ * must not collide with nodes whose content contains that substring.
  *
- * 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. */
+ * Ported from the release runtime 2026-07-16 self-review: chat.el has called
+ * this since 2026-07-01 but the function only existed in
+ * releases/v1.0.0-20260501/el_runtime.c — the soul daemon (which builds
+ * against THIS runtime) failed to compile once clang made implicit
+ * declarations an error. */
 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("{}"));
@@ -7798,19 +8127,36 @@ el_val_t engram_search_json(el_val_t query, el_val_t limit) {
     JsonBuf b; jb_init(&b);
     jb_putc(&b, '[');
     int first = 1;
-    int64_t found = 0;
     if (q && *q) {
-        for (int64_t i = 0; i < g->node_count && found < lim; i++) {
-            EngramNode* n = &g->nodes[i];
-            /* Filter transparent layers — same as engram_search. */
-            if (engram_layer_is_transparent(n->layer_id)) continue;
-            if (istr_contains(n->content, q) ||
-                istr_contains(n->label,   q) ||
-                istr_contains(n->tags,    q)) {
-                if (!first) jb_putc(&b, ',');
-                engram_emit_node_json(&b, n);
-                first = 0;
-                found++;
+        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++;
+                    }
+                }
+                /* 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);
             }
         }
     }
@@ -8330,6 +8676,9 @@ el_val_t engram_load_merge(el_val_t path) {
         }
     }
 
+    /* Merged nodes can carry snapshot WM weights too — hold the cap here as
+     * well (see eg_enforce_wm_cap_global). */
+    eg_enforce_wm_cap_global(g);
     free(data);
     return (el_val_t)added_nodes;
 }

lang/el-compiler/runtime/el_seed.c

@@ -1072,7 +1072,6 @@ 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,7 +226,6 @@ 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,7 +2670,6 @@ 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 }
@@ -2917,6 +2916,24 @@ fn build_int_names_for_params(params: [Map<String, Any>]) -> Bool {
     return true
 }
 
+// fn_has_decorator — does this FnDef carry a decorator named `name`?
+// Reads the `decorators` list [{name, args}] attached by the parser. Absent
+// key -> native_list_len returns 0 -> false. This is the multi-decorator-aware
+// replacement for the old single `decorator` string check, so a fn may stack
+// roles with other decorators (e.g. `@route(...) @manager fn ...`).
+fn fn_has_decorator(stmt: Map<String, Any>, name: String) -> Bool {
+    let dl = stmt["decorators"]
+    let n: Int = native_list_len(dl)
+    let i = 0
+    while i < n {
+        let d = native_list_get(dl, i)
+        let dn: String = d["name"]
+        if str_eq(dn, name) { return true }
+        let i = i + 1
+    }
+    false
+}
+
 fn cg_fn(stmt: Map<String, Any>) -> Void {
     let fn_name: String = stmt["name"]
     // Skip El's `fn main()` - C provides its own main() for top-level stmts
@@ -2928,10 +2945,10 @@ fn cg_fn(stmt: Map<String, Any>) -> Void {
     let params_c: String = params_to_c(params)
     // VBD role enforcement: dharma_emit / dharma_field may only be called
     // from @manager-decorated functions. Surface violations to the C compiler
-    // via #error directives emitted before the function definition.
-    let decorator: String = stmt["decorator"]
+    // via #error directives emitted before the function definition. Read the
+    // decorator LIST so the role may be stacked with other decorators.
     if vbd_has_restricted_call(body) {
-        if !str_eq(decorator, "manager") {
+        if !fn_has_decorator(stmt, "manager") {
             emit_line("#error \"VBD violation: dharma_emit/dharma_field called from non-@manager fn '" + fn_name + "'\"")
         }
     }
@@ -3480,6 +3497,259 @@ fn cg_decl_streaming(stmt: Map<String, Any>) -> Void {
     }
 }
 
+// ── @route dispatcher generation ──────────────────────────────────────────────
+//
+// Scan the token stream for @route-decorated fns and synthesize a generic HTTP
+// dispatcher `el_route_dispatch(method, clean, path, body)`. A decorated handler
+// must have the uniform signature (method, path, body) -> String. The dispatcher
+// matches `clean` (the query-stripped path, supplied by the caller) against each
+// route and calls the handler with the ORIGINAL `path` so query strings survive.
+// Returns the sentinel "__EL_NO_ROUTE__" when nothing matches, so the caller may
+// fall through to any remaining hand-written branches (mixed mode).
+//
+// Decorator grammar: @route(path, method, kind, suffix)
+//   path   — the match string (or the prefix, for compound)
+//   method — "GET" | "POST" | ... ; a '|'-list like "GET|POST"; "ANY"/"" = no guard
+//   kind   — "exact" (default) | "prefix" | "suffix" | "compound"
+//   suffix — for "compound": the required str_ends_with suffix
+//
+// The dispatch table is emitted SPECIFICITY-SORTED (most-specific first), NOT in
+// source order, so overlapping prefixes (e.g. /api/x/search vs /api/x) never
+// shadow each other regardless of how the handlers are written.
+
+// split_pipe — split "GET|POST" on '|' into ["GET","POST"]. Self-contained
+// (no dependency on str_split runtime semantics).
+fn split_pipe(s: String) -> [String] {
+    let out: [String] = native_list_empty()
+    let cur: String = ""
+    let n: Int = str_len(s)
+    let i: Int = 0
+    while i < n {
+        let ch: String = str_slice(s, i, i + 1)
+        if str_eq(ch, "|") {
+            let out = native_list_append(out, cur)
+            let cur = ""
+        } else {
+            let cur = cur + ch
+        }
+        let i = i + 1
+    }
+    let out = native_list_append(out, cur)
+    out
+}
+
+// route_make_record — build a route record map from the @route decorator args.
+fn route_make_record(fn_name: String, args: [String]) -> Map<String, Any> {
+    let na: Int = native_list_len(args)
+    let rpath: String = ""
+    if na >= 1 { let rpath = native_list_get(args, 0) }
+    let rmethod: String = "GET"
+    if na >= 2 { let rmethod = native_list_get(args, 1) }
+    let rkind: String = "exact"
+    if na >= 3 { let rkind = native_list_get(args, 2) }
+    let rsuffix: String = ""
+    if na >= 4 { let rsuffix = native_list_get(args, 3) }
+    { "name": fn_name, "path": rpath, "method": rmethod, "kind": rkind, "suffix": rsuffix }
+}
+
+// route_spec_score — higher = more specific = emitted earlier. Ordering:
+// exact > compound > suffix > prefix; within a class, a longer path/suffix
+// wins (so /api/x/search sorts before /api/x). Guarantees correct dispatch
+// independent of source order.
+fn route_spec_score(rec: Map<String, Any>) -> Int {
+    let kind: String = rec["kind"]
+    let path: String = rec["path"]
+    let suffix: String = rec["suffix"]
+    let plen: Int = str_len(path)
+    let slen: Int = str_len(suffix)
+    if str_eq(kind, "exact") { return 4000000 + plen }
+    if str_eq(kind, "compound") { return 3000000 + plen * 100 + slen }
+    if str_eq(kind, "suffix") { return 2000000 + slen }
+    return 1000000 + plen
+}
+
+// route_sort_desc — selection sort of route records by descending specificity.
+// N is small (routes per module), so O(n^2) is fine and keeps codegen simple.
+fn route_sort_desc(recs: [Map<String, Any>]) -> [Map<String, Any>] {
+    let n: Int = native_list_len(recs)
+    let out: [Map<String, Any>] = native_list_empty()
+    let used: [Bool] = native_list_empty()
+    let u: Int = 0
+    while u < n {
+        let used = native_list_append(used, false)
+        let u = u + 1
+    }
+    let picked: Int = 0
+    while picked < n {
+        let best_i: Int = 0 - 1
+        let best_score: Int = 0 - 1
+        let i: Int = 0
+        while i < n {
+            let is_used: Bool = native_list_get(used, i)
+            if !is_used {
+                let sc: Int = route_spec_score(native_list_get(recs, i))
+                if sc > best_score {
+                    let best_score = sc
+                    let best_i = i
+                }
+            }
+            let i = i + 1
+        }
+        let out = native_list_append(out, native_list_get(recs, best_i))
+        // Rebuild `used` with best_i marked (runtime has no native_list_set).
+        let new_used: [Bool] = native_list_empty()
+        let j: Int = 0
+        while j < n {
+            if j == best_i {
+                let new_used = native_list_append(new_used, true)
+            } else {
+                let new_used = native_list_append(new_used, native_list_get(used, j))
+            }
+            let j = j + 1
+        }
+        let used = new_used
+        let picked = picked + 1
+    }
+    out
+}
+
+// scan_routes — token-level scan collecting every @route-decorated fn as a
+// route record. Runs once per module (like scan_fn_sigs) so the dispatcher can
+// be synthesized in the streaming backend, which discards per-fn ASTs. Handles
+// decorator STACKING: `@route(...) @manager fn` still records the route.
+fn scan_routes(tokens: [Any]) -> [Map<String, Any>] {
+    let total: Int = native_list_len(tokens) / 2
+    let recs: [Map<String, Any>] = native_list_empty()
+    let has_pending: Bool = false
+    let pending_args: [String] = native_list_empty()
+    let pos: Int = 0
+    let going: Bool = true
+    while going {
+        if pos >= total {
+            let going = false
+        } else {
+            let k: String = tok_kind(tokens, pos)
+            if str_eq(k, "Eof") {
+                let going = false
+            } else {
+                if str_eq(k, "At") {
+                    let dname: String = tok_value(tokens, pos + 1)
+                    let p: Int = pos + 2
+                    let args: [String] = native_list_empty()
+                    let ka: String = tok_kind(tokens, p)
+                    if str_eq(ka, "LParen") {
+                        let p = p + 1
+                        let running: Bool = true
+                        while running {
+                            let kd: String = tok_kind(tokens, p)
+                            if str_eq(kd, "RParen") {
+                                let running = false
+                            } else {
+                                if str_eq(kd, "Eof") {
+                                    let running = false
+                                } else {
+                                    if str_eq(kd, "Str") {
+                                        let args = native_list_append(args, tok_value(tokens, p))
+                                    }
+                                    let p = p + 1
+                                }
+                            }
+                        }
+                        if str_eq(tok_kind(tokens, p), "RParen") { let p = p + 1 }
+                    }
+                    if str_eq(dname, "route") {
+                        let has_pending = true
+                        let pending_args = args
+                    }
+                    let pos = p
+                } else {
+                    if str_eq(k, "Fn") {
+                        let fname: String = tok_value(tokens, pos + 1)
+                        if has_pending {
+                            let recs = native_list_append(recs, route_make_record(fname, pending_args))
+                            let has_pending = false
+                        }
+                        let pos = pos + 2
+                    } else {
+                        let pos = pos + 1
+                    }
+                }
+            }
+        }
+    }
+    recs
+}
+
+// program_has_routes — did scan_routes find any @route fn?
+fn program_has_routes(recs: [Map<String, Any>]) -> Bool {
+    native_list_len(recs) > 0
+}
+
+// route_method_guard — C boolean prefix guarding on HTTP method, or "" for none.
+fn route_method_guard(method: String) -> String {
+    if str_eq(method, "") { return "" }
+    if str_eq(method, "ANY") { return "" }
+    if str_contains(method, "|") {
+        let parts: [String] = split_pipe(method)
+        let np: Int = native_list_len(parts)
+        let expr: String = ""
+        let i: Int = 0
+        while i < np {
+            let m: String = native_list_get(parts, i)
+            if str_eq(m, "") {
+                let i = i + 1
+            } else {
+                let piece: String = "str_eq(method, EL_STR(" + c_str_lit(m) + "))"
+                if str_eq(expr, "") {
+                    let expr = piece
+                } else {
+                    let expr = expr + " || " + piece
+                }
+                let i = i + 1
+            }
+        }
+        if str_eq(expr, "") { return "" }
+        return "(" + expr + ") && "
+    }
+    "str_eq(method, EL_STR(" + c_str_lit(method) + ")) && "
+}
+
+// route_match_expr — C boolean matching `clean` against the route path/kind.
+fn route_match_expr(kind: String, path: String, suffix: String) -> String {
+    if str_eq(kind, "prefix") {
+        return "str_starts_with(clean, EL_STR(" + c_str_lit(path) + "))"
+    }
+    if str_eq(kind, "suffix") {
+        return "str_ends_with(clean, EL_STR(" + c_str_lit(path) + "))"
+    }
+    if str_eq(kind, "compound") {
+        return "str_starts_with(clean, EL_STR(" + c_str_lit(path) + ")) && str_ends_with(clean, EL_STR(" + c_str_lit(suffix) + "))"
+    }
+    "str_eq(clean, EL_STR(" + c_str_lit(path) + "))"
+}
+
+// emit_route_dispatch — emit the generated el_route_dispatch definition from the
+// specificity-sorted route records. No-op if there are no routes.
+fn emit_route_dispatch(recs: [Map<String, Any>]) -> Void {
+    if !program_has_routes(recs) { return }
+    let sorted: [Map<String, Any>] = route_sort_desc(recs)
+    emit_line("// ── generated @route dispatcher (specificity-sorted) ──")
+    emit_line("el_val_t el_route_dispatch(el_val_t method, el_val_t clean, el_val_t path, el_val_t body) {")
+    let n: Int = native_list_len(sorted)
+    let i: Int = 0
+    while i < n {
+        let rec = native_list_get(sorted, i)
+        let guard: String = route_method_guard(rec["method"])
+        let match_e: String = route_match_expr(rec["kind"], rec["path"], rec["suffix"])
+        let fn_name: String = rec["name"]
+        emit_line("  if (" + guard + match_e + ") { return " + fn_name + "(method, path, body); }")
+        let i = i + 1
+    }
+    emit_line("  return EL_STR(\"__EL_NO_ROUTE__\");")
+    emit_line("}")
+    emit_blank()
+}
+
 // emit_streaming_preamble — emit #includes, forward decls, and file-scope lets
 // using the pre-scanned signature data (no full AST).
 fn emit_streaming_preamble(sigs: [Map<String, Any>], source: String) -> Void {
@@ -3572,6 +3842,17 @@ fn codegen_streaming(tokens: [Any], sigs: [Map<String, Any>], source: String) ->
     emit_streaming_preamble(sigs, source)
     el_arena_pop(preamble_mark)
 
+    // @route: scan the token stream once for @route-decorated fns. Kept in
+    // codegen_streaming scope (survives the per-fn arena pops and el_release of
+    // tokens below via refcount, like `sigs`). If any exist, forward-declare the
+    // generated dispatcher NOW so hand-written fns (e.g. handle_request) may call
+    // it before its definition is emitted after the fn-emit loop.
+    let route_records: [Map<String, Any>] = scan_routes(tokens)
+    if program_has_routes(route_records) {
+        emit_line("el_val_t el_route_dispatch(el_val_t method, el_val_t clean, el_val_t path, el_val_t body);")
+        emit_blank()
+    }
+
     // Detect whether there is a fn main() and whether there are top-level
     // executable stmts (for library detection) from sigs.
     let has_el_main: Bool = false
@@ -3759,6 +4040,15 @@ fn codegen_streaming(tokens: [Any], sigs: [Map<String, Any>], source: String) ->
         }
     }
 
+    // @route: emit the generated dispatcher definition now — after every handler
+    // fn has been emitted, but before `tokens` is released (route_records holds
+    // its own refs to the extracted strings). No-op unless the module declared
+    // at least one @route fn. Emitted before the test/library early-returns so it
+    // is present in library modules (e.g. neuron's routes.el) too.
+    let route_arena_mark: Any = el_arena_push()
+    emit_route_dispatch(route_records)
+    el_arena_pop(route_arena_mark)
+
     // Tokens fully consumed by the streaming loop — release now to free peak heap.
     el_release(tokens)
 

lang/el-compiler/src/parser.el

@@ -23,10 +23,29 @@ fn tok_at(tokens: [Any], pos: Int) -> Map<String, Any> {
 }
 
 fn tok_kind(tokens: [Any], pos: Int) -> String {
+    // Out-of-range reads must report the Eof sentinel so every `== "Eof"`
+    // termination guard in the parser fires. Without this, reading past the
+    // single trailing Eof token returns runtime null (el_list_get OOB -> 0),
+    // which matches no delimiter, letting inner parse loops append AST nodes
+    // forever on malformed input -> unbounded allocation -> OOM.
+    let n: Int = native_list_len(tokens) / 2
+    if pos < 0 {
+        return "Eof"
+    }
+    if pos >= n {
+        return "Eof"
+    }
     native_list_get(tokens, pos * 2)
 }
 
 fn tok_value(tokens: [Any], pos: Int) -> String {
+    let n: Int = native_list_len(tokens) / 2
+    if pos < 0 {
+        return ""
+    }
+    if pos >= n {
+        return ""
+    }
     native_list_get(tokens, pos * 2 + 1)
 }
 
@@ -35,7 +54,12 @@ fn expect(tokens: [Any], pos: Int, kind: String) -> Int {
     if k == kind {
         return pos + 1
     }
-    // On mismatch just advance; error recovery is best-effort
+    // On mismatch, error recovery is best-effort. But never step PAST the Eof
+    // sentinel: once at Eof a mismatch means the input ended early, and
+    // advancing would run the cursor off the token list.
+    if k == "Eof" {
+        return pos
+    }
     pos + 1
 }
 
@@ -1734,23 +1758,68 @@ fn parse_stmt(tokens: [Any], pos: Int) -> Map<String, Any> {
         return make_result({ "stmt": "TryCatch", "try_body": try_body, "catch_name": catch_name, "catch_body": native_list_empty() }, p)
     }
 
-    // @decorator - capture decorator name and attach to following stmt
+    // @decorator - capture decorator name (and optional string args) and
+    // attach to the following stmt. Backward-compatible: bare @manager /
+    // @engine / @accessor still parse (no parens -> empty args). Decorators
+    // STACK: `@route("/p","GET") @manager fn f()` attaches BOTH to f via a
+    // `decorators` list [{name, args}]. The legacy `decorator` string is kept
+    // populated (topmost decorator) so the JS backend keeps working unchanged.
     if k == "At" {
         let p = pos + 1
         let dec_name = tok_value(tokens, p)
         let p = p + 1
+        // Optional decorator argument list: @name("a", "b", ...)
+        let dec_args = native_list_empty()
+        let ka = tok_kind(tokens, p)
+        if str_eq(ka, "LParen") {
+            let p = p + 1
+            let running_da = true
+            while running_da {
+                let kd = tok_kind(tokens, p)
+                if str_eq(kd, "RParen") {
+                    let running_da = false
+                } else {
+                    if str_eq(kd, "Eof") {
+                        let running_da = false
+                    } else {
+                        if str_eq(kd, "Str") {
+                            let dec_args = native_list_append(dec_args, tok_value(tokens, p))
+                        }
+                        let p = p + 1
+                        let kc = tok_kind(tokens, p)
+                        if str_eq(kc, "Comma") {
+                            let p = p + 1
+                        }
+                    }
+                }
+            }
+            let p = expect(tokens, p, "RParen")
+        }
         let r = parse_stmt(tokens, p)
         let inner = r["node"]
         let p2 = r["pos"]
         let inner_kind: String = inner["stmt"]
         if str_eq(inner_kind, "FnDef") {
+            // Stack this decorator (topmost-first) onto any decorators the inner
+            // FnDef already carries from decorators written below this one.
+            let this_dec = { "name": dec_name, "args": dec_args }
+            let existing = inner["decorators"]
+            let dlist = native_list_empty()
+            let dlist = native_list_append(dlist, this_dec)
+            let ne: Int = native_list_len(existing)
+            let ei = 0
+            while ei < ne {
+                let dlist = native_list_append(dlist, native_list_get(existing, ei))
+                let ei = ei + 1
+            }
             let with_dec = {
                 "stmt": "FnDef",
                 "name": inner["name"],
                 "params": inner["params"],
                 "body": inner["body"],
                 "ret_type": inner["ret_type"],
-                "decorator": dec_name
+                "decorator": dec_name,
+                "decorators": dlist
             }
             // r result map fully consumed — release to free peak heap.
             el_release(r)

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

@@ -117,6 +117,15 @@ el_val_t  el_min(el_val_t a, el_val_t b);
 void      el_retain(el_val_t v);
 void      el_release(el_val_t v);
 
+/* ── Arena scoping ────────────────────────────────────────────────────────────
+ * el_arena_push() activates the string arena (if not already active) and
+ * returns a mark; el_arena_pop(mark) frees all strings allocated since that
+ * mark. Used by codegen for per-function/statement scoping and by long-running
+ * EL loops (e.g. the soul daemon's awareness tick) to reclaim per-iteration
+ * allocations. */
+el_val_t  el_arena_push(void);
+el_val_t  el_arena_pop(el_val_t mark);
+
 /* ── List ────────────────────────────────────────────────────────────────── */
 
 el_val_t  el_list_new(el_val_t count, ...);
@@ -142,6 +151,7 @@ el_val_t  http_get_with_headers(el_val_t url, el_val_t headers_map);
 el_val_t  http_post_with_headers(el_val_t url, el_val_t body, el_val_t headers_map);
 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);
+el_val_t  http_delete_json(el_val_t url, el_val_t json_body);
 void      http_serve(el_val_t port, el_val_t handler);
 void      http_set_handler(el_val_t name);
 
@@ -167,6 +177,11 @@ void      http_set_handler(el_val_t name);
 void      http_serve_v2(el_val_t port, el_val_t handler);
 void      http_set_handler_v2(el_val_t name);
 
+/* Non-blocking variant of http_serve: runs the accept loop in a background
+ * pthread and returns immediately so the caller can continue (used by the
+ * soul daemon to run awareness_run() after starting its HTTP API). */
+void      http_serve_async(el_val_t port, el_val_t handler);
+
 /* Build an HTTP response envelope. `headers_json` should be a JSON object
  * literal like `{"WWW-Authenticate":"Basic"}` (or "" / "{}" for none). The
  * returned string carries the discriminator `{"el_http_response":1,...}`
@@ -576,6 +591,7 @@ el_val_t  engram_list_layers(void);
 el_val_t  engram_get_node(el_val_t id);
 void      engram_strengthen(el_val_t node_id);
 void      engram_forget(el_val_t node_id);
+el_val_t  engram_prune_telemetry(el_val_t older_than_ms);
 el_val_t  engram_node_count(void);
 el_val_t  engram_search(el_val_t query, el_val_t limit);
 el_val_t  engram_scan_nodes(el_val_t limit, el_val_t offset);
@@ -594,12 +610,25 @@ 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);
 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_act_stats_json(void);
+el_val_t  engram_text_health_json(void);
+el_val_t  engram_cosine_sim(el_val_t id_a, el_val_t id_b);
+/* Destructively pop up to `max` newly-formed Hebbian associations as a JSON
+ * array of {from_id,to_id,weight,hebb}. The learning process (soul daemon) is
+ * not the process that owns persistence (engram HTTP server); this is how a
+ * self-formed association crosses that boundary. (2026-08-07 self-review.) */
+el_val_t  engram_hebb_drain_json(el_val_t max);
+/* Document frequency of a term across node labels — term-specificity signal
+ * for curiosity seed selection. (2026-08-03 self-review.) */
+el_val_t  engram_label_df(el_val_t term);
+el_val_t  engram_embed_backfill(el_val_t count);
 el_val_t  engram_list_layers_json(void);
 /* Working memory introspection — count, mean weight, and top-N snapshot.
  * Ported from el-compiler/runtime on 2026-06-30 self-review. */