From bef36a5e3a0d842c1e64adb5e99fc3accce3ad48 Mon Sep 17 00:00:00 2001 From: Tim Lingo <1timlingo@gmail.com> Date: Fri, 7 Aug 2026 16:45:19 -0500 Subject: [PATCH] =?UTF-8?q?feat(soul):=20Stage=201=20structural=20audit=20?= =?UTF-8?q?as=20a=20real=20route=20=E2=80=94=20an=20annotated=20characteri?= =?UTF-8?q?zation,=20not=20a=20score=20(#91)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit `runStructuralAudit` has been an advertised MCP tool with nothing behind it: the dispatcher GET'd /session/begin and returned that unrelated session digest under an audit tool's name. Meanwhile the failure the audit would have caught ran silently for about three weeks — the soul reporting 103,089 nodes while the engram, which OWNS persistence, held ~79,900, a crash discarding the difference, and every boot reporting green throughout, because nothing in the system ever compared the two sides. WHAT THE PATENT SPECIFIES, AND HOW IT SHAPED THIS CGI provisional, 05-detailed-description.md, "Stage 1: Structural audit 430". Two clauses did the design work. First the four things the module evaluates: the density and typed distribution of causal edges; value/execution-record consistency; the richness and connectivity of the self-model; and wonder- manifest authenticity. Second, and decisively: it "produces a coherence assessment 432 — NOT A BINARY SCORE but an annotated characterization of the graph's structural properties." So every finding carries its numbers AND a plain-language note saying what they mean and how they were obtained. There is no pass/fail and no composite health figure, and `"score":null` is emitted explicitly so a reader cannot mistake its absence for an omission. WHAT IS IN STAGE 1 (four findings) owner_runtime_divergence — the motivating case. Runtime counts vs the owner's own GET /api/stats, the delta, and the trend against the previous audit, so a second call answers "is the gap growing?" rather than restating it. self_model_connectivity — the three identity pillars plus the self root: present, content length, one-hop degree. This RETIRES the Claude-side vitals identity block, which lived outside the system it was checking and went on reporting green while the memory-philosophy pillar was absent from the live graph. Asking the running soul is the designed mechanism; a shell probe was the fourth patch on the same hole. typed_edge_distribution — exact counts against the claim-10 vocabulary, plus density, plus a separate count of LOWERCASE near-misses ("causes" vs "Causes"): "the vocabulary is unused" and "the vocabulary is misspelled by the write paths" are different defects with different fixes. orphans_and_dangling_edges — the tool's own long-standing promise. WHAT IS DEFERRED, AND WHY IT IS DATA RATHER THAN A COMMENT Value/execution-record consistency and wonder-manifest authenticity ship as a `deferred` array that MEASURES the populations they would need (Prediction and WonderQuestion nodes) and reports those counts as the reason. Both are ~0 today — WonderQuestion because of a known write/read node-type mismatch. Asserting value coherence or a pull-weight correlation on an empty population would be a fabricated result, which is worse than a stated gap. MEASUREMENT HONESTY: EXACT WHERE CHEAP, SAMPLED WHERE NOT, ALWAYS LABELLED Counts, edge typing and self-model connectivity are exact. Orphan and dangling rates are sampled, because engram_find_node_index is a linear scan — an exhaustive dangling check is O(nodes x edges), ~2.2e9 string compares at today's scale. Samples are UNIFORM across the whole population (str_index_of_all gives every edge offset in one pass, so any index is O(1); json_array_get would have been O(n^2)), never head-of-list, and each figure ships with its own sampled / population / exhaustive fields. ?edge_sample= and ?node_sample= at population size run either check exhaustively. The real fix is an id index in the runtime. ONE BUG THIS FOUND IN ITSELF, CAUGHT IN TEST http_get does not return "" when the owner is unreachable — it returns a JSON error object. Testing only for "" made a DEAD owner read as reachable with node_count 0, so the audit reported 100% divergence and named it data loss. Reachability is now proved by the presence of the node_count field, and the owner's raw reply is attached. A confident wrong answer is exactly what this route exists to stop. Edge findings need relation labels and the runtime has no edge-enumeration builtin, so they use the same scratch export GET /api/graph/edges already uses (engram_save to TMPDIR, never the owner's canonical file — #117). That is a large write on a large graph, so this is a manual route, not a timer; ?edges=0 skips it. neuron-api.el:900-1273 handler + helpers routes.el:567,752 GET and POST /api/neuron/audit/structural mcp-wrapper/src/main.el:113,682 tool description + dispatch off /session/begin dist/soul.c regenerated (1255 bodies) Rung: E2E-VERIFIED. Soul built from this branch (gen-soul-amalgam + cc-brain, 921,192 bytes, 16 warnings, 0 errors), booted on throwaway ports 7893/7896/7897 with throwaway HOMEs against a stub owner on 7894. Three scenarios pass: owner reachable (runtime 62 vs owner 42, delta 20 / 32.2%, trend flat on the second call; 12/20 edges claim-10 typed, 3 lowercase near-misses; 50/62 orphans, 3/20 dangling — every figure matches the fixture by construction), owner unreachable (reported as a finding with the raw reply, not a crash), and file mode (owner "none", divergence undefined). Reached end-to-end through the MCP tool via a locally built wrapper. verify-soul-contract.sh: GATE PASS, 27/27 routes + immutability. No process left running; live :7770 and :8742 untouched (GET only). Co-Authored-By: Claude Opus 5 (1M context) --- dist/soul.c | 455 ++++++++++++++++++++++++++++----------- mcp-wrapper/src/main.el | 13 +- neuron-api.el | 459 ++++++++++++++++++++++++++++++++++++++++ neuron-api.elh | 1 + routes.el | 13 ++ 5 files changed, 814 insertions(+), 127 deletions(-) diff --git a/dist/soul.c b/dist/soul.c index bb7814c..c6cc2ad 100644 --- a/dist/soul.c +++ b/dist/soul.c @@ -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) { diff --git a/mcp-wrapper/src/main.el b/mcp-wrapper/src/main.el index aba5c55..3262dc6 100644 --- a/mcp-wrapper/src/main.el +++ b/mcp-wrapper/src/main.el @@ -110,7 +110,7 @@ tool("beginSession", "Initialize session: surface recent high-importance memorie "," + tool("linkCausal", "Create a causal edge (cause -> effect).") + "," + tool("restructureCausalGraph", "Re-balance the causal subgraph after new evidence.") + "," + tool("rebuildGraph", "Rebuild graph indices from the on-disk snapshot.") + -"," + tool("runStructuralAudit", "Audit graph structure for orphans, dangling edges, mislabeled types.") + +"," + tool("runStructuralAudit", "Stage 1 structural audit: owner-vs-runtime divergence, orphans and dangling edges, typed-edge distribution, self-model connectivity. Returns an annotated characterization, not a score.") + // ── Backlog + work ────────────────────────────────────────────────────────── "," + tool("planWork", "Create a backlog item.") + "," + tool("reviewBacklog", "Browse work items.") + @@ -680,7 +680,16 @@ fn dispatch_tool_call(tool_name: String, args: String) -> String { return mcp_json_result(resp) } if str_eq(tool_name, "runStructuralAudit") { - let resp: String = http_get(neuron_url() + "/session/begin") + // Was: GET /session/begin — an unrelated session digest returned under an + // audit tool name, i.e. the tool advertised a check that did not exist. + // Now points at the real Stage 1 route (neuron-api.el + // handle_api_structural_audit). Sample caps ride the query string; the + // defaults keep a manual audit to a couple of seconds. + let e_s: Int = json_get_int(args, "edge_sample") + let n_s: Int = json_get_int(args, "node_sample") + let qs: String = "?edge_sample=" + int_to_str(if e_s > 0 { e_s } else { 3000 }) + + "&node_sample=" + int_to_str(if n_s > 0 { n_s } else { 300 }) + let resp: String = http_get(neuron_url() + "/audit/structural" + qs) return mcp_json_result(resp) } diff --git a/neuron-api.el b/neuron-api.el index b85ca1b..09a9bbc 100644 --- a/neuron-api.el +++ b/neuron-api.el @@ -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":""`. 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() + "}" +} diff --git a/neuron-api.elh b/neuron-api.elh index c3dbccb..d89b067 100644 --- a/neuron-api.elh +++ b/neuron-api.elh @@ -37,3 +37,4 @@ extern fn handle_api_memory_update(body: String) -> String extern fn handle_api_cultivate(body: String) -> String extern fn handle_api_list_typed(node_type: String, path: String, body: String) -> String extern fn handle_api_consolidate(body: String) -> String +extern fn handle_api_structural_audit(method: String, path: String, body: String) -> String diff --git a/routes.el b/routes.el index 6a49e3d..b7bd43e 100644 --- a/routes.el +++ b/routes.el @@ -567,6 +567,13 @@ fn route_dispatch(method: String, path: String, body: String) -> String { if str_starts_with(clean, "/api/neuron/graph") { return handle_api_inspect_graph(method, path, body) } + // Stage 1 structural audit (CGI provisional, "Structural audit 430"). + // GET because it is a read of the graph's own structure; the query string + // carries the sample caps (?edge_sample=, ?node_sample=, ?edges=0), so + // str_starts_with rather than str_eq. + if str_starts_with(clean, "/api/neuron/audit/structural") { + return handle_api_structural_audit(method, path, body) + } if str_starts_with(clean, "/api/neuron/list/") { // Offset 17 = len("/api/neuron/list/"). Was 16, which left a leading "/" on node_type // ("/BacklogItem"), so engram_scan_nodes_by_type_json matched nothing → list/ @@ -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) }