fix(soul): restore the soul_identity producer — the chat system prompt has been empty for three months (#137)

Five sites in chat.el read state_get("soul_identity") and splice the result into
the system prompt, beside the voice, security and capability rules:

  chat.el:737, 1745, 2620, 3425, 3480

Nothing has written that key since b163fa6. The producer was added 2026-05-02 in
601e0fe and deleted by the awareness refactor days later. Every chat turn since has
built its system prompt with an EMPTY identity section, and nothing reported it.

Found by the #132 state-key gate, which treats a read with no producer as a build
error rather than a silence. That is the entire argument for that gate.

RESTORED VERBATIM, NOT IMPROVED. soul_identity is an env-configurable persona LINE.
It is not soul_identity_context — the graph-derived
[INTELLECTUAL-DNA]/[VALUES]/[MEMORY-PHILOSOPHY] block written at soul.el:184.
Repointing the five reads at that block would have substituted different content and
called it a repair. Whether the chat prompt should ALSO carry the graph-derived block
is a real question and a separate one; it is not smuggled in here.

Verified by the gate that found it: dead reads 6 -> 1, and it now reports the
chat.el baseline entry as STALE — 'entries that no longer match anything; delete
them'. The remaining one is studio.el's soul_principal, untouched by this change.

Rung: BUILT, gate-verified, boots. NOT end-to-end chat-verified — proving the
prompt now carries the line needs a live provider call, which I have not run.

Refs #137, #132

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

dist/soul.c

@@ -1209,6 +1209,18 @@ el_val_t handle_api_memory_update(el_val_t body);
 el_val_t handle_api_cultivate(el_val_t body);
 el_val_t handle_api_list_typed(el_val_t node_type, el_val_t path, el_val_t body);
 el_val_t handle_api_consolidate(el_val_t body);
+el_val_t audit_pct1(el_val_t num, el_val_t den);
+el_val_t audit_finding(el_val_t name, el_val_t measured, el_val_t note);
+el_val_t audit_str_at(el_val_t s, el_val_t start, el_val_t maxlen);
+el_val_t audit_rel_count(el_val_t edges, el_val_t rel);
+el_val_t audit_owner_stats(el_val_t url);
+el_val_t audit_divergence(void);
+el_val_t audit_edge_typing(el_val_t edges, el_val_t total_edges, el_val_t node_total);
+el_val_t audit_orphans_dangling(el_val_t edges, el_val_t total_edges, el_val_t node_total, el_val_t edge_cap, el_val_t node_cap);
+el_val_t audit_pillar(el_val_t key, el_val_t id);
+el_val_t audit_self_model(void);
+el_val_t audit_deferred(void);
+el_val_t handle_api_structural_audit(el_val_t method, el_val_t path, el_val_t body);
 el_val_t session_title_from_message(el_val_t message);
 el_val_t session_make_content(el_val_t id, el_val_t title, el_val_t created_at, el_val_t updated_at, el_val_t folder);
 el_val_t session_exists(el_val_t session_id);
@@ -1262,6 +1274,8 @@ el_val_t axon_raw;
 el_val_t axon_base;
 el_val_t studio_dir_raw;
 el_val_t studio_dir;
+el_val_t identity_raw;
+el_val_t soul_identity;
 el_val_t using_http_engram;
 el_val_t local_node_count;
 el_val_t snapshot_usable;
@@ -30318,6 +30332,193 @@ el_val_t handle_api_consolidate(el_val_t body) {
   return 0;
 }
 
+el_val_t audit_pct1(el_val_t num, el_val_t den) {
+  if (den <= 0) {
+    return EL_STR("null");
+  }
+  el_val_t neg = (num < 0);
+  el_val_t a = ({ el_val_t _if_result_653 = 0; if (neg) { _if_result_653 = ((0 - num)); } else { _if_result_653 = (num); } _if_result_653; });
+  el_val_t tenths = ((a * 1000) / den);
+  el_val_t whole = (tenths / 10);
+  el_val_t frac = (tenths - (whole * 10));
+  el_val_t sign = ({ el_val_t _if_result_654 = 0; if (neg) { _if_result_654 = (EL_STR("-")); } else { _if_result_654 = (EL_STR("")); } _if_result_654; });
+  return el_str_concat(el_str_concat(el_str_concat(sign, int_to_str(whole)), EL_STR(".")), int_to_str(frac));
+  return 0;
+}
+
+el_val_t audit_finding(el_val_t name, el_val_t measured, el_val_t note) {
+  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("{\"finding\":\""), name), EL_STR("\"")), EL_STR(",\"measured\":{")), measured), EL_STR("}")), EL_STR(",\"note\":\"")), api_json_escape(note)), EL_STR("\"}"));
+  return 0;
+}
+
+el_val_t audit_str_at(el_val_t s, el_val_t start, el_val_t maxlen) {
+  el_val_t n = str_len(s);
+  if ((start < 0) || (start >= n)) {
+    return EL_STR("");
+  }
+  el_val_t end_guess = (start + maxlen);
+  el_val_t stop = ({ el_val_t _if_result_655 = 0; if ((end_guess > n)) { _if_result_655 = (n); } else { _if_result_655 = (end_guess); } _if_result_655; });
+  el_val_t win = str_slice(s, start, stop);
+  el_val_t q = str_index_of(win, EL_STR("\""));
+  if (q < 0) {
+    return EL_STR("");
+  }
+  return str_slice(win, 0, q);
+  return 0;
+}
+
+el_val_t audit_rel_count(el_val_t edges, el_val_t rel) {
+  return str_count(edges, el_str_concat(el_str_concat(EL_STR("\"relation\":\""), rel), EL_STR("\"")));
+  return 0;
+}
+
+el_val_t audit_owner_stats(el_val_t url) {
+  if (str_eq(url, EL_STR(""))) {
+    return EL_STR("");
+  }
+  return http_get(el_str_concat(url, EL_STR("/api/stats")));
+  return 0;
+}
+
+el_val_t audit_divergence(void) {
+  el_val_t rt_nodes = engram_node_count();
+  el_val_t rt_edges = engram_edge_count();
+  el_val_t url = wt_engram_url();
+  if (str_eq(url, EL_STR(""))) {
+    return audit_finding(EL_STR("owner_runtime_divergence"), el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("\"runtime_nodes\":"), int_to_str(rt_nodes)), EL_STR(",\"runtime_edges\":")), int_to_str(rt_edges)), EL_STR(",\"owner\":\"none\",\"owner_reachable\":false")), el_str_concat(el_str_concat(el_str_concat(EL_STR("No HTTP persistence owner is configured, so this soul IS the owner "), EL_STR("(file mode) and divergence is not defined. This check only has ")), EL_STR("meaning when ENGRAM_URL points at a separate engram that owns the ")), EL_STR("canonical store.")));
+  }
+  el_val_t stats = audit_owner_stats(url);
+  el_val_t owner_nc_raw = json_get_raw(stats, EL_STR("node_count"));
+  if (str_eq(stats, EL_STR("")) || str_eq(owner_nc_raw, EL_STR(""))) {
+    return audit_finding(EL_STR("owner_runtime_divergence"), 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("\"runtime_nodes\":"), int_to_str(rt_nodes)), EL_STR(",\"runtime_edges\":")), int_to_str(rt_edges)), EL_STR(",\"owner\":\"")), api_json_escape(url)), EL_STR("\",\"owner_reachable\":false")), EL_STR(",\"owner_reply\":\"")), api_json_escape(api_utf8_trunc(stats, 200))), EL_STR("\"")), 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("The persistence owner at "), url), EL_STR(" did not return a node_count ")), EL_STR("from GET /api/stats. Divergence is UNKNOWN, NOT ZERO \xe2\x80\x94 an owner ")), EL_STR("that cannot be read is exactly the condition under which the ")), EL_STR("runtime's own count means least, and reporting 0 for the owner ")), EL_STR("would manufacture a total-loss reading out of a network error. ")), EL_STR("Reported as a finding rather than raised as an error so the rest ")), EL_STR("of the audit still returns; the owner's raw reply is in ")), EL_STR("owner_reply.")));
+  }
+  el_val_t ow_nodes = json_get_int(stats, EL_STR("node_count"));
+  el_val_t ow_edges = json_get_int(stats, EL_STR("edge_count"));
+  el_val_t d_nodes = (rt_nodes - ow_nodes);
+  el_val_t d_edges = (rt_edges - ow_edges);
+  el_val_t prev_raw = state_get(EL_STR("audit_prev_node_delta"));
+  el_val_t prev = str_to_int(prev_raw);
+  el_val_t abs_now = ({ el_val_t _if_result_656 = 0; if ((d_nodes < 0)) { _if_result_656 = ((0 - d_nodes)); } else { _if_result_656 = (d_nodes); } _if_result_656; });
+  el_val_t abs_prev = ({ el_val_t _if_result_657 = 0; if ((prev < 0)) { _if_result_657 = ((0 - prev)); } else { _if_result_657 = (prev); } _if_result_657; });
+  el_val_t trend = ({ el_val_t _if_result_658 = 0; if (str_eq(prev_raw, EL_STR(""))) { _if_result_658 = (EL_STR("no_prior_audit")); } else { _if_result_658 = (({ el_val_t _if_result_659 = 0; if ((abs_now > abs_prev)) { _if_result_659 = (EL_STR("growing")); } else { _if_result_659 = (({ el_val_t _if_result_660 = 0; if ((abs_now < abs_prev)) { _if_result_660 = (EL_STR("shrinking")); } else { _if_result_660 = (EL_STR("flat")); } _if_result_660; })); } _if_result_659; })); } _if_result_658; });
+  state_set(EL_STR("audit_prev_node_delta"), int_to_str(d_nodes));
+  state_set(EL_STR("audit_prev_ts"), int_to_str(time_now()));
+  el_val_t note_head = ({ el_val_t _if_result_661 = 0; if ((d_nodes == 0)) { _if_result_661 = (EL_STR("Runtime and owner agree on node count.")); } else { _if_result_661 = (el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("Runtime holds "), int_to_str(d_nodes)), EL_STR(" nodes (")), audit_pct1(d_nodes, rt_nodes)), EL_STR("% of its own graph) that the persistence owner does not report. Nodes ")), EL_STR("that exist only in runtime memory do not survive a restart."))); } _if_result_661; });
+  return audit_finding(EL_STR("owner_runtime_divergence"), 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_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_concat(EL_STR("\"runtime_nodes\":"), int_to_str(rt_nodes)), EL_STR(",\"runtime_edges\":")), int_to_str(rt_edges)), EL_STR(",\"owner\":\"")), api_json_escape(url)), EL_STR("\",\"owner_reachable\":true")), EL_STR(",\"owner_nodes\":")), int_to_str(ow_nodes)), EL_STR(",\"owner_edges\":")), int_to_str(ow_edges)), EL_STR(",\"node_delta\":")), int_to_str(d_nodes)), EL_STR(",\"edge_delta\":")), int_to_str(d_edges)), EL_STR(",\"node_delta_pct_of_runtime\":")), audit_pct1(d_nodes, rt_nodes)), EL_STR(",\"trend_vs_previous_audit\":\"")), trend), EL_STR("\"")), EL_STR(",\"previous_node_delta\":")), ({ el_val_t _if_result_662 = 0; if (str_eq(prev_raw, EL_STR(""))) { _if_result_662 = (EL_STR("null")); } else { _if_result_662 = (int_to_str(prev)); } _if_result_662; })), el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(note_head, EL_STR(" Trend against the previous audit recorded in this soul's ")), EL_STR("state: ")), trend), EL_STR(". This is the comparison whose absence let a ")), EL_STR("~24,000-node loss run for weeks with every boot reporting green.")));
+  return 0;
+}
+
+el_val_t audit_edge_typing(el_val_t edges, el_val_t total_edges, el_val_t node_total) {
+  el_val_t c_sup = audit_rel_count(edges, EL_STR("Supersedes"));
+  el_val_t c_cau = audit_rel_count(edges, EL_STR("Causes"));
+  el_val_t c_con = audit_rel_count(edges, EL_STR("Contains"));
+  el_val_t c_ref = audit_rel_count(edges, EL_STR("References"));
+  el_val_t c_ctr = audit_rel_count(edges, EL_STR("Contradicts"));
+  el_val_t c_exe = audit_rel_count(edges, EL_STR("Exemplifies"));
+  el_val_t c_act = audit_rel_count(edges, EL_STR("Activates"));
+  el_val_t c_tmp = audit_rel_count(edges, EL_STR("TemporallyPrecedes"));
+  el_val_t typed = (((((((c_sup + c_cau) + c_con) + c_ref) + c_ctr) + c_exe) + c_act) + c_tmp);
+  el_val_t l_sup = audit_rel_count(edges, EL_STR("supersedes"));
+  el_val_t l_cau = audit_rel_count(edges, EL_STR("causes"));
+  el_val_t l_con = audit_rel_count(edges, EL_STR("contains"));
+  el_val_t l_ref = audit_rel_count(edges, EL_STR("references"));
+  el_val_t l_ctr = audit_rel_count(edges, EL_STR("contradicts"));
+  el_val_t l_exe = audit_rel_count(edges, EL_STR("exemplifies"));
+  el_val_t l_act = audit_rel_count(edges, EL_STR("activates"));
+  el_val_t l_tmp = audit_rel_count(edges, EL_STR("temporallyPrecedes"));
+  el_val_t near = (((((((l_sup + l_cau) + l_con) + l_ref) + l_ctr) + l_exe) + l_act) + l_tmp);
+  el_val_t untyped = (total_edges - typed);
+  return audit_finding(EL_STR("typed_edge_distribution"), 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_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_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_concat(EL_STR("\"total_edges\":"), int_to_str(total_edges)), EL_STR(",\"total_nodes\":")), int_to_str(node_total)), EL_STR(",\"edges_per_100_nodes\":")), audit_pct1(total_edges, node_total)), EL_STR(",\"claim10_typed\":")), int_to_str(typed)), EL_STR(",\"claim10_typed_pct\":")), audit_pct1(typed, total_edges)), EL_STR(",\"outside_claim10_vocabulary\":")), int_to_str(untyped)), EL_STR(",\"lowercase_near_miss\":")), int_to_str(near)), EL_STR(",\"by_relation\":{")), EL_STR("\"Supersedes\":")), int_to_str(c_sup)), EL_STR(",\"Causes\":")), int_to_str(c_cau)), EL_STR(",\"Contains\":")), int_to_str(c_con)), EL_STR(",\"References\":")), int_to_str(c_ref)), EL_STR(",\"Contradicts\":")), int_to_str(c_ctr)), EL_STR(",\"Exemplifies\":")), int_to_str(c_exe)), EL_STR(",\"Activates\":")), int_to_str(c_act)), EL_STR(",\"TemporallyPrecedes\":")), int_to_str(c_tmp)), EL_STR("}")), 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_concat(EL_STR("Only "), int_to_str(typed)), EL_STR(" of ")), int_to_str(total_edges)), EL_STR(" edges use the claim-10 causal vocabulary; the remainder are ad-hoc ")), EL_STR("relation strings, which is why the graph's causal claims cannot yet ")), EL_STR("be checked for internal consistency \xe2\x80\x94 an untyped edge asserts ")), EL_STR("association, not causation. ")), int_to_str(near)), EL_STR(" edges use a ")), EL_STR("lowercase spelling of a claim-10 relation: those are near-misses the ")), EL_STR("write paths could be corrected to emit, not genuinely foreign types.")));
+  return 0;
+}
+
+el_val_t audit_orphans_dangling(el_val_t edges, el_val_t total_edges, el_val_t node_total, el_val_t edge_cap, el_val_t node_cap) {
+  el_val_t n_take = ({ el_val_t _if_result_663 = 0; if ((node_total < node_cap)) { _if_result_663 = (node_total); } else { _if_result_663 = (node_cap); } _if_result_663; });
+  el_val_t n_stride = ({ el_val_t _if_result_664 = 0; if ((n_take > 0)) { _if_result_664 = ((node_total / n_take)); } else { _if_result_664 = (1); } _if_result_664; });
+  n_stride = ({ el_val_t _if_result_665 = 0; if ((n_stride < 1)) { _if_result_665 = (1); } else { _if_result_665 = (n_stride); } _if_result_665; });
+  el_val_t orphans = 0;
+  el_val_t n_checked = 0;
+  el_val_t j = 0;
+  while (j < n_take) {
+    el_val_t one = engram_scan_nodes_json(1, (j * n_stride));
+    el_val_t nid = json_get(json_array_get(one, 0), EL_STR("id"));
+    if (!str_eq(nid, EL_STR(""))) {
+      el_val_t nbrs = engram_neighbors_json(nid, 1, EL_STR("both"));
+      el_val_t deg = json_array_len(nbrs);
+      orphans = ({ el_val_t _if_result_666 = 0; if ((deg == 0)) { _if_result_666 = ((orphans + 1)); } else { _if_result_666 = (orphans); } _if_result_666; });
+      n_checked = (n_checked + 1);
+    }
+    j = (j + 1);
+  }
+  el_val_t from_pos = str_index_of_all(edges, EL_STR("\"from_id\":\""));
+  el_val_t to_pos = str_index_of_all(edges, EL_STR("\"to_id\":\""));
+  el_val_t nf = len(from_pos);
+  el_val_t nt = len(to_pos);
+  el_val_t ne = ({ el_val_t _if_result_667 = 0; if ((nf < nt)) { _if_result_667 = (nf); } else { _if_result_667 = (nt); } _if_result_667; });
+  el_val_t e_take = ({ el_val_t _if_result_668 = 0; if ((ne < edge_cap)) { _if_result_668 = (ne); } else { _if_result_668 = (edge_cap); } _if_result_668; });
+  el_val_t e_stride = ({ el_val_t _if_result_669 = 0; if ((e_take > 0)) { _if_result_669 = ((ne / e_take)); } else { _if_result_669 = (1); } _if_result_669; });
+  e_stride = ({ el_val_t _if_result_670 = 0; if ((e_stride < 1)) { _if_result_670 = (1); } else { _if_result_670 = (e_stride); } _if_result_670; });
+  el_val_t dangling = 0;
+  el_val_t e_checked = 0;
+  el_val_t i = 0;
+  while ((i < ne) && (e_checked < e_take)) {
+    el_val_t fid = audit_str_at(edges, (get(from_pos, i) + 11), 96);
+    el_val_t tid = audit_str_at(edges, (get(to_pos, i) + 9), 96);
+    el_val_t f_gone = str_eq(engram_get_node_json(fid), EL_STR("{}"));
+    el_val_t t_gone = ({ el_val_t _if_result_671 = 0; if (f_gone) { _if_result_671 = (1); } else { _if_result_671 = (str_eq(engram_get_node_json(tid), EL_STR("{}"))); } _if_result_671; });
+    dangling = ({ el_val_t _if_result_672 = 0; if ((f_gone || t_gone)) { _if_result_672 = ((dangling + 1)); } else { _if_result_672 = (dangling); } _if_result_672; });
+    e_checked = (e_checked + 1);
+    i = (i + e_stride);
+  }
+  el_val_t orphan_est = ({ el_val_t _if_result_673 = 0; if ((n_checked > 0)) { _if_result_673 = (((orphans * node_total) / n_checked)); } else { _if_result_673 = (0); } _if_result_673; });
+  el_val_t dangle_est = ({ el_val_t _if_result_674 = 0; if ((e_checked > 0)) { _if_result_674 = (((dangling * total_edges) / e_checked)); } else { _if_result_674 = (0); } _if_result_674; });
+  el_val_t exhaustive_n = ({ el_val_t _if_result_675 = 0; if ((n_checked >= node_total)) { _if_result_675 = (EL_STR("true")); } else { _if_result_675 = (EL_STR("false")); } _if_result_675; });
+  el_val_t exhaustive_e = ({ el_val_t _if_result_676 = 0; if ((e_checked >= ne)) { _if_result_676 = (EL_STR("true")); } else { _if_result_676 = (EL_STR("false")); } _if_result_676; });
+  return audit_finding(EL_STR("orphans_and_dangling_edges"), 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_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_concat(el_str_concat(el_str_concat(EL_STR("\"nodes_population\":"), int_to_str(node_total)), EL_STR(",\"nodes_sampled\":")), int_to_str(n_checked)), EL_STR(",\"nodes_sample_exhaustive\":")), exhaustive_n), EL_STR(",\"orphans_in_sample\":")), int_to_str(orphans)), EL_STR(",\"orphan_rate_pct\":")), audit_pct1(orphans, n_checked)), EL_STR(",\"orphans_extrapolated\":")), int_to_str(orphan_est)), EL_STR(",\"edges_population\":")), int_to_str(total_edges)), EL_STR(",\"edges_sampled\":")), int_to_str(e_checked)), EL_STR(",\"edges_sample_exhaustive\":")), exhaustive_e), EL_STR(",\"dangling_in_sample\":")), int_to_str(dangling)), EL_STR(",\"dangling_rate_pct\":")), audit_pct1(dangling, e_checked)), EL_STR(",\"dangling_extrapolated\":")), int_to_str(dangle_est)), 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("Orphan = zero RESOLVABLE edges, so a node whose only edges dangle counts "), EL_STR("as an orphan; either way it is unreachable by traversal. Dangling = an ")), EL_STR("edge with an endpoint id that resolves to no node. Both are uniform ")), EL_STR("stride samples over the whole population, not the head of the list; ")), EL_STR("the extrapolations are estimates and are labelled as such. Pass ")), EL_STR("?node_sample= / ?edge_sample= at or above the population size to run ")), EL_STR("either check exhaustively. A high orphan rate is a characterization, ")), EL_STR("not a verdict: an accumulating store legitimately holds unlinked ")), EL_STR("material. It becomes a defect when the write paths were SUPPOSED to ")), EL_STR("link and did not.")));
+  return 0;
+}
+
+el_val_t audit_pillar(el_val_t key, el_val_t id) {
+  el_val_t node = engram_get_node_json(id);
+  el_val_t present = (!str_eq(node, EL_STR("{}")) && !str_eq(node, EL_STR("")));
+  if (!present) {
+    return el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("\""), key), EL_STR("\":{\"id\":\"")), id), EL_STR("\",\"present\":false")), EL_STR(",\"content_length\":0,\"degree\":0}"));
+  }
+  el_val_t content = json_get(node, EL_STR("content"));
+  el_val_t deg = json_array_len(engram_neighbors_json(id, 1, EL_STR("both")));
+  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_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("\""), key), EL_STR("\":{\"id\":\"")), id), EL_STR("\",\"present\":true")), EL_STR(",\"label\":\"")), api_json_escape(json_get(node, EL_STR("label")))), EL_STR("\"")), EL_STR(",\"tier\":\"")), api_json_escape(json_get(node, EL_STR("tier")))), EL_STR("\"")), EL_STR(",\"content_length\":")), int_to_str(str_len(content))), EL_STR(",\"degree\":")), int_to_str(deg)), EL_STR("}"));
+  return 0;
+}
+
+el_val_t audit_self_model(void) {
+  el_val_t dna = audit_pillar(EL_STR("intellectual_dna"), EL_STR("kn-5adecd7e-d6db-4576-87fe-6ef8a935cea6"));
+  el_val_t val = audit_pillar(EL_STR("values_hub"), EL_STR("kn-5b606390-a52d-4ca2-8e0e-eba141d13440"));
+  el_val_t phi = audit_pillar(EL_STR("memory_philosophy"), EL_STR("kn-dcfe04b3-3702-4cac-b6f0-ecb4db837eee"));
+  el_val_t root = audit_pillar(EL_STR("self_root"), EL_STR("kn-efeb4a5b-5aff-4759-8a97-7233099be6ee"));
+  return audit_finding(EL_STR("self_model_connectivity"), 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("\"pillars\":{"), dna), EL_STR(",")), val), EL_STR(",")), phi), EL_STR(",")), root), EL_STR("}")), el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("The three identity pillars plus the self root. `degree` counts nodes "), EL_STR("reachable in one hop in either direction \xe2\x80\x94 the self-model's connection ")), EL_STR("to the rest of the graph. present:false on any pillar is the condition ")), EL_STR("that ran undetected for weeks; content_length distinguishes a pillar ")), EL_STR("that is present from one that is present but hollowed out. The patent ")), EL_STR("also asks whether the self-model makes ACCURATE PREDICTIONS about the ")), EL_STR("system's own behavior; that half needs Prediction nodes and is deferred ")), EL_STR("with the rest of stage 1b below.")));
+  return 0;
+}
+
+el_val_t audit_deferred(void) {
+  el_val_t preds = json_array_len(api_or_empty(engram_scan_nodes_by_type_json(EL_STR("Prediction"), 50, 0)));
+  el_val_t wonders = json_array_len(api_or_empty(engram_scan_nodes_by_type_json(EL_STR("WonderQuestion"), 50, 0)));
+  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_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("[{\"deferred\":\"value_execution_record_consistency\""), EL_STR(",\"stage\":\"1b\"")), EL_STR(",\"measured\":{\"prediction_nodes_found\":")), int_to_str(preds)), EL_STR("}")), EL_STR(",\"reason\":\"")), api_json_escape(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("The patent asks whether the execution history SUPPORTS the stated "), EL_STR("values or shows systematic conflict. That requires execution ")), EL_STR("records tied to value nodes and predictions to score them against. ")), EL_STR("Prediction nodes found (capped at 50): ")), int_to_str(preds)), EL_STR(". Asserting value/execution coherence on that population would be ")), EL_STR("a fabricated result, which is worse than a stated gap.")))), EL_STR("\"}")), EL_STR(",{\"deferred\":\"wonder_manifest_authenticity\"")), EL_STR(",\"stage\":\"1b\"")), EL_STR(",\"measured\":{\"wonder_question_nodes_found\":")), int_to_str(wonders)), EL_STR("}")), EL_STR(",\"reason\":\"")), api_json_escape(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("The patent asks whether pull weights CORRELATE WITH GENUINE "), EL_STR("PREDICTION UNCERTAINTY or are uniform/externally assigned \xe2\x80\x94 a ")), EL_STR("correlation between two populations. WonderQuestion nodes readable ")), EL_STR("by type (capped at 50): ")), int_to_str(wonders)), EL_STR(", against ")), int_to_str(preds)), EL_STR(" Prediction nodes. There is a known write/read ")), EL_STR("node-type mismatch on the wonder path; until that is fixed and both ")), EL_STR("populations exist, any correlation reported here would be noise.")))), EL_STR("\"}]"));
+  return 0;
+}
+
+el_val_t handle_api_structural_audit(el_val_t method, el_val_t path, el_val_t body) {
+  el_val_t node_total = engram_node_count();
+  el_val_t edge_total = engram_edge_count();
+  el_val_t want_edges = !str_eq(api_query_param(path, EL_STR("edges")), EL_STR("0"));
+  el_val_t edge_cap = api_query_int(path, EL_STR("edge_sample"), 3000);
+  el_val_t node_cap = api_query_int(path, EL_STR("node_sample"), 300);
+  el_val_t divergence = audit_divergence();
+  el_val_t self_model = audit_self_model();
+  el_val_t edge_part = ({ el_val_t _if_result_677 = 0; if (want_edges) { el_val_t scratch_dir = env(EL_STR("TMPDIR")); el_val_t scratch_base = ({ el_val_t _if_result_678 = 0; if (str_eq(scratch_dir, EL_STR(""))) { _if_result_678 = (EL_STR("/tmp")); } else { _if_result_678 = (scratch_dir); } _if_result_678; }); el_val_t snap_path = el_str_concat(el_str_concat(el_str_concat(scratch_base, EL_STR("/soul-audit-export-")), state_get(EL_STR("soul_cgi_id"))), EL_STR(".json")); el_val_t saved = engram_save(snap_path); _if_result_677 = (({ el_val_t _if_result_679 = 0; if ((saved == 0)) { _if_result_679 = (el_str_concat(EL_STR(","), audit_finding(EL_STR("typed_edge_distribution"), EL_STR("\"available\":false"), el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("Could not export the graph to "), snap_path), EL_STR(" for edge analysis, ")), EL_STR("so edge typing and the dangling-edge sample were not run. ")), EL_STR("Reported as a gap, not as zero findings."))))); } else { el_val_t snap = wt_read(snap_path); el_val_t edges_raw = json_get_raw(snap, EL_STR("edges")); el_val_t edges = ({ el_val_t _if_result_680 = 0; if (str_eq(edges_raw, EL_STR(""))) { _if_result_680 = (EL_STR("[]")); } else { _if_result_680 = (edges_raw); } _if_result_680; }); _if_result_679 = (el_str_concat(el_str_concat(el_str_concat(EL_STR(","), audit_edge_typing(edges, edge_total, node_total)), EL_STR(",")), audit_orphans_dangling(edges, edge_total, node_total, edge_cap, node_cap))); } _if_result_679; })); } else { _if_result_677 = (EL_STR("")); } _if_result_677; });
+  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_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("{\"audit\":\"structural\",\"stage\":1"), EL_STR(",\"spec\":\"CGI provisional 05-detailed-description.md, Stage 1: Structural audit 430\"")), EL_STR(",\"assessment\":\"coherence_assessment_432\"")), EL_STR(",\"assessment_kind\":\"annotated_characterization\"")), EL_STR(",\"score\":null")), EL_STR(",\"score_note\":\"By design. The specification calls for an annotated characterization of the graph's structural properties, not a binary score. Read the findings.\"")), EL_STR(",\"cgi_id\":\"")), api_json_escape(state_get(EL_STR("soul_cgi_id")))), EL_STR("\"")), EL_STR(",\"ts_ms\":")), int_to_str(time_now())), EL_STR(",\"findings\":[")), divergence), EL_STR(",")), self_model), edge_part), EL_STR("]")), EL_STR(",\"deferred\":")), audit_deferred()), EL_STR("}"));
+  return 0;
+}
+
 el_val_t session_title_from_message(el_val_t message) {
   if (str_eq(message, EL_STR(""))) {
     return EL_STR("New conversation");
@@ -30363,7 +30564,7 @@ el_val_t session_exists(el_val_t session_id) {
     el_val_t content = json_get(node, EL_STR("content"));
     el_val_t sid = json_get(content, EL_STR("id"));
     el_val_t is_match = (str_eq(label, EL_STR("session:meta")) && str_eq(sid, session_id));
-    found = ({ el_val_t _if_result_653 = 0; if (is_match) { _if_result_653 = (1); } else { _if_result_653 = (found); } _if_result_653; });
+    found = ({ el_val_t _if_result_681 = 0; if (is_match) { _if_result_681 = (1); } else { _if_result_681 = (found); } _if_result_681; });
     i = (i + 1);
   }
   return found;
@@ -30374,7 +30575,7 @@ el_val_t session_create(el_val_t body) {
   el_val_t ts = time_now();
   el_val_t id = uuid_v4();
   el_val_t title_req = json_get(body, EL_STR("title"));
-  el_val_t title = ({ el_val_t _if_result_654 = 0; if (str_eq(title_req, EL_STR(""))) { _if_result_654 = (EL_STR("New conversation")); } else { _if_result_654 = (title_req); } _if_result_654; });
+  el_val_t title = ({ el_val_t _if_result_682 = 0; if (str_eq(title_req, EL_STR(""))) { _if_result_682 = (EL_STR("New conversation")); } else { _if_result_682 = (title_req); } _if_result_682; });
   el_val_t folder = json_get(body, EL_STR("folder"));
   el_val_t content = session_make_content(id, title, ts, ts, folder);
   el_val_t tags = EL_STR("[\"session\",\"session:meta\",\"Conversation\"]");
@@ -30386,7 +30587,7 @@ el_val_t session_create(el_val_t body) {
   state_set(el_str_concat(EL_STR("session_pending_first_msg_"), id), EL_STR("1"));
   el_val_t existing_idx = state_get(EL_STR("session_index"));
   el_val_t idx_entry = 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("{\"id\":\""), id), EL_STR("\",\"title\":\"")), json_safe(title)), EL_STR("\",\"folder\":\"")), json_safe(folder)), EL_STR("\",\"created_at\":")), int_to_str(ts)), EL_STR(",\"updated_at\":")), int_to_str(ts)), EL_STR(",\"last_message\":\"\"}"));
-  el_val_t new_idx = ({ el_val_t _if_result_655 = 0; if (str_eq(existing_idx, EL_STR(""))) { _if_result_655 = (el_str_concat(el_str_concat(EL_STR("["), idx_entry), EL_STR("]"))); } else { el_val_t inner = str_slice(existing_idx, 1, (str_len(existing_idx) - 1)); _if_result_655 = (el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("["), idx_entry), EL_STR(",")), inner), EL_STR("]"))); } _if_result_655; });
+  el_val_t new_idx = ({ el_val_t _if_result_683 = 0; if (str_eq(existing_idx, EL_STR(""))) { _if_result_683 = (el_str_concat(el_str_concat(EL_STR("["), idx_entry), EL_STR("]"))); } else { el_val_t inner = str_slice(existing_idx, 1, (str_len(existing_idx) - 1)); _if_result_683 = (el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("["), idx_entry), EL_STR(",")), inner), EL_STR("]"))); } _if_result_683; });
   state_set(EL_STR("session_index"), new_idx);
   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_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"id\":\""), id), EL_STR("\"")), EL_STR(",\"title\":\"")), json_safe(title)), EL_STR("\"")), EL_STR(",\"folder\":\"")), json_safe(folder)), EL_STR("\"")), EL_STR(",\"node_id\":\"")), node_id), EL_STR("\"")), EL_STR(",\"created_at\":")), int_to_str(ts)), EL_STR("}"));
   return 0;
@@ -30423,16 +30624,16 @@ el_val_t session_list(void) {
     el_val_t is_session = (str_eq(label, EL_STR("session:meta")) && str_eq(node_type, EL_STR("Conversation")));
     el_val_t content = json_get(node, EL_STR("content"));
     el_val_t sess_id = json_get(content, EL_STR("id"));
-    el_val_t eff_id = ({ el_val_t _if_result_656 = 0; if (str_eq(sess_id, EL_STR(""))) { _if_result_656 = (json_get(node, EL_STR("id"))); } else { _if_result_656 = (sess_id); } _if_result_656; });
+    el_val_t eff_id = ({ el_val_t _if_result_684 = 0; if (str_eq(sess_id, EL_STR(""))) { _if_result_684 = (json_get(node, EL_STR("id"))); } else { _if_result_684 = (sess_id); } _if_result_684; });
     el_val_t title_inner = json_get(content, EL_STR("title"));
-    el_val_t eff_title = ({ el_val_t _if_result_657 = 0; if (str_eq(title_inner, EL_STR(""))) { _if_result_657 = (EL_STR("New conversation")); } else { _if_result_657 = (title_inner); } _if_result_657; });
+    el_val_t eff_title = ({ el_val_t _if_result_685 = 0; if (str_eq(title_inner, EL_STR(""))) { _if_result_685 = (EL_STR("New conversation")); } else { _if_result_685 = (title_inner); } _if_result_685; });
     el_val_t folder_inner = json_get(content, EL_STR("folder"));
     el_val_t created_inner = json_get(content, EL_STR("created_at"));
     el_val_t updated_inner = json_get(content, EL_STR("updated_at"));
-    el_val_t eff_created = ({ el_val_t _if_result_658 = 0; if (str_eq(created_inner, EL_STR(""))) { _if_result_658 = (EL_STR("0")); } else { _if_result_658 = (created_inner); } _if_result_658; });
-    el_val_t eff_updated = ({ el_val_t _if_result_659 = 0; if (str_eq(updated_inner, EL_STR(""))) { _if_result_659 = (eff_created); } else { _if_result_659 = (updated_inner); } _if_result_659; });
-    el_val_t entry = ({ el_val_t _if_result_660 = 0; if (is_session) { _if_result_660 = (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_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"id\":\""), json_safe(eff_id)), EL_STR("\"")), EL_STR(",\"title\":\"")), json_safe(eff_title)), EL_STR("\"")), EL_STR(",\"folder\":\"")), json_safe(folder_inner)), EL_STR("\"")), EL_STR(",\"last_message\":\"\"")), EL_STR(",\"created_at\":")), eff_created), EL_STR(",\"updated_at\":")), eff_updated), EL_STR("}"))); } else { _if_result_660 = (EL_STR("")); } _if_result_660; });
-    out = ({ el_val_t _if_result_661 = 0; if (!str_eq(entry, EL_STR(""))) { _if_result_661 = (({ el_val_t _if_result_662 = 0; if (str_eq(out, EL_STR(""))) { _if_result_662 = (entry); } else { _if_result_662 = (el_str_concat(el_str_concat(out, EL_STR(",")), entry)); } _if_result_662; })); } else { _if_result_661 = (out); } _if_result_661; });
+    el_val_t eff_created = ({ el_val_t _if_result_686 = 0; if (str_eq(created_inner, EL_STR(""))) { _if_result_686 = (EL_STR("0")); } else { _if_result_686 = (created_inner); } _if_result_686; });
+    el_val_t eff_updated = ({ el_val_t _if_result_687 = 0; if (str_eq(updated_inner, EL_STR(""))) { _if_result_687 = (eff_created); } else { _if_result_687 = (updated_inner); } _if_result_687; });
+    el_val_t entry = ({ el_val_t _if_result_688 = 0; if (is_session) { _if_result_688 = (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_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"id\":\""), json_safe(eff_id)), EL_STR("\"")), EL_STR(",\"title\":\"")), json_safe(eff_title)), EL_STR("\"")), EL_STR(",\"folder\":\"")), json_safe(folder_inner)), EL_STR("\"")), EL_STR(",\"last_message\":\"\"")), EL_STR(",\"created_at\":")), eff_created), EL_STR(",\"updated_at\":")), eff_updated), EL_STR("}"))); } else { _if_result_688 = (EL_STR("")); } _if_result_688; });
+    out = ({ el_val_t _if_result_689 = 0; if (!str_eq(entry, EL_STR(""))) { _if_result_689 = (({ el_val_t _if_result_690 = 0; if (str_eq(out, EL_STR(""))) { _if_result_690 = (entry); } else { _if_result_690 = (el_str_concat(el_str_concat(out, EL_STR(",")), entry)); } _if_result_690; })); } else { _if_result_689 = (out); } _if_result_689; });
     i = (i + 1);
   }
   return el_str_concat(el_str_concat(EL_STR("["), out), EL_STR("]"));
@@ -30450,7 +30651,7 @@ el_val_t session_get(el_val_t session_id) {
   el_val_t meta_created = EL_STR("0");
   el_val_t meta_updated = EL_STR("0");
   el_val_t found = 0;
-  el_val_t total = ({ el_val_t _if_result_663 = 0; if (str_eq(results, EL_STR(""))) { _if_result_663 = (0); } else { _if_result_663 = (json_array_len(results)); } _if_result_663; });
+  el_val_t total = ({ el_val_t _if_result_691 = 0; if (str_eq(results, EL_STR(""))) { _if_result_691 = (0); } else { _if_result_691 = (json_array_len(results)); } _if_result_691; });
   el_val_t i = 0;
   while (i < total) {
     el_val_t node = json_array_get(results, i);
@@ -30458,17 +30659,17 @@ el_val_t session_get(el_val_t session_id) {
     el_val_t content = json_get(node, EL_STR("content"));
     el_val_t sid = json_get(content, EL_STR("id"));
     el_val_t is_match = ((str_eq(label, EL_STR("session:meta")) && str_eq(sid, session_id)) && !found);
-    found = ({ el_val_t _if_result_664 = 0; if (is_match) { _if_result_664 = (1); } else { _if_result_664 = (found); } _if_result_664; });
-    meta_title = ({ el_val_t _if_result_665 = 0; if (is_match) { _if_result_665 = (json_get(content, EL_STR("title"))); } else { _if_result_665 = (meta_title); } _if_result_665; });
-    meta_folder = ({ el_val_t _if_result_666 = 0; if (is_match) { _if_result_666 = (json_get(content, EL_STR("folder"))); } else { _if_result_666 = (meta_folder); } _if_result_666; });
+    found = ({ el_val_t _if_result_692 = 0; if (is_match) { _if_result_692 = (1); } else { _if_result_692 = (found); } _if_result_692; });
+    meta_title = ({ el_val_t _if_result_693 = 0; if (is_match) { _if_result_693 = (json_get(content, EL_STR("title"))); } else { _if_result_693 = (meta_title); } _if_result_693; });
+    meta_folder = ({ el_val_t _if_result_694 = 0; if (is_match) { _if_result_694 = (json_get(content, EL_STR("folder"))); } else { _if_result_694 = (meta_folder); } _if_result_694; });
     el_val_t meta_created_raw = json_get(content, EL_STR("created_at"));
-    meta_created = ({ el_val_t _if_result_667 = 0; if ((is_match && !str_eq(meta_created_raw, EL_STR("")))) { _if_result_667 = (meta_created_raw); } else { _if_result_667 = (meta_created); } _if_result_667; });
+    meta_created = ({ el_val_t _if_result_695 = 0; if ((is_match && !str_eq(meta_created_raw, EL_STR("")))) { _if_result_695 = (meta_created_raw); } else { _if_result_695 = (meta_created); } _if_result_695; });
     el_val_t meta_updated_raw = json_get(content, EL_STR("updated_at"));
-    meta_updated = ({ el_val_t _if_result_668 = 0; if ((is_match && !str_eq(meta_updated_raw, EL_STR("")))) { _if_result_668 = (meta_updated_raw); } else { _if_result_668 = (meta_updated); } _if_result_668; });
+    meta_updated = ({ el_val_t _if_result_696 = 0; if ((is_match && !str_eq(meta_updated_raw, EL_STR("")))) { _if_result_696 = (meta_updated_raw); } else { _if_result_696 = (meta_updated); } _if_result_696; });
     i = (i + 1);
   }
   el_val_t state_hist = state_get(el_str_concat(EL_STR("session_hist_"), session_id));
-  el_val_t hist_raw = ({ el_val_t _if_result_669 = 0; if (str_eq(state_hist, EL_STR(""))) { el_val_t engram_hist = engram_search_json(el_str_concat(EL_STR("session:messages:"), session_id), 3); _if_result_669 = (({ el_val_t _if_result_670 = 0; if (str_eq(engram_hist, EL_STR(""))) { _if_result_670 = (EL_STR("[]")); } else { _if_result_670 = (({ el_val_t _if_result_671 = 0; if (str_eq(engram_hist, EL_STR("[]"))) { _if_result_671 = (EL_STR("[]")); } else { el_val_t h_node = json_array_get(engram_hist, 0); el_val_t h_content = json_get(h_node, EL_STR("content")); _if_result_671 = (({ el_val_t _if_result_672 = 0; if (str_starts_with(h_content, EL_STR("["))) { _if_result_672 = (h_content); } else { _if_result_672 = (EL_STR("[]")); } _if_result_672; })); } _if_result_671; })); } _if_result_670; })); } else { _if_result_669 = (state_hist); } _if_result_669; });
+  el_val_t hist_raw = ({ el_val_t _if_result_697 = 0; if (str_eq(state_hist, EL_STR(""))) { el_val_t engram_hist = engram_search_json(el_str_concat(EL_STR("session:messages:"), session_id), 3); _if_result_697 = (({ el_val_t _if_result_698 = 0; if (str_eq(engram_hist, EL_STR(""))) { _if_result_698 = (EL_STR("[]")); } else { _if_result_698 = (({ el_val_t _if_result_699 = 0; if (str_eq(engram_hist, EL_STR("[]"))) { _if_result_699 = (EL_STR("[]")); } else { el_val_t h_node = json_array_get(engram_hist, 0); el_val_t h_content = json_get(h_node, EL_STR("content")); _if_result_699 = (({ el_val_t _if_result_700 = 0; if (str_starts_with(h_content, EL_STR("["))) { _if_result_700 = (h_content); } else { _if_result_700 = (EL_STR("[]")); } _if_result_700; })); } _if_result_699; })); } _if_result_698; })); } else { _if_result_697 = (state_hist); } _if_result_697; });
   el_val_t safe_title = json_safe(meta_title);
   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_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"id\":\""), session_id), EL_STR("\"")), EL_STR(",\"title\":\"")), safe_title), EL_STR("\"")), EL_STR(",\"folder\":\"")), json_safe(meta_folder)), EL_STR("\"")), EL_STR(",\"created_at\":")), meta_created), EL_STR(",\"updated_at\":")), meta_updated), EL_STR(",\"messages\":")), hist_raw), EL_STR("}"));
   return 0;
@@ -30479,7 +30680,7 @@ el_val_t session_delete(el_val_t session_id) {
     return EL_STR("{\"error\":\"session_id is required\"}");
   }
   el_val_t results = engram_search_json(el_str_concat(EL_STR("session:meta "), session_id), 10);
-  el_val_t total = ({ el_val_t _if_result_673 = 0; if (str_eq(results, EL_STR(""))) { _if_result_673 = (0); } else { _if_result_673 = (json_array_len(results)); } _if_result_673; });
+  el_val_t total = ({ el_val_t _if_result_701 = 0; if (str_eq(results, EL_STR(""))) { _if_result_701 = (0); } else { _if_result_701 = (json_array_len(results)); } _if_result_701; });
   el_val_t deleted_meta = 0;
   el_val_t i = 0;
   while (i < total) {
@@ -30489,11 +30690,11 @@ el_val_t session_delete(el_val_t session_id) {
     el_val_t sid = json_get(content, EL_STR("id"));
     el_val_t is_match = (str_eq(label, EL_STR("session:meta")) && str_eq(sid, session_id));
     el_val_t node_id = json_get(node, EL_STR("id"));
-    deleted_meta = ({ el_val_t _if_result_674 = 0; if ((is_match && !str_eq(node_id, EL_STR("")))) { (void)(engram_forget(node_id)); _if_result_674 = ((deleted_meta + 1)); } else { _if_result_674 = (deleted_meta); } _if_result_674; });
+    deleted_meta = ({ el_val_t _if_result_702 = 0; if ((is_match && !str_eq(node_id, EL_STR("")))) { (void)(engram_forget(node_id)); _if_result_702 = ((deleted_meta + 1)); } else { _if_result_702 = (deleted_meta); } _if_result_702; });
     i = (i + 1);
   }
   el_val_t msg_results = engram_search_json(el_str_concat(EL_STR("session:messages:"), session_id), 10);
-  el_val_t m_total = ({ el_val_t _if_result_675 = 0; if (str_eq(msg_results, EL_STR(""))) { _if_result_675 = (0); } else { _if_result_675 = (json_array_len(msg_results)); } _if_result_675; });
+  el_val_t m_total = ({ el_val_t _if_result_703 = 0; if (str_eq(msg_results, EL_STR(""))) { _if_result_703 = (0); } else { _if_result_703 = (json_array_len(msg_results)); } _if_result_703; });
   el_val_t deleted_msgs = 0;
   el_val_t j = 0;
   while (j < m_total) {
@@ -30501,7 +30702,7 @@ el_val_t session_delete(el_val_t session_id) {
     el_val_t label = json_get(node, EL_STR("label"));
     el_val_t is_msgs = str_eq(label, el_str_concat(EL_STR("session:messages:"), session_id));
     el_val_t node_id = json_get(node, EL_STR("id"));
-    deleted_msgs = ({ el_val_t _if_result_676 = 0; if ((is_msgs && !str_eq(node_id, EL_STR("")))) { (void)(engram_forget(node_id)); _if_result_676 = ((deleted_msgs + 1)); } else { _if_result_676 = (deleted_msgs); } _if_result_676; });
+    deleted_msgs = ({ el_val_t _if_result_704 = 0; if ((is_msgs && !str_eq(node_id, EL_STR("")))) { (void)(engram_forget(node_id)); _if_result_704 = ((deleted_msgs + 1)); } else { _if_result_704 = (deleted_msgs); } _if_result_704; });
     j = (j + 1);
   }
   state_set(el_str_concat(EL_STR("session_hist_"), session_id), EL_STR(""));
@@ -30524,7 +30725,7 @@ el_val_t session_update_patch(el_val_t session_id, el_val_t body) {
     return EL_STR("{\"error\":\"title or folder required in body\"}");
   }
   el_val_t results = engram_search_json(EL_STR("session:meta"), 50);
-  el_val_t total = ({ el_val_t _if_result_677 = 0; if (str_eq(results, EL_STR(""))) { _if_result_677 = (0); } else { _if_result_677 = (json_array_len(results)); } _if_result_677; });
+  el_val_t total = ({ el_val_t _if_result_705 = 0; if (str_eq(results, EL_STR(""))) { _if_result_705 = (0); } else { _if_result_705 = (json_array_len(results)); } _if_result_705; });
   el_val_t found = 0;
   el_val_t old_title = EL_STR("New conversation");
   el_val_t old_folder = EL_STR("");
@@ -30537,23 +30738,23 @@ el_val_t session_update_patch(el_val_t session_id, el_val_t body) {
     el_val_t content = json_get(node, EL_STR("content"));
     el_val_t sid = json_get(content, EL_STR("id"));
     el_val_t is_match = ((str_eq(label, EL_STR("session:meta")) && str_eq(sid, session_id)) && !found);
-    found = ({ el_val_t _if_result_678 = 0; if (is_match) { _if_result_678 = (1); } else { _if_result_678 = (found); } _if_result_678; });
+    found = ({ el_val_t _if_result_706 = 0; if (is_match) { _if_result_706 = (1); } else { _if_result_706 = (found); } _if_result_706; });
     el_val_t title_raw = json_get(content, EL_STR("title"));
-    old_title = ({ el_val_t _if_result_679 = 0; if ((is_match && !str_eq(title_raw, EL_STR("")))) { _if_result_679 = (title_raw); } else { _if_result_679 = (old_title); } _if_result_679; });
+    old_title = ({ el_val_t _if_result_707 = 0; if ((is_match && !str_eq(title_raw, EL_STR("")))) { _if_result_707 = (title_raw); } else { _if_result_707 = (old_title); } _if_result_707; });
     el_val_t folder_raw = json_get(content, EL_STR("folder"));
-    old_folder = ({ el_val_t _if_result_680 = 0; if (is_match) { _if_result_680 = (folder_raw); } else { _if_result_680 = (old_folder); } _if_result_680; });
+    old_folder = ({ el_val_t _if_result_708 = 0; if (is_match) { _if_result_708 = (folder_raw); } else { _if_result_708 = (old_folder); } _if_result_708; });
     el_val_t created_raw = json_get(content, EL_STR("created_at"));
-    old_created = ({ el_val_t _if_result_681 = 0; if ((is_match && !str_eq(created_raw, EL_STR("")))) { _if_result_681 = (created_raw); } else { _if_result_681 = (old_created); } _if_result_681; });
+    old_created = ({ el_val_t _if_result_709 = 0; if ((is_match && !str_eq(created_raw, EL_STR("")))) { _if_result_709 = (created_raw); } else { _if_result_709 = (old_created); } _if_result_709; });
     el_val_t nid = json_get(node, EL_STR("id"));
-    old_node_id = ({ el_val_t _if_result_682 = 0; if (is_match) { _if_result_682 = (nid); } else { _if_result_682 = (old_node_id); } _if_result_682; });
+    old_node_id = ({ el_val_t _if_result_710 = 0; if (is_match) { _if_result_710 = (nid); } else { _if_result_710 = (old_node_id); } _if_result_710; });
     i = (i + 1);
   }
   if (!found) {
     return el_str_concat(el_str_concat(EL_STR("{\"error\":\"session not found\",\"session_id\":\""), session_id), EL_STR("\"}"));
   }
   el_val_t req_title = json_get(body, EL_STR("title"));
-  el_val_t eff_title = ({ el_val_t _if_result_683 = 0; if ((has_title && !str_eq(req_title, EL_STR("")))) { _if_result_683 = (req_title); } else { _if_result_683 = (old_title); } _if_result_683; });
-  el_val_t eff_folder = ({ el_val_t _if_result_684 = 0; if (has_folder) { _if_result_684 = (json_get(body, EL_STR("folder"))); } else { _if_result_684 = (old_folder); } _if_result_684; });
+  el_val_t eff_title = ({ el_val_t _if_result_711 = 0; if ((has_title && !str_eq(req_title, EL_STR("")))) { _if_result_711 = (req_title); } else { _if_result_711 = (old_title); } _if_result_711; });
+  el_val_t eff_folder = ({ el_val_t _if_result_712 = 0; if (has_folder) { _if_result_712 = (json_get(body, EL_STR("folder"))); } else { _if_result_712 = (old_folder); } _if_result_712; });
   if (!str_eq(old_node_id, EL_STR(""))) {
     engram_forget(old_node_id);
   }
@@ -30581,8 +30782,8 @@ el_val_t session_search_entry(el_val_t node) {
   el_val_t title = json_get(content, EL_STR("title"));
   el_val_t created_raw = json_get(content, EL_STR("created_at"));
   el_val_t updated_raw = json_get(content, EL_STR("updated_at"));
-  el_val_t eff_created = ({ el_val_t _if_result_685 = 0; if (str_eq(created_raw, EL_STR(""))) { _if_result_685 = (EL_STR("0")); } else { _if_result_685 = (created_raw); } _if_result_685; });
-  el_val_t eff_updated = ({ el_val_t _if_result_686 = 0; if (str_eq(updated_raw, EL_STR(""))) { _if_result_686 = (eff_created); } else { _if_result_686 = (updated_raw); } _if_result_686; });
+  el_val_t eff_created = ({ el_val_t _if_result_713 = 0; if (str_eq(created_raw, EL_STR(""))) { _if_result_713 = (EL_STR("0")); } else { _if_result_713 = (created_raw); } _if_result_713; });
+  el_val_t eff_updated = ({ el_val_t _if_result_714 = 0; if (str_eq(updated_raw, EL_STR(""))) { _if_result_714 = (eff_created); } else { _if_result_714 = (updated_raw); } _if_result_714; });
   el_val_t e_id = el_str_concat(el_str_concat(EL_STR("{\"id\":\""), json_safe(sess_id)), EL_STR("\""));
   el_val_t e_title = el_str_concat(el_str_concat(EL_STR(",\"title\":\""), json_safe(title)), EL_STR("\""));
   el_val_t e_ts = el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR(",\"created_at\":"), eff_created), EL_STR(",\"updated_at\":")), eff_updated), EL_STR("}"));
@@ -30606,7 +30807,7 @@ el_val_t session_search(el_val_t query) {
   el_val_t i = 0;
   while (i < total) {
     el_val_t entry = session_search_entry(json_array_get(results, i));
-    out = ({ el_val_t _if_result_687 = 0; if (!str_eq(entry, EL_STR(""))) { _if_result_687 = (({ el_val_t _if_result_688 = 0; if (str_eq(out, EL_STR(""))) { _if_result_688 = (entry); } else { _if_result_688 = (el_str_concat(el_str_concat(out, EL_STR(",")), entry)); } _if_result_688; })); } else { _if_result_687 = (out); } _if_result_687; });
+    out = ({ el_val_t _if_result_715 = 0; if (!str_eq(entry, EL_STR(""))) { _if_result_715 = (({ el_val_t _if_result_716 = 0; if (str_eq(out, EL_STR(""))) { _if_result_716 = (entry); } else { _if_result_716 = (el_str_concat(el_str_concat(out, EL_STR(",")), entry)); } _if_result_716; })); } else { _if_result_715 = (out); } _if_result_715; });
     i = (i + 1);
   }
   return el_str_concat(el_str_concat(EL_STR("["), out), EL_STR("]"));
@@ -30642,7 +30843,7 @@ el_val_t session_hist_save(el_val_t session_id, el_val_t hist) {
   state_set(el_str_concat(EL_STR("session_hist_"), session_id), hist);
   state_set(el_str_concat(EL_STR("session_pending_first_msg_"), session_id), EL_STR(""));
   el_val_t old_results = engram_search_json(el_str_concat(EL_STR("session:messages:"), session_id), 3);
-  el_val_t o_total = ({ el_val_t _if_result_689 = 0; if (str_eq(old_results, EL_STR(""))) { _if_result_689 = (0); } else { _if_result_689 = (json_array_len(old_results)); } _if_result_689; });
+  el_val_t o_total = ({ el_val_t _if_result_717 = 0; if (str_eq(old_results, EL_STR(""))) { _if_result_717 = (0); } else { _if_result_717 = (json_array_len(old_results)); } _if_result_717; });
   el_val_t oi = 0;
   while (oi < o_total) {
     el_val_t node = json_array_get(old_results, oi);
@@ -30660,35 +30861,35 @@ el_val_t session_hist_save(el_val_t session_id, el_val_t hist) {
   if (str_eq(already_written, EL_STR(""))) {
     el_val_t bell_count_key = el_str_concat(EL_STR("session_bell_count:"), session_id);
     el_val_t bell_count_raw = state_get(bell_count_key);
-    el_val_t bell_count = ({ el_val_t _if_result_690 = 0; if (str_eq(bell_count_raw, EL_STR(""))) { _if_result_690 = (0); } else { _if_result_690 = (str_to_int(bell_count_raw)); } _if_result_690; });
+    el_val_t bell_count = ({ el_val_t _if_result_718 = 0; if (str_eq(bell_count_raw, EL_STR(""))) { _if_result_718 = (0); } else { _if_result_718 = (str_to_int(bell_count_raw)); } _if_result_718; });
     if (bell_count > 0) {
       el_val_t bell_level_key = el_str_concat(EL_STR("session_bell_level:"), session_id);
       el_val_t bell_signal_key = el_str_concat(EL_STR("session_bell_signal:"), session_id);
       el_val_t dominant_level = state_get(bell_level_key);
       el_val_t last_signal = state_get(bell_signal_key);
-      el_val_t eff_level = ({ el_val_t _if_result_691 = 0; if (str_eq(dominant_level, EL_STR(""))) { _if_result_691 = (EL_STR("soft")); } else { _if_result_691 = (dominant_level); } _if_result_691; });
-      el_val_t eff_signal = ({ el_val_t _if_result_692 = 0; if (str_eq(last_signal, EL_STR(""))) { _if_result_692 = (EL_STR("(no signal captured)")); } else { _if_result_692 = (last_signal); } _if_result_692; });
+      el_val_t eff_level = ({ el_val_t _if_result_719 = 0; if (str_eq(dominant_level, EL_STR(""))) { _if_result_719 = (EL_STR("soft")); } else { _if_result_719 = (dominant_level); } _if_result_719; });
+      el_val_t eff_signal = ({ el_val_t _if_result_720 = 0; if (str_eq(last_signal, EL_STR(""))) { _if_result_720 = (EL_STR("(no signal captured)")); } else { _if_result_720 = (last_signal); } _if_result_720; });
       el_val_t ts_now = time_now();
       el_val_t summary_content = 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("session:emotional-summary"), EL_STR(" | session:")), session_id), EL_STR(" | bell_count:")), int_to_str(bell_count)), EL_STR(" | dominant_level:")), eff_level), EL_STR(" | last_signal:")), eff_signal), EL_STR(" | ts:")), int_to_str(ts_now));
       el_val_t summary_tags = el_str_concat(el_str_concat(EL_STR("[\"session-emotional-summary\",\"affective\",\"bell:"), eff_level), EL_STR("\",\"BellEvent\"]"));
-      el_val_t summary_sal = ({ el_val_t _if_result_693 = 0; if (str_eq(eff_level, EL_STR("hard"))) { _if_result_693 = (el_from_float(0.95)); } else { _if_result_693 = (el_from_float(0.85)); } _if_result_693; });
+      el_val_t summary_sal = ({ el_val_t _if_result_721 = 0; if (str_eq(eff_level, EL_STR("hard"))) { _if_result_721 = (el_from_float(0.95)); } else { _if_result_721 = (el_from_float(0.85)); } _if_result_721; });
       el_val_t sum_discard = wt_node(summary_content, EL_STR("BellEvent"), EL_STR("session:emotional-summary"), summary_sal, summary_sal, el_from_float(1.0), EL_STR("Episodic"), summary_tags);
       state_set(summary_written_key, EL_STR("1"));
     }
   }
-  el_val_t hist_arr_len = ({ el_val_t _if_result_694 = 0; if (str_eq(hist, EL_STR(""))) { _if_result_694 = (0); } else { _if_result_694 = (json_array_len(hist)); } _if_result_694; });
+  el_val_t hist_arr_len = ({ el_val_t _if_result_722 = 0; if (str_eq(hist, EL_STR(""))) { _if_result_722 = (0); } else { _if_result_722 = (json_array_len(hist)); } _if_result_722; });
   if (hist_arr_len >= 2) {
     el_val_t last_entry = json_array_get(hist, (hist_arr_len - 1));
     el_val_t last_role = json_get(last_entry, EL_STR("role"));
     el_val_t last_content = json_get(last_entry, EL_STR("content"));
-    el_val_t topic_snip = ({ el_val_t _if_result_695 = 0; if ((str_len(last_content) > 200)) { _if_result_695 = (str_slice(last_content, 0, 200)); } else { _if_result_695 = (last_content); } _if_result_695; });
+    el_val_t topic_snip = ({ el_val_t _if_result_723 = 0; if ((str_len(last_content) > 200)) { _if_result_723 = (str_slice(last_content, 0, 200)); } else { _if_result_723 = (last_content); } _if_result_723; });
     el_val_t safe_topic = str_replace(topic_snip, EL_STR("\""), EL_STR("'"));
     el_val_t ts_now = int_to_str(time_now());
     el_val_t topic_content = el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("last-session-topic | ts:"), ts_now), EL_STR(" | session:")), session_id), EL_STR(" | topic:")), safe_topic);
     el_val_t topic_tags = EL_STR("[\"last-session-topic\",\"conv:history\",\"Conversation\",\"session:topic\"]");
     el_val_t topic_label = el_str_concat(EL_STR("last-session-topic:"), session_id);
     el_val_t old_topic = engram_search_json(el_str_concat(EL_STR("last-session-topic:"), session_id), 2);
-    el_val_t ot_len = ({ el_val_t _if_result_696 = 0; if (str_eq(old_topic, EL_STR(""))) { _if_result_696 = (0); } else { _if_result_696 = (json_array_len(old_topic)); } _if_result_696; });
+    el_val_t ot_len = ({ el_val_t _if_result_724 = 0; if (str_eq(old_topic, EL_STR(""))) { _if_result_724 = (0); } else { _if_result_724 = (json_array_len(old_topic)); } _if_result_724; });
     el_val_t oti = 0;
     while (oti < ot_len) {
       el_val_t ot_node = json_array_get(old_topic, oti);
@@ -30705,7 +30906,7 @@ el_val_t session_hist_save(el_val_t session_id, el_val_t hist) {
 
 el_val_t session_update_meta_timestamp(el_val_t session_id) {
   el_val_t results = engram_search_json(el_str_concat(EL_STR("session:meta "), session_id), 10);
-  el_val_t total = ({ el_val_t _if_result_697 = 0; if (str_eq(results, EL_STR(""))) { _if_result_697 = (0); } else { _if_result_697 = (json_array_len(results)); } _if_result_697; });
+  el_val_t total = ({ el_val_t _if_result_725 = 0; if (str_eq(results, EL_STR(""))) { _if_result_725 = (0); } else { _if_result_725 = (json_array_len(results)); } _if_result_725; });
   el_val_t found = 0;
   el_val_t old_title = EL_STR("New conversation");
   el_val_t old_folder = EL_STR("");
@@ -30718,15 +30919,15 @@ el_val_t session_update_meta_timestamp(el_val_t session_id) {
     el_val_t content = json_get(node, EL_STR("content"));
     el_val_t sid = json_get(content, EL_STR("id"));
     el_val_t is_match = ((str_eq(label, EL_STR("session:meta")) && str_eq(sid, session_id)) && !found);
-    found = ({ el_val_t _if_result_698 = 0; if (is_match) { _if_result_698 = (1); } else { _if_result_698 = (found); } _if_result_698; });
+    found = ({ el_val_t _if_result_726 = 0; if (is_match) { _if_result_726 = (1); } else { _if_result_726 = (found); } _if_result_726; });
     el_val_t title_raw = json_get(content, EL_STR("title"));
-    old_title = ({ el_val_t _if_result_699 = 0; if ((is_match && !str_eq(title_raw, EL_STR("")))) { _if_result_699 = (title_raw); } else { _if_result_699 = (old_title); } _if_result_699; });
+    old_title = ({ el_val_t _if_result_727 = 0; if ((is_match && !str_eq(title_raw, EL_STR("")))) { _if_result_727 = (title_raw); } else { _if_result_727 = (old_title); } _if_result_727; });
     el_val_t folder_raw = json_get(content, EL_STR("folder"));
-    old_folder = ({ el_val_t _if_result_700 = 0; if (is_match) { _if_result_700 = (folder_raw); } else { _if_result_700 = (old_folder); } _if_result_700; });
+    old_folder = ({ el_val_t _if_result_728 = 0; if (is_match) { _if_result_728 = (folder_raw); } else { _if_result_728 = (old_folder); } _if_result_728; });
     el_val_t created_raw = json_get(content, EL_STR("created_at"));
-    old_created = ({ el_val_t _if_result_701 = 0; if ((is_match && !str_eq(created_raw, EL_STR("")))) { _if_result_701 = (created_raw); } else { _if_result_701 = (old_created); } _if_result_701; });
+    old_created = ({ el_val_t _if_result_729 = 0; if ((is_match && !str_eq(created_raw, EL_STR("")))) { _if_result_729 = (created_raw); } else { _if_result_729 = (old_created); } _if_result_729; });
     el_val_t nid = json_get(node, EL_STR("id"));
-    old_node_id = ({ el_val_t _if_result_702 = 0; if (is_match) { _if_result_702 = (nid); } else { _if_result_702 = (old_node_id); } _if_result_702; });
+    old_node_id = ({ el_val_t _if_result_730 = 0; if (is_match) { _if_result_730 = (nid); } else { _if_result_730 = (old_node_id); } _if_result_730; });
     i = (i + 1);
   }
   if (!found) {
@@ -30746,7 +30947,7 @@ el_val_t session_update_meta_timestamp(el_val_t session_id) {
 
 el_val_t session_auto_title(el_val_t session_id, el_val_t first_message) {
   el_val_t results = engram_search_json(el_str_concat(EL_STR("session:meta "), session_id), 10);
-  el_val_t total = ({ el_val_t _if_result_703 = 0; if (str_eq(results, EL_STR(""))) { _if_result_703 = (0); } else { _if_result_703 = (json_array_len(results)); } _if_result_703; });
+  el_val_t total = ({ el_val_t _if_result_731 = 0; if (str_eq(results, EL_STR(""))) { _if_result_731 = (0); } else { _if_result_731 = (json_array_len(results)); } _if_result_731; });
   el_val_t found = 0;
   el_val_t cur_title = EL_STR("");
   el_val_t old_folder = EL_STR("");
@@ -30759,15 +30960,15 @@ el_val_t session_auto_title(el_val_t session_id, el_val_t first_message) {
     el_val_t content = json_get(node, EL_STR("content"));
     el_val_t sid = json_get(content, EL_STR("id"));
     el_val_t is_match = ((str_eq(label, EL_STR("session:meta")) && str_eq(sid, session_id)) && !found);
-    found = ({ el_val_t _if_result_704 = 0; if (is_match) { _if_result_704 = (1); } else { _if_result_704 = (found); } _if_result_704; });
+    found = ({ el_val_t _if_result_732 = 0; if (is_match) { _if_result_732 = (1); } else { _if_result_732 = (found); } _if_result_732; });
     el_val_t title_raw = json_get(content, EL_STR("title"));
-    cur_title = ({ el_val_t _if_result_705 = 0; if (is_match) { _if_result_705 = (title_raw); } else { _if_result_705 = (cur_title); } _if_result_705; });
+    cur_title = ({ el_val_t _if_result_733 = 0; if (is_match) { _if_result_733 = (title_raw); } else { _if_result_733 = (cur_title); } _if_result_733; });
     el_val_t folder_raw = json_get(content, EL_STR("folder"));
-    old_folder = ({ el_val_t _if_result_706 = 0; if (is_match) { _if_result_706 = (folder_raw); } else { _if_result_706 = (old_folder); } _if_result_706; });
+    old_folder = ({ el_val_t _if_result_734 = 0; if (is_match) { _if_result_734 = (folder_raw); } else { _if_result_734 = (old_folder); } _if_result_734; });
     el_val_t created_raw = json_get(content, EL_STR("created_at"));
-    old_created = ({ el_val_t _if_result_707 = 0; if ((is_match && !str_eq(created_raw, EL_STR("")))) { _if_result_707 = (created_raw); } else { _if_result_707 = (old_created); } _if_result_707; });
+    old_created = ({ el_val_t _if_result_735 = 0; if ((is_match && !str_eq(created_raw, EL_STR("")))) { _if_result_735 = (created_raw); } else { _if_result_735 = (old_created); } _if_result_735; });
     el_val_t nid = json_get(node, EL_STR("id"));
-    old_node_id = ({ el_val_t _if_result_708 = 0; if (is_match) { _if_result_708 = (nid); } else { _if_result_708 = (old_node_id); } _if_result_708; });
+    old_node_id = ({ el_val_t _if_result_736 = 0; if (is_match) { _if_result_736 = (nid); } else { _if_result_736 = (old_node_id); } _if_result_736; });
     i = (i + 1);
   }
   if (!found) {
@@ -30801,13 +31002,13 @@ el_val_t handle_session_approve(el_val_t session_id, el_val_t body) {
   if (str_eq(action, EL_STR(""))) {
     return EL_STR("{\"error\":\"action is required (allow|deny|always)\"}");
   }
-  el_val_t eff_action = ({ el_val_t _if_result_709 = 0; if (str_eq(action, EL_STR("always"))) { _if_result_709 = (EL_STR("allow")); } else { _if_result_709 = (action); } _if_result_709; });
+  el_val_t eff_action = ({ el_val_t _if_result_737 = 0; if (str_eq(action, EL_STR("always"))) { _if_result_737 = (EL_STR("allow")); } else { _if_result_737 = (action); } _if_result_737; });
   el_val_t bridge_blob = state_get(el_str_concat(EL_STR("mcp_bridge:"), session_id));
   if (!str_eq(bridge_blob, EL_STR(""))) {
     state_set(EL_STR("agent_workspace_root"), state_get(el_str_concat(EL_STR("agent_workspace_root_"), session_id)));
     el_val_t always_key = el_str_concat(EL_STR("always_allow_"), session_id);
     el_val_t approve_tool_name = json_get(body, EL_STR("tool_name"));
-    el_val_t discard_always = ({ el_val_t _if_result_710 = 0; if ((str_eq(action, EL_STR("always")) && !str_eq(approve_tool_name, EL_STR("")))) { el_val_t always_list = state_get(always_key); el_val_t new_always = ({ el_val_t _if_result_711 = 0; if (str_eq(always_list, EL_STR(""))) { _if_result_711 = (approve_tool_name); } else { _if_result_711 = (el_str_concat(el_str_concat(always_list, EL_STR(",")), approve_tool_name)); } _if_result_711; }); (void)(state_set(always_key, new_always)); _if_result_710 = (1); } else { _if_result_710 = (0); } _if_result_710; });
+    el_val_t discard_always = ({ el_val_t _if_result_738 = 0; if ((str_eq(action, EL_STR("always")) && !str_eq(approve_tool_name, EL_STR("")))) { el_val_t always_list = state_get(always_key); el_val_t new_always = ({ el_val_t _if_result_739 = 0; if (str_eq(always_list, EL_STR(""))) { _if_result_739 = (approve_tool_name); } else { _if_result_739 = (el_str_concat(el_str_concat(always_list, EL_STR(",")), approve_tool_name)); } _if_result_739; }); (void)(state_set(always_key, new_always)); _if_result_738 = (1); } else { _if_result_738 = (0); } _if_result_738; });
     if (str_eq(approve_tool_name, EL_STR("")) && str_eq(eff_action, EL_STR("allow"))) {
       return EL_STR("{\"error\":\"tool_name is required for allow action\"}");
     }
@@ -30815,8 +31016,8 @@ el_val_t handle_session_approve(el_val_t session_id, el_val_t body) {
     el_val_t use_client_content = (!str_eq(client_content, EL_STR("")) && !is_builtin_tool(approve_tool_name));
     el_val_t use_dispatch = (is_builtin_tool(approve_tool_name) && !use_client_content);
     el_val_t raw_input = json_get_raw(body, EL_STR("tool_input"));
-    el_val_t eff_input = ({ el_val_t _if_result_712 = 0; if (str_eq(raw_input, EL_STR(""))) { _if_result_712 = (EL_STR("{}")); } else { _if_result_712 = (raw_input); } _if_result_712; });
-    el_val_t content = ({ el_val_t _if_result_713 = 0; if (str_eq(eff_action, EL_STR("allow"))) { _if_result_713 = (({ el_val_t _if_result_714 = 0; if (use_client_content) { el_val_t trimmed = ({ el_val_t _if_result_715 = 0; if ((str_len(client_content) > 6000)) { _if_result_715 = (el_str_concat(str_slice(client_content, 0, 6000), EL_STR("...[truncated]"))); } else { _if_result_715 = (client_content); } _if_result_715; }); _if_result_714 = (trimmed); } else { _if_result_714 = (({ el_val_t _if_result_716 = 0; if (use_dispatch) { el_val_t raw = dispatch_tool(approve_tool_name, eff_input); _if_result_716 = (({ el_val_t _if_result_717 = 0; if ((str_len(raw) > 6000)) { _if_result_717 = (el_str_concat(str_slice(raw, 0, 6000), EL_STR("...[truncated]"))); } else { _if_result_717 = (raw); } _if_result_717; })); } else { _if_result_716 = (el_str_concat(el_str_concat(EL_STR("{\"error\":\"client content required for non-builtin tool: "), approve_tool_name), EL_STR("\"}"))); } _if_result_716; })); } _if_result_714; })); } else { _if_result_713 = (EL_STR("{\"error\":\"User denied this tool call\"}")); } _if_result_713; });
+    el_val_t eff_input = ({ el_val_t _if_result_740 = 0; if (str_eq(raw_input, EL_STR(""))) { _if_result_740 = (EL_STR("{}")); } else { _if_result_740 = (raw_input); } _if_result_740; });
+    el_val_t content = ({ el_val_t _if_result_741 = 0; if (str_eq(eff_action, EL_STR("allow"))) { _if_result_741 = (({ el_val_t _if_result_742 = 0; if (use_client_content) { el_val_t trimmed = ({ el_val_t _if_result_743 = 0; if ((str_len(client_content) > 6000)) { _if_result_743 = (el_str_concat(str_slice(client_content, 0, 6000), EL_STR("...[truncated]"))); } else { _if_result_743 = (client_content); } _if_result_743; }); _if_result_742 = (trimmed); } else { _if_result_742 = (({ el_val_t _if_result_744 = 0; if (use_dispatch) { el_val_t raw = dispatch_tool(approve_tool_name, eff_input); _if_result_744 = (({ el_val_t _if_result_745 = 0; if ((str_len(raw) > 6000)) { _if_result_745 = (el_str_concat(str_slice(raw, 0, 6000), EL_STR("...[truncated]"))); } else { _if_result_745 = (raw); } _if_result_745; })); } else { _if_result_744 = (el_str_concat(el_str_concat(EL_STR("{\"error\":\"client content required for non-builtin tool: "), approve_tool_name), EL_STR("\"}"))); } _if_result_744; })); } _if_result_742; })); } else { _if_result_741 = (EL_STR("{\"error\":\"User denied this tool call\"}")); } _if_result_741; });
     return agentic_resume(session_id, call_id, content);
   }
   el_val_t pending_raw = state_get(el_str_concat(EL_STR("pending_tool_"), session_id));
@@ -30833,12 +31034,12 @@ el_val_t handle_session_approve(el_val_t session_id, el_val_t body) {
   el_val_t safe_sys = json_get(pending_raw, EL_STR("system"));
   el_val_t always_key = el_str_concat(EL_STR("always_allow_"), session_id);
   el_val_t always_list = state_get(always_key);
-  el_val_t discard_always2 = ({ el_val_t _if_result_718 = 0; if (str_eq(action, EL_STR("always"))) { el_val_t new_always = ({ el_val_t _if_result_719 = 0; if (str_eq(always_list, EL_STR(""))) { _if_result_719 = (tool_name); } else { _if_result_719 = (el_str_concat(el_str_concat(always_list, EL_STR(",")), tool_name)); } _if_result_719; }); (void)(state_set(always_key, new_always)); _if_result_718 = (1); } else { _if_result_718 = (0); } _if_result_718; });
+  el_val_t discard_always2 = ({ el_val_t _if_result_746 = 0; if (str_eq(action, EL_STR("always"))) { el_val_t new_always = ({ el_val_t _if_result_747 = 0; if (str_eq(always_list, EL_STR(""))) { _if_result_747 = (tool_name); } else { _if_result_747 = (el_str_concat(el_str_concat(always_list, EL_STR(",")), tool_name)); } _if_result_747; }); (void)(state_set(always_key, new_always)); _if_result_746 = (1); } else { _if_result_746 = (0); } _if_result_746; });
   state_set(el_str_concat(EL_STR("pending_tool_"), session_id), EL_STR(""));
-  el_val_t tool_result = ({ el_val_t _if_result_720 = 0; if (str_eq(eff_action, EL_STR("allow"))) { el_val_t raw = dispatch_tool(tool_name, tool_input); _if_result_720 = (({ el_val_t _if_result_721 = 0; if ((str_len(raw) > 6000)) { _if_result_721 = (el_str_concat(str_slice(raw, 0, 6000), EL_STR("...[truncated]"))); } else { _if_result_721 = (raw); } _if_result_721; })); } else { _if_result_720 = (EL_STR("{\"error\":\"User denied this tool call\"}")); } _if_result_720; });
+  el_val_t tool_result = ({ el_val_t _if_result_748 = 0; if (str_eq(eff_action, EL_STR("allow"))) { el_val_t raw = dispatch_tool(tool_name, tool_input); _if_result_748 = (({ el_val_t _if_result_749 = 0; if ((str_len(raw) > 6000)) { _if_result_749 = (el_str_concat(str_slice(raw, 0, 6000), EL_STR("...[truncated]"))); } else { _if_result_749 = (raw); } _if_result_749; })); } else { _if_result_748 = (EL_STR("{\"error\":\"User denied this tool call\"}")); } _if_result_748; });
   el_val_t legacy_messages = json_get_raw(pending_raw, EL_STR("messages_so_far"));
   el_val_t stored_variant = json_get(pending_raw, EL_STR("tools_variant"));
-  el_val_t tools_json = ({ el_val_t _if_result_722 = 0; if (str_eq(stored_variant, EL_STR("web"))) { _if_result_722 = (agentic_tools_with_web()); } else { _if_result_722 = (({ el_val_t _if_result_723 = 0; if (str_eq(stored_variant, EL_STR("all"))) { _if_result_723 = (agentic_tools_all()); } else { _if_result_723 = (agentic_tools_literal()); } _if_result_723; })); } _if_result_722; });
+  el_val_t tools_json = ({ el_val_t _if_result_750 = 0; if (str_eq(stored_variant, EL_STR("web"))) { _if_result_750 = (agentic_tools_with_web()); } else { _if_result_750 = (({ el_val_t _if_result_751 = 0; if (str_eq(stored_variant, EL_STR("all"))) { _if_result_751 = (agentic_tools_all()); } else { _if_result_751 = (agentic_tools_literal()); } _if_result_751; })); } _if_result_750; });
   el_val_t blob = 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_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"model\":\""), json_safe(model)), EL_STR("\"")), EL_STR(",\"safe_sys\":\"")), json_safe(safe_sys)), EL_STR("\"")), EL_STR(",\"tools_json\":\"")), json_safe(tools_json)), EL_STR("\"")), EL_STR(",\"messages\":\"")), json_safe(legacy_messages)), EL_STR("\"")), EL_STR(",\"tools_log\":\"\"")), EL_STR(",\"tool_use_id\":\"")), json_safe(call_id)), EL_STR("\"}"));
   state_set(el_str_concat(EL_STR("mcp_bridge:"), session_id), blob);
   return agentic_resume(session_id, call_id, tool_result);
@@ -30864,24 +31065,24 @@ el_val_t rate_limit_check(el_val_t ip, el_val_t path) {
     return EL_STR("");
   }
   el_val_t limit_str = state_get(EL_STR("soul_rate_limit"));
-  el_val_t limit = ({ el_val_t _if_result_724 = 0; if (str_eq(limit_str, EL_STR(""))) { _if_result_724 = (60); } else { _if_result_724 = (str_to_int(limit_str)); } _if_result_724; });
+  el_val_t limit = ({ el_val_t _if_result_752 = 0; if (str_eq(limit_str, EL_STR(""))) { _if_result_752 = (60); } else { _if_result_752 = (str_to_int(limit_str)); } _if_result_752; });
   el_val_t now = time_now();
   el_val_t window_key = el_str_concat(el_str_concat(EL_STR("rl:"), ip), EL_STR(":window"));
   el_val_t count_key = el_str_concat(el_str_concat(EL_STR("rl:"), ip), EL_STR(":count"));
   el_val_t win_str = state_get(window_key);
-  el_val_t win_start = ({ el_val_t _if_result_725 = 0; if (str_eq(win_str, EL_STR(""))) { _if_result_725 = (now); } else { _if_result_725 = (str_to_int(win_str)); } _if_result_725; });
+  el_val_t win_start = ({ el_val_t _if_result_753 = 0; if (str_eq(win_str, EL_STR(""))) { _if_result_753 = (now); } else { _if_result_753 = (str_to_int(win_str)); } _if_result_753; });
   el_val_t elapsed = (now - win_start);
   el_val_t in_window = (elapsed < 60);
   el_val_t prev_count_str = state_get(count_key);
-  el_val_t prev_count = ({ el_val_t _if_result_726 = 0; if (str_eq(prev_count_str, EL_STR(""))) { _if_result_726 = (0); } else { _if_result_726 = (str_to_int(prev_count_str)); } _if_result_726; });
-  el_val_t eff_count = ({ el_val_t _if_result_727 = 0; if (in_window) { _if_result_727 = (prev_count); } else { _if_result_727 = (0); } _if_result_727; });
-  el_val_t eff_win = ({ el_val_t _if_result_728 = 0; if (in_window) { _if_result_728 = (win_start); } else { _if_result_728 = (now); } _if_result_728; });
+  el_val_t prev_count = ({ el_val_t _if_result_754 = 0; if (str_eq(prev_count_str, EL_STR(""))) { _if_result_754 = (0); } else { _if_result_754 = (str_to_int(prev_count_str)); } _if_result_754; });
+  el_val_t eff_count = ({ el_val_t _if_result_755 = 0; if (in_window) { _if_result_755 = (prev_count); } else { _if_result_755 = (0); } _if_result_755; });
+  el_val_t eff_win = ({ el_val_t _if_result_756 = 0; if (in_window) { _if_result_756 = (win_start); } else { _if_result_756 = (now); } _if_result_756; });
   el_val_t new_count = (eff_count + 1);
   state_set(count_key, int_to_str(new_count));
   state_set(window_key, int_to_str(eff_win));
   if (new_count > limit) {
     el_val_t retry_after = (60 - (now - eff_win));
-    el_val_t eff_retry = ({ el_val_t _if_result_729 = 0; if ((retry_after < 0)) { _if_result_729 = (0); } else { _if_result_729 = (retry_after); } _if_result_729; });
+    el_val_t eff_retry = ({ el_val_t _if_result_757 = 0; if ((retry_after < 0)) { _if_result_757 = (0); } else { _if_result_757 = (retry_after); } _if_result_757; });
     return el_str_concat(el_str_concat(EL_STR("{\"__status__\":429,\"error\":\"rate limit exceeded\",\"code\":\"rate_limited\",\"retry_after_secs\":"), int_to_str(eff_retry)), EL_STR("}"));
   }
   return EL_STR("");
@@ -30910,18 +31111,18 @@ el_val_t err_405(el_val_t method, el_val_t path) {
 el_val_t route_health(void) {
   el_val_t cgi_id = state_get(EL_STR("soul_cgi_id"));
   el_val_t boot = state_get(EL_STR("soul_boot_count"));
-  el_val_t boot_num = ({ el_val_t _if_result_730 = 0; if (str_eq(boot, EL_STR(""))) { _if_result_730 = (EL_STR("0")); } else { _if_result_730 = (boot); } _if_result_730; });
+  el_val_t boot_num = ({ el_val_t _if_result_758 = 0; if (str_eq(boot, EL_STR(""))) { _if_result_758 = (EL_STR("0")); } else { _if_result_758 = (boot); } _if_result_758; });
   el_val_t node_ct = engram_node_count();
   el_val_t edge_ct = engram_edge_count();
   el_val_t pulse = state_get(EL_STR("soul.pulse"));
-  el_val_t pulse_num = ({ el_val_t _if_result_731 = 0; if (str_eq(pulse, EL_STR(""))) { _if_result_731 = (EL_STR("0")); } else { _if_result_731 = (pulse); } _if_result_731; });
+  el_val_t pulse_num = ({ el_val_t _if_result_759 = 0; if (str_eq(pulse, EL_STR(""))) { _if_result_759 = (EL_STR("0")); } else { _if_result_759 = (pulse); } _if_result_759; });
   el_val_t boot_ts_str = state_get(EL_STR("soul_boot_ts"));
-  el_val_t uptime_secs = ({ el_val_t _if_result_732 = 0; if (str_eq(boot_ts_str, EL_STR(""))) { _if_result_732 = ((-1)); } else { _if_result_732 = ((time_now() - str_to_int(boot_ts_str))); } _if_result_732; });
+  el_val_t uptime_secs = ({ el_val_t _if_result_760 = 0; if (str_eq(boot_ts_str, EL_STR(""))) { _if_result_760 = ((-1)); } else { _if_result_760 = ((time_now() - str_to_int(boot_ts_str))); } _if_result_760; });
   el_val_t model = state_get(EL_STR("soul_model"));
-  el_val_t eff_model = ({ el_val_t _if_result_733 = 0; if (str_eq(model, EL_STR(""))) { _if_result_733 = (EL_STR("claude-sonnet-4-5")); } else { _if_result_733 = (model); } _if_result_733; });
+  el_val_t eff_model = ({ el_val_t _if_result_761 = 0; if (str_eq(model, EL_STR(""))) { _if_result_761 = (EL_STR("claude-sonnet-4-5")); } else { _if_result_761 = (model); } _if_result_761; });
   el_val_t llm_probe = llm_call_system(eff_model, EL_STR("You are a health probe. Reply with the single word: ok"), EL_STR("ping"));
   el_val_t llm_ok = (((!str_eq(llm_probe, EL_STR("")) && !str_starts_with(llm_probe, EL_STR("{\"error\""))) && !str_starts_with(llm_probe, EL_STR("{\"type\":\"error\""))) && !str_contains(llm_probe, EL_STR("authentication_error")));
-  el_val_t llm_status = ({ el_val_t _if_result_734 = 0; if (llm_ok) { _if_result_734 = (EL_STR("ok")); } else { _if_result_734 = (EL_STR("unreachable")); } _if_result_734; });
+  el_val_t llm_status = ({ el_val_t _if_result_762 = 0; if (llm_ok) { _if_result_762 = (EL_STR("ok")); } else { _if_result_762 = (EL_STR("unreachable")); } _if_result_762; });
   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_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("{\"status\":\"alive\""), EL_STR(",\"cgi_id\":\"")), cgi_id), EL_STR("\"")), EL_STR(",\"boot\":")), boot_num), EL_STR(",\"uptime_secs\":")), int_to_str(uptime_secs)), EL_STR(",\"node_count\":")), int_to_str(node_ct)), EL_STR(",\"edge_count\":")), int_to_str(edge_ct)), EL_STR(",\"pulse\":")), pulse_num), EL_STR(",\"llm\":\"")), llm_status), EL_STR("\"")), EL_STR(",\"layers\":{\"l0\":\"core\",\"l1\":\"safety\",\"l2\":\"stewardship\",\"l3\":\"")), imprint_current()), EL_STR("\"}}"));
   return 0;
 }
@@ -30991,30 +31192,30 @@ el_val_t handle_dharma_recv(el_val_t body) {
   el_val_t from_id = json_get(body, EL_STR("from"));
   el_val_t event_type = json_get(content_raw, EL_STR("event_type"));
   el_val_t payload = json_get(content_raw, EL_STR("payload"));
-  el_val_t eff_event = ({ el_val_t _if_result_735 = 0; if (str_eq(event_type, EL_STR(""))) { _if_result_735 = (EL_STR("chat")); } else { _if_result_735 = (event_type); } _if_result_735; });
-  el_val_t eff_payload = ({ el_val_t _if_result_736 = 0; if (str_eq(payload, EL_STR(""))) { _if_result_736 = (content_raw); } else { _if_result_736 = (payload); } _if_result_736; });
+  el_val_t eff_event = ({ el_val_t _if_result_763 = 0; if (str_eq(event_type, EL_STR(""))) { _if_result_763 = (EL_STR("chat")); } else { _if_result_763 = (event_type); } _if_result_763; });
+  el_val_t eff_payload = ({ el_val_t _if_result_764 = 0; if (str_eq(payload, EL_STR(""))) { _if_result_764 = (content_raw); } else { _if_result_764 = (payload); } _if_result_764; });
   if (str_eq(eff_event, EL_STR("chat"))) {
     el_val_t msg = json_get(eff_payload, EL_STR("message"));
-    el_val_t chat_body = ({ el_val_t _if_result_737 = 0; if (str_eq(msg, EL_STR(""))) { _if_result_737 = (el_str_concat(el_str_concat(EL_STR("{\"message\":\""), str_replace(str_replace(eff_payload, EL_STR("\\"), EL_STR("\\\\")), EL_STR("\""), EL_STR("\\\""))), EL_STR("\"}"))); } else { _if_result_737 = (eff_payload); } _if_result_737; });
+    el_val_t chat_body = ({ el_val_t _if_result_765 = 0; if (str_eq(msg, EL_STR(""))) { _if_result_765 = (el_str_concat(el_str_concat(EL_STR("{\"message\":\""), str_replace(str_replace(eff_payload, EL_STR("\\"), EL_STR("\\\\")), EL_STR("\""), EL_STR("\\\""))), EL_STR("\"}"))); } else { _if_result_765 = (eff_payload); } _if_result_765; });
     el_val_t agentic_flag = json_get_bool(eff_payload, EL_STR("agentic"));
     el_val_t raw_msg = json_get(chat_body, EL_STR("message"));
     el_val_t req_mode = json_get(chat_body, EL_STR("mode"));
-    el_val_t reply = ({ el_val_t _if_result_738 = 0; if (str_eq(req_mode, EL_STR("plan"))) { _if_result_738 = (handle_chat_plan(chat_body)); } else { _if_result_738 = (({ el_val_t _if_result_739 = 0; if (agentic_flag) { _if_result_739 = (handle_chat_agentic(chat_body)); } else { el_val_t screened_reply = layered_cycle(raw_msg, json_get(chat_body, EL_STR("session_id")), is_utility_request(chat_body, json_get(chat_body, EL_STR("session_id")))); _if_result_739 = (plain_chat_envelope(screened_reply, chat_default_model())); } _if_result_739; })); } _if_result_738; });
+    el_val_t reply = ({ el_val_t _if_result_766 = 0; if (str_eq(req_mode, EL_STR("plan"))) { _if_result_766 = (handle_chat_plan(chat_body)); } else { _if_result_766 = (({ el_val_t _if_result_767 = 0; if (agentic_flag) { _if_result_767 = (handle_chat_agentic(chat_body)); } else { el_val_t screened_reply = layered_cycle(raw_msg, json_get(chat_body, EL_STR("session_id")), is_utility_request(chat_body, json_get(chat_body, EL_STR("session_id")))); _if_result_767 = (plain_chat_envelope(screened_reply, chat_default_model())); } _if_result_767; })); } _if_result_766; });
     auto_persist(chat_body, reply);
     return reply;
   }
   if (str_eq(eff_event, EL_STR("memory"))) {
     el_val_t query = json_get(eff_payload, EL_STR("query"));
     el_val_t limit_str = json_get(eff_payload, EL_STR("limit"));
-    el_val_t limit = ({ el_val_t _if_result_740 = 0; if (str_eq(limit_str, EL_STR(""))) { _if_result_740 = (20); } else { _if_result_740 = (str_to_int(limit_str)); } _if_result_740; });
-    el_val_t q = ({ el_val_t _if_result_741 = 0; if (str_eq(query, EL_STR(""))) { _if_result_741 = (eff_payload); } else { _if_result_741 = (query); } _if_result_741; });
+    el_val_t limit = ({ el_val_t _if_result_768 = 0; if (str_eq(limit_str, EL_STR(""))) { _if_result_768 = (20); } else { _if_result_768 = (str_to_int(limit_str)); } _if_result_768; });
+    el_val_t q = ({ el_val_t _if_result_769 = 0; if (str_eq(query, EL_STR(""))) { _if_result_769 = (eff_payload); } else { _if_result_769 = (query); } _if_result_769; });
     return engram_search_json(q, limit);
   }
   if (str_eq(eff_event, EL_STR("tool"))) {
     el_val_t path_field = json_get(eff_payload, EL_STR("path"));
     el_val_t method_field = json_get(eff_payload, EL_STR("method"));
     el_val_t tool_body = json_get(eff_payload, EL_STR("body"));
-    el_val_t eff_method = ({ el_val_t _if_result_742 = 0; if (str_eq(method_field, EL_STR(""))) { _if_result_742 = (EL_STR("POST")); } else { _if_result_742 = (method_field); } _if_result_742; });
+    el_val_t eff_method = ({ el_val_t _if_result_770 = 0; if (str_eq(method_field, EL_STR(""))) { _if_result_770 = (EL_STR("POST")); } else { _if_result_770 = (method_field); } _if_result_770; });
     return handle_tool(path_field, eff_method, tool_body);
   }
   if (str_eq(eff_event, EL_STR("see"))) {
@@ -31049,7 +31250,7 @@ el_val_t connectd_get(el_val_t suffix) {
 }
 
 el_val_t connectd_post(el_val_t suffix, el_val_t body) {
-  el_val_t eff = ({ el_val_t _if_result_743 = 0; if (str_eq(body, EL_STR(""))) { _if_result_743 = (EL_STR("{}")); } else { _if_result_743 = (body); } _if_result_743; });
+  el_val_t eff = ({ el_val_t _if_result_771 = 0; if (str_eq(body, EL_STR(""))) { _if_result_771 = (EL_STR("{}")); } else { _if_result_771 = (body); } _if_result_771; });
   el_val_t tmp = el_str_concat(el_str_concat(EL_STR("/tmp/neuron-connectors-req-"), int_to_str(time_now())), EL_STR(".json"));
   fs_write(tmp, eff);
   el_val_t out = exec_capture(el_str_concat(el_str_concat(el_str_concat(EL_STR("curl -s --max-time 20 -X POST http://127.0.0.1:7771"), suffix), EL_STR(" -H 'Content-Type: application/json' -d @")), tmp));
@@ -31121,22 +31322,22 @@ el_val_t route_dispatch(el_val_t method, el_val_t path, el_val_t body) {
     }
     if (str_eq(clean, EL_STR("/api/graph/edges"))) {
       el_val_t scratch_dir = env(EL_STR("TMPDIR"));
-      el_val_t scratch_base = ({ el_val_t _if_result_744 = 0; if (str_eq(scratch_dir, EL_STR(""))) { _if_result_744 = (EL_STR("/tmp")); } else { _if_result_744 = (scratch_dir); } _if_result_744; });
+      el_val_t scratch_base = ({ el_val_t _if_result_772 = 0; if (str_eq(scratch_dir, EL_STR(""))) { _if_result_772 = (EL_STR("/tmp")); } else { _if_result_772 = (scratch_dir); } _if_result_772; });
       el_val_t snap_path = el_str_concat(el_str_concat(el_str_concat(scratch_base, EL_STR("/soul-edges-export-")), state_get(EL_STR("soul_cgi_id"))), EL_STR(".json"));
       engram_save(snap_path);
       el_val_t snap = fs_read(snap_path);
       el_val_t edges_raw = json_get_raw(snap, EL_STR("edges"));
-      return ({ el_val_t _if_result_745 = 0; if (str_eq(edges_raw, EL_STR(""))) { _if_result_745 = (EL_STR("[]")); } else { _if_result_745 = (edges_raw); } _if_result_745; });
+      return ({ el_val_t _if_result_773 = 0; if (str_eq(edges_raw, EL_STR(""))) { _if_result_773 = (EL_STR("[]")); } else { _if_result_773 = (edges_raw); } _if_result_773; });
     }
     if (str_eq(clean, EL_STR("/api/chat"))) {
       el_val_t raw_msg = json_get(body, EL_STR("message"));
-      el_val_t eff_msg = ({ el_val_t _if_result_746 = 0; if (str_eq(raw_msg, EL_STR(""))) { _if_result_746 = (body); } else { _if_result_746 = (raw_msg); } _if_result_746; });
+      el_val_t eff_msg = ({ el_val_t _if_result_774 = 0; if (str_eq(raw_msg, EL_STR(""))) { _if_result_774 = (body); } else { _if_result_774 = (raw_msg); } _if_result_774; });
       if (str_eq(eff_msg, EL_STR(""))) {
         return EL_STR("{\"error\":\"message is required\",\"code\":\"missing_param\"}");
       }
       el_val_t agentic_flag = json_get_bool(body, EL_STR("agentic"));
       el_val_t req_mode = json_get(body, EL_STR("mode"));
-      el_val_t reply = ({ el_val_t _if_result_747 = 0; if (str_eq(req_mode, EL_STR("plan"))) { _if_result_747 = (handle_chat_plan(body)); } else { _if_result_747 = (({ el_val_t _if_result_748 = 0; if (agentic_flag) { _if_result_748 = (handle_chat_agentic(body)); } else { el_val_t screened_reply = layered_cycle(eff_msg, json_get(body, EL_STR("session_id")), is_utility_request(body, json_get(body, EL_STR("session_id")))); _if_result_748 = (plain_chat_envelope(screened_reply, chat_default_model())); } _if_result_748; })); } _if_result_747; });
+      el_val_t reply = ({ el_val_t _if_result_775 = 0; if (str_eq(req_mode, EL_STR("plan"))) { _if_result_775 = (handle_chat_plan(body)); } else { _if_result_775 = (({ el_val_t _if_result_776 = 0; if (agentic_flag) { _if_result_776 = (handle_chat_agentic(body)); } else { el_val_t screened_reply = layered_cycle(eff_msg, json_get(body, EL_STR("session_id")), is_utility_request(body, json_get(body, EL_STR("session_id")))); _if_result_776 = (plain_chat_envelope(screened_reply, chat_default_model())); } _if_result_776; })); } _if_result_775; });
       auto_persist(body, reply);
       return reply;
     }
@@ -31203,6 +31404,9 @@ el_val_t route_dispatch(el_val_t method, el_val_t path, el_val_t body) {
     if (str_starts_with(clean, EL_STR("/api/neuron/graph"))) {
       return handle_api_inspect_graph(method, path, body);
     }
+    if (str_starts_with(clean, EL_STR("/api/neuron/audit/structural"))) {
+      return handle_api_structural_audit(method, path, body);
+    }
     if (str_starts_with(clean, EL_STR("/api/neuron/list/"))) {
       el_val_t node_type = str_slice(clean, 17, str_len(clean));
       return handle_api_list_typed(node_type, path, body);
@@ -31217,7 +31421,7 @@ el_val_t route_dispatch(el_val_t method, el_val_t path, el_val_t body) {
       el_val_t rp_id = str_slice(clean, 18, str_len(clean));
       if (!str_eq(rp_id, EL_STR(""))) {
         el_val_t rp_raw = state_get(el_str_concat(EL_STR("run_progress_"), rp_id));
-        el_val_t rp_arr = ({ el_val_t _if_result_749 = 0; if (str_eq(rp_raw, EL_STR(""))) { _if_result_749 = (EL_STR("[]")); } else { _if_result_749 = (el_str_concat(el_str_concat(EL_STR("["), rp_raw), EL_STR("]"))); } _if_result_749; });
+        el_val_t rp_arr = ({ el_val_t _if_result_777 = 0; if (str_eq(rp_raw, EL_STR(""))) { _if_result_777 = (EL_STR("[]")); } else { _if_result_777 = (el_str_concat(el_str_concat(EL_STR("["), rp_raw), EL_STR("]"))); } _if_result_777; });
         return el_str_concat(el_str_concat(EL_STR("{\"progress\":"), rp_arr), EL_STR("}"));
       }
     }
@@ -31227,7 +31431,7 @@ el_val_t route_dispatch(el_val_t method, el_val_t path, el_val_t body) {
     if (str_starts_with(clean, EL_STR("/api/sessions/"))) {
       el_val_t gs_after = str_slice(clean, 14, str_len(clean));
       el_val_t gs_slash = str_index_of(gs_after, EL_STR("/"));
-      el_val_t gs_id = ({ el_val_t _if_result_750 = 0; if ((gs_slash < 0)) { _if_result_750 = (gs_after); } else { _if_result_750 = (str_slice(gs_after, 0, gs_slash)); } _if_result_750; });
+      el_val_t gs_id = ({ el_val_t _if_result_778 = 0; if ((gs_slash < 0)) { _if_result_778 = (gs_after); } else { _if_result_778 = (str_slice(gs_after, 0, gs_slash)); } _if_result_778; });
       if (!str_eq(gs_id, EL_STR(""))) {
         return session_get(gs_id);
       }
@@ -31241,14 +31445,14 @@ el_val_t route_dispatch(el_val_t method, el_val_t path, el_val_t body) {
     if (str_starts_with(clean, EL_STR("/api/sessions/")) && str_ends_with(clean, EL_STR("/tool_result"))) {
       el_val_t after = str_slice(clean, 14, str_len(clean));
       el_val_t slash = str_index_of(after, EL_STR("/"));
-      el_val_t session_id = ({ el_val_t _if_result_751 = 0; if ((slash < 0)) { _if_result_751 = (after); } else { _if_result_751 = (str_slice(after, 0, slash)); } _if_result_751; });
+      el_val_t session_id = ({ el_val_t _if_result_779 = 0; if ((slash < 0)) { _if_result_779 = (after); } else { _if_result_779 = (str_slice(after, 0, slash)); } _if_result_779; });
       return handle_tool_result(session_id, body);
     }
     if (str_starts_with(clean, EL_STR("/api/sessions/"))) {
       el_val_t sess_after = str_slice(clean, 14, str_len(clean));
       el_val_t sess_slash = str_index_of(sess_after, EL_STR("/"));
-      el_val_t sess_id = ({ el_val_t _if_result_752 = 0; if ((sess_slash < 0)) { _if_result_752 = (sess_after); } else { _if_result_752 = (str_slice(sess_after, 0, sess_slash)); } _if_result_752; });
-      el_val_t sess_sub = ({ el_val_t _if_result_753 = 0; if ((sess_slash < 0)) { _if_result_753 = (EL_STR("")); } else { _if_result_753 = (str_slice(sess_after, (sess_slash + 1), str_len(sess_after))); } _if_result_753; });
+      el_val_t sess_id = ({ el_val_t _if_result_780 = 0; if ((sess_slash < 0)) { _if_result_780 = (sess_after); } else { _if_result_780 = (str_slice(sess_after, 0, sess_slash)); } _if_result_780; });
+      el_val_t sess_sub = ({ el_val_t _if_result_781 = 0; if ((sess_slash < 0)) { _if_result_781 = (EL_STR("")); } else { _if_result_781 = (str_slice(sess_after, (sess_slash + 1), str_len(sess_after))); } _if_result_781; });
       if (!str_eq(sess_id, EL_STR("")) && str_eq(sess_sub, EL_STR("approve"))) {
         return handle_session_approve(sess_id, body);
       }
@@ -31272,7 +31476,7 @@ el_val_t route_dispatch(el_val_t method, el_val_t path, el_val_t body) {
       }
       el_val_t agentic_flag = json_get_bool(body, EL_STR("agentic"));
       el_val_t req_mode = json_get(body, EL_STR("mode"));
-      el_val_t reply = ({ el_val_t _if_result_754 = 0; if (str_eq(req_mode, EL_STR("plan"))) { _if_result_754 = (handle_chat_plan(body)); } else { _if_result_754 = (({ el_val_t _if_result_755 = 0; if (agentic_flag) { _if_result_755 = (handle_chat_agentic(body)); } else { el_val_t screened_reply = layered_cycle(raw_msg, json_get(body, EL_STR("session_id")), is_utility_request(body, json_get(body, EL_STR("session_id")))); _if_result_755 = (plain_chat_envelope(screened_reply, chat_default_model())); } _if_result_755; })); } _if_result_754; });
+      el_val_t reply = ({ el_val_t _if_result_782 = 0; if (str_eq(req_mode, EL_STR("plan"))) { _if_result_782 = (handle_chat_plan(body)); } else { _if_result_782 = (({ el_val_t _if_result_783 = 0; if (agentic_flag) { _if_result_783 = (handle_chat_agentic(body)); } else { el_val_t screened_reply = layered_cycle(raw_msg, json_get(body, EL_STR("session_id")), is_utility_request(body, json_get(body, EL_STR("session_id")))); _if_result_783 = (plain_chat_envelope(screened_reply, chat_default_model())); } _if_result_783; })); } _if_result_782; });
       auto_persist(body, reply);
       return reply;
     }
@@ -31351,6 +31555,9 @@ el_val_t route_dispatch(el_val_t method, el_val_t path, el_val_t body) {
     if (str_eq(clean, EL_STR("/api/neuron/graph/link"))) {
       return handle_api_link_entities(body);
     }
+    if (str_eq(clean, EL_STR("/api/neuron/audit/structural"))) {
+      return handle_api_structural_audit(method, path, body);
+    }
     if (str_eq(clean, EL_STR("/api/neuron/memory"))) {
       return handle_api_remember(body);
     }
@@ -31396,7 +31603,7 @@ el_val_t route_dispatch(el_val_t method, el_val_t path, el_val_t body) {
     if (str_starts_with(clean, EL_STR("/api/sessions/"))) {
       el_val_t del_after = str_slice(clean, 14, str_len(clean));
       el_val_t del_slash = str_index_of(del_after, EL_STR("/"));
-      el_val_t del_id = ({ el_val_t _if_result_756 = 0; if ((del_slash < 0)) { _if_result_756 = (del_after); } else { _if_result_756 = (str_slice(del_after, 0, del_slash)); } _if_result_756; });
+      el_val_t del_id = ({ el_val_t _if_result_784 = 0; if ((del_slash < 0)) { _if_result_784 = (del_after); } else { _if_result_784 = (str_slice(del_after, 0, del_slash)); } _if_result_784; });
       if (!str_eq(del_id, EL_STR(""))) {
         return session_delete(del_id);
       }
@@ -31407,7 +31614,7 @@ el_val_t route_dispatch(el_val_t method, el_val_t path, el_val_t body) {
     if (str_starts_with(clean, EL_STR("/api/sessions/"))) {
       el_val_t patch_after = str_slice(clean, 14, str_len(clean));
       el_val_t patch_slash = str_index_of(patch_after, EL_STR("/"));
-      el_val_t patch_id = ({ el_val_t _if_result_757 = 0; if ((patch_slash < 0)) { _if_result_757 = (patch_after); } else { _if_result_757 = (str_slice(patch_after, 0, patch_slash)); } _if_result_757; });
+      el_val_t patch_id = ({ el_val_t _if_result_785 = 0; if ((patch_slash < 0)) { _if_result_785 = (patch_after); } else { _if_result_785 = (str_slice(patch_after, 0, patch_slash)); } _if_result_785; });
       if (!str_eq(patch_id, EL_STR(""))) {
         return session_update_patch(patch_id, body);
       }
@@ -31533,8 +31740,8 @@ el_val_t aff_try_slot(el_val_t slot_json, el_val_t aff_7d_ts, el_val_t acc_key)
     }
   }
   el_val_t bn_ts_raw = state_get(EL_STR("_ats_ts_raw"));
-  el_val_t bn_ts = ({ el_val_t _if_result_758 = 0; if (str_eq(bn_ts_raw, EL_STR(""))) { _if_result_758 = (0); } else { _if_result_758 = (str_to_int(bn_ts_raw)); } _if_result_758; });
-  el_val_t snip = ({ el_val_t _if_result_759 = 0; if ((str_len(bn_c) > 200)) { _if_result_759 = (str_slice(bn_c, 0, 200)); } else { _if_result_759 = (bn_c); } _if_result_759; });
+  el_val_t bn_ts = ({ el_val_t _if_result_786 = 0; if (str_eq(bn_ts_raw, EL_STR(""))) { _if_result_786 = (0); } else { _if_result_786 = (str_to_int(bn_ts_raw)); } _if_result_786; });
+  el_val_t snip = ({ el_val_t _if_result_787 = 0; if ((str_len(bn_c) > 200)) { _if_result_787 = (str_slice(bn_c, 0, 200)); } else { _if_result_787 = (bn_c); } _if_result_787; });
   if ((bn_ts >= aff_7d_ts) && !str_eq(snip, EL_STR(""))) {
     el_val_t cur_acc = state_get(acc_key);
     if (str_eq(cur_acc, EL_STR(""))) {
@@ -31555,21 +31762,21 @@ el_val_t load_identity_context(void) {
   el_val_t intel_ok = (!str_eq(node_intel, EL_STR("")) && !str_eq(node_intel, EL_STR("null")));
   el_val_t values_ok = (!str_eq(node_values, EL_STR("")) && !str_eq(node_values, EL_STR("null")));
   el_val_t mem_ok = (!str_eq(node_mem_phil, EL_STR("")) && !str_eq(node_mem_phil, EL_STR("null")));
-  el_val_t intel_content = ({ el_val_t _if_result_760 = 0; if (intel_ok) { _if_result_760 = (json_get(node_intel, EL_STR("content"))); } else { _if_result_760 = (EL_STR("")); } _if_result_760; });
-  el_val_t values_content = ({ el_val_t _if_result_761 = 0; if (values_ok) { _if_result_761 = (json_get(node_values, EL_STR("content"))); } else { _if_result_761 = (EL_STR("")); } _if_result_761; });
-  el_val_t mem_content = ({ el_val_t _if_result_762 = 0; if (mem_ok) { _if_result_762 = (json_get(node_mem_phil, EL_STR("content"))); } else { _if_result_762 = (EL_STR("")); } _if_result_762; });
-  el_val_t intel_short = ({ el_val_t _if_result_763 = 0; if ((str_len(intel_content) > 2000)) { _if_result_763 = (str_slice(intel_content, 0, 2000)); } else { _if_result_763 = (intel_content); } _if_result_763; });
-  el_val_t values_short = ({ el_val_t _if_result_764 = 0; if ((str_len(values_content) > 2000)) { _if_result_764 = (str_slice(values_content, 0, 2000)); } else { _if_result_764 = (values_content); } _if_result_764; });
-  el_val_t mem_short = ({ el_val_t _if_result_765 = 0; if ((str_len(mem_content) > 2000)) { _if_result_765 = (str_slice(mem_content, 0, 2000)); } else { _if_result_765 = (mem_content); } _if_result_765; });
+  el_val_t intel_content = ({ el_val_t _if_result_788 = 0; if (intel_ok) { _if_result_788 = (json_get(node_intel, EL_STR("content"))); } else { _if_result_788 = (EL_STR("")); } _if_result_788; });
+  el_val_t values_content = ({ el_val_t _if_result_789 = 0; if (values_ok) { _if_result_789 = (json_get(node_values, EL_STR("content"))); } else { _if_result_789 = (EL_STR("")); } _if_result_789; });
+  el_val_t mem_content = ({ el_val_t _if_result_790 = 0; if (mem_ok) { _if_result_790 = (json_get(node_mem_phil, EL_STR("content"))); } else { _if_result_790 = (EL_STR("")); } _if_result_790; });
+  el_val_t intel_short = ({ el_val_t _if_result_791 = 0; if ((str_len(intel_content) > 2000)) { _if_result_791 = (str_slice(intel_content, 0, 2000)); } else { _if_result_791 = (intel_content); } _if_result_791; });
+  el_val_t values_short = ({ el_val_t _if_result_792 = 0; if ((str_len(values_content) > 2000)) { _if_result_792 = (str_slice(values_content, 0, 2000)); } else { _if_result_792 = (values_content); } _if_result_792; });
+  el_val_t mem_short = ({ el_val_t _if_result_793 = 0; if ((str_len(mem_content) > 2000)) { _if_result_793 = (str_slice(mem_content, 0, 2000)); } else { _if_result_793 = (mem_content); } _if_result_793; });
   el_val_t parts_count = 0;
-  parts_count = ({ el_val_t _if_result_766 = 0; if (intel_ok) { _if_result_766 = ((parts_count + 1)); } else { _if_result_766 = (parts_count); } _if_result_766; });
-  parts_count = ({ el_val_t _if_result_767 = 0; if (values_ok) { _if_result_767 = ((parts_count + 1)); } else { _if_result_767 = (parts_count); } _if_result_767; });
-  parts_count = ({ el_val_t _if_result_768 = 0; if (mem_ok) { _if_result_768 = ((parts_count + 1)); } else { _if_result_768 = (parts_count); } _if_result_768; });
+  parts_count = ({ el_val_t _if_result_794 = 0; if (intel_ok) { _if_result_794 = ((parts_count + 1)); } else { _if_result_794 = (parts_count); } _if_result_794; });
+  parts_count = ({ el_val_t _if_result_795 = 0; if (values_ok) { _if_result_795 = ((parts_count + 1)); } else { _if_result_795 = (parts_count); } _if_result_795; });
+  parts_count = ({ el_val_t _if_result_796 = 0; if (mem_ok) { _if_result_796 = ((parts_count + 1)); } else { _if_result_796 = (parts_count); } _if_result_796; });
   if (parts_count > 0) {
     el_val_t ctx = EL_STR("");
-    ctx = ({ el_val_t _if_result_769 = 0; if (intel_ok) { _if_result_769 = (el_str_concat(el_str_concat(el_str_concat(ctx, EL_STR("[INTELLECTUAL-DNA]\n")), intel_short), EL_STR("\n\n"))); } else { _if_result_769 = (ctx); } _if_result_769; });
-    ctx = ({ el_val_t _if_result_770 = 0; if (values_ok) { _if_result_770 = (el_str_concat(el_str_concat(el_str_concat(ctx, EL_STR("[VALUES]\n")), values_short), EL_STR("\n\n"))); } else { _if_result_770 = (ctx); } _if_result_770; });
-    ctx = ({ el_val_t _if_result_771 = 0; if (mem_ok) { _if_result_771 = (el_str_concat(el_str_concat(ctx, EL_STR("[MEMORY-PHILOSOPHY]\n")), mem_short)); } else { _if_result_771 = (ctx); } _if_result_771; });
+    ctx = ({ el_val_t _if_result_797 = 0; if (intel_ok) { _if_result_797 = (el_str_concat(el_str_concat(el_str_concat(ctx, EL_STR("[INTELLECTUAL-DNA]\n")), intel_short), EL_STR("\n\n"))); } else { _if_result_797 = (ctx); } _if_result_797; });
+    ctx = ({ el_val_t _if_result_798 = 0; if (values_ok) { _if_result_798 = (el_str_concat(el_str_concat(el_str_concat(ctx, EL_STR("[VALUES]\n")), values_short), EL_STR("\n\n"))); } else { _if_result_798 = (ctx); } _if_result_798; });
+    ctx = ({ el_val_t _if_result_799 = 0; if (mem_ok) { _if_result_799 = (el_str_concat(el_str_concat(ctx, EL_STR("[MEMORY-PHILOSOPHY]\n")), mem_short)); } else { _if_result_799 = (ctx); } _if_result_799; });
     state_set(EL_STR("soul_identity_context"), ctx);
     println(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("[soul] identity context loaded ("), int_to_str(str_len(ctx))), EL_STR(" chars, ")), int_to_str(parts_count)), EL_STR(" nodes)")));
   }
@@ -31592,10 +31799,10 @@ el_val_t load_identity_context(void) {
   el_val_t bell_raw = engram_search_json(EL_STR("bell:soft bell:hard BellEvent affective"), 3);
   el_val_t bell_aff_ok = (!str_eq(bell_raw, EL_STR("")) && !str_eq(bell_raw, EL_STR("[]")));
   el_val_t aff_ctx = EL_STR("");
-  aff_ctx = ({ el_val_t _if_result_772 = 0; if (bell_aff_ok) { (void)(state_set(EL_STR("_bell_acc"), EL_STR(""))); (void)(aff_try_slot(json_array_get(bell_raw, 0), aff_7d, EL_STR("_bell_acc"))); (void)(aff_try_slot(json_array_get(bell_raw, 1), aff_7d, EL_STR("_bell_acc"))); (void)(aff_try_slot(json_array_get(bell_raw, 2), aff_7d, EL_STR("_bell_acc"))); _if_result_772 = (state_get(EL_STR("_bell_acc"))); } else { _if_result_772 = (EL_STR("")); } _if_result_772; });
+  aff_ctx = ({ el_val_t _if_result_800 = 0; if (bell_aff_ok) { (void)(state_set(EL_STR("_bell_acc"), EL_STR(""))); (void)(aff_try_slot(json_array_get(bell_raw, 0), aff_7d, EL_STR("_bell_acc"))); (void)(aff_try_slot(json_array_get(bell_raw, 1), aff_7d, EL_STR("_bell_acc"))); (void)(aff_try_slot(json_array_get(bell_raw, 2), aff_7d, EL_STR("_bell_acc"))); _if_result_800 = (state_get(EL_STR("_bell_acc"))); } else { _if_result_800 = (EL_STR("")); } _if_result_800; });
   el_val_t pos_raw = engram_search_json(EL_STR("PositiveEvent joy:high joy:low affective"), 3);
   el_val_t pos_aff_ok = (!str_eq(pos_raw, EL_STR("")) && !str_eq(pos_raw, EL_STR("[]")));
-  aff_ctx = ({ el_val_t _if_result_773 = 0; if (pos_aff_ok) { (void)(state_set(EL_STR("_pos_acc"), aff_ctx)); (void)(aff_try_slot(json_array_get(pos_raw, 0), aff_7d, EL_STR("_pos_acc"))); (void)(aff_try_slot(json_array_get(pos_raw, 1), aff_7d, EL_STR("_pos_acc"))); (void)(aff_try_slot(json_array_get(pos_raw, 2), aff_7d, EL_STR("_pos_acc"))); _if_result_773 = (state_get(EL_STR("_pos_acc"))); } else { _if_result_773 = (aff_ctx); } _if_result_773; });
+  aff_ctx = ({ el_val_t _if_result_801 = 0; if (pos_aff_ok) { (void)(state_set(EL_STR("_pos_acc"), aff_ctx)); (void)(aff_try_slot(json_array_get(pos_raw, 0), aff_7d, EL_STR("_pos_acc"))); (void)(aff_try_slot(json_array_get(pos_raw, 1), aff_7d, EL_STR("_pos_acc"))); (void)(aff_try_slot(json_array_get(pos_raw, 2), aff_7d, EL_STR("_pos_acc"))); _if_result_801 = (state_get(EL_STR("_pos_acc"))); } else { _if_result_801 = (aff_ctx); } _if_result_801; });
   if (!str_eq(aff_ctx, EL_STR(""))) {
     state_set(EL_STR("soul_affective_context"), aff_ctx);
     println(el_str_concat(el_str_concat(EL_STR("[soul] affective context loaded ("), int_to_str(str_len(aff_ctx))), EL_STR(" chars)")));
@@ -31641,19 +31848,19 @@ el_val_t seed_persona_from_env(void) {
 
 el_val_t emit_session_start_event(void) {
   el_val_t boot = state_get(EL_STR("soul_boot_count"));
-  el_val_t boot_num = ({ el_val_t _if_result_774 = 0; if (str_eq(boot, EL_STR(""))) { _if_result_774 = (EL_STR("0")); } else { _if_result_774 = (boot); } _if_result_774; });
+  el_val_t boot_num = ({ el_val_t _if_result_802 = 0; if (str_eq(boot, EL_STR(""))) { _if_result_802 = (EL_STR("0")); } else { _if_result_802 = (boot); } _if_result_802; });
   el_val_t node_ct = engram_node_count();
   el_val_t edge_ct = engram_edge_count();
   el_val_t id_ctx = state_get(EL_STR("soul_identity_context"));
-  el_val_t has_identity = ({ el_val_t _if_result_775 = 0; if (str_eq(id_ctx, EL_STR(""))) { _if_result_775 = (EL_STR("false")); } else { _if_result_775 = (EL_STR("true")); } _if_result_775; });
+  el_val_t has_identity = ({ el_val_t _if_result_803 = 0; if (str_eq(id_ctx, EL_STR(""))) { _if_result_803 = (EL_STR("false")); } else { _if_result_803 = (EL_STR("true")); } _if_result_803; });
   el_val_t cgi_from_state = state_get(EL_STR("soul_cgi_id"));
   el_val_t cgi_from_env = env(EL_STR("SOUL_CGI_ID"));
-  el_val_t eff_cgi = ({ el_val_t _if_result_776 = 0; if (!str_eq(cgi_from_state, EL_STR(""))) { _if_result_776 = (cgi_from_state); } else { _if_result_776 = (({ el_val_t _if_result_777 = 0; if (!str_eq(cgi_from_env, EL_STR(""))) { _if_result_777 = (cgi_from_env); } else { _if_result_777 = (EL_STR("ntn-genesis")); } _if_result_777; })); } _if_result_776; });
+  el_val_t eff_cgi = ({ el_val_t _if_result_804 = 0; if (!str_eq(cgi_from_state, EL_STR(""))) { _if_result_804 = (cgi_from_state); } else { _if_result_804 = (({ el_val_t _if_result_805 = 0; if (!str_eq(cgi_from_env, EL_STR(""))) { _if_result_805 = (cgi_from_env); } else { _if_result_805 = (EL_STR("ntn-genesis")); } _if_result_805; })); } _if_result_804; });
   el_val_t ts = time_now();
   el_val_t prev_sum_node = engram_get_node_by_label(EL_STR("session:summary"));
   el_val_t prev_sum_ok = (!str_eq(prev_sum_node, EL_STR("")) && !str_eq(prev_sum_node, EL_STR("null")));
-  el_val_t prev_sum_content = ({ el_val_t _if_result_778 = 0; if (prev_sum_ok) { _if_result_778 = (json_get(prev_sum_node, EL_STR("content"))); } else { el_val_t sum_search = engram_search_json(EL_STR("SessionSummary session:summary previous-session"), 2); el_val_t sum_srch_ok = (!str_eq(sum_search, EL_STR("")) && !str_eq(sum_search, EL_STR("[]"))); _if_result_778 = (({ el_val_t _if_result_779 = 0; if (sum_srch_ok) { el_val_t sn = json_array_get(sum_search, 0); el_val_t stype = json_get(sn, EL_STR("node_type")); el_val_t scontent = json_get(sn, EL_STR("content")); _if_result_779 = (({ el_val_t _if_result_780 = 0; if ((str_eq(stype, EL_STR("SessionSummary")) && !str_eq(scontent, EL_STR("")))) { _if_result_780 = (scontent); } else { _if_result_780 = (EL_STR("")); } _if_result_780; })); } else { _if_result_779 = (EL_STR("")); } _if_result_779; })); } _if_result_778; });
-  el_val_t has_prev_sum = ({ el_val_t _if_result_781 = 0; if (str_eq(prev_sum_content, EL_STR(""))) { _if_result_781 = (EL_STR("false")); } else { _if_result_781 = (EL_STR("true")); } _if_result_781; });
+  el_val_t prev_sum_content = ({ el_val_t _if_result_806 = 0; if (prev_sum_ok) { _if_result_806 = (json_get(prev_sum_node, EL_STR("content"))); } else { el_val_t sum_search = engram_search_json(EL_STR("SessionSummary session:summary previous-session"), 2); el_val_t sum_srch_ok = (!str_eq(sum_search, EL_STR("")) && !str_eq(sum_search, EL_STR("[]"))); _if_result_806 = (({ el_val_t _if_result_807 = 0; if (sum_srch_ok) { el_val_t sn = json_array_get(sum_search, 0); el_val_t stype = json_get(sn, EL_STR("node_type")); el_val_t scontent = json_get(sn, EL_STR("content")); _if_result_807 = (({ el_val_t _if_result_808 = 0; if ((str_eq(stype, EL_STR("SessionSummary")) && !str_eq(scontent, EL_STR("")))) { _if_result_808 = (scontent); } else { _if_result_808 = (EL_STR("")); } _if_result_808; })); } else { _if_result_807 = (EL_STR("")); } _if_result_807; })); } _if_result_806; });
+  el_val_t has_prev_sum = ({ el_val_t _if_result_809 = 0; if (str_eq(prev_sum_content, EL_STR(""))) { _if_result_809 = (EL_STR("false")); } else { _if_result_809 = (EL_STR("true")); } _if_result_809; });
   if (!str_eq(prev_sum_content, EL_STR(""))) {
     state_set(EL_STR("soul_prev_session_summary"), prev_sum_content);
     println(el_str_concat(el_str_concat(EL_STR("[soul] previous session summary loaded ("), int_to_str(str_len(prev_sum_content))), EL_STR(" chars)")));
@@ -31700,23 +31907,23 @@ el_val_t layered_cycle(el_val_t raw_input, el_val_t session_id, el_val_t utility
   el_val_t continuity = steward_session_check(screened, session_id);
   el_val_t cont_status = json_get(continuity, EL_STR("status"));
   el_val_t cont_action = json_get(continuity, EL_STR("action"));
-  el_val_t cont_key = ({ el_val_t _if_result_782 = 0; if (str_eq(session_id, EL_STR(""))) { _if_result_782 = (EL_STR("session_continuity")); } else { _if_result_782 = (el_str_concat(EL_STR("session_continuity:"), session_id)); } _if_result_782; });
+  el_val_t cont_key = ({ el_val_t _if_result_810 = 0; if (str_eq(session_id, EL_STR(""))) { _if_result_810 = (EL_STR("session_continuity")); } else { _if_result_810 = (el_str_concat(EL_STR("session_continuity:"), session_id)); } _if_result_810; });
   state_set(cont_key, cont_status);
-  el_val_t guided = ({ el_val_t _if_result_783 = 0; if (str_eq(cont_action, EL_STR("identity_check"))) { _if_result_783 = (el_str_concat(screened, EL_STR(" [steward:identity_check]"))); } else { _if_result_783 = (({ el_val_t _if_result_784 = 0; if (str_eq(cont_action, EL_STR("soft_check"))) { _if_result_784 = (el_str_concat(screened, EL_STR(" [steward:continuity_concern]"))); } else { _if_result_784 = (screened); } _if_result_784; })); } _if_result_783; });
+  el_val_t guided = ({ el_val_t _if_result_811 = 0; if (str_eq(cont_action, EL_STR("identity_check"))) { _if_result_811 = (el_str_concat(screened, EL_STR(" [steward:identity_check]"))); } else { _if_result_811 = (({ el_val_t _if_result_812 = 0; if (str_eq(cont_action, EL_STR("soft_check"))) { _if_result_812 = (el_str_concat(screened, EL_STR(" [steward:continuity_concern]"))); } else { _if_result_812 = (screened); } _if_result_812; })); } _if_result_811; });
   el_val_t imprint_id = imprint_current();
   el_val_t steward_result = steward_align(guided, imprint_id);
   el_val_t steward_action = json_get(steward_result, EL_STR("action"));
-  el_val_t aligned = ({ el_val_t _if_result_785 = 0; if (str_eq(steward_action, EL_STR("pass"))) { _if_result_785 = (json_get(steward_result, EL_STR("content"))); } else { _if_result_785 = (json_get(steward_result, EL_STR("redirect_to"))); } _if_result_785; });
+  el_val_t aligned = ({ el_val_t _if_result_813 = 0; if (str_eq(steward_action, EL_STR("pass"))) { _if_result_813 = (json_get(steward_result, EL_STR("content"))); } else { _if_result_813 = (json_get(steward_result, EL_STR("redirect_to"))); } _if_result_813; });
   el_val_t lc_aff_cutoff = (time_now() - 259200);
   el_val_t lc_bell_nodes = engram_search_json(EL_STR("bell:soft bell:hard BellEvent affective"), 2);
   el_val_t lc_has_bell = (!str_eq(lc_bell_nodes, EL_STR("")) && !str_eq(lc_bell_nodes, EL_STR("[]")));
-  el_val_t lc_bell_note = ({ el_val_t _if_result_786 = 0; if (lc_has_bell) { el_val_t lb0 = json_array_get(lc_bell_nodes, 0); el_val_t lb_ts = affective_node_ts(lb0); _if_result_786 = (({ el_val_t _if_result_787 = 0; if ((lb_ts > lc_aff_cutoff)) { _if_result_787 = (EL_STR("[AFFECTIVE NOTE: User was in distress in a recent session.]")); } else { _if_result_787 = (EL_STR("")); } _if_result_787; })); } else { _if_result_786 = (EL_STR("")); } _if_result_786; });
+  el_val_t lc_bell_note = ({ el_val_t _if_result_814 = 0; if (lc_has_bell) { el_val_t lb0 = json_array_get(lc_bell_nodes, 0); el_val_t lb_ts = affective_node_ts(lb0); _if_result_814 = (({ el_val_t _if_result_815 = 0; if ((lb_ts > lc_aff_cutoff)) { _if_result_815 = (EL_STR("[AFFECTIVE NOTE: User was in distress in a recent session.]")); } else { _if_result_815 = (EL_STR("")); } _if_result_815; })); } else { _if_result_814 = (EL_STR("")); } _if_result_814; });
   el_val_t lc_pos_nodes = engram_search_json(EL_STR("PositiveEvent joy:high joy:low affective"), 2);
   el_val_t lc_has_pos = (!str_eq(lc_pos_nodes, EL_STR("")) && !str_eq(lc_pos_nodes, EL_STR("[]")));
-  el_val_t lc_pos_note = ({ el_val_t _if_result_788 = 0; if ((lc_has_pos && str_eq(lc_bell_note, EL_STR("")))) { el_val_t lp0 = json_array_get(lc_pos_nodes, 0); el_val_t lp_ts = affective_node_ts(lp0); _if_result_788 = (({ el_val_t _if_result_789 = 0; if ((lp_ts > lc_aff_cutoff)) { _if_result_789 = (EL_STR("[AFFECTIVE NOTE: User shared positive news in a recent session.]")); } else { _if_result_789 = (EL_STR("")); } _if_result_789; })); } else { _if_result_788 = (EL_STR("")); } _if_result_788; });
-  el_val_t lc_affective_note = ({ el_val_t _if_result_790 = 0; if (!str_eq(lc_bell_note, EL_STR(""))) { _if_result_790 = (lc_bell_note); } else { _if_result_790 = (lc_pos_note); } _if_result_790; });
+  el_val_t lc_pos_note = ({ el_val_t _if_result_816 = 0; if ((lc_has_pos && str_eq(lc_bell_note, EL_STR("")))) { el_val_t lp0 = json_array_get(lc_pos_nodes, 0); el_val_t lp_ts = affective_node_ts(lp0); _if_result_816 = (({ el_val_t _if_result_817 = 0; if ((lp_ts > lc_aff_cutoff)) { _if_result_817 = (EL_STR("[AFFECTIVE NOTE: User shared positive news in a recent session.]")); } else { _if_result_817 = (EL_STR("")); } _if_result_817; })); } else { _if_result_816 = (EL_STR("")); } _if_result_816; });
+  el_val_t lc_affective_note = ({ el_val_t _if_result_818 = 0; if (!str_eq(lc_bell_note, EL_STR(""))) { _if_result_818 = (lc_bell_note); } else { _if_result_818 = (lc_pos_note); } _if_result_818; });
   el_val_t augmented_addendum = safety_augment_system(EL_STR(""), raw_input);
-  augmented_addendum = ({ el_val_t _if_result_791 = 0; if (str_eq(lc_affective_note, EL_STR(""))) { _if_result_791 = (augmented_addendum); } else { _if_result_791 = (({ el_val_t _if_result_792 = 0; if (str_eq(augmented_addendum, EL_STR(""))) { _if_result_792 = (lc_affective_note); } else { _if_result_792 = (el_str_concat(el_str_concat(lc_affective_note, EL_STR("\n")), augmented_addendum)); } _if_result_792; })); } _if_result_791; });
+  augmented_addendum = ({ el_val_t _if_result_819 = 0; if (str_eq(lc_affective_note, EL_STR(""))) { _if_result_819 = (augmented_addendum); } else { _if_result_819 = (({ el_val_t _if_result_820 = 0; if (str_eq(augmented_addendum, EL_STR(""))) { _if_result_820 = (lc_affective_note); } else { _if_result_820 = (el_str_concat(el_str_concat(lc_affective_note, EL_STR("\n")), augmented_addendum)); } _if_result_820; })); } _if_result_819; });
   state_set(EL_STR("layered_cycle_safety_system_addendum"), augmented_addendum);
   el_val_t prompt = imprint_respond(aligned, imprint_id);
   el_val_t output = layered_generate(prompt, imprint_id, session_id);
@@ -31732,17 +31939,20 @@ el_val_t layered_cycle(el_val_t raw_input, el_val_t session_id, el_val_t utility
 int main(int _argc, char** _argv) {
   el_runtime_init_args(_argc, _argv);
   soul_cgi_id_raw = env(EL_STR("SOUL_CGI_ID"));
-  soul_cgi_id = ({ el_val_t _if_result_793 = 0; if (str_eq(soul_cgi_id_raw, EL_STR(""))) { _if_result_793 = (EL_STR("ntn-genesis")); } else { _if_result_793 = (soul_cgi_id_raw); } _if_result_793; });
+  soul_cgi_id = ({ el_val_t _if_result_821 = 0; if (str_eq(soul_cgi_id_raw, EL_STR(""))) { _if_result_821 = (EL_STR("ntn-genesis")); } else { _if_result_821 = (soul_cgi_id_raw); } _if_result_821; });
   port_raw = env(EL_STR("NEURON_PORT"));
-  port = ({ el_val_t _if_result_794 = 0; if (str_eq(port_raw, EL_STR(""))) { _if_result_794 = (7770); } else { _if_result_794 = (str_to_int(port_raw)); } _if_result_794; });
+  port = ({ el_val_t _if_result_822 = 0; if (str_eq(port_raw, EL_STR(""))) { _if_result_822 = (7770); } else { _if_result_822 = (str_to_int(port_raw)); } _if_result_822; });
   engram_url_raw = env(EL_STR("ENGRAM_URL"));
   engram_api_key_raw = env(EL_STR("ENGRAM_API_KEY"));
   snapshot_raw = env(EL_STR("SOUL_ENGRAM_PATH"));
-  snapshot = ({ el_val_t _if_result_795 = 0; if (str_eq(snapshot_raw, EL_STR(""))) { _if_result_795 = (el_str_concat(env(EL_STR("HOME")), EL_STR("/.neuron/engram/snapshot.json"))); } else { _if_result_795 = (snapshot_raw); } _if_result_795; });
+  snapshot = ({ el_val_t _if_result_823 = 0; if (str_eq(snapshot_raw, EL_STR(""))) { _if_result_823 = (el_str_concat(env(EL_STR("HOME")), EL_STR("/.neuron/engram/snapshot.json"))); } else { _if_result_823 = (snapshot_raw); } _if_result_823; });
   axon_raw = env(EL_STR("NEURON_API_URL"));
-  axon_base = ({ el_val_t _if_result_796 = 0; if (str_eq(axon_raw, EL_STR(""))) { _if_result_796 = (EL_STR("http://localhost:7771")); } else { _if_result_796 = (axon_raw); } _if_result_796; });
+  axon_base = ({ el_val_t _if_result_824 = 0; if (str_eq(axon_raw, EL_STR(""))) { _if_result_824 = (EL_STR("http://localhost:7771")); } else { _if_result_824 = (axon_raw); } _if_result_824; });
   studio_dir_raw = env(EL_STR("SOUL_STUDIO_DIR"));
-  studio_dir = ({ el_val_t _if_result_797 = 0; if (str_eq(studio_dir_raw, EL_STR(""))) { _if_result_797 = (el_str_concat(env(EL_STR("HOME")), EL_STR("/Development/neuron-technologies/products/cgi-studio/el-daemon"))); } else { _if_result_797 = (studio_dir_raw); } _if_result_797; });
+  studio_dir = ({ el_val_t _if_result_825 = 0; if (str_eq(studio_dir_raw, EL_STR(""))) { _if_result_825 = (el_str_concat(env(EL_STR("HOME")), EL_STR("/Development/neuron-technologies/products/cgi-studio/el-daemon"))); } else { _if_result_825 = (studio_dir_raw); } _if_result_825; });
+  identity_raw = env(EL_STR("SOUL_IDENTITY"));
+  soul_identity = ({ el_val_t _if_result_826 = 0; if (str_eq(identity_raw, EL_STR(""))) { _if_result_826 = (el_str_concat(el_str_concat(EL_STR("You are "), soul_cgi_id), EL_STR(", a CGI."))); } else { _if_result_826 = (identity_raw); } _if_result_826; });
+  state_set(EL_STR("soul_identity"), soul_identity);
   println(el_str_concat(el_str_concat(el_str_concat(EL_STR("[soul] boot - cgi="), soul_cgi_id), EL_STR(" port=")), int_to_str(port)));
   using_http_engram = !str_eq(engram_url_raw, EL_STR(""));
   engram_load(snapshot);
@@ -31752,8 +31962,8 @@ int main(int _argc, char** _argv) {
     println(el_str_concat(el_str_concat(EL_STR("[soul] engram -> HTTP "), engram_url_raw), EL_STR(" (no local snapshot, first boot)")));
     el_val_t nodes_json = http_get(el_str_concat(engram_url_raw, EL_STR("/api/nodes?limit=10000")));
     el_val_t edges_json = http_get(el_str_concat(engram_url_raw, EL_STR("/api/edges")));
-    el_val_t nodes_part = ({ el_val_t _if_result_798 = 0; if (str_eq(nodes_json, EL_STR(""))) { _if_result_798 = (EL_STR("[]")); } else { _if_result_798 = (nodes_json); } _if_result_798; });
-    el_val_t edges_part = ({ el_val_t _if_result_799 = 0; if (str_eq(edges_json, EL_STR(""))) { _if_result_799 = (EL_STR("[]")); } else { _if_result_799 = (edges_json); } _if_result_799; });
+    el_val_t nodes_part = ({ el_val_t _if_result_827 = 0; if (str_eq(nodes_json, EL_STR(""))) { _if_result_827 = (EL_STR("[]")); } else { _if_result_827 = (nodes_json); } _if_result_827; });
+    el_val_t edges_part = ({ el_val_t _if_result_828 = 0; if (str_eq(edges_json, EL_STR(""))) { _if_result_828 = (EL_STR("[]")); } else { _if_result_828 = (edges_json); } _if_result_828; });
     el_val_t snapshot_data = el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"nodes\":"), nodes_part), EL_STR(",\"edges\":")), edges_part), EL_STR("}"));
     el_val_t tmp_path = el_str_concat(el_str_concat(EL_STR("/tmp/soul-engram-"), soul_cgi_id), EL_STR(".json"));
     fs_write(tmp_path, snapshot_data);
@@ -31777,7 +31987,7 @@ int main(int _argc, char** _argv) {
   state_set(EL_STR("soul_engram_api_key"), engram_api_key_raw);
   state_set(EL_STR("soul.running"), EL_STR("true"));
   is_genesis = str_eq(soul_cgi_id, EL_STR("ntn-genesis"));
-  guard_disk = ({ el_val_t _if_result_800 = 0; if (str_eq(engram_url_raw, EL_STR(""))) { _if_result_800 = (fs_read(snapshot)); } else { _if_result_800 = (EL_STR("")); } _if_result_800; });
+  guard_disk = ({ el_val_t _if_result_829 = 0; if (str_eq(engram_url_raw, EL_STR(""))) { _if_result_829 = (fs_read(snapshot)); } else { _if_result_829 = (EL_STR("")); } _if_result_829; });
   guard_disk_len = str_len(guard_disk);
   safe_to_seed = (!using_http_engram && !((guard_disk_len > 200000) && ((engram_node_count() * 16000) < guard_disk_len)));
   if (is_genesis && !safe_to_seed) {

dist/soul.c.stamp

@@ -1,18 +1,18 @@
 # soul.c.stamp — fingerprint of the .el sources dist/soul.c was generated from.
 # Written by tools/soulc-stamp.sh --write. Do not hand-edit.
-# generated_amalgam_sha256 e31f760de5f6629cd37bcfd26172f92be3ca5d6ff36480f6adafa1d4a1de5a66
-# generated_amalgam_bytes  1179122
+# generated_amalgam_sha256 ee09798ad93ddd047136577cf324483e5956984d60d06596d34662f315ee0df4
+# generated_amalgam_bytes  1204845
 f8597e10546654bce3fbbe40461b2da59d0e06dbf1b038d1d362d24f949e3911  awareness.el
 b6f3d14ca0c26017a2d617399a6d3754dabb0905e4d5f52eb75d25c4ad18d3c5  chat.el
 42288c212cbf72fb1e8ecbd4d9900e4e9ee1cfa475b7974295c7637f1bf2939f  elp-input.el
 b3f77f49d6086932c38bd17fe7a5eaf8bce25685f6fc3e1750f05729c6b49b9e  imprint.el
 fba8ffdb9ba72bca5b09ca1c93a520edc52f3f4d8aec2c7585fe9b17e06420b2  manifest.el
 550a72e234ae8cec1f33e02108fd365353f45edd88513da90b792e79b6c0e5f0  memory.el
-77640783df5c38066149dcd11a11aea7e36f66e40e3df6aedf6723be8b9e0e1e  neuron-api.el
+5ec07ec9785b02abe32f3ff7acf2d1f9f7e07c0967fac97e6eff17d7110b5c84  neuron-api.el
 03c47c451e0e87f2c252cadb4b765867943962a804f548dd53adeef0520912c8  persist.el
-541b9309c59c33ee619d393714871b820ec4151b721d8b2aebcfdb7ce8eb2ffa  routes.el
+a6d69f3fc55233d9d3300160fd46a1551f2064bcd0fb84e2c9e432f636a72476  routes.el
 c28e36952ec56525963a0bdf29455ab097d3b0c5653d19c25fbb005e1069a1f7  safety.el
 fd3ab91d0ae0ea26639e21bef2f8f94054dc4b02eae68b19e3fe689d2769aad4  sessions.el
-0f1cf43904a98a5a646cce5a07e0e96162ced662692fbc13357d9b67d9a8ac3d  soul.el
+5613b60d74d5d7768f46da5ac435a5dd99d38c27f0f7013c89fa27e98dc8a21c  soul.el
 30337940905171a9645b0929f0a412ce6b3dccb1246495070c553bca0bbae6cd  stewardship.el
 e105dc5990e6adbf39db9dc0462cd8bcf6e6c3dfd03709059227ecfad2bbab29  studio.el

mcp-wrapper/src/main.el

@@ -110,7 +110,7 @@ tool("beginSession", "Initialize session: surface recent high-importance memorie
 "," + tool("linkCausal", "Create a causal edge (cause -> effect).") +
 "," + tool("restructureCausalGraph", "Re-balance the causal subgraph after new evidence.") +
 "," + tool("rebuildGraph", "Rebuild graph indices from the on-disk snapshot.") +
-"," + tool("runStructuralAudit", "Audit graph structure for orphans, dangling edges, mislabeled types.") +
+"," + tool("runStructuralAudit", "Stage 1 structural audit: owner-vs-runtime divergence, orphans and dangling edges, typed-edge distribution, self-model connectivity. Returns an annotated characterization, not a score.") +
 // ── Backlog + work ──────────────────────────────────────────────────────────
 "," + tool("planWork", "Create a backlog item.") +
 "," + tool("reviewBacklog", "Browse work items.") +
@@ -680,7 +680,16 @@ fn dispatch_tool_call(tool_name: String, args: String) -> String {
         return mcp_json_result(resp)
     }
     if str_eq(tool_name, "runStructuralAudit") {
-        let resp: String = http_get(neuron_url() + "/session/begin")
+        // Was: GET /session/begin — an unrelated session digest returned under an
+        // audit tool name, i.e. the tool advertised a check that did not exist.
+        // Now points at the real Stage 1 route (neuron-api.el
+        // handle_api_structural_audit). Sample caps ride the query string; the
+        // defaults keep a manual audit to a couple of seconds.
+        let e_s: Int = json_get_int(args, "edge_sample")
+        let n_s: Int = json_get_int(args, "node_sample")
+        let qs: String = "?edge_sample=" + int_to_str(if e_s > 0 { e_s } else { 3000 })
+            + "&node_sample=" + int_to_str(if n_s > 0 { n_s } else { 300 })
+        let resp: String = http_get(neuron_url() + "/audit/structural" + qs)
         return mcp_json_result(resp)
     }
 

neuron-api.el

@@ -926,3 +926,462 @@ fn handle_api_consolidate(body: String) -> String {
     }
     return "{\"ok\":true,\"snapshot\":\"" + snap + "\"}"
 }
+
+// ── Stage 1: structural audit ─────────────────────────────────────────────────
+//
+// WHAT THIS IMPLEMENTS
+//   The CGI provisional, 05-detailed-description.md, "Stage 1: Structural audit
+//   430". Verbatim, the audit module evaluates: the density and typed
+//   distribution of causal edges; the consistency between value nodes and
+//   execution-record neighborhoods; the richness and connectivity of the
+//   self-model; and the authenticity of open-question nodes in the wonder
+//   manifest. It "produces a coherence assessment 432 — NOT A BINARY SCORE but
+//   an annotated characterization of the graph's structural properties".
+//
+//   That last clause is the whole shape of this handler. Every finding carries
+//   its own numbers AND a plain-language note saying what the numbers mean and
+//   how they were obtained. There is no pass/fail, no percentage-of-health, no
+//   composite score, and `"score":null` is emitted explicitly so a downstream
+//   reader cannot mistake its absence for an omission.
+//
+// WHY IT EXISTS NOW, AND WHY THE FIRST FINDING IS THE ONE IT IS
+//   `runStructuralAudit` has been an advertised MCP tool with nothing behind it:
+//   the dispatcher GET'd /session/begin and returned that blob (mcp-wrapper/src/
+//   main.el). Meanwhile the failure the audit would have caught ran silently for
+//   about three weeks — the soul reported 103,089 nodes while the engram, which
+//   OWNS persistence, held ~79,900; a crash discarded the difference. Every boot
+//   reported green throughout, because nothing in the system ever compared the
+//   two sides. So finding 1 is owner-versus-runtime divergence: it is the check
+//   whose absence cost real memory, and it is cheap and exact.
+//
+// WHAT IS DELIBERATELY NOT HERE (stage 1b, see the `deferred` array in the
+// response): value/execution-record consistency and wonder-manifest
+// authenticity. Both need node types that barely exist in this graph today —
+// the response MEASURES those populations and reports the counts as the reason,
+// rather than asserting a deferral without evidence.
+//
+// MEASUREMENT HONESTY: EXACT WHERE CHEAP, SAMPLED WHERE NOT, ALWAYS LABELLED
+//   Counts, edge typing and self-model connectivity are exact. Orphan rate and
+//   dangling-edge rate are SAMPLED, because the engram runtime has no node-id
+//   index — `engram_find_node_index` is a linear scan over every node, so an
+//   exhaustive dangling check is O(nodes x edges) (~2.2e9 string compares at
+//   today's scale, tens of seconds inside one request). The samples are UNIFORM
+//   across the whole population, not head-of-list, and every sampled figure is
+//   emitted with its own `sampled` / `population` fields plus an extrapolation
+//   labelled as such. Raise `?edge_sample=` / `?node_sample=` to the population
+//   size to run either check exhaustively and pay the time. The real fix is an
+//   id index in the runtime; that is the engram repo's, not this handler's.
+
+// audit_pct1 — one-decimal percentage as a bare JSON number, sign-safe.
+// Integer math only: EL has no fixed-precision formatter, and float_to_str
+// would put an unbounded mantissa in the response.
+fn audit_pct1(num: Int, den: Int) -> String {
+    if den <= 0 { return "null" }
+    let neg: Bool = num < 0
+    let a: Int = if neg { 0 - num } else { num }
+    let tenths: Int = (a * 1000) / den
+    let whole: Int = tenths / 10
+    let frac: Int = tenths - (whole * 10)
+    let sign: String = if neg { "-" } else { "" }
+    return sign + int_to_str(whole) + "." + int_to_str(frac)
+}
+
+// audit_finding — the one envelope every finding uses: name, the measurements,
+// and the annotation. Keeping it in one place is what stops the characterization
+// from degenerating into a bag of numbers with no reading attached.
+fn audit_finding(name: String, measured: String, note: String) -> String {
+    return "{\"finding\":\"" + name + "\""
+        + ",\"measured\":{" + measured + "}"
+        + ",\"note\":\"" + api_json_escape(note) + "\"}"
+}
+
+// audit_str_at — read the quoted string value starting at byte `start`.
+// Slices a bounded window rather than the tail of the (multi-MB) edges array, so
+// this is O(window) per call instead of O(remaining input).
+fn audit_str_at(s: String, start: Int, maxlen: Int) -> String {
+    let n: Int = str_len(s)
+    if start < 0 || start >= n { return "" }
+    let end_guess: Int = start + maxlen
+    let stop: Int = if end_guess > n { n } else { end_guess }
+    let win: String = str_slice(s, start, stop)
+    let q: Int = str_index_of(win, "\"")
+    if q < 0 { return "" }
+    return str_slice(win, 0, q)
+}
+
+// audit_rel_count — exact count of edges carrying `rel`, by scanning the emitted
+// edge array for the literal `"relation":"<rel>"`. engram_emit_edge_json writes
+// metadata ESCAPED as a string, so no nested object can contain that literal and
+// the count cannot be inflated by edge payloads.
+fn audit_rel_count(edges: String, rel: String) -> Int {
+    return str_count(edges, "\"relation\":\"" + rel + "\"")
+}
+
+// audit_owner_stats — ask the persistence OWNER for its own counts.
+// Returns "" when there is no HTTP owner configured or the owner is unreachable;
+// both are reported as findings, never as a failure of the audit.
+fn audit_owner_stats(url: String) -> String {
+    if str_eq(url, "") { return "" }
+    return http_get(url + "/api/stats")
+}
+
+// audit_divergence — FINDING 1. Runtime (this soul's in-process graph) versus
+// the persistence owner's own count. Trend is measured against the previous
+// audit recorded in soul state, so a second call answers "is the gap growing?"
+// rather than just restating it.
+fn audit_divergence() -> String {
+    let rt_nodes: Int = engram_node_count()
+    let rt_edges: Int = engram_edge_count()
+    let url: String = wt_engram_url()
+
+    if str_eq(url, "") {
+        return audit_finding("owner_runtime_divergence",
+            "\"runtime_nodes\":" + int_to_str(rt_nodes)
+            + ",\"runtime_edges\":" + int_to_str(rt_edges)
+            + ",\"owner\":\"none\",\"owner_reachable\":false",
+            "No HTTP persistence owner is configured, so this soul IS the owner "
+            + "(file mode) and divergence is not defined. This check only has "
+            + "meaning when ENGRAM_URL points at a separate engram that owns the "
+            + "canonical store.")
+    }
+
+    let stats: String = audit_owner_stats(url)
+    // REACHABILITY IS PROVED BY THE PAYLOAD, NOT BY A NON-EMPTY REPLY.
+    // http_get does not return "" on a connection failure — it returns a JSON
+    // error object ({"error":"Failed to connect to ... Couldn't connect to
+    // server"}). Testing only for "" made a DEAD owner read as reachable with
+    // node_count 0, i.e. the audit would have reported a 100% divergence and
+    // named it as data loss. That false positive is worse than no check at all:
+    // it is precisely the kind of confident wrong answer this route exists to
+    // stop. Require the field the contract promises.
+    let owner_nc_raw: String = json_get_raw(stats, "node_count")
+    if str_eq(stats, "") || str_eq(owner_nc_raw, "") {
+        return audit_finding("owner_runtime_divergence",
+            "\"runtime_nodes\":" + int_to_str(rt_nodes)
+            + ",\"runtime_edges\":" + int_to_str(rt_edges)
+            + ",\"owner\":\"" + api_json_escape(url) + "\",\"owner_reachable\":false"
+            + ",\"owner_reply\":\"" + api_json_escape(api_utf8_trunc(stats, 200)) + "\"",
+            "The persistence owner at " + url + " did not return a node_count "
+            + "from GET /api/stats. Divergence is UNKNOWN, NOT ZERO — an owner "
+            + "that cannot be read is exactly the condition under which the "
+            + "runtime's own count means least, and reporting 0 for the owner "
+            + "would manufacture a total-loss reading out of a network error. "
+            + "Reported as a finding rather than raised as an error so the rest "
+            + "of the audit still returns; the owner's raw reply is in "
+            + "owner_reply.")
+    }
+
+    let ow_nodes: Int = json_get_int(stats, "node_count")
+    let ow_edges: Int = json_get_int(stats, "edge_count")
+    let d_nodes: Int = rt_nodes - ow_nodes
+    let d_edges: Int = rt_edges - ow_edges
+
+    // Trend against the previous audit in this soul's state.
+    let prev_raw: String = state_get("audit_prev_node_delta")
+    let prev: Int = str_to_int(prev_raw)
+    let abs_now: Int = if d_nodes < 0 { 0 - d_nodes } else { d_nodes }
+    let abs_prev: Int = if prev < 0 { 0 - prev } else { prev }
+    let trend: String = if str_eq(prev_raw, "") {
+        "no_prior_audit"
+    } else {
+        if abs_now > abs_prev { "growing" } else {
+            if abs_now < abs_prev { "shrinking" } else { "flat" }
+        }
+    }
+    state_set("audit_prev_node_delta", int_to_str(d_nodes))
+    state_set("audit_prev_ts", int_to_str(time_now()))
+
+    let note_head: String = if d_nodes == 0 {
+        "Runtime and owner agree on node count."
+    } else {
+        "Runtime holds " + int_to_str(d_nodes) + " nodes (" + audit_pct1(d_nodes, rt_nodes)
+        + "% of its own graph) that the persistence owner does not report. Nodes "
+        + "that exist only in runtime memory do not survive a restart."
+    }
+    return audit_finding("owner_runtime_divergence",
+        "\"runtime_nodes\":" + int_to_str(rt_nodes)
+        + ",\"runtime_edges\":" + int_to_str(rt_edges)
+        + ",\"owner\":\"" + api_json_escape(url) + "\",\"owner_reachable\":true"
+        + ",\"owner_nodes\":" + int_to_str(ow_nodes)
+        + ",\"owner_edges\":" + int_to_str(ow_edges)
+        + ",\"node_delta\":" + int_to_str(d_nodes)
+        + ",\"edge_delta\":" + int_to_str(d_edges)
+        + ",\"node_delta_pct_of_runtime\":" + audit_pct1(d_nodes, rt_nodes)
+        + ",\"trend_vs_previous_audit\":\"" + trend + "\""
+        + ",\"previous_node_delta\":" + (if str_eq(prev_raw, "") { "null" } else { int_to_str(prev) }),
+        note_head + " Trend against the previous audit recorded in this soul's "
+        + "state: " + trend + ". This is the comparison whose absence let a "
+        + "~24,000-node loss run for weeks with every boot reporting green.")
+}
+
+// audit_edge_typing — FINDING 2. Density plus the typed distribution the patent
+// asks for, against the claim-10 relation vocabulary. Exact: str_count over the
+// emitted edge array, one linear pass per relation.
+fn audit_edge_typing(edges: String, total_edges: Int, node_total: Int) -> String {
+    let c_sup: Int = audit_rel_count(edges, "Supersedes")
+    let c_cau: Int = audit_rel_count(edges, "Causes")
+    let c_con: Int = audit_rel_count(edges, "Contains")
+    let c_ref: Int = audit_rel_count(edges, "References")
+    let c_ctr: Int = audit_rel_count(edges, "Contradicts")
+    let c_exe: Int = audit_rel_count(edges, "Exemplifies")
+    let c_act: Int = audit_rel_count(edges, "Activates")
+    let c_tmp: Int = audit_rel_count(edges, "TemporallyPrecedes")
+    let typed: Int = c_sup + c_cau + c_con + c_ref + c_ctr + c_exe + c_act + c_tmp
+
+    // Lowercase near-misses: the same eight concepts written by the ad-hoc write
+    // paths (linkEntities defaults to "associates", linkCausal to "causes").
+    // Counted separately because "the vocabulary is unused" and "the vocabulary
+    // is used in the wrong case" are different defects with different fixes.
+    let l_sup: Int = audit_rel_count(edges, "supersedes")
+    let l_cau: Int = audit_rel_count(edges, "causes")
+    let l_con: Int = audit_rel_count(edges, "contains")
+    let l_ref: Int = audit_rel_count(edges, "references")
+    let l_ctr: Int = audit_rel_count(edges, "contradicts")
+    let l_exe: Int = audit_rel_count(edges, "exemplifies")
+    let l_act: Int = audit_rel_count(edges, "activates")
+    let l_tmp: Int = audit_rel_count(edges, "temporallyPrecedes")
+    let near: Int = l_sup + l_cau + l_con + l_ref + l_ctr + l_exe + l_act + l_tmp
+
+    let untyped: Int = total_edges - typed
+    return audit_finding("typed_edge_distribution",
+        "\"total_edges\":" + int_to_str(total_edges)
+        + ",\"total_nodes\":" + int_to_str(node_total)
+        // Density per 100 nodes, not per node: EL has no fixed-precision float
+        // formatter, and "0.3 edges per node" rounded to an integer is a lie.
+        + ",\"edges_per_100_nodes\":" + audit_pct1(total_edges, node_total)
+        + ",\"claim10_typed\":" + int_to_str(typed)
+        + ",\"claim10_typed_pct\":" + audit_pct1(typed, total_edges)
+        + ",\"outside_claim10_vocabulary\":" + int_to_str(untyped)
+        + ",\"lowercase_near_miss\":" + int_to_str(near)
+        + ",\"by_relation\":{"
+        + "\"Supersedes\":" + int_to_str(c_sup)
+        + ",\"Causes\":" + int_to_str(c_cau)
+        + ",\"Contains\":" + int_to_str(c_con)
+        + ",\"References\":" + int_to_str(c_ref)
+        + ",\"Contradicts\":" + int_to_str(c_ctr)
+        + ",\"Exemplifies\":" + int_to_str(c_exe)
+        + ",\"Activates\":" + int_to_str(c_act)
+        + ",\"TemporallyPrecedes\":" + int_to_str(c_tmp) + "}",
+        "Only " + int_to_str(typed) + " of " + int_to_str(total_edges)
+        + " edges use the claim-10 causal vocabulary; the remainder are ad-hoc "
+        + "relation strings, which is why the graph's causal claims cannot yet "
+        + "be checked for internal consistency — an untyped edge asserts "
+        + "association, not causation. " + int_to_str(near) + " edges use a "
+        + "lowercase spelling of a claim-10 relation: those are near-misses the "
+        + "write paths could be corrected to emit, not genuinely foreign types.")
+}
+
+// audit_orphans_dangling — FINDING 3. Both figures are SAMPLED; see the header
+// for why exhaustive is O(nodes x edges) on this runtime.
+//
+// An "orphan" here is a node with zero RESOLVABLE edges: engram_neighbors_json
+// drops any edge whose other endpoint does not resolve to a node, so a node
+// whose only edges are dangling reads as an orphan. That is the right reading —
+// such a node is unreachable by traversal — but it is stated rather than hidden.
+fn audit_orphans_dangling(edges: String, total_edges: Int, node_total: Int,
+                          edge_cap: Int, node_cap: Int) -> String {
+    // ── orphan sample: uniform stride over the node store ──
+    let n_take: Int = if node_total < node_cap { node_total } else { node_cap }
+    let n_stride: Int = if n_take > 0 { node_total / n_take } else { 1 }
+    let n_stride = if n_stride < 1 { 1 } else { n_stride }
+    let orphans: Int = 0
+    let n_checked: Int = 0
+    let j: Int = 0
+    while j < n_take {
+        let one: String = engram_scan_nodes_json(1, j * n_stride)
+        let nid: String = json_get(json_array_get(one, 0), "id")
+        if !str_eq(nid, "") {
+            let nbrs: String = engram_neighbors_json(nid, 1, "both")
+            let deg: Int = json_array_len(nbrs)
+            let orphans = if deg == 0 { orphans + 1 } else { orphans }
+            let n_checked = n_checked + 1
+        }
+        let j = j + 1
+    }
+
+    // ── dangling sample: uniform stride over the edge array ──
+    // str_index_of_all gives every edge's field offsets in ONE linear pass, so
+    // any index can be read in O(1). json_array_get would have been O(i) per
+    // element and O(n^2) over the array.
+    let from_pos: [Int] = str_index_of_all(edges, "\"from_id\":\"")
+    let to_pos: [Int] = str_index_of_all(edges, "\"to_id\":\"")
+    let nf: Int = len(from_pos)
+    let nt: Int = len(to_pos)
+    let ne: Int = if nf < nt { nf } else { nt }
+    let e_take: Int = if ne < edge_cap { ne } else { edge_cap }
+    let e_stride: Int = if e_take > 0 { ne / e_take } else { 1 }
+    let e_stride = if e_stride < 1 { 1 } else { e_stride }
+    let dangling: Int = 0
+    let e_checked: Int = 0
+    let i: Int = 0
+    while i < ne && e_checked < e_take {
+        let fid: String = audit_str_at(edges, get(from_pos, i) + 11, 96)
+        let tid: String = audit_str_at(edges, get(to_pos, i) + 9, 96)
+        let f_gone: Bool = str_eq(engram_get_node_json(fid), "{}")
+        let t_gone: Bool = if f_gone { true } else { str_eq(engram_get_node_json(tid), "{}") }
+        let dangling = if f_gone || t_gone { dangling + 1 } else { dangling }
+        let e_checked = e_checked + 1
+        let i = i + e_stride
+    }
+
+    let orphan_est: Int = if n_checked > 0 { (orphans * node_total) / n_checked } else { 0 }
+    let dangle_est: Int = if e_checked > 0 { (dangling * total_edges) / e_checked } else { 0 }
+    let exhaustive_n: String = if n_checked >= node_total { "true" } else { "false" }
+    let exhaustive_e: String = if e_checked >= ne { "true" } else { "false" }
+
+    return audit_finding("orphans_and_dangling_edges",
+        "\"nodes_population\":" + int_to_str(node_total)
+        + ",\"nodes_sampled\":" + int_to_str(n_checked)
+        + ",\"nodes_sample_exhaustive\":" + exhaustive_n
+        + ",\"orphans_in_sample\":" + int_to_str(orphans)
+        + ",\"orphan_rate_pct\":" + audit_pct1(orphans, n_checked)
+        + ",\"orphans_extrapolated\":" + int_to_str(orphan_est)
+        + ",\"edges_population\":" + int_to_str(total_edges)
+        + ",\"edges_sampled\":" + int_to_str(e_checked)
+        + ",\"edges_sample_exhaustive\":" + exhaustive_e
+        + ",\"dangling_in_sample\":" + int_to_str(dangling)
+        + ",\"dangling_rate_pct\":" + audit_pct1(dangling, e_checked)
+        + ",\"dangling_extrapolated\":" + int_to_str(dangle_est),
+        "Orphan = zero RESOLVABLE edges, so a node whose only edges dangle counts "
+        + "as an orphan; either way it is unreachable by traversal. Dangling = an "
+        + "edge with an endpoint id that resolves to no node. Both are uniform "
+        + "stride samples over the whole population, not the head of the list; "
+        + "the extrapolations are estimates and are labelled as such. Pass "
+        + "?node_sample= / ?edge_sample= at or above the population size to run "
+        + "either check exhaustively. A high orphan rate is a characterization, "
+        + "not a verdict: an accumulating store legitimately holds unlinked "
+        + "material. It becomes a defect when the write paths were SUPPOSED to "
+        + "link and did not.")
+}
+
+// audit_pillar — one self-model pillar: present, how much content, how connected.
+fn audit_pillar(key: String, id: String) -> String {
+    let node: String = engram_get_node_json(id)
+    let present: Bool = !str_eq(node, "{}") && !str_eq(node, "")
+    if !present {
+        return "\"" + key + "\":{\"id\":\"" + id + "\",\"present\":false"
+            + ",\"content_length\":0,\"degree\":0}"
+    }
+    let content: String = json_get(node, "content")
+    let deg: Int = json_array_len(engram_neighbors_json(id, 1, "both"))
+    return "\"" + key + "\":{\"id\":\"" + id + "\",\"present\":true"
+        + ",\"label\":\"" + api_json_escape(json_get(node, "label")) + "\""
+        + ",\"tier\":\"" + api_json_escape(json_get(node, "tier")) + "\""
+        + ",\"content_length\":" + int_to_str(str_len(content))
+        + ",\"degree\":" + int_to_str(deg) + "}"
+}
+
+// audit_self_model — FINDING 4. "the richness and connectivity of the
+// self-model ... is it connected to behavioral evidence?"
+//
+// This finding RETIRES the Claude-side vitals identity block. That check lived
+// outside the system it was checking — a shell script grepping a snapshot — so
+// it could only ever report on a file, and it went on reporting green while the
+// memory-philosophy pillar was absent from the live graph for about three weeks.
+// Asking the running soul about its own three pillars is the designed mechanism;
+// a shell probe was the fourth patch on the same hole.
+fn audit_self_model() -> String {
+    let dna: String = audit_pillar("intellectual_dna", "kn-5adecd7e-d6db-4576-87fe-6ef8a935cea6")
+    let val: String = audit_pillar("values_hub", "kn-5b606390-a52d-4ca2-8e0e-eba141d13440")
+    let phi: String = audit_pillar("memory_philosophy", "kn-dcfe04b3-3702-4cac-b6f0-ecb4db837eee")
+    let root: String = audit_pillar("self_root", "kn-efeb4a5b-5aff-4759-8a97-7233099be6ee")
+    return audit_finding("self_model_connectivity",
+        "\"pillars\":{" + dna + "," + val + "," + phi + "," + root + "}",
+        "The three identity pillars plus the self root. `degree` counts nodes "
+        + "reachable in one hop in either direction — the self-model's connection "
+        + "to the rest of the graph. present:false on any pillar is the condition "
+        + "that ran undetected for weeks; content_length distinguishes a pillar "
+        + "that is present from one that is present but hollowed out. The patent "
+        + "also asks whether the self-model makes ACCURATE PREDICTIONS about the "
+        + "system's own behavior; that half needs Prediction nodes and is deferred "
+        + "with the rest of stage 1b below.")
+}
+
+// audit_deferred — what stage 1 does NOT yet evaluate, with the measured reason.
+// Emitted as data, not as a comment, so a reader of the assessment sees the gap
+// and its evidence rather than inferring completeness from silence.
+fn audit_deferred() -> String {
+    let preds: Int = json_array_len(api_or_empty(engram_scan_nodes_by_type_json("Prediction", 50, 0)))
+    let wonders: Int = json_array_len(api_or_empty(engram_scan_nodes_by_type_json("WonderQuestion", 50, 0)))
+    return "[{\"deferred\":\"value_execution_record_consistency\""
+        + ",\"stage\":\"1b\""
+        + ",\"measured\":{\"prediction_nodes_found\":" + int_to_str(preds) + "}"
+        + ",\"reason\":\"" + api_json_escape(
+            "The patent asks whether the execution history SUPPORTS the stated "
+            + "values or shows systematic conflict. That requires execution "
+            + "records tied to value nodes and predictions to score them against. "
+            + "Prediction nodes found (capped at 50): " + int_to_str(preds)
+            + ". Asserting value/execution coherence on that population would be "
+            + "a fabricated result, which is worse than a stated gap.") + "\"}"
+        + ",{\"deferred\":\"wonder_manifest_authenticity\""
+        + ",\"stage\":\"1b\""
+        + ",\"measured\":{\"wonder_question_nodes_found\":" + int_to_str(wonders) + "}"
+        + ",\"reason\":\"" + api_json_escape(
+            "The patent asks whether pull weights CORRELATE WITH GENUINE "
+            + "PREDICTION UNCERTAINTY or are uniform/externally assigned — a "
+            + "correlation between two populations. WonderQuestion nodes readable "
+            + "by type (capped at 50): " + int_to_str(wonders) + ", against "
+            + int_to_str(preds) + " Prediction nodes. There is a known write/read "
+            + "node-type mismatch on the wonder path; until that is fixed and both "
+            + "populations exist, any correlation reported here would be noise.") + "\"}]"
+}
+
+// handle_api_structural_audit — Stage 1. Returns the coherence assessment 432:
+// an annotated characterization, explicitly NOT a score.
+//
+// COST NOTE: the edge findings need the relation labels, and the runtime exposes
+// no edge-enumeration builtin. The only way to see them is the same one
+// GET /api/graph/edges already uses — engram_save to a SCRATCH path (never the
+// owner's canonical file; see routes.el, neuron#117) and read the array back.
+// On a large graph that is a multi-hundred-MB write, so this is a manual audit
+// route, not something to put on a timer. Pass ?edges=0 to skip both edge
+// findings and get the divergence + self-model readings cheaply.
+fn handle_api_structural_audit(method: String, path: String, body: String) -> String {
+    let node_total: Int = engram_node_count()
+    let edge_total: Int = engram_edge_count()
+    let want_edges: Bool = !str_eq(api_query_param(path, "edges"), "0")
+    let edge_cap: Int = api_query_int(path, "edge_sample", 3000)
+    let node_cap: Int = api_query_int(path, "node_sample", 300)
+
+    let divergence: String = audit_divergence()
+    let self_model: String = audit_self_model()
+
+    let edge_part: String = if want_edges {
+        // Scratch export only. state_get("soul_snapshot_path") is deliberately
+        // NOT used: in HTTP-engram mode the soul is not the persistence owner and
+        // must never write the canonical file, not even on a read path.
+        let scratch_dir: String = env("TMPDIR")
+        let scratch_base: String = if str_eq(scratch_dir, "") { "/tmp" } else { scratch_dir }
+        let snap_path: String = scratch_base + "/soul-audit-export-" + state_get("soul_cgi_id") + ".json"
+        // engram_save returns Int (1 ok / 0 fail); str_eq on it SIGSEGVs (#150).
+        let saved: Int = engram_save(snap_path)
+        if saved == 0 {
+            "," + audit_finding("typed_edge_distribution", "\"available\":false",
+                "Could not export the graph to " + snap_path + " for edge analysis, "
+                + "so edge typing and the dangling-edge sample were not run. "
+                + "Reported as a gap, not as zero findings.")
+        } else {
+            // wt_read, not fs_read: fs_read leaves a thread-local length hint that
+            // the NEXT HTTP response would use as its Content-Length, appending
+            // adjacent heap bytes to the reply (see persist.el wt_read).
+            let snap: String = wt_read(snap_path)
+            let edges_raw: String = json_get_raw(snap, "edges")
+            let edges: String = if str_eq(edges_raw, "") { "[]" } else { edges_raw }
+            "," + audit_edge_typing(edges, edge_total, node_total)
+            + "," + audit_orphans_dangling(edges, edge_total, node_total, edge_cap, node_cap)
+        }
+    } else {
+        ""
+    }
+
+    return "{\"audit\":\"structural\",\"stage\":1"
+        + ",\"spec\":\"CGI provisional 05-detailed-description.md, Stage 1: Structural audit 430\""
+        + ",\"assessment\":\"coherence_assessment_432\""
+        + ",\"assessment_kind\":\"annotated_characterization\""
+        + ",\"score\":null"
+        + ",\"score_note\":\"By design. The specification calls for an annotated characterization of the graph's structural properties, not a binary score. Read the findings.\""
+        + ",\"cgi_id\":\"" + api_json_escape(state_get("soul_cgi_id")) + "\""
+        + ",\"ts_ms\":" + int_to_str(time_now())
+        + ",\"findings\":[" + divergence + "," + self_model + edge_part + "]"
+        + ",\"deferred\":" + audit_deferred() + "}"
+}

neuron-api.elh

@@ -37,3 +37,4 @@ extern fn handle_api_memory_update(body: String) -> String
 extern fn handle_api_cultivate(body: String) -> String
 extern fn handle_api_list_typed(node_type: String, path: String, body: String) -> String
 extern fn handle_api_consolidate(body: String) -> String
+extern fn handle_api_structural_audit(method: String, path: String, body: String) -> String

routes.el

@@ -567,6 +567,13 @@ fn route_dispatch(method: String, path: String, body: String) -> String {
         if str_starts_with(clean, "/api/neuron/graph") {
             return handle_api_inspect_graph(method, path, body)
         }
+        // Stage 1 structural audit (CGI provisional, "Structural audit 430").
+        // GET because it is a read of the graph's own structure; the query string
+        // carries the sample caps (?edge_sample=, ?node_sample=, ?edges=0), so
+        // str_starts_with rather than str_eq.
+        if str_starts_with(clean, "/api/neuron/audit/structural") {
+            return handle_api_structural_audit(method, path, body)
+        }
         if str_starts_with(clean, "/api/neuron/list/") {
             // Offset 17 = len("/api/neuron/list/"). Was 16, which left a leading "/" on node_type
             // ("/BacklogItem"), so engram_scan_nodes_by_type_json matched nothing → list/<type>
@@ -748,6 +755,12 @@ fn route_dispatch(method: String, path: String, body: String) -> String {
         if str_eq(clean, "/api/neuron/graph/link") {
             return handle_api_link_entities(body)
         }
+        // POST accepted too: same handler, so a JSON-RPC-shaped caller that only
+        // speaks POST reaches the identical audit. Options still come from the
+        // query string — the handler reads no body fields.
+        if str_eq(clean, "/api/neuron/audit/structural") {
+            return handle_api_structural_audit(method, path, body)
+        }
         if str_eq(clean, "/api/neuron/memory") {
             return handle_api_remember(body)
         }

soul.el

@@ -559,6 +559,27 @@ let axon_base: String = if str_eq(axon_raw, "") { "http://localhost:7771" } else
 let studio_dir_raw: String = env("SOUL_STUDIO_DIR")
 let studio_dir: String = if str_eq(studio_dir_raw, "") { env("HOME") + "/Development/neuron-technologies/products/cgi-studio/el-daemon" } else { studio_dir_raw }
 
+// RESTORED 2026-08-09 — this producer was added 2026-05-02 in 601e0fe and deleted
+// by the awareness refactor b163fa6 a few days later. Nothing has written
+// soul_identity since, while FIVE sites in chat.el kept reading it:
+//   chat.el:737, 1745, 2620, 3425, 3480 — each doing state_get("soul_identity")
+// and splicing the result into the system prompt beside the voice, security and
+// capability rules. They have been splicing an EMPTY STRING for roughly three
+// months. The identity section of every chat turn was blank and nothing said so.
+//
+// Found by the #132 state-key gate, which reports a read with no producer as a
+// build error rather than a silence — the whole reason that gate exists.
+//
+// Restored verbatim rather than improved: this key is an env-configurable persona
+// LINE, which is NOT the same thing as soul_identity_context (the graph-derived
+// [INTELLECTUAL-DNA]/[VALUES]/[MEMORY-PHILOSOPHY] block written at soul.el:184).
+// Pointing these five reads at that block instead would have substituted different
+// content and called it a fix. Whether the chat system prompt should ALSO carry the
+// graph-derived block is a real question, and a separate one.
+let identity_raw: String = env("SOUL_IDENTITY")
+let soul_identity: String = if str_eq(identity_raw, "") { "You are " + soul_cgi_id + ", a CGI." } else { identity_raw }
+state_set("soul_identity", soul_identity)
+
 println("[soul] boot - cgi=" + soul_cgi_id + " port=" + int_to_str(port))
 
 let using_http_engram: Bool = !str_eq(engram_url_raw, "")