neuron-technologies/neuron
3
0
Fork 0
Code Issues 44 Pull Requests 7 Actions Packages Projects Releases Wiki Activity

feat(engine): structural audit stage one — the runtime-vs-owner divergence check #142

Closed
tim.lingo wants to merge 1 commits from feat/structural-audit into main
pull from: feat/structural-audit
merge into: :main
Conversation 1 Commits 1 Files Changed 5
+814 -127
5 changed files with 814 additions and 127 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Showing only changes of commit bef36a5e3a - Show all commits
dist/soul.c
Generated Vendored
+330 -125
View File
@@ -1205,6 +1205,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);
@@ -30219,6 +30231,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");
@@ -30264,7 +30463,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;
@@ -30275,7 +30474,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\"]");
@@ -30287,7 +30486,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;
@@ -30324,16 +30523,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("]"));
@@ -30351,7 +30550,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);
@@ -30359,17 +30558,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;
@@ -30380,7 +30579,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) {
@@ -30390,11 +30589,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) {
@@ -30402,7 +30601,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(""));
@@ -30425,7 +30624,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("");
@@ -30438,23 +30637,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);
}
@@ -30482,8 +30681,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("}"));
@@ -30507,7 +30706,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("]"));
@@ -30543,7 +30742,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);
@@ -30561,35 +30760,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);
@@ -30606,7 +30805,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("");
@@ -30619,15 +30818,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) {
@@ -30647,7 +30846,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("");
@@ -30660,15 +30859,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) {
@@ -30702,13 +30901,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\"}");
}
@@ -30716,8 +30915,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));
@@ -30734,12 +30933,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);
@@ -30765,24 +30964,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("");
@@ -30811,18 +31010,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;
}
@@ -30892,30 +31091,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"))) {
@@ -30950,7 +31149,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));
@@ -31022,22 +31221,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;
}
@@ -31104,6 +31303,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);
@@ -31118,7 +31320,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("}"));
}
}
@@ -31128,7 +31330,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);
}
@@ -31142,14 +31344,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);
}
@@ -31173,7 +31375,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;
}
@@ -31252,6 +31454,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);
}
@@ -31297,7 +31502,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);
}
@@ -31308,7 +31513,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);
}
@@ -31434,8 +31639,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(""))) {
@@ -31456,21 +31661,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)")));
}
@@ -31493,10 +31698,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)")));
@@ -31542,19 +31747,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)")));
@@ -31601,23 +31806,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);
@@ -31633,17 +31838,17 @@ 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; });
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);
@@ -31653,8 +31858,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_826 = 0; if (str_eq(nodes_json, EL_STR(""))) { _if_result_826 = (EL_STR("[]")); } else { _if_result_826 = (nodes_json); } _if_result_826; });
el_val_t edges_part = ({ el_val_t _if_result_827 = 0; if (str_eq(edges_json, EL_STR(""))) { _if_result_827 = (EL_STR("[]")); } else { _if_result_827 = (edges_json); } _if_result_827; });
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);
@@ -31678,7 +31883,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_828 = 0; if (str_eq(engram_url_raw, EL_STR(""))) { _if_result_828 = (fs_read(snapshot)); } else { _if_result_828 = (EL_STR("")); } _if_result_828; });
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) {
mcp-wrapper/src/main.el
+11 -2
View File
@@ -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
+459
View File
@@ -889,3 +889,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
+1
View File
@@ -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
+13
View File
@@ -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)
}