Add native interruptibility for dispatched agent workers

Cancellation-token control channel checked at every step boundary lets a
coordinator PAUSE/RESUME/REDIRECT/KILL a running worker mid-task instead of
waiting for the whole (possibly wrong) plan to finish. Bounded purviews
mean no half-committed state to unwind on interrupt. Includes a proof
harness (proof.el, run.sh) comparing a broken non-interruptible worker
against the new one under identical kill/redirect/pause timing.

Distinct from the already-preserved swarm-ccr orchestrator (fan-out/
converge dispatch): this is single-worker interruptibility, a
complementary mechanism, not a duplicate.

.gitea/workflows/ci-stage.yaml

@@ -212,12 +212,21 @@ jobs:
         env:
           GCP_SA_KEY: ${{ secrets.GCP_SA_KEY }}
         run: |
+          # Fail loudly: previously this step had no `set -e`, so an auth or
+          # upload failure was swallowed (step exited 0 on the trailing echo)
+          # and the SDK silently never published. Surface failures now.
+          set -euo pipefail
+          if [ -z "${GCP_SA_KEY:-}" ]; then
+            echo "FATAL: GCP_SA_KEY secret is empty — cannot authenticate to publish" >&2
+            exit 1
+          fi
           echo "${GCP_SA_KEY}" > /tmp/gcp-key.json
           apt-get install -y -qq apt-transport-https ca-certificates curl
           echo "deb [trusted=yes] https://packages.cloud.google.com/apt cloud-sdk main" > /etc/apt/sources.list.d/google-cloud-sdk.list
           apt-get update -qq && apt-get install -y google-cloud-cli
           gcloud auth activate-service-account --key-file=/tmp/gcp-key.json
           gcloud config set project neuron-785695
+          echo "Publishing as active account: $(gcloud config get-value account 2>/dev/null)"
 
           VERSION="${GITHUB_SHA:0:8}"
 
@@ -253,6 +262,12 @@ jobs:
         # Patches ci-base:stage in-place: pulls the existing image (which has all
         # system deps — Node, Go, gcloud, Docker CLI, etc.) and overlays the freshly
         # built El SDK on top. Keeps the full ci-base rebuild fast and incremental.
+        #
+        # continue-on-error: this is a CI-cache optimization, NOT the release
+        # artifact. It runs Docker (pull/build/push ~600MB) on the host-mode GCE
+        # runner where DinD/Docker availability is fragile. A failure here must
+        # never block or redden the job — the SDK publish above is the deliverable.
+        continue-on-error: true
         if: github.event_name == 'push'
         env:
           GCP_SA_KEY: ${{ secrets.GCP_SA_KEY }}

.gitea/workflows/sdk-release.yaml

@@ -288,12 +288,21 @@ jobs:
         env:
           GCP_SA_KEY: ${{ secrets.GCP_SA_KEY }}
         run: |
+          # Fail loudly: previously this step had no `set -e`, so an auth or
+          # upload failure was swallowed (step exited 0 on the trailing echo)
+          # and the SDK silently never published. Surface failures now.
+          set -euo pipefail
+          if [ -z "${GCP_SA_KEY:-}" ]; then
+            echo "FATAL: GCP_SA_KEY secret is empty — cannot authenticate to publish" >&2
+            exit 1
+          fi
           echo "${GCP_SA_KEY}" > /tmp/gcp-key.json
           apt-get install -y -qq apt-transport-https ca-certificates curl
           echo "deb [trusted=yes] https://packages.cloud.google.com/apt cloud-sdk main" > /etc/apt/sources.list.d/google-cloud-sdk.list
           apt-get update -qq && apt-get install -y google-cloud-cli
           gcloud auth activate-service-account --key-file=/tmp/gcp-key.json
           gcloud config set project neuron-785695
+          echo "Publishing as active account: $(gcloud config get-value account 2>/dev/null)"
 
           VERSION="${GITHUB_SHA:0:8}"
 
@@ -345,6 +354,12 @@ jobs:
         # Patches ci-base:latest in-place: pulls the existing image (which has all
         # system deps — Node, Go, gcloud, Docker CLI, etc.) and overlays the freshly
         # built El SDK on top. Keeps the full ci-base rebuild fast and incremental.
+        #
+        # continue-on-error: this is a CI-cache optimization, NOT the release
+        # artifact. It runs Docker (pull/build/push ~600MB) on the host-mode GCE
+        # runner where DinD/Docker availability is fragile. A failure here must
+        # never block or redden the job — the SDK publish above is the deliverable.
+        continue-on-error: true
         if: github.event_name == 'push'
         env:
           GCP_SA_KEY: ${{ secrets.GCP_SA_KEY }}

engram/dist/engram.c

@@ -10,6 +10,7 @@ el_val_t query_param(el_val_t path, el_val_t key);
 el_val_t query_int(el_val_t path, el_val_t key, el_val_t default_val);
 el_val_t extract_id(el_val_t path, el_val_t prefix);
 el_val_t route_stats(el_val_t method, el_val_t path, el_val_t body);
+el_val_t persist_canonical(void);
 el_val_t route_create_node(el_val_t method, el_val_t path, el_val_t body);
 el_val_t route_get_node(el_val_t method, el_val_t path, el_val_t body);
 el_val_t route_scan_nodes(el_val_t method, el_val_t path, el_val_t body);
@@ -20,18 +21,23 @@ el_val_t route_create_edge(el_val_t method, el_val_t path, el_val_t body);
 el_val_t route_neighbors(el_val_t method, el_val_t path, el_val_t body);
 el_val_t route_strengthen(el_val_t method, el_val_t path, el_val_t body);
 el_val_t route_forget(el_val_t method, el_val_t path, el_val_t body);
-el_val_t route_create_ise(el_val_t method, el_val_t path, el_val_t body);
-el_val_t route_sync(el_val_t method, el_val_t path, el_val_t body);
 el_val_t route_save(el_val_t method, el_val_t path, el_val_t body);
 el_val_t route_load(el_val_t method, el_val_t path, el_val_t body);
 el_val_t route_health(el_val_t method, el_val_t path, el_val_t body);
+el_val_t route_sync(el_val_t method, el_val_t path, el_val_t body);
+el_val_t route_load_merge(el_val_t method, el_val_t path, el_val_t body);
+el_val_t route_emit_ise(el_val_t method, el_val_t path, el_val_t body);
+el_val_t route_capture_knowledge(el_val_t method, el_val_t path, el_val_t body);
 el_val_t check_auth_ok(el_val_t method, el_val_t body);
 el_val_t handle_request(el_val_t method, el_val_t path, el_val_t body);
 
+el_val_t bind_raw;
 el_val_t bind_str;
 el_val_t port;
+el_val_t data_dir_raw;
 el_val_t data_dir;
 el_val_t snapshot_path;
+el_val_t boot_snap;
 
 el_val_t parse_port(el_val_t bind) {
   el_val_t colon = str_index_of(bind, EL_STR(":"));
@@ -110,17 +116,22 @@ el_val_t route_stats(el_val_t method, el_val_t path, el_val_t body) {
   return 0;
 }
 
+el_val_t persist_canonical(void) {
+  el_val_t dir_raw = env(EL_STR("ENGRAM_DATA_DIR"));
+  el_val_t dir = ({ el_val_t _if_result_1 = 0; if (str_eq(dir_raw, EL_STR(""))) { _if_result_1 = (EL_STR("/tmp/engram")); } else { _if_result_1 = (dir_raw); } _if_result_1; });
+  engram_save(el_str_concat(dir, EL_STR("/snapshot.json")));
+  return 1;
+  return 0;
+}
+
 el_val_t route_create_node(el_val_t method, el_val_t path, el_val_t body) {
   el_val_t content = json_get_string(body, EL_STR("content"));
-  el_val_t 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 nt_raw = json_get_string(body, EL_STR("node_type"));
+  el_val_t node_type = ({ el_val_t _if_result_2 = 0; if (str_eq(nt_raw, EL_STR(""))) { _if_result_2 = (EL_STR("Memory")); } else { _if_result_2 = (nt_raw); } _if_result_2; });
+  el_val_t sal_raw = json_get_float(body, EL_STR("salience"));
+  el_val_t salience = ({ el_val_t _if_result_3 = 0; if ((sal_raw == el_from_float(0.0))) { _if_result_3 = (el_from_float(0.5)); } else { _if_result_3 = (sal_raw); } _if_result_3; });
   el_val_t id = engram_node(content, node_type, salience);
+  el_val_t saved = persist_canonical();
   return el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"id\":\""), id), EL_STR("\",\"content\":\"")), content), EL_STR("\",\"node_type\":\"")), node_type), EL_STR("\"}"));
   return 0;
 }
@@ -146,11 +157,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_4 = 0; if (str_eq(dir_raw, EL_STR(""))) { _if_result_4 = (EL_STR("/tmp/engram")); } else { _if_result_4 = (dir_raw); } _if_result_4; });
+  el_val_t snap_path = el_str_concat(dir, EL_STR("/.scan-export.json"));
   engram_save(snap_path);
   el_val_t snap = fs_read(snap_path);
   if (str_eq(snap, EL_STR(""))) {
@@ -165,36 +174,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_5 = 0; if (str_eq(method, EL_STR("GET"))) { _if_result_5 = (query_param(path, EL_STR("q"))); } else { _if_result_5 = (json_get_string(body, EL_STR("query"))); } _if_result_5; });
+  el_val_t lim_url = query_int(path, EL_STR("limit"), 0);
+  el_val_t lim_body = json_get_int(body, EL_STR("limit"));
+  el_val_t lim_either = ({ el_val_t _if_result_6 = 0; if ((lim_url > 0)) { _if_result_6 = (lim_url); } else { _if_result_6 = (lim_body); } _if_result_6; });
+  el_val_t limit = ({ el_val_t _if_result_7 = 0; if ((lim_either > 0)) { _if_result_7 = (lim_either); } else { _if_result_7 = (20); } _if_result_7; });
   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_8 = 0; if (str_eq(method, EL_STR("GET"))) { _if_result_8 = (query_param(path, EL_STR("q"))); } else { _if_result_8 = (json_get_string(body, EL_STR("query"))); } _if_result_8; });
+  if (str_eq(q, EL_STR(""))) {
+    return err_json(EL_STR("missing query"));
   }
+  el_val_t d_raw = ({ el_val_t _if_result_9 = 0; if (str_eq(method, EL_STR("GET"))) { _if_result_9 = (query_int(path, EL_STR("depth"), 3)); } else { _if_result_9 = (json_get_int(body, EL_STR("depth"))); } _if_result_9; });
+  el_val_t depth = ({ el_val_t _if_result_10 = 0; if ((d_raw > 0)) { _if_result_10 = (d_raw); } else { _if_result_10 = (3); } _if_result_10; });
   return el_str_concat(el_str_concat(EL_STR("{\"results\":"), engram_activate_json(q, depth)), EL_STR("}"));
   return 0;
 }
@@ -202,15 +197,12 @@ 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_11 = 0; if (str_eq(rel_raw, EL_STR(""))) { _if_result_11 = (EL_STR("associates")); } else { _if_result_11 = (rel_raw); } _if_result_11; });
+  el_val_t w_raw = json_get_float(body, EL_STR("weight"));
+  el_val_t weight = ({ el_val_t _if_result_12 = 0; if ((w_raw == el_from_float(0.0))) { _if_result_12 = (el_from_float(0.5)); } else { _if_result_12 = (w_raw); } _if_result_12; });
   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;
 }
@@ -231,6 +223,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,29 +234,40 @@ 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 content = json_get_string(body, EL_STR("content"));
-  if (str_eq(content, EL_STR(""))) {
-    return err_json(EL_STR("missing content"));
-  }
-  el_val_t sal = el_from_float(0.3);
-  el_val_t imp = el_from_float(0.3);
-  el_val_t conf = el_from_float(0.8);
-  el_val_t id = engram_node_full(content, EL_STR("InternalStateEvent"), EL_STR("state-event"), sal, imp, conf, EL_STR("Episodic"), EL_STR("[\"internal-state\",\"InternalStateEvent\"]"));
-  return el_str_concat(el_str_concat(EL_STR("{\"ok\":true,\"id\":\""), id), EL_STR("\"}"));
+el_val_t route_save(el_val_t method, el_val_t path, el_val_t body) {
+  el_val_t p_raw = json_get_string(body, EL_STR("path"));
+  el_val_t dir_raw = env(EL_STR("ENGRAM_DATA_DIR"));
+  el_val_t dir = ({ el_val_t _if_result_13 = 0; if (str_eq(dir_raw, EL_STR(""))) { _if_result_13 = (EL_STR("/tmp/engram")); } else { _if_result_13 = (dir_raw); } _if_result_13; });
+  el_val_t p = ({ el_val_t _if_result_14 = 0; if (str_eq(p_raw, EL_STR(""))) { _if_result_14 = (el_str_concat(dir, EL_STR("/snapshot.json"))); } else { _if_result_14 = (p_raw); } _if_result_14; });
+  engram_save(p);
+  return el_str_concat(el_str_concat(EL_STR("{\"ok\":true,\"path\":\""), p), EL_STR("\"}"));
+  return 0;
+}
+
+el_val_t route_load(el_val_t method, el_val_t path, el_val_t body) {
+  el_val_t p_raw = json_get_string(body, EL_STR("path"));
+  el_val_t dir_raw = env(EL_STR("ENGRAM_DATA_DIR"));
+  el_val_t dir = ({ el_val_t _if_result_15 = 0; if (str_eq(dir_raw, EL_STR(""))) { _if_result_15 = (EL_STR("/tmp/engram")); } else { _if_result_15 = (dir_raw); } _if_result_15; });
+  el_val_t p = ({ el_val_t _if_result_16 = 0; if (str_eq(p_raw, EL_STR(""))) { _if_result_16 = (el_str_concat(dir, EL_STR("/snapshot.json"))); } else { _if_result_16 = (p_raw); } _if_result_16; });
+  engram_load(p);
+  return ok_json();
+  return 0;
+}
+
+el_val_t route_health(el_val_t method, el_val_t path, el_val_t body) {
+  return EL_STR("{\"status\":\"ok\",\"engine\":\"engram-runtime-native\"}");
   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 snap_path = el_str_concat(dir, EL_STR("/sync-export.json"));
+  el_val_t dir_raw = env(EL_STR("ENGRAM_DATA_DIR"));
+  el_val_t dir = ({ el_val_t _if_result_17 = 0; if (str_eq(dir_raw, EL_STR(""))) { _if_result_17 = (EL_STR("/tmp/engram")); } else { _if_result_17 = (dir_raw); } _if_result_17; });
+  el_val_t snap_path = el_str_concat(dir, EL_STR("/.sync-export.json"));
   engram_save(snap_path);
   el_val_t snap = fs_read(snap_path);
   if (str_eq(snap, EL_STR(""))) {
@@ -273,36 +277,68 @@ el_val_t route_sync(el_val_t method, el_val_t path, el_val_t body) {
   return 0;
 }
 
-el_val_t route_save(el_val_t method, el_val_t path, el_val_t body) {
+el_val_t route_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(""))) {
-    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"));
+    return err_json(EL_STR("path is required"));
   }
-  engram_save(p);
-  return el_str_concat(el_str_concat(EL_STR("{\"ok\":true,\"path\":\""), p), EL_STR("\"}"));
+  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_load(el_val_t method, el_val_t path, el_val_t body) {
-  el_val_t p = json_get_string(body, EL_STR("path"));
-  if (str_eq(p, EL_STR(""))) {
-    el_val_t dir = env(EL_STR("ENGRAM_DATA_DIR"));
-    if (str_eq(dir, EL_STR(""))) {
-      dir = EL_STR("/tmp/engram");
-    }
-    p = el_str_concat(dir, EL_STR("/snapshot.json"));
+el_val_t 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"));
   }
-  engram_load(p);
-  return ok_json();
+  el_val_t sal = el_from_float(0.3);
+  el_val_t imp = el_from_float(0.3);
+  el_val_t conf = el_from_float(0.8);
+  el_val_t id = engram_node_full(content, EL_STR("InternalStateEvent"), EL_STR("state-event"), sal, imp, conf, EL_STR("Episodic"), EL_STR("[\"internal-state\",\"InternalStateEvent\"]"));
+  el_val_t ret_raw = env(EL_STR("ENGRAM_ISE_RETENTION_MS"));
+  el_val_t ret_ms = ({ el_val_t _if_result_18 = 0; if (str_eq(ret_raw, EL_STR(""))) { _if_result_18 = (172800000); } else { _if_result_18 = (str_to_int(ret_raw)); } _if_result_18; });
+  el_val_t pruned = engram_prune_telemetry(ret_ms);
+  return el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"ok\":true,\"id\":\""), id), EL_STR("\",\"pruned\":")), int_to_str(pruned)), EL_STR("}"));
   return 0;
 }
 
-el_val_t route_health(el_val_t method, el_val_t path, el_val_t body) {
-  return EL_STR("{\"status\":\"ok\",\"engine\":\"engram-runtime-native\"}");
+el_val_t route_capture_knowledge(el_val_t method, el_val_t path, el_val_t body) {
+  el_val_t content = json_get_string(body, EL_STR("content"));
+  if (str_eq(content, EL_STR(""))) {
+    return err_json(EL_STR("missing content"));
+  }
+  el_val_t title = json_get_string(body, EL_STR("title"));
+  el_val_t label = ({ el_val_t _if_result_19 = 0; if (str_eq(title, EL_STR(""))) { _if_result_19 = (str_slice(content, 0, 60)); } else { _if_result_19 = (title); } _if_result_19; });
+  el_val_t category_raw = json_get_string(body, EL_STR("category"));
+  el_val_t category = ({ el_val_t _if_result_20 = 0; if (str_eq(category_raw, EL_STR(""))) { _if_result_20 = (EL_STR("other")); } else { _if_result_20 = (category_raw); } _if_result_20; });
+  el_val_t ktier_raw = json_get_string(body, EL_STR("tier"));
+  el_val_t ktier = ({ el_val_t _if_result_21 = 0; if (str_eq(ktier_raw, EL_STR(""))) { _if_result_21 = (EL_STR("note")); } else { _if_result_21 = (ktier_raw); } _if_result_21; });
+  el_val_t project = json_get_string(body, EL_STR("project"));
+  el_val_t tags_raw = json_get_raw(body, EL_STR("tags"));
+  el_val_t tags_base = ({ el_val_t _if_result_22 = 0; if (str_eq(tags_raw, EL_STR(""))) { _if_result_22 = (EL_STR("[]")); } else { _if_result_22 = (tags_raw); } _if_result_22; });
+  el_val_t base_len = str_len(tags_base);
+  el_val_t head = str_slice(tags_base, 0, (base_len - 1));
+  el_val_t sep = ({ el_val_t _if_result_23 = 0; if (str_eq(head, EL_STR("["))) { _if_result_23 = (EL_STR("")); } else { _if_result_23 = (EL_STR(",")); } _if_result_23; });
+  el_val_t safe_cat = str_replace(category, EL_STR("\""), EL_STR("'"));
+  el_val_t safe_tier = str_replace(ktier, EL_STR("\""), EL_STR("'"));
+  el_val_t safe_proj = str_replace(project, EL_STR("\""), EL_STR("'"));
+  el_val_t proj_tag = ({ el_val_t _if_result_24 = 0; if (str_eq(safe_proj, EL_STR(""))) { _if_result_24 = (EL_STR("")); } else { _if_result_24 = (el_str_concat(el_str_concat(EL_STR(",\"project:"), safe_proj), EL_STR("\""))); } _if_result_24; });
+  el_val_t tags = el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(head, sep), EL_STR("\"category:")), safe_cat), EL_STR("\",\"tier:")), safe_tier), EL_STR("\"")), proj_tag), EL_STR("]"));
+  el_val_t sal = el_from_float(0.5);
+  el_val_t imp = el_from_float(0.5);
+  el_val_t conf = el_from_float(0.9);
+  el_val_t id = engram_node_full(content, EL_STR("Knowledge"), label, sal, imp, conf, EL_STR("Semantic"), tags);
+  el_val_t saved = persist_canonical();
+  return el_str_concat(el_str_concat(EL_STR("{\"ok\":true,\"id\":\""), id), EL_STR("\"}"));
   return 0;
 }
 
@@ -329,12 +365,15 @@ 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);
   }
@@ -374,32 +413,40 @@ el_val_t handle_request(el_val_t method, el_val_t path, el_val_t body) {
   if (str_eq(method, EL_STR("POST")) && (str_eq(clean, EL_STR("/api/strengthen")) || str_eq(clean, EL_STR("/strengthen")))) {
     return route_strengthen(method, path, body);
   }
-  if (str_eq(method, EL_STR("GET")) && (str_eq(clean, EL_STR("/api/sync")) || str_eq(clean, EL_STR("/sync")))) {
-    return route_sync(method, path, body);
-  }
   if (str_eq(method, EL_STR("POST")) && (str_eq(clean, EL_STR("/api/save")) || str_eq(clean, EL_STR("/save")))) {
     return route_save(method, path, body);
   }
   if (str_eq(method, EL_STR("POST")) && (str_eq(clean, EL_STR("/api/load")) || str_eq(clean, EL_STR("/load")))) {
     return route_load(method, path, body);
   }
+  if (str_eq(method, EL_STR("POST")) && (str_eq(clean, EL_STR("/api/load-merge")) || str_eq(clean, EL_STR("/load-merge")))) {
+    return route_load_merge(method, path, body);
+  }
+  if (str_eq(method, EL_STR("GET")) && str_eq(clean, EL_STR("/api/sync"))) {
+    return route_sync(method, path, body);
+  }
   return el_str_concat(el_str_concat(EL_STR("{\"error\":\"not found\",\"path\":\""), clean), EL_STR("\"}"));
   return 0;
 }
 
 int main(int _argc, char** _argv) {
   el_runtime_init_args(_argc, _argv);
-  bind_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_25 = 0; if (str_eq(bind_raw, EL_STR(""))) { _if_result_25 = (EL_STR(":8742")); } else { _if_result_25 = (bind_raw); } _if_result_25; });
   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_26 = 0; if (str_eq(data_dir_raw, EL_STR(""))) { _if_result_26 = (EL_STR("/tmp/engram")); } else { _if_result_26 = (data_dir_raw); } _if_result_26; });
   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,43 @@ fn route_stats(method: String, path: String, body: String) -> String {
     engram_stats_json()
 }
 
+// (2026-07-18 self-review) Scoping sweep: `let` inside an if-block creates an
+// inner scope only — it does NOT mutate the outer binding (documented with
+// evidence in awareness.el, 2026-05-25). Every default/reassignment below used
+// that broken pattern, so defaults never applied: nodes were created with
+// node_type="" and salience=0.0, /api/search and /api/activate ALWAYS ran with
+// q="" regardless of input, edges defaulted to relation=""/weight=0.0, and
+// save/load with no "path" hit engram_save(""). Rewritten to the
+// `let x = if cond { a } else { b }` expression form (the pattern the newer
+// routes route_emit_ise/route_capture_knowledge already use correctly).
+// persist_canonical — save the canonical snapshot after a durable write.
+//
+// WHY (2026-07-22 self-review): the 2026-07-21 fix correctly stopped READ
+// routes from writing the canonical snapshot.json — but nothing was left
+// that saved it on WRITE. Every mutation (node create, edge create,
+// knowledge capture, forget, merge) lived only in RAM until someone POSTed
+// /api/save manually; a process restart silently discarded everything since
+// the last manual save. Observed live: two engram restarts during the
+// 2026-07-22 review reverted the store to a ~17h-old snapshot, destroying
+// same-day writes. Reads must never write the canonical; writes must always
+// persist it. ISE telemetry is deliberately excluded (48h-pruned, loss-
+// tolerant, ~2/min — snapshotting the whole store per heartbeat is waste;
+// any durable write that follows persists the pruning too).
+fn persist_canonical() -> Int {
+    let dir_raw: String = env("ENGRAM_DATA_DIR")
+    let dir: String = if str_eq(dir_raw, "") { "/tmp/engram" } else { dir_raw }
+    engram_save(dir + "/snapshot.json")
+    return 1
+}
+
 fn route_create_node(method: String, path: String, body: String) -> String {
     let content: String = json_get_string(body, "content")
-    let 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 nt_raw: String = json_get_string(body, "node_type")
+    let node_type: String = if str_eq(nt_raw, "") { "Memory" } else { nt_raw }
+    let sal_raw: Float = json_get_float(body, "salience")
+    let salience: Float = if sal_raw == 0.0 { 0.5 } else { sal_raw }
     let id: String = engram_node(content, node_type, salience)
+    let saved: Int = persist_canonical()
     "{\"id\":\"" + id + "\",\"content\":\"" + content + "\",\"node_type\":\"" + node_type + "\"}"
 }
 
@@ -103,13 +133,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,40 +153,34 @@ 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 }
+    let w_raw: Float = json_get_float(body, "weight")
+    let weight: Float = if w_raw == 0.0 { 0.5 } else { w_raw }
     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 + "\"}"
 }
 
@@ -170,6 +195,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,27 +203,24 @@ 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"
-    }
+    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 }
     engram_save(p)
     "{\"ok\":true,\"path\":\"" + p + "\"}"
 }
 
 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"
-    }
+    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 }
     engram_load(p)
     ok_json()
 }
@@ -219,15 +242,36 @@ 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\":[]}" }
     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 +285,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,6 +310,64 @@ 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 + "\"}"
 }
 
@@ -295,6 +407,12 @@ 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)
@@ -351,6 +469,9 @@ 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") {
@@ -362,16 +483,31 @@ fn handle_request(method: String, path: String, body: String) -> String {
 
 // ── 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

@@ -82,8 +82,14 @@ static _Thread_local ElArena _tl_arena = {NULL, 0, 0};
 static _Thread_local int     _tl_arena_active = 0;
 
 /* Binary-safe fs_read length — set by fs_read, consumed by http_send_response.
- * Allows serving PNGs and other binary files without strlen truncation. */
-static _Thread_local size_t  _tl_fs_read_len  = 0;
+ * Allows serving PNGs and other binary files without strlen truncation.
+ * PAIRED with the buffer pointer it describes: the length may only be applied
+ * to the exact buffer fs_read returned. Without the pairing, any handler that
+ * fs_read a file and then WRAPPED it into a larger response had that response
+ * truncated to the file's length (Content-Length lied AND the send stopped
+ * short) — the safety-contact onboarding trap, 2026-07-17. */
+static _Thread_local size_t      _tl_fs_read_len  = 0;
+static _Thread_local const char* _tl_fs_read_buf  = NULL;
 
 static void el_arena_track(char* p) {
     if (!_tl_arena_active || !p) return;
@@ -101,6 +107,8 @@ static void el_arena_track(char* p) {
 void el_request_start(void) {
     _tl_arena.count  = 0;
     _tl_arena_active = 1;
+    _tl_fs_read_len  = 0;     /* never let a previous request's file length */
+    _tl_fs_read_buf  = NULL;  /* leak into this response's byte accounting  */
 }
 
 /* Called by http_worker after the El handler returns and the response is sent.
@@ -1484,11 +1492,14 @@ static void http_send_response(int fd, const char* body) {
     }
 
     const char* eff_body = is_envelope ? env_body : body;
-    /* Use the real byte count from fs_read if available (handles binary files
-     * with embedded null bytes — PNG, WOFF2, etc.). Fall back to strlen for
-     * normal text/JSON responses where _tl_fs_read_len is 0. */
-    size_t blen = (_tl_fs_read_len > 0) ? _tl_fs_read_len : strlen(eff_body);
+    /* Use the real byte count from fs_read ONLY when this body IS the exact
+     * buffer fs_read returned (binary files with embedded null bytes — PNG,
+     * WOFF2, etc.). Any other body — wrapped, enveloped, or derived — must be
+     * measured with strlen, or it is truncated/over-read to the file's size. */
+    size_t blen = (_tl_fs_read_len > 0 && eff_body == _tl_fs_read_buf)
+                      ? _tl_fs_read_len : strlen(eff_body);
     _tl_fs_read_len = 0;  /* consume — one-shot per response */
+    _tl_fs_read_buf = NULL;
     int head_only = _tl_http_head_only;
 
     JsonBuf hdrs; jb_init(&hdrs);
@@ -1568,11 +1579,22 @@ static void* http_worker(void* arg) {
             const char* rs = EL_CSTR(r);
             /* Copy response out BEFORE arena teardown.
              * For binary files, _tl_fs_read_len holds the real byte count —
-             * use memcpy instead of strdup so null bytes are preserved. */
-            size_t rlen = _tl_fs_read_len > 0 ? _tl_fs_read_len : (rs ? strlen(rs) : 0);
+             * use memcpy instead of strdup so null bytes are preserved.
+             * The stored length applies ONLY when the response IS the exact
+             * fs_read buffer; a wrapped/derived response must use strlen or
+             * it gets truncated (or over-read) to the file's length. */
+            size_t rlen;
+            if (_tl_fs_read_len > 0 && rs && rs == _tl_fs_read_buf) {
+                rlen = _tl_fs_read_len;   /* raw file bytes — binary-safe */
+            } else {
+                rlen = rs ? strlen(rs) : 0;
+                _tl_fs_read_len = 0;      /* hint doesn't describe this body */
+                _tl_fs_read_buf = NULL;
+            }
             response = malloc(rlen + 1);
             if (response && rs) { memcpy(response, rs, rlen); response[rlen] = '\0'; }
             else if (response) { response[0] = '\0'; }
+            if (_tl_fs_read_len > 0) _tl_fs_read_buf = response; /* hint follows the copy */
         } else {
             response = el_strdup_persist("el-runtime: no http handler registered");
         }
@@ -1822,10 +1844,20 @@ static void* http_worker_v2(void* arg) {
             el_val_t hmap = http_build_headers_map(hdr_block ? hdr_block : "");
             el_val_t r = h(EL_STR(dispatch_method), EL_STR(path), hmap, EL_STR(body));
             const char* rs = EL_CSTR(r);
-            size_t rlen = _tl_fs_read_len > 0 ? _tl_fs_read_len : (rs ? strlen(rs) : 0);
+            /* Same pairing rule as the v1 worker: the fs_read length is only
+             * trustworthy for the exact buffer fs_read returned. */
+            size_t rlen;
+            if (_tl_fs_read_len > 0 && rs && rs == _tl_fs_read_buf) {
+                rlen = _tl_fs_read_len;   /* raw file bytes — binary-safe */
+            } else {
+                rlen = rs ? strlen(rs) : 0;
+                _tl_fs_read_len = 0;      /* hint doesn't describe this body */
+                _tl_fs_read_buf = NULL;
+            }
             response = malloc(rlen + 1);
             if (response && rs) { memcpy(response, rs, rlen); response[rlen] = '\0'; }
             else if (response) { response[0] = '\0'; }
+            if (_tl_fs_read_len > 0) _tl_fs_read_buf = response; /* hint follows the copy */
             el_release(hmap);
         } else {
             response = el_strdup_persist(
@@ -2024,6 +2056,7 @@ el_val_t http_response(el_val_t status, el_val_t headers_json, el_val_t body) {
 el_val_t fs_read(el_val_t pathv) {
     const char* path = EL_CSTR(pathv);
     _tl_fs_read_len = 0;
+    _tl_fs_read_buf = NULL;
     if (!path) return el_wrap_str(el_strdup(""));
     FILE* f = fopen(path, "rb");
     if (!f) return el_wrap_str(el_strdup(""));
@@ -2035,6 +2068,7 @@ el_val_t fs_read(el_val_t pathv) {
     size_t got = fread(buf, 1, (size_t)sz, f);
     buf[got] = '\0';
     _tl_fs_read_len = got;   /* store real byte count for binary-safe send */
+    _tl_fs_read_buf = buf;   /* ...valid ONLY for this exact buffer */
     fclose(f);
     return el_wrap_str(buf);
 }
@@ -3577,8 +3611,10 @@ el_val_t json_get_raw(el_val_t json_str, el_val_t key) {
     const char* k    = EL_CSTR(key);
     const char* p = json_find_key(json, k);
     /* Clear fs_read binary-length hint — result is a fresh null-terminated
-     * string, not the raw file bytes, so Content-Length must use strlen. */
+     * string, not the raw file bytes, so Content-Length must use strlen.
+     * (Kept although the pointer pairing now makes this redundant.) */
     _tl_fs_read_len = 0;
+    _tl_fs_read_buf = NULL;
     if (!p) return el_wrap_str(el_strdup(""));
     const char* end = json_skip_value(p);
     size_t n = (size_t)(end - p);

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

@@ -0,0 +1,186 @@
+#ifndef EL_PLATFORM_WIN_H
+#define EL_PLATFORM_WIN_H
+/*
+ * el_platform_win.h — Windows OS-boundary shim for el_runtime.c.
+ *
+ * Branch: feat/windows-el-runtime. Included ONLY when _WIN32 is defined; the POSIX build is
+ * untouched. Goal: let el_runtime.c (a BSD-sockets / dlfcn / fork host) compile and link with
+ * mingw-w64 into a native neuron.exe, with no behavioural change to the Linux/macOS build.
+ *
+ * What it maps:
+ *   - sockets  : winsock2 (same call names: socket/bind/listen/accept/recv/send/setsockopt).
+ *                Sockets close with closesocket() (see el_closesocket), and the stack must be
+ *                started once with WSAStartup — done automatically via a load-time constructor.
+ *   - dlsym    : el_runtime.c uses dlsym(RTLD_DEFAULT, name) to resolve callback/tool symbols
+ *                exported by the main module. Windows equivalent: GetProcAddress on the process
+ *                module. Link the soul with -Wl,--export-all-symbols so the symbols are findable.
+ *   - popen    : mapped to _popen/_pclose.
+ *   - threads  : UNCHANGED. mingw-w64 ships winpthreads, so <pthread.h> + -lpthread just work.
+ */
+
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <winsock2.h>
+#include <ws2tcpip.h>
+#include <windows.h>
+#include <io.h>
+#include <process.h>
+
+/* Portable headers mingw-w64 provides (verified present). */
+#include <stdarg.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <strings.h>   /* strcasecmp */
+#include <ctype.h>
+#include <math.h>
+#include <time.h>
+#include <sys/time.h>  /* mingw-w64 provides gettimeofday here */
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <dirent.h>
+#include <errno.h>
+#include <pthread.h>
+
+/* ── socket close ─────────────────────────────────────────────────────────── */
+/* Winsock closes sockets with closesocket(), not close() (close() is for file fds). The POSIX
+   build defines the same helper as close() so the call sites are identical across platforms. */
+static inline int el_closesocket(SOCKET s) { return closesocket(s); }
+
+/* ── setsockopt optval type ───────────────────────────────────────────────── */
+/* Winsock's setsockopt takes optval as (const char*); POSIX takes (const void*), so el_runtime.c
+   passes &int directly. GCC 14+ makes that an error under -Wincompatible-pointer-types. Wrap it so
+   the runtime's POSIX-style call sites compile unchanged (defined before the macro so the wrapper
+   itself resolves to the real winsock setsockopt). */
+static inline int el_setsockopt(SOCKET s, int level, int optname, const void* optval, int optlen) {
+    return setsockopt(s, level, optname, (const char*)optval, optlen);
+}
+#define setsockopt(s, l, o, v, n) el_setsockopt((s), (l), (o), (v), (int)(n))
+
+/* ── winsock init (once, at load) ─────────────────────────────────────────── */
+static void el__win_net_init(void) {
+    static int inited = 0;
+    if (!inited) { WSADATA w; WSAStartup(MAKEWORD(2, 2), &w); inited = 1; }
+}
+__attribute__((constructor)) static void el__win_ctor(void) { el__win_net_init(); }
+
+/* ── dlsym → GetProcAddress ───────────────────────────────────────────────── */
+#ifndef RTLD_DEFAULT
+#define RTLD_DEFAULT ((void*)0)
+#endif
+static inline void* el_win_dlsym(void* handle, const char* name) {
+    (void)handle;
+    return (void*)(uintptr_t)GetProcAddress(GetModuleHandleA(NULL), name);
+}
+#define dlsym(h, n) el_win_dlsym((h), (n))
+
+/* ── popen / pclose ───────────────────────────────────────────────────────── */
+#define popen  _popen
+#define pclose _pclose
+
+/* ── misc POSIX → Win32 shims ─────────────────────────────────────────────── */
+#include <direct.h>            /* _mkdir */
+#define mkdir(path, mode) _mkdir(path)     /* POSIX mkdir(path,mode) → _mkdir(path) */
+#define timegm _mkgmtime                   /* UTC tm → time_t */
+
+/* setenv/unsetenv: not in the Windows CRT; map to _putenv_s / SetEnvironmentVariable. */
+static inline int setenv(const char* name, const char* value, int overwrite) {
+    (void)overwrite;
+    return _putenv_s(name, value ? value : "");
+}
+static inline int unsetenv(const char* name) {
+    /* _putenv_s(name, "") sets VAR="" rather than removing it.
+     * SetEnvironmentVariableA(name, NULL) truly deletes it from the Win32
+     * env block; then we sync the CRT cache with _putenv("NAME=").       */
+    SetEnvironmentVariableA(name, NULL);
+    size_t len = strlen(name);
+    char *buf = (char*)malloc(len + 2);
+    if (!buf) return -1;
+    memcpy(buf, name, len);
+    buf[len] = '=';
+    buf[len + 1] = '\0';
+    _putenv(buf);
+    free(buf);
+    return 0;
+}
+
+/* nanosleep — not available in MSVC/UCRT; approximate with Sleep(). */
+static inline int el_nanosleep(const struct timespec *req, struct timespec *rem) {
+    (void)rem;
+    DWORD ms = (DWORD)((req->tv_sec * 1000ULL) + (req->tv_nsec / 1000000ULL));
+    Sleep(ms ? ms : 1);
+    return 0;
+}
+#define nanosleep(req, rem) el_nanosleep((req), (rem))
+
+/* localtime_r/gmtime_r: Windows offers localtime_s/gmtime_s with reversed arg order. */
+static inline struct tm* localtime_r(const time_t* t, struct tm* out) {
+    return localtime_s(out, t) == 0 ? out : (struct tm*)0;
+}
+static inline struct tm* gmtime_r(const time_t* t, struct tm* out) {
+    return gmtime_s(out, t) == 0 ? out : (struct tm*)0;
+}
+
+/* ── libcurl: degradable stubs for the curl-less Windows build ─────────────── */
+/* The curl-less validation build (WITH_CURL=0) links no libcurl. el_runtime.c uses libcurl
+ * unconditionally for its HTTP client / LLM layer; these stubs let it compile and link so the
+ * runtime, HTTP *server*, graph and memory work natively on Windows. Live outbound HTTP/LLM calls
+ * degrade to a runtime error (curl_easy_perform returns an error) — matching the documented
+ * curl-less contract. When HAVE_CURL is defined (WITH_CURL=1) the real <curl/curl.h> is used and
+ * this whole block is compiled out. POSIX never sees this header, so the POSIX build is untouched. */
+#ifndef HAVE_CURL
+
+typedef void CURL;
+typedef int  CURLcode;
+
+#define CURLE_OK                    0
+#define CURLE_HTTP_RETURNED_ERROR   22
+#define CURL_ERROR_SIZE             256
+
+/* Option ids: values are irrelevant to the no-op setopt below; kept distinct for readability. */
+#define CURLOPT_URL              10002
+#define CURLOPT_WRITEFUNCTION    20011
+#define CURLOPT_WRITEDATA        10001
+#define CURLOPT_POSTFIELDS       10015
+#define CURLOPT_POSTFIELDSIZE      120
+#define CURLOPT_POST                47
+#define CURLOPT_HTTPHEADER       10023
+#define CURLOPT_TIMEOUT_MS         155
+#define CURLOPT_NOSIGNAL            99
+#define CURLOPT_USERAGENT        10018
+#define CURLOPT_FOLLOWLOCATION      52
+#define CURLOPT_ERRORBUFFER      10010
+#define CURLOPT_CUSTOMREQUEST    10036
+#define CURLOPT_FAILONERROR         45
+
+struct curl_slist { char* data; struct curl_slist* next; };
+
+static inline struct curl_slist* curl_slist_append(struct curl_slist* list, const char* s) {
+    struct curl_slist* node = (struct curl_slist*)malloc(sizeof(struct curl_slist));
+    if (!node) return list;
+    node->data = s ? strdup(s) : NULL;
+    node->next = NULL;
+    if (!list) return node;
+    struct curl_slist* p = list;
+    while (p->next) p = p->next;
+    p->next = node;
+    return list;
+}
+static inline void curl_slist_free_all(struct curl_slist* list) {
+    while (list) { struct curl_slist* n = list->next; free(list->data); free(list); list = n; }
+}
+
+static inline CURL* curl_easy_init(void) { return (CURL*)malloc(1); }
+static inline CURLcode curl_easy_setopt(CURL* h, int opt, ...) { (void)h; (void)opt; return CURLE_OK; }
+static inline CURLcode curl_easy_perform(CURL* h) { (void)h; return 7 /* CURLE_COULDNT_CONNECT */; }
+static inline void curl_easy_cleanup(CURL* h) { free(h); }
+static inline const char* curl_easy_strerror(CURLcode c) {
+    (void)c; return "libcurl not built in (curl-less build)";
+}
+
+#endif /* !HAVE_CURL */
+
+#endif /* EL_PLATFORM_WIN_H */

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

@@ -758,6 +758,18 @@ el_val_t trace_span_start(el_val_t name);
 el_val_t trace_span_end(el_val_t span_handle);
 el_val_t emit_event(el_val_t name, el_val_t duration_ms);
 
+/* ── Runtime symbols required by the soul modules ──────────────────────────── */
+/* All implemented in el_runtime.c but omitted from this release header; the soul dist modules
+ * reference them directly, so the public header must export them. Declarations only — mirrors the
+ * mainline el_runtime.h and is platform-independent (no behavioural change to the POSIX build). */
+typedef el_val_t (*http_handler_fn)(el_val_t method, el_val_t path, el_val_t body);
+typedef el_val_t (*http_handler4_fn)(el_val_t method, el_val_t path, el_val_t body, el_val_t headers);
+el_val_t  el_arena_push(void);
+el_val_t  el_arena_pop(el_val_t mark);
+void      http_serve_async(el_val_t port, el_val_t handler);
+el_val_t  engram_get_node_by_label(el_val_t label);
+el_val_t  engram_prune_telemetry(el_val_t older_than_ms);
+
 #ifdef __cplusplus
 }
 #endif

lang/runtime/swarm.el

@@ -0,0 +1,269 @@
+// swarm.el — Native interruptibility for Neuron-dispatched agents.
+//
+// CANON: Neuron memory 1ca4d3e9 (native-interruptibility). A dispatched worker
+// must be re-steerable OR killable the INSTANT a correction / new signal arrives,
+// MID-TASK — like a human who stops the moment they're told "that's wrong", not
+// one who finishes the wrong workflow first. Claude's sub-agents cannot do this:
+// reset off a wrong path, they finish the current workflow before absorbing the
+// correction, wasting work on a KNOWN-WRONG thing. Neuron's must never.
+//
+// MECHANISM (Will's steer, 2026-08-15 — "not a hard problem, don't over-engineer"):
+//   CancellationToken + always-on input.
+//   (1) INPUT ALWAYS ON — every worker holds a CONTROL CHANNEL (the token). The
+//       coordinator can push a signal at ANY time; the channel is NEVER gated by
+//       whether the worker is busy. Like a person who keeps hearing while talking.
+//   (2) COOPERATIVE CANCELLATION — the worker CHECKS the token at every step
+//       boundary (a non-blocking poll, __channel_try_recv). On a signal it STOPS,
+//       ABSORBS the correction (re-plans) or TERMINATES cleanly — with ZERO wasted
+//       continuation of known-wrong work.
+//
+// The SAME mechanism serves the conversational speech loop: a mic barge-in simply
+// invokes the token on the running render (see peripheral loop 66155ba9).
+//
+// SAFETY (Rule-4 single-writer / bounded purview): a worker holds its task as a
+// PURVIEW (a meaning-plan). It writes ONLY to its own out-channel and its own
+// local purview — it holds NO global write-lock. So it can be interrupted or
+// killed mid-step with NO half-committed global state; the coordinator just
+// signals stop. Bounded purviews are what make live interruption clean.
+//
+// Built on the runtime concurrency primitives:
+//   __channel_new / __channel_send / __channel_recv / __channel_try_recv  (channels)
+//   __thread_create / __thread_join                                       (workers)
+//
+// Contrast: the pre-existing channel.el `_channel_worker` loop spawns+joins the
+// WHOLE task with no signal check — the exact broken pattern. This module checks
+// the token BETWEEN every bounded step, so the interrupt latency is one step, not
+// one whole workflow.
+
+// ── low-level worker/thread wrappers (call seed prims directly; no collision) ──
+
+fn _swarm_spawn(fn_name: String, arg: String) -> Int {
+    return __thread_create(fn_name, arg)
+}
+
+fn _swarm_join(tid: Int) -> String {
+    return __thread_join(tid)
+}
+
+// ── Cancellation token — the always-on control channel ─────────────────────────
+
+// token_new — create a cancellation/pause/redirect token for one worker.
+// Unbounded so the coordinator NEVER blocks when it signals (always-on input).
+fn token_new() -> Int {
+    return __channel_new(0)
+}
+
+// ── Coordinator ops — INVOKE the token (interrupt / re-steer / kill) ───────────
+
+// token_signal — send a raw signal JSON. Low-level; prefer the named helpers.
+fn token_signal(tok: Int, sig_json: String) {
+    __channel_send(tok, sig_json)
+}
+
+// token_interrupt — ask the worker to stop at the next step boundary and hold.
+fn token_interrupt(tok: Int) {
+    __channel_send(tok, "{\"sig\":\"PAUSE\"}")
+}
+
+// token_pause — alias for interrupt: stop stepping, hold state, wait for RESUME.
+fn token_pause(tok: Int) {
+    __channel_send(tok, "{\"sig\":\"PAUSE\"}")
+}
+
+// token_resume — resume a paused worker on its held plan.
+fn token_resume(tok: Int) {
+    __channel_send(tok, "{\"sig\":\"RESUME\"}")
+}
+
+// token_kill — terminate the worker cleanly at the next step boundary.
+fn token_kill(tok: Int) {
+    __channel_send(tok, "{\"sig\":\"KILL\"}")
+}
+
+// token_redirect — re-steer the worker onto a NEW plan MID-TASK. Progress already
+// made (completed steps, emitted outputs) is PRESERVED; only the remaining plan is
+// replaced. new_steps is a JSON array string, e.g. "[\"step-a\",\"step-b\"]".
+fn token_redirect(tok: Int, new_goal: String, new_steps: String) {
+    let msg: String = "{\"sig\":\"REDIRECT\",\"goal\":\"" +
+                      json_escape_string(new_goal) + "\",\"steps\":" + new_steps + "}"
+    __channel_send(tok, msg)
+}
+
+// ── Worker ops — CHECK the token (cooperative cancellation point) ──────────────
+
+// token_check — non-blocking poll of the token. Returns the pending signal JSON,
+// or "" when there is no signal. Called at every step boundary. This is the
+// always-on check: it never blocks the worker, so work proceeds at full speed
+// until — and only until — a signal actually arrives.
+fn token_check(tok: Int) -> String {
+    return __channel_try_recv(tok)
+}
+
+// token_wait — BLOCK until the next signal. Used only while PAUSED (the worker is
+// idle, so blocking is correct — it is not spinning).
+fn token_wait(tok: Int) -> String {
+    return __channel_recv(tok)
+}
+
+// ── Purview — the worker's meaning-plan (held task, resumable) ─────────────────
+
+// purview_new — build a bounded meaning-plan the worker carries.
+//   id    — purview id
+//   goal  — what the worker is trying to achieve (steerable)
+//   steps — JSON array string of step descriptors (the remaining plan)
+// A redirect UPDATES this plan; it is not lost.
+fn purview_new(id: String, goal: String, steps: String) -> String {
+    return "{\"id\":\"" + json_escape_string(id) +
+           "\",\"goal\":\"" + json_escape_string(goal) +
+           "\",\"steps\":" + steps +
+           ",\"idx\":0,\"completed\":0,\"status\":\"ready\"}"
+}
+
+// ── The interruptible worker loop ──────────────────────────────────────────────
+
+// swarm_worker_run — the generic natively-interruptible worker.
+//
+// arg is a JSON object carrying:
+//   "tok"     — the cancellation token (control channel handle)
+//   "out"     — the worker's own output channel handle (its ONLY write surface)
+//   "step_fn" — name of an El fn (String)->String that performs ONE bounded step
+//   "purview" — the meaning-plan (from purview_new)
+//
+// The loop: at EVERY iteration it first polls the token (always-on check). Only
+// then does it execute ONE bounded step. So a KILL/REDIRECT/PAUSE is absorbed
+// within a single step — never after finishing the whole (possibly wrong) plan.
+//
+// step_fn is invoked as a child thread joined immediately: exactly ONE step of
+// work is in flight, so the interrupt latency is bounded by a single step.
+//
+// Returns the final purview JSON (status: complete | killed | redirected).
+fn swarm_worker_run(arg: String) -> String {
+    let tok: Int = str_to_int(json_get(arg, "tok"))
+    let out_ch: Int = str_to_int(json_get(arg, "out"))
+    let step_fn: String = json_get(arg, "step_fn")
+    let purview: String = json_get_raw(arg, "purview")
+
+    let pid: String = json_get(purview, "id")
+    let goal: String = json_get(purview, "goal")
+    let steps: String = json_get_raw(purview, "steps")
+    let n: Int = json_array_len(steps)
+    let idx: Int = 0
+    let completed: Int = 0
+    let status: String = "running"
+    let stop: Int = 0
+
+    while stop == 0 {
+        // ── ALWAYS-ON INTERRUPT CHECK (the cooperative cancellation point) ──
+        let sig: String = token_check(tok)
+        if str_eq(sig, "") {
+            // no signal — proceed with one bounded step (or finish)
+            if idx >= n {
+                let status = "complete"
+                let stop = 1
+            } else {
+                let step: String = json_array_get(steps, idx)
+                let step_arg: String = "{\"goal\":\"" + json_escape_string(goal) +
+                                       "\",\"idx\":" + int_to_str(idx) +
+                                       ",\"step\":" + step + "}"
+                let tid: Int = _swarm_spawn(step_fn, step_arg)
+                let result: String = _swarm_join(tid)
+                __channel_send(out_ch, result)
+                let idx = idx + 1
+                let completed = completed + 1
+            }
+        } else {
+            // a signal arrived — ABSORB it immediately, before any more work
+            let kind: String = json_get(sig, "sig")
+            if str_eq(kind, "KILL") {
+                // terminate cleanly — commit nothing further. Bounded purview =
+                // no half-committed global state to unwind.
+                __channel_send(out_ch, "[KILL absorbed @step " + int_to_str(idx) +
+                                     " — stopped, no wasted continuation]")
+                let status = "killed"
+                let stop = 1
+            } else {
+                if str_eq(kind, "REDIRECT") {
+                    // ABSORB the correction: re-plan onto the new goal/steps.
+                    // Completed steps + emitted outputs are PRESERVED; only the
+                    // remaining plan is replaced.
+                    let kept: Int = completed
+                    let goal = json_get(sig, "goal")
+                    let steps = json_get_raw(sig, "steps")
+                    let n = json_array_len(steps)
+                    let idx = 0
+                    let status = "redirected"
+                    __channel_send(out_ch, "[REDIRECT absorbed @step " +
+                                         int_to_str(kept) + " — kept " +
+                                         int_to_str(kept) +
+                                         " done, re-planned to goal=" + goal + "]")
+                } else {
+                    if str_eq(kind, "PAUSE") {
+                        // hold state; idle-wait for the next signal
+                        __channel_send(out_ch, "[PAUSE absorbed @step " +
+                                             int_to_str(idx) + " — holding plan]")
+                        let status = "paused"
+                        let resumed: Int = 0
+                        while resumed == 0 {
+                            let s2: String = token_wait(tok)
+                            let k2: String = json_get(s2, "sig")
+                            if str_eq(k2, "RESUME") {
+                                __channel_send(out_ch, "[RESUME @step " +
+                                                     int_to_str(idx) + "]")
+                                let status = "running"
+                                let resumed = 1
+                            } else {
+                                if str_eq(k2, "KILL") {
+                                    __channel_send(out_ch, "[KILL absorbed while paused]")
+                                    let status = "killed"
+                                    let stop = 1
+                                    let resumed = 1
+                                } else {
+                                    if str_eq(k2, "REDIRECT") {
+                                        let goal = json_get(s2, "goal")
+                                        let steps = json_get_raw(s2, "steps")
+                                        let n = json_array_len(steps)
+                                        let idx = 0
+                                        __channel_send(out_ch, "[REDIRECT absorbed while paused — goal=" + goal + "]")
+                                        let status = "running"
+                                        let resumed = 1
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    // final purview snapshot
+    let final: String = "{\"id\":\"" + pid +
+                        "\",\"goal\":\"" + json_escape_string(goal) +
+                        "\",\"idx\":" + int_to_str(idx) +
+                        ",\"completed\":" + int_to_str(completed) +
+                        ",\"planned\":" + int_to_str(n) +
+                        ",\"status\":\"" + status + "\"}"
+    __channel_send(out_ch, "[DONE status=" + status +
+                         " completed=" + int_to_str(completed) + "]")
+    return final
+}
+
+// ── Coordinator convenience — dispatch an interruptible worker ─────────────────
+
+// swarm_dispatch — spawn a natively-interruptible worker on a purview.
+//   step_fn — name of the per-step executor (String)->String
+//   purview — the meaning-plan (from purview_new)
+// Returns a handle JSON: {"tok":T,"out":O,"tid":D} — the coordinator holds `tok`
+// to interrupt/redirect/kill live, and drains `out` for results.
+fn swarm_dispatch(step_fn: String, purview: String) -> String {
+    let tok: Int = token_new()
+    let out_ch: Int = __channel_new(0)
+    let arg: String = "{\"tok\":" + int_to_str(tok) +
+                      ",\"out\":" + int_to_str(out_ch) +
+                      ",\"step_fn\":\"" + step_fn +
+                      "\",\"purview\":" + purview + "}"
+    let tid: Int = _swarm_spawn("swarm_worker_run", arg)
+    return "{\"tok\":" + int_to_str(tok) +
+           ",\"out\":" + int_to_str(out_ch) +
+           ",\"tid\":" + int_to_str(tid) + "}"
+}

lang/tests/swarm/proof.el

@@ -0,0 +1,180 @@
+// proof.el — Proof of native interruptibility for Neuron-dispatched agents.
+//
+// Concatenated after runtime/swarm.el (see run.sh). Demonstrates, with raw
+// before/after counts, that a dispatched worker interrupted MID-TASK stops
+// instantly (not after finishing the wrong workflow), absorbs a redirect
+// (re-plans, keeping progress), or terminates cleanly.
+//
+// Three scenarios on the SAME 12-step plan, SAME per-step cost, SAME signal
+// timing (sent ~50ms in ≈ after step 3):
+//   A. BASELINE — the broken Claude-style worker: no mid-loop signal check.
+//      A kill sent at step ~3 is ignored until the whole plan finishes → all 12
+//      steps run = wasted work on a known-wrong task.
+//   B. INTERRUPTIBLE KILL — swarm_worker_run: the kill is absorbed within one
+//      step → stops at ~3, status=killed, ~9 steps of waste AVOIDED.
+//   C. INTERRUPTIBLE REDIRECT — mirrors the live incident (build-python-synth →
+//      native-fetch-render): the correction is absorbed mid-task; the 3 done
+//      steps are kept; the worker re-plans onto the new goal and finishes it.
+
+// ── per-step work — one bounded unit (~15ms) ──────────────────────────────────
+fn demo_step(arg: String) -> String {
+    let goal: String = json_get(arg, "goal")
+    let idx: String = json_get(arg, "idx")
+    let step: String = json_get(arg, "step")
+    sleep_ms(15)
+    return "did[" + goal + "] step#" + idx + " (" + step + ")"
+}
+
+// ── BASELINE: the broken, non-interruptible worker (Claude-style) ─────────────
+// Same shape as swarm_worker_run BUT it never polls the token during the loop.
+// It "finishes the workflow" and only notices the signal at the very end — the
+// exact pattern Will called out. Reports how many steps it wasted post-signal.
+fn broken_worker_run(arg: String) -> String {
+    let tok: Int = str_to_int(json_get(arg, "tok"))
+    let out_ch: Int = str_to_int(json_get(arg, "out"))
+    let step_fn: String = json_get(arg, "step_fn")
+    let purview: String = json_get_raw(arg, "purview")
+    let goal: String = json_get(purview, "goal")
+    let steps: String = json_get_raw(purview, "steps")
+    let n: Int = json_array_len(steps)
+    let idx: Int = 0
+    // NO token check inside the loop — this is the bug.
+    while idx < n {
+        let step: String = json_array_get(steps, idx)
+        let step_arg: String = "{\"goal\":\"" + goal + "\",\"idx\":" +
+                               int_to_str(idx) + ",\"step\":" + step + "}"
+        let tid: Int = __thread_create(step_fn, step_arg)
+        let result: String = __thread_join(tid)
+        __channel_send(out_ch, result)
+        let idx = idx + 1
+    }
+    // Only NOW does it look at the control signal — too late.
+    let late: String = token_check(tok)
+    if str_eq(late, "") {
+        __channel_send(out_ch, "[no signal]")
+    } else {
+        __channel_send(out_ch, "[TOO LATE: absorbed " + json_get(late, "sig") +
+                              " only after running ALL " + int_to_str(n) +
+                              " steps — wasted work]")
+    }
+    return "{\"status\":\"ran-to-completion\",\"completed\":" + int_to_str(idx) + "}"
+}
+
+// ── helpers ───────────────────────────────────────────────────────────────────
+
+// drain_count — drain out_ch, print each line, return count of real step outputs
+// (lines beginning with "did").
+fn drain_and_report(out_ch: Int) -> Int {
+    let done: Int = 0
+    let did: Int = 0
+    while done == 0 {
+        let m: String = __channel_try_recv(out_ch)
+        if str_eq(m, "") {
+            let done = 1
+        } else {
+            println("      | " + m)
+            if str_starts_with(m, "did") {
+                let did = did + 1
+            }
+        }
+    }
+    return did
+}
+
+fn twelve_steps() -> String {
+    return "[\"s0\",\"s1\",\"s2\",\"s3\",\"s4\",\"s5\",\"s6\",\"s7\",\"s8\",\"s9\",\"s10\",\"s11\"]"
+}
+
+fn main() -> Void {
+    println("=====================================================================")
+    println(" NATIVE INTERRUPTIBILITY — PROOF (canon 1ca4d3e9)")
+    println(" plan: 12 bounded steps @ ~15ms; signal sent ~50ms in (≈ after step 3)")
+    println("=====================================================================")
+
+    // ── A. BASELINE — broken, non-interruptible ──
+    println("")
+    println("[A] BASELINE  broken worker (no mid-loop signal check) — Claude-style")
+    let tokA: Int = token_new()
+    let outA: Int = __channel_new(0)
+    let pvA: String = purview_new("A", "build-wrong-thing", twelve_steps())
+    let argA: String = "{\"tok\":" + int_to_str(tokA) + ",\"out\":" + int_to_str(outA) +
+                       ",\"step_fn\":\"demo_step\",\"purview\":" + pvA + "}"
+    let t0A: Int = time_now()
+    let tidA: Int = __thread_create("broken_worker_run", argA)
+    sleep_ms(50)
+    println("      -> coordinator sends KILL at +" + int_to_str(time_now() - t0A) + "ms (≈step 3)")
+    token_kill(tokA)
+    let finA: String = __thread_join(tidA)
+    let elapA: Int = time_now() - t0A
+    let didA: Int = drain_and_report(outA)
+    println("      RESULT: executed " + int_to_str(didA) + "/12 steps, wall=" +
+            int_to_str(elapA) + "ms, final=" + finA)
+    println("      >> ignored the kill, RAN ALL 12 — ~9 steps of KNOWN-WRONG waste")
+
+    // ── B. INTERRUPTIBLE KILL ──
+    println("")
+    println("[B] INTERRUPTIBLE  swarm_worker_run + token_kill")
+    let pvB: String = purview_new("B", "build-wrong-thing", twelve_steps())
+    let hB: String = swarm_dispatch("demo_step", pvB)
+    let tokB: Int = str_to_int(json_get(hB, "tok"))
+    let outB: Int = str_to_int(json_get(hB, "out"))
+    let tidB: Int = str_to_int(json_get(hB, "tid"))
+    let t0B: Int = time_now()
+    sleep_ms(50)
+    println("      -> coordinator sends KILL at +" + int_to_str(time_now() - t0B) + "ms (≈step 3)")
+    token_kill(tokB)
+    let finB: String = __thread_join(tidB)
+    let elapB: Int = time_now() - t0B
+    let didB: Int = drain_and_report(outB)
+    println("      RESULT: executed " + int_to_str(didB) + "/12 steps, wall=" +
+            int_to_str(elapB) + "ms, final=" + finB)
+    println("      >> STOPPED within one step of the signal — no wasted continuation")
+
+    // ── C. INTERRUPTIBLE REDIRECT (the live incident) ──
+    println("")
+    println("[C] INTERRUPTIBLE  redirect mid-task: build-python-synth -> native-fetch-render")
+    let pvC: String = purview_new("C", "build-python-synth-renderer", twelve_steps())
+    let hC: String = swarm_dispatch("demo_step", pvC)
+    let tokC: Int = str_to_int(json_get(hC, "tok"))
+    let outC: Int = str_to_int(json_get(hC, "out"))
+    let tidC: Int = str_to_int(json_get(hC, "tid"))
+    let t0C: Int = time_now()
+    sleep_ms(50)
+    println("      -> coordinator REDIRECTS at +" + int_to_str(time_now() - t0C) + "ms (≈step 3)")
+    token_redirect(tokC, "native-fetch-render", "[\"fetch\",\"realize\",\"cohere\"]")
+    let finC: String = __thread_join(tidC)
+    let elapC: Int = time_now() - t0C
+    let didC: Int = drain_and_report(outC)
+    println("      RESULT: executed " + int_to_str(didC) + " steps total, wall=" +
+            int_to_str(elapC) + "ms, final=" + finC)
+    println("      >> absorbed the correction mid-task: kept early progress,")
+    println("         re-planned onto native-fetch-render, finished the RIGHT plan")
+
+    // ── D. INTERRUPTIBLE PAUSE -> RESUME (hold state, then continue) ──
+    println("")
+    println("[D] INTERRUPTIBLE  pause mid-task, hold state, then resume to finish")
+    let pvD: String = purview_new("D", "long-render", twelve_steps())
+    let hD: String = swarm_dispatch("demo_step", pvD)
+    let tokD: Int = str_to_int(json_get(hD, "tok"))
+    let outD: Int = str_to_int(json_get(hD, "out"))
+    let tidD: Int = str_to_int(json_get(hD, "tid"))
+    let t0D: Int = time_now()
+    sleep_ms(50)
+    println("      -> coordinator PAUSES at +" + int_to_str(time_now() - t0D) + "ms (≈step 3)")
+    token_pause(tokD)
+    sleep_ms(60)
+    println("      -> worker held idle for ~60ms; coordinator RESUMES at +" +
+            int_to_str(time_now() - t0D) + "ms")
+    token_resume(tokD)
+    let finD: String = __thread_join(tidD)
+    let didD: Int = drain_and_report(outD)
+    println("      RESULT: executed " + int_to_str(didD) + "/12 steps, final=" + finD)
+    println("      >> paused on the spot, held its plan, resumed and finished it")
+
+    println("")
+    println("=====================================================================")
+    println(" A ran all 12 wrong steps. B stopped at ~3. C re-planned at ~3.")
+    println(" Same plan, same timing, same signal — only the interruptible worker")
+    println(" stops the instant it's told, like a human. QED.")
+    println("=====================================================================")
+}

lang/tests/swarm/run.sh

@@ -0,0 +1,56 @@
+#!/usr/bin/env bash
+# run.sh — build and run the native-interruptibility proof.
+#
+# Concatenates runtime/swarm.el + proof.el into one translation unit (the El
+# multi-file strategy — elc does not resolve cross-directory imports), compiles
+# via the canonical elc, links against el_runtime.c, and runs.
+#
+# A tiny forward-declaration prelude is prepended to the generated C for the
+# __channel_* seed primitives (they are defined in el_runtime.c but not declared
+# in el_runtime.h). This touches nothing shared — it is local to this build.
+
+set -uo pipefail
+cd "$(dirname "$0")"
+
+EL_HOME="${EL_HOME:-$(cd ../.. && pwd)}"
+ELC="${EL_HOME}/dist/platform/elc"
+RT="${EL_HOME}/el-compiler/runtime"
+SWARM="${EL_HOME}/runtime/swarm.el"
+
+OSSL="$(brew --prefix openssl@3 2>/dev/null || brew --prefix openssl 2>/dev/null || echo /usr/local)"
+LDF=(); [ -d "${OSSL}/lib" ] && LDF=(-L"${OSSL}/lib")
+
+BUILD="$(mktemp -d -t swarmproof.XXXXXX)"
+trap 'rm -rf "${BUILD}"' EXIT
+
+if [ ! -x "${ELC}" ]; then echo "elc not found at ${ELC}" >&2; exit 1; fi
+
+# 1. Concatenate library + proof into one .el
+cat "${SWARM}" proof.el > "${BUILD}/combined.el"
+
+# 2. elc emit -> C
+if ! "${ELC}" "${BUILD}/combined.el" > "${BUILD}/body.c" 2>"${BUILD}/elc.err"; then
+    echo "elc FAILED:"; sed 's/^/  /' "${BUILD}/elc.err"; exit 1
+fi
+
+# 3. Prepend forward-decl prelude for the __channel_* seed primitives
+cat > "${BUILD}/prog.c" <<'PRELUDE'
+#include <stdint.h>
+typedef int64_t el_val_t;
+el_val_t __channel_new(el_val_t);
+el_val_t __channel_send(el_val_t, el_val_t);
+el_val_t __channel_recv(el_val_t);
+el_val_t __channel_try_recv(el_val_t);
+el_val_t __channel_close(el_val_t);
+PRELUDE
+cat "${BUILD}/body.c" >> "${BUILD}/prog.c"
+
+# 4. cc link
+if ! cc -O2 -Wno-implicit-function-declaration -I "${RT}" "${LDF[@]}" \
+        "${BUILD}/prog.c" "${RT}/el_runtime.c" \
+        -lcurl -lssl -lcrypto -lpthread -lm -o "${BUILD}/proof" 2>"${BUILD}/cc.err"; then
+    echo "cc FAILED:"; tail -20 "${BUILD}/cc.err"; exit 1
+fi
+
+# 5. run
+"${BUILD}/proof"