#include <stdint.h>
#include <stdlib.h>
#include "el_runtime.h"

el_val_t tier_working(void);
el_val_t tier_episodic(void);
el_val_t tier_canonical(void);
el_val_t mem_store(el_val_t content, el_val_t label, el_val_t tags);
el_val_t mem_remember(el_val_t content, el_val_t tags);
el_val_t mem_recall(el_val_t query, el_val_t depth);
el_val_t mem_search(el_val_t query, el_val_t limit);
el_val_t mem_strengthen(el_val_t node_id);
el_val_t mem_tombstone(el_val_t node_id);
el_val_t mem_forget(el_val_t node_id);
el_val_t mem_consolidate(void);
el_val_t mem_save(el_val_t path);
el_val_t mem_load(el_val_t path);
el_val_t mem_boot_count_get(void);
el_val_t mem_boot_count_inc(void);
el_val_t mem_emit_state_event(el_val_t trigger, el_val_t kind, el_val_t content);
el_val_t is_protected_node(el_val_t id);
el_val_t api_err_protected(el_val_t id);
el_val_t api_json_escape(el_val_t s);
el_val_t api_query_param(el_val_t path, el_val_t key);
el_val_t api_query_int(el_val_t path, el_val_t key, el_val_t default_val);
el_val_t api_ok(el_val_t extra);
el_val_t api_err(el_val_t msg);
el_val_t api_nonempty(el_val_t s);
el_val_t api_or_empty(el_val_t s);
el_val_t api_num_or_zero(el_val_t obj, el_val_t key);
el_val_t api_utf8_trunc(el_val_t s, el_val_t n);
el_val_t api_compact_node(el_val_t node, el_val_t snip);
el_val_t api_compact_node_array(el_val_t raw, el_val_t max_items, el_val_t snip);
el_val_t api_compact_activated(el_val_t raw, el_val_t max_items, el_val_t snip);
el_val_t api_persisted(el_val_t id);
el_val_t api_not_persisted(el_val_t id);
el_val_t tombstone_node(el_val_t id);
el_val_t tombstoned_id_set(void);
el_val_t memory_hide_tombstoned(el_val_t raw, el_val_t path);
el_val_t handle_api_begin_session(el_val_t body);
el_val_t handle_api_compile_ctx(el_val_t body);
el_val_t handle_api_remember(el_val_t body);
el_val_t handle_api_node_create(el_val_t body);
el_val_t handle_api_node_delete(el_val_t body);
el_val_t handle_api_node_update(el_val_t body);
el_val_t handle_api_recall(el_val_t method, el_val_t path, el_val_t body);
el_val_t handle_api_search_knowledge(el_val_t method, el_val_t path, el_val_t body);
el_val_t handle_api_browse_knowledge(el_val_t path, el_val_t body);
el_val_t handle_api_capture_knowledge(el_val_t body);
el_val_t handle_api_evolve_knowledge(el_val_t body);
el_val_t handle_api_promote_knowledge(el_val_t body);
el_val_t handle_api_browse_processes(el_val_t method, el_val_t path, el_val_t body);
el_val_t handle_api_define_process(el_val_t body);
el_val_t handle_api_log_state_event(el_val_t body);
el_val_t handle_api_list_state_events(el_val_t method, el_val_t path, el_val_t body);
el_val_t handle_api_inspect_config(el_val_t path, el_val_t body);
el_val_t handle_api_tune_config(el_val_t body);
el_val_t handle_api_inspect_graph(el_val_t method, el_val_t path, el_val_t body);
el_val_t handle_api_link_entities(el_val_t body);
el_val_t handle_api_forget(el_val_t body);
el_val_t handle_api_evolve_memory(el_val_t body);
el_val_t handle_api_memory_delete(el_val_t body);
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 is_protected_node(el_val_t id) {
  if (str_eq(id, EL_STR("kn-efeb4a5b-5aff-4759-8a97-7233099be6ee"))) {
    return 1;
  }
  if (str_eq(id, EL_STR("kn-5b606390-a52d-4ca2-8e0e-eba141d13440"))) {
    return 1;
  }
  if (str_eq(id, EL_STR("kn-5adecd7e-d6db-4576-87fe-6ef8a935cea6"))) {
    return 1;
  }
  if (str_eq(id, EL_STR("kn-dcfe04b3-3702-4cac-b6f0-ecb4db837eee"))) {
    return 1;
  }
  if (str_eq(id, EL_STR("kn-10fa60db-8af3-47de-a7dd-5095eb881d81"))) {
    return 1;
  }
  if (str_eq(id, EL_STR("kn-86b95848-e22e-4a48-ae65-5a47ef5c3798"))) {
    return 1;
  }
  if (str_eq(id, EL_STR("kn-04368bee-74fd-44dd-b4ba-ca9e39b19e7c"))) {
    return 1;
  }
  if (str_eq(id, EL_STR("kn-a5b3d0ac-f6a1-49a4-aebb-b8b4cd67fe83"))) {
    return 1;
  }
  if (str_eq(id, EL_STR("kn-22d77abe-b3c5-42fd-afcd-dcb87d924929"))) {
    return 1;
  }
  if (str_eq(id, EL_STR("kn-6061318f-046b-4935-907d-8eafdce14930"))) {
    return 1;
  }
  if (str_eq(id, EL_STR("kn-13f60407-7b70-4db1-964f-ea1f8196efbd"))) {
    return 1;
  }
  if (str_eq(id, EL_STR("kn-f230b362-b201-4402-9833-4160c89ab3d4"))) {
    return 1;
  }
  if (str_eq(id, EL_STR("kn-78db5396-3dbc-4481-bfc7-e4e1422feb1c"))) {
    return 1;
  }
  if (str_eq(id, EL_STR("kn-5de5a9ac-fd15-45ab-bf18-77566781cf40"))) {
    return 1;
  }
  if (str_eq(id, EL_STR("kn-e0423482-cfa5-4796-8689-8495c93b66bc"))) {
    return 1;
  }
  return 0;
  return 0;
}

el_val_t api_err_protected(el_val_t id) {
  return el_str_concat(el_str_concat(EL_STR("{\"__status__\":403,\"error\":\"identity/values node is write-protected\",\"id\":\""), id), EL_STR("\",\"hint\":\"use POST /api/neuron/cultivate for intentional cultivation\"}"));
  return 0;
}

el_val_t api_json_escape(el_val_t s) {
  el_val_t s1 = str_replace(s, EL_STR("\\"), EL_STR("\\\\"));
  el_val_t s2 = str_replace(s1, EL_STR("\""), EL_STR("\\\""));
  el_val_t s3 = str_replace(s2, EL_STR("\n"), EL_STR("\\n"));
  el_val_t s4 = str_replace(s3, EL_STR("\r"), EL_STR("\\r"));
  return s4;
  return 0;
}

el_val_t api_query_param(el_val_t path, el_val_t key) {
  el_val_t q = str_index_of(path, EL_STR("?"));
  if (q < 0) {
    return EL_STR("");
  }
  el_val_t qs = str_slice(path, (q + 1), str_len(path));
  el_val_t needle = el_str_concat(key, EL_STR("="));
  el_val_t pos = str_index_of(qs, needle);
  if (pos < 0) {
    return EL_STR("");
  }
  el_val_t after = str_slice(qs, (pos + str_len(needle)), str_len(qs));
  el_val_t amp = str_index_of(after, EL_STR("&"));
  if (amp < 0) {
    return after;
  }
  return str_slice(after, 0, amp);
  return 0;
}

el_val_t api_query_int(el_val_t path, el_val_t key, el_val_t default_val) {
  el_val_t v = api_query_param(path, key);
  if (str_eq(v, EL_STR(""))) {
    return default_val;
  }
  return str_to_int(v);
  return 0;
}

el_val_t api_ok(el_val_t extra) {
  if (str_eq(extra, EL_STR(""))) {
    return EL_STR("{\"ok\":true}");
  }
  return el_str_concat(el_str_concat(EL_STR("{\"ok\":true,"), extra), EL_STR("}"));
  return 0;
}

el_val_t api_err(el_val_t msg) {
  return el_str_concat(el_str_concat(EL_STR("{\"error\":\""), msg), EL_STR("\"}"));
  return 0;
}

el_val_t api_nonempty(el_val_t s) {
  return ((!str_eq(s, EL_STR("")) && !str_eq(s, EL_STR("[]"))) && !str_eq(s, EL_STR("null")));
  return 0;
}

el_val_t api_or_empty(el_val_t s) {
  if (api_nonempty(s)) {
    return s;
  }
  return EL_STR("[]");
  return 0;
}

el_val_t api_num_or_zero(el_val_t obj, el_val_t key) {
  el_val_t v = json_get_raw(obj, key);
  if (str_eq(v, EL_STR(""))) {
    return EL_STR("0");
  }
  return v;
  return 0;
}

el_val_t api_utf8_trunc(el_val_t s, el_val_t n) {
  if (str_len(s) <= n) {
    return s;
  }
  el_val_t cut = n;
  el_val_t scanning = 1;
  while (scanning && (cut > 0)) {
    el_val_t b = str_char_code(s, cut);
    el_val_t is_cont = ((b >= 128) && (b < 192));
    cut = ({ el_val_t _if_result_1 = 0; if (is_cont) { _if_result_1 = ((cut - 1)); } else { _if_result_1 = (cut); } _if_result_1; });
    scanning = is_cont;
  }
  return str_slice(s, 0, cut);
  return 0;
}

el_val_t api_compact_node(el_val_t node, el_val_t snip) {
  el_val_t id = json_get(node, EL_STR("id"));
  el_val_t ntype = json_get(node, EL_STR("node_type"));
  el_val_t label = json_get(node, EL_STR("label"));
  el_val_t tier = json_get(node, EL_STR("tier"));
  el_val_t content = json_get(node, EL_STR("content"));
  el_val_t snippet = api_utf8_trunc(content, snip);
  el_val_t trunc_str = ({ el_val_t _if_result_2 = 0; if ((str_len(content) > snip)) { _if_result_2 = (EL_STR("true")); } else { _if_result_2 = (EL_STR("false")); } _if_result_2; });
  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_concat(el_str_concat(EL_STR("{\"id\":\""), api_json_escape(id)), EL_STR("\"")), EL_STR(",\"node_type\":\"")), api_json_escape(ntype)), EL_STR("\"")), EL_STR(",\"label\":\"")), api_json_escape(label)), EL_STR("\"")), EL_STR(",\"tier\":\"")), api_json_escape(tier)), EL_STR("\"")), EL_STR(",\"importance\":")), api_num_or_zero(node, EL_STR("importance"))), EL_STR(",\"salience\":")), api_num_or_zero(node, EL_STR("salience"))), EL_STR(",\"content\":\"")), api_json_escape(snippet)), EL_STR("\"")), EL_STR(",\"content_truncated\":")), trunc_str), EL_STR("}"));
  return 0;
}

el_val_t api_compact_node_array(el_val_t raw, el_val_t max_items, el_val_t snip) {
  if (!api_nonempty(raw)) {
    return EL_STR("[]");
  }
  el_val_t n = json_array_len(raw);
  el_val_t cap = ({ el_val_t _if_result_3 = 0; if ((n < max_items)) { _if_result_3 = (n); } else { _if_result_3 = (max_items); } _if_result_3; });
  el_val_t out = EL_STR("[");
  el_val_t i = 0;
  while (i < cap) {
    el_val_t node = json_array_get(raw, i);
    el_val_t sep = ({ el_val_t _if_result_4 = 0; if ((i == 0)) { _if_result_4 = (EL_STR("")); } else { _if_result_4 = (EL_STR(",")); } _if_result_4; });
    out = el_str_concat(el_str_concat(out, sep), api_compact_node(node, snip));
    i = (i + 1);
  }
  return el_str_concat(out, EL_STR("]"));
  return 0;
}

el_val_t api_compact_activated(el_val_t raw, el_val_t max_items, el_val_t snip) {
  if (!api_nonempty(raw)) {
    return EL_STR("[]");
  }
  el_val_t n = json_array_len(raw);
  el_val_t cap = ({ el_val_t _if_result_5 = 0; if ((n < max_items)) { _if_result_5 = (n); } else { _if_result_5 = (max_items); } _if_result_5; });
  el_val_t out = EL_STR("[");
  el_val_t i = 0;
  while (i < cap) {
    el_val_t el = json_array_get(raw, i);
    el_val_t node = json_get_raw(el, EL_STR("node"));
    el_val_t sep = ({ el_val_t _if_result_6 = 0; if ((i == 0)) { _if_result_6 = (EL_STR("")); } else { _if_result_6 = (EL_STR(",")); } _if_result_6; });
    out = el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(out, sep), EL_STR("{\"node\":")), api_compact_node(node, snip)), EL_STR(",\"activation_strength\":")), api_num_or_zero(el, EL_STR("activation_strength"))), EL_STR(",\"working_memory_weight\":")), api_num_or_zero(el, EL_STR("working_memory_weight"))), EL_STR(",\"epistemic_confidence\":")), api_num_or_zero(el, EL_STR("epistemic_confidence"))), EL_STR(",\"hops\":")), api_num_or_zero(el, EL_STR("hops"))), EL_STR(",\"promoted\":")), api_num_or_zero(el, EL_STR("promoted"))), EL_STR("}"));
    i = (i + 1);
  }
  return el_str_concat(out, EL_STR("]"));
  return 0;
}

el_val_t api_persisted(el_val_t id) {
  if (str_eq(id, EL_STR(""))) {
    return 0;
  }
  el_val_t node = engram_get_node_json(id);
  return ((!str_eq(node, EL_STR("")) && !str_eq(node, EL_STR("null"))) && !str_eq(node, EL_STR("{}")));
  return 0;
}

el_val_t api_not_persisted(el_val_t id) {
  return el_str_concat(el_str_concat(EL_STR("{\"ok\":false,\"error\":\"write_not_persisted\",\"id\":\""), id), EL_STR("\"}"));
  return 0;
}

el_val_t tombstone_node(el_val_t id) {
  return mem_tombstone(id);
  return 0;
}

el_val_t tombstoned_id_set(void) {
  el_val_t markers = engram_scan_nodes_by_type_json(EL_STR("Tombstone"), 5000, 0);
  if (str_eq(markers, EL_STR("")) || str_eq(markers, EL_STR("[]"))) {
    return EL_STR("");
  }
  el_val_t n = json_array_len(markers);
  el_val_t acc = EL_STR("|");
  el_val_t i = 0;
  while (i < n) {
    el_val_t m = json_array_get(markers, i);
    el_val_t tid = json_get(m, EL_STR("content"));
    acc = ({ el_val_t _if_result_7 = 0; if (str_eq(tid, EL_STR(""))) { _if_result_7 = (acc); } else { _if_result_7 = (el_str_concat(el_str_concat(acc, tid), EL_STR("|"))); } _if_result_7; });
    i = (i + 1);
  }
  return acc;
  return 0;
}

el_val_t memory_hide_tombstoned(el_val_t raw, el_val_t path) {
  if (str_contains(path, EL_STR("include_deleted"))) {
    return raw;
  }
  if (str_eq(raw, EL_STR("")) || str_eq(raw, EL_STR("[]"))) {
    return raw;
  }
  el_val_t dead = tombstoned_id_set();
  if (str_eq(dead, EL_STR(""))) {
    return raw;
  }
  el_val_t n = json_array_len(raw);
  if (n > 1000) {
    return raw;
  }
  el_val_t out = EL_STR("[");
  el_val_t first = 1;
  el_val_t i = 0;
  while (i < n) {
    el_val_t node = json_array_get(raw, i);
    el_val_t nid = json_get(node, EL_STR("id"));
    el_val_t ntype = json_get(node, EL_STR("node_type"));
    el_val_t is_dead = (!str_eq(nid, EL_STR("")) && str_contains(dead, el_str_concat(el_str_concat(EL_STR("|"), nid), EL_STR("|"))));
    el_val_t keep = (!str_eq(ntype, EL_STR("Tombstone")) && !is_dead);
    out = ({ el_val_t _if_result_8 = 0; if (keep) { _if_result_8 = (({ el_val_t _if_result_9 = 0; if (first) { _if_result_9 = (el_str_concat(out, node)); } else { _if_result_9 = (el_str_concat(el_str_concat(out, EL_STR(",")), node)); } _if_result_9; })); } else { _if_result_8 = (out); } _if_result_8; });
    first = ({ el_val_t _if_result_10 = 0; if (keep) { _if_result_10 = (0); } else { _if_result_10 = (first); } _if_result_10; });
    i = (i + 1);
  }
  return el_str_concat(out, EL_STR("]"));
  return 0;
}

el_val_t handle_api_begin_session(el_val_t body) {
  el_val_t stats = engram_stats_json();
  el_val_t activated_raw = engram_activate_json(EL_STR("session start recent memory important"), 1);
  el_val_t activated = api_compact_activated(activated_raw, 8, 240);
  el_val_t state_events_raw = engram_scan_nodes_by_type_json(EL_STR("InternalStateEvent"), 5, 0);
  el_val_t state_events = api_compact_node_array(state_events_raw, 5, 500);
  el_val_t recent_raw = engram_scan_nodes_json(10, 0);
  el_val_t recent = api_compact_node_array(recent_raw, 10, 240);
  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("{\"stats\":"), stats), EL_STR(",\"recent\":")), recent), EL_STR(",\"activated\":")), activated), EL_STR(",\"self_neighbors\":[]")), EL_STR(",\"recent_state_events\":")), state_events), EL_STR("}"));
  return 0;
}

el_val_t handle_api_compile_ctx(el_val_t body) {
  el_val_t stats = engram_stats_json();
  el_val_t activated_raw = engram_activate_json(EL_STR("active work context current task in progress"), 2);
  el_val_t activated = api_compact_activated(activated_raw, 10, 240);
  el_val_t recent_raw = engram_scan_nodes_json(20, 0);
  el_val_t recent = api_compact_node_array(recent_raw, 20, 240);
  return el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"stats\":"), stats), EL_STR(",\"recent_nodes\":")), recent), EL_STR(",\"activated\":")), activated), EL_STR("}"));
  return 0;
}

el_val_t handle_api_remember(el_val_t body) {
  el_val_t content = json_get(body, EL_STR("content"));
  if (str_eq(content, EL_STR(""))) {
    return api_err(EL_STR("content is required"));
  }
  el_val_t importance = json_get(body, EL_STR("importance"));
  el_val_t tags_raw = json_get(body, EL_STR("tags"));
  el_val_t project = json_get(body, EL_STR("project"));
  el_val_t sal_str = ({ el_val_t _if_result_11 = 0; if (str_eq(importance, EL_STR("critical"))) { _if_result_11 = (EL_STR("0.95")); } else { _if_result_11 = (({ el_val_t _if_result_12 = 0; if (str_eq(importance, EL_STR("high"))) { _if_result_12 = (EL_STR("0.75")); } else { _if_result_12 = (({ el_val_t _if_result_13 = 0; if (str_eq(importance, EL_STR("low"))) { _if_result_13 = (EL_STR("0.25")); } else { _if_result_13 = (EL_STR("0.50")); } _if_result_13; })); } _if_result_12; })); } _if_result_11; });
  el_val_t sal = ({ el_val_t _if_result_14 = 0; if (str_eq(sal_str, EL_STR("0.95"))) { _if_result_14 = (el_from_float(0.95)); } else { _if_result_14 = (({ el_val_t _if_result_15 = 0; if (str_eq(sal_str, EL_STR("0.75"))) { _if_result_15 = (el_from_float(0.75)); } else { _if_result_15 = (({ el_val_t _if_result_16 = 0; if (str_eq(sal_str, EL_STR("0.25"))) { _if_result_16 = (el_from_float(0.25)); } else { _if_result_16 = (el_from_float(0.5)); } _if_result_16; })); } _if_result_15; })); } _if_result_14; });
  el_val_t base_tags = ({ el_val_t _if_result_17 = 0; if (str_eq(tags_raw, EL_STR(""))) { _if_result_17 = (EL_STR("[\"Memory\"]")); } else { _if_result_17 = (tags_raw); } _if_result_17; });
  el_val_t final_tags = ({ el_val_t _if_result_18 = 0; if (str_eq(project, EL_STR(""))) { _if_result_18 = (base_tags); } else { el_val_t inner = str_slice(base_tags, 1, (str_len(base_tags) - 1)); _if_result_18 = (el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("["), inner), EL_STR(",\"project:")), project), EL_STR("\"]"))); } _if_result_18; });
  el_val_t id = engram_node_full(content, EL_STR("Memory"), EL_STR("memory:remembered"), sal, sal, el_from_float(0.9), EL_STR("Episodic"), final_tags);
  if (!api_persisted(id)) {
    return api_not_persisted(id);
  }
  return el_str_concat(el_str_concat(EL_STR("{\"id\":\""), id), EL_STR("\",\"ok\":true}"));
  return 0;
}

el_val_t handle_api_node_create(el_val_t body) {
  el_val_t content = json_get(body, EL_STR("content"));
  if (str_eq(content, EL_STR(""))) {
    return api_err(EL_STR("content is required"));
  }
  el_val_t nt_raw = json_get(body, EL_STR("node_type"));
  el_val_t node_type = ({ el_val_t _if_result_19 = 0; if (str_eq(nt_raw, EL_STR(""))) { _if_result_19 = (EL_STR("Memory")); } else { _if_result_19 = (nt_raw); } _if_result_19; });
  el_val_t label_raw = json_get(body, EL_STR("label"));
  el_val_t label = ({ el_val_t _if_result_20 = 0; if (str_eq(label_raw, EL_STR(""))) { _if_result_20 = (EL_STR("node:created")); } else { _if_result_20 = (label_raw); } _if_result_20; });
  el_val_t tier_raw = json_get(body, EL_STR("tier"));
  el_val_t tier = ({ el_val_t _if_result_21 = 0; if (str_eq(tier_raw, EL_STR(""))) { _if_result_21 = (EL_STR("Episodic")); } else { _if_result_21 = (tier_raw); } _if_result_21; });
  el_val_t tags_raw = json_get(body, EL_STR("tags"));
  el_val_t tags = ({ el_val_t _if_result_22 = 0; if (str_eq(tags_raw, EL_STR(""))) { _if_result_22 = (el_str_concat(el_str_concat(EL_STR("[\""), node_type), EL_STR("\"]"))); } else { _if_result_22 = (tags_raw); } _if_result_22; });
  el_val_t importance = json_get(body, EL_STR("importance"));
  el_val_t sal = ({ el_val_t _if_result_23 = 0; if (str_eq(importance, EL_STR("critical"))) { _if_result_23 = (el_from_float(0.95)); } else { _if_result_23 = (({ el_val_t _if_result_24 = 0; if (str_eq(importance, EL_STR("high"))) { _if_result_24 = (el_from_float(0.75)); } else { _if_result_24 = (({ el_val_t _if_result_25 = 0; if (str_eq(importance, EL_STR("low"))) { _if_result_25 = (el_from_float(0.25)); } else { _if_result_25 = (el_from_float(0.5)); } _if_result_25; })); } _if_result_24; })); } _if_result_23; });
  el_val_t id = engram_node_full(content, node_type, label, sal, sal, el_from_float(0.9), tier, tags);
  if (!api_persisted(id)) {
    return api_not_persisted(id);
  }
  return el_str_concat(el_str_concat(EL_STR("{\"id\":\""), id), EL_STR("\",\"ok\":true}"));
  return 0;
}

el_val_t handle_api_node_delete(el_val_t body) {
  el_val_t id = json_get(body, EL_STR("id"));
  if (str_eq(id, EL_STR(""))) {
    return api_err(EL_STR("id is required"));
  }
  if (is_protected_node(id)) {
    return api_err_protected(id);
  }
  el_val_t existing = engram_get_node_json(id);
  if (str_eq(existing, EL_STR("{}"))) {
    return api_err(el_str_concat(EL_STR("node not found: "), id));
  }
  el_val_t marker = tombstone_node(id);
  if (str_eq(marker, EL_STR(""))) {
    return api_err(el_str_concat(EL_STR("tombstone failed: "), id));
  }
  return el_str_concat(el_str_concat(EL_STR("{\"ok\":true,\"id\":\""), id), EL_STR("\",\"tombstoned\":true}"));
  return 0;
}

el_val_t handle_api_node_update(el_val_t body) {
  el_val_t id = json_get(body, EL_STR("id"));
  if (str_eq(id, EL_STR(""))) {
    return api_err(EL_STR("id is required"));
  }
  if (!api_persisted(id)) {
    return el_str_concat(el_str_concat(EL_STR("{\"ok\":false,\"error\":\"not_found\",\"id\":\""), id), EL_STR("\"}"));
  }
  el_val_t old = engram_get_node_json(id);
  el_val_t body_content = json_get(body, EL_STR("content"));
  el_val_t content = ({ el_val_t _if_result_26 = 0; if (str_eq(body_content, EL_STR(""))) { _if_result_26 = (json_get(old, EL_STR("content"))); } else { _if_result_26 = (body_content); } _if_result_26; });
  el_val_t body_nt = json_get(body, EL_STR("node_type"));
  el_val_t old_nt = json_get(old, EL_STR("node_type"));
  el_val_t node_type = ({ el_val_t _if_result_27 = 0; if (!str_eq(body_nt, EL_STR(""))) { _if_result_27 = (body_nt); } else { _if_result_27 = (({ el_val_t _if_result_28 = 0; if (!str_eq(old_nt, EL_STR(""))) { _if_result_28 = (old_nt); } else { _if_result_28 = (EL_STR("Memory")); } _if_result_28; })); } _if_result_27; });
  el_val_t body_label = json_get(body, EL_STR("label"));
  el_val_t old_label = json_get(old, EL_STR("label"));
  el_val_t label = ({ el_val_t _if_result_29 = 0; if (!str_eq(body_label, EL_STR(""))) { _if_result_29 = (body_label); } else { _if_result_29 = (({ el_val_t _if_result_30 = 0; if (!str_eq(old_label, EL_STR(""))) { _if_result_30 = (old_label); } else { _if_result_30 = (EL_STR("node:updated")); } _if_result_30; })); } _if_result_29; });
  el_val_t body_tier = json_get(body, EL_STR("tier"));
  el_val_t old_tier = json_get(old, EL_STR("tier"));
  el_val_t tier = ({ el_val_t _if_result_31 = 0; if (!str_eq(body_tier, EL_STR(""))) { _if_result_31 = (body_tier); } else { _if_result_31 = (({ el_val_t _if_result_32 = 0; if (!str_eq(old_tier, EL_STR(""))) { _if_result_32 = (old_tier); } else { _if_result_32 = (EL_STR("Episodic")); } _if_result_32; })); } _if_result_31; });
  el_val_t body_tags = json_get(body, EL_STR("tags"));
  el_val_t tags = ({ el_val_t _if_result_33 = 0; if (str_eq(body_tags, EL_STR(""))) { _if_result_33 = (el_str_concat(el_str_concat(EL_STR("[\""), node_type), EL_STR("\"]"))); } else { _if_result_33 = (body_tags); } _if_result_33; });
  el_val_t new_id = engram_node_full(content, node_type, label, el_from_float(0.5), el_from_float(0.5), el_from_float(0.8), tier, tags);
  if (!api_persisted(new_id)) {
    return api_not_persisted(new_id);
  }
  engram_connect(new_id, id, el_from_float(0.9), EL_STR("supersedes"));
  return el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"id\":\""), new_id), EL_STR("\",\"supersedes\":\"")), id), EL_STR("\",\"ok\":true}"));
  return 0;
}

el_val_t handle_api_recall(el_val_t method, el_val_t path, el_val_t body) {
  el_val_t url_q = ({ el_val_t _if_result_34 = 0; if (str_eq(api_query_param(path, EL_STR("query")), EL_STR(""))) { _if_result_34 = (api_query_param(path, EL_STR("q"))); } else { _if_result_34 = (api_query_param(path, EL_STR("query"))); } _if_result_34; });
  el_val_t body_query = json_get(body, EL_STR("query"));
  el_val_t body_q = json_get(body, EL_STR("q"));
  el_val_t q = ({ el_val_t _if_result_35 = 0; if (!str_eq(url_q, EL_STR(""))) { _if_result_35 = (url_q); } else { _if_result_35 = (({ el_val_t _if_result_36 = 0; if (!str_eq(body_query, EL_STR(""))) { _if_result_36 = (body_query); } else { _if_result_36 = (body_q); } _if_result_36; })); } _if_result_35; });
  el_val_t chain = json_get(body, EL_STR("chain_name"));
  el_val_t limit = api_query_int(path, EL_STR("limit"), 0);
  limit = ({ el_val_t _if_result_37 = 0; if ((limit == 0)) { _if_result_37 = (json_get_int(body, EL_STR("limit"))); } else { _if_result_37 = (limit); } _if_result_37; });
  limit = ({ el_val_t _if_result_38 = 0; if ((limit == 0)) { _if_result_38 = (10); } else { _if_result_38 = (limit); } _if_result_38; });
  el_val_t eff_q = ({ el_val_t _if_result_39 = 0; if (str_eq(q, EL_STR(""))) { _if_result_39 = (chain); } else { _if_result_39 = (q); } _if_result_39; });
  if (str_eq(eff_q, EL_STR(""))) {
    return api_or_empty(engram_scan_nodes_json(limit, 0));
  }
  el_val_t results = engram_search_json(eff_q, limit);
  return api_or_empty(results);
  return 0;
}

el_val_t handle_api_search_knowledge(el_val_t method, el_val_t path, el_val_t body) {
  el_val_t url_q = api_query_param(path, EL_STR("q"));
  el_val_t body_query = json_get(body, EL_STR("query"));
  el_val_t body_q = json_get(body, EL_STR("q"));
  el_val_t q = ({ el_val_t _if_result_40 = 0; if (!str_eq(url_q, EL_STR(""))) { _if_result_40 = (url_q); } else { _if_result_40 = (({ el_val_t _if_result_41 = 0; if (!str_eq(body_query, EL_STR(""))) { _if_result_41 = (body_query); } else { _if_result_41 = (body_q); } _if_result_41; })); } _if_result_40; });
  el_val_t limit = api_query_int(path, EL_STR("limit"), 0);
  limit = ({ el_val_t _if_result_42 = 0; if ((limit == 0)) { _if_result_42 = (json_get_int(body, EL_STR("limit"))); } else { _if_result_42 = (limit); } _if_result_42; });
  limit = ({ el_val_t _if_result_43 = 0; if ((limit == 0)) { _if_result_43 = (10); } else { _if_result_43 = (limit); } _if_result_43; });
  if (str_eq(q, EL_STR(""))) {
    return api_err(EL_STR("query is required"));
  }
  el_val_t results = engram_search_json(q, limit);
  if (str_eq(results, EL_STR(""))) {
    return EL_STR("[]");
  }
  el_val_t first = str_slice(results, 0, 1);
  if (!str_eq(first, EL_STR("[")) && !str_eq(first, EL_STR("{"))) {
    return api_or_empty(engram_activate_json(q, 2));
  }
  return results;
  return 0;
}

el_val_t handle_api_browse_knowledge(el_val_t path, el_val_t body) {
  el_val_t limit = api_query_int(path, EL_STR("limit"), 50);
  return api_or_empty(engram_scan_nodes_by_type_json(EL_STR("Knowledge"), limit, 0));
  return 0;
}

el_val_t handle_api_capture_knowledge(el_val_t body) {
  el_val_t content = json_get(body, EL_STR("content"));
  el_val_t title = json_get(body, EL_STR("title"));
  if (str_eq(content, EL_STR(""))) {
    return api_err(EL_STR("content is required"));
  }
  el_val_t full = ({ el_val_t _if_result_44 = 0; if (str_eq(title, EL_STR(""))) { _if_result_44 = (content); } else { _if_result_44 = (el_str_concat(el_str_concat(title, EL_STR(": ")), content)); } _if_result_44; });
  el_val_t lbl = str_slice(title, 0, 80);
  el_val_t tags = EL_STR("[\"Knowledge\",\"captured\"]");
  el_val_t id = engram_node_full(full, EL_STR("Knowledge"), lbl, el_from_float(0.85), el_from_float(0.8), el_from_float(0.9), EL_STR("Episodic"), tags);
  if (!api_persisted(id)) {
    return api_not_persisted(id);
  }
  return el_str_concat(el_str_concat(EL_STR("{\"id\":\""), id), EL_STR("\",\"ok\":true}"));
  return 0;
}

el_val_t handle_api_evolve_knowledge(el_val_t body) {
  el_val_t prior_id = json_get(body, EL_STR("id"));
  el_val_t content = json_get(body, EL_STR("content"));
  if (str_eq(content, EL_STR(""))) {
    return api_err(EL_STR("content is required"));
  }
  if (!str_eq(prior_id, EL_STR("")) && is_protected_node(prior_id)) {
    return api_err_protected(prior_id);
  }
  el_val_t tags = EL_STR("[\"Knowledge\",\"evolved\"]");
  el_val_t new_id = engram_node_full(content, EL_STR("Knowledge"), EL_STR(""), el_from_float(0.75), el_from_float(0.75), el_from_float(0.9), EL_STR("Episodic"), tags);
  if (!api_persisted(new_id)) {
    return api_not_persisted(new_id);
  }
  if (!str_eq(prior_id, EL_STR(""))) {
    engram_connect(new_id, prior_id, el_from_float(0.9), EL_STR("supersedes"));
  }
  return el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"id\":\""), new_id), EL_STR("\",\"supersedes\":\"")), prior_id), EL_STR("\",\"ok\":true}"));
  return 0;
}

el_val_t handle_api_promote_knowledge(el_val_t body) {
  el_val_t prior_id = json_get(body, EL_STR("id"));
  el_val_t content = json_get(body, EL_STR("content"));
  if (str_eq(content, EL_STR(""))) {
    return api_err(EL_STR("content is required"));
  }
  if (str_eq(prior_id, EL_STR(""))) {
    return api_err(EL_STR("id (prior node) is required"));
  }
  el_val_t tags_raw = json_get(body, EL_STR("tags"));
  el_val_t tags = ({ el_val_t _if_result_45 = 0; if (str_eq(tags_raw, EL_STR(""))) { _if_result_45 = (EL_STR("[\"Knowledge\",\"tier:canonical\",\"disposition:stable\"]")); } else { _if_result_45 = (tags_raw); } _if_result_45; });
  el_val_t new_id = engram_node_full(content, EL_STR("Knowledge"), EL_STR(""), el_from_float(0.9), el_from_float(0.9), el_from_float(1.0), EL_STR("Canonical"), tags);
  if (!api_persisted(new_id)) {
    return api_not_persisted(new_id);
  }
  engram_connect(new_id, prior_id, el_from_float(0.95), EL_STR("supersedes"));
  return el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"ok\":true,\"new_id\":\""), new_id), EL_STR("\",\"supersedes\":\"")), prior_id), EL_STR("\"}"));
  return 0;
}

el_val_t handle_api_browse_processes(el_val_t method, el_val_t path, el_val_t body) {
  el_val_t name = ({ el_val_t _if_result_46 = 0; if (str_eq(method, EL_STR("GET"))) { _if_result_46 = (api_query_param(path, EL_STR("name"))); } else { _if_result_46 = (json_get(body, EL_STR("name"))); } _if_result_46; });
  el_val_t limit = api_query_int(path, EL_STR("limit"), 50);
  if (str_eq(name, EL_STR(""))) {
    return api_or_empty(engram_scan_nodes_by_type_json(EL_STR("Process"), limit, 0));
  }
  return api_or_empty(engram_search_json(name, limit));
  return 0;
}

el_val_t handle_api_define_process(el_val_t body) {
  el_val_t content = json_get(body, EL_STR("content"));
  el_val_t name = json_get(body, EL_STR("name"));
  if (str_eq(content, EL_STR(""))) {
    return api_err(EL_STR("content is required"));
  }
  el_val_t label = ({ el_val_t _if_result_47 = 0; if (str_eq(name, EL_STR(""))) { _if_result_47 = (EL_STR("process:unnamed")); } else { _if_result_47 = (el_str_concat(EL_STR("process:"), name)); } _if_result_47; });
  el_val_t tags = EL_STR("[\"Process\"]");
  el_val_t id = engram_node_full(content, EL_STR("Process"), label, el_from_float(0.8), el_from_float(0.8), el_from_float(0.9), EL_STR("Canonical"), tags);
  if (!api_persisted(id)) {
    return api_not_persisted(id);
  }
  return el_str_concat(el_str_concat(EL_STR("{\"id\":\""), id), EL_STR("\",\"ok\":true}"));
  return 0;
}

el_val_t handle_api_log_state_event(el_val_t body) {
  el_val_t trigger = json_get(body, EL_STR("trigger"));
  el_val_t pre = json_get(body, EL_STR("pre_reasoning"));
  el_val_t post = json_get(body, EL_STR("post_reasoning"));
  el_val_t ratio = json_get(body, EL_STR("compression_ratio"));
  el_val_t gap = json_get(body, EL_STR("gap_direction"));
  el_val_t legacy = json_get(body, EL_STR("content"));
  el_val_t parts = EL_STR("INTERNAL STATE EVENT");
  parts = ({ el_val_t _if_result_48 = 0; if (!str_eq(trigger, EL_STR(""))) { _if_result_48 = (el_str_concat(el_str_concat(parts, EL_STR("\nTrigger: ")), trigger)); } else { _if_result_48 = (parts); } _if_result_48; });
  parts = ({ el_val_t _if_result_49 = 0; if (!str_eq(pre, EL_STR(""))) { _if_result_49 = (el_str_concat(el_str_concat(parts, EL_STR("\nPre-reasoning: ")), pre)); } else { _if_result_49 = (parts); } _if_result_49; });
  parts = ({ el_val_t _if_result_50 = 0; if (!str_eq(post, EL_STR(""))) { _if_result_50 = (el_str_concat(el_str_concat(parts, EL_STR("\nPost-reasoning: ")), post)); } else { _if_result_50 = (parts); } _if_result_50; });
  parts = ({ el_val_t _if_result_51 = 0; if (!str_eq(ratio, EL_STR(""))) { _if_result_51 = (el_str_concat(el_str_concat(parts, EL_STR("\nCompression-ratio: ")), ratio)); } else { _if_result_51 = (parts); } _if_result_51; });
  parts = ({ el_val_t _if_result_52 = 0; if (!str_eq(gap, EL_STR(""))) { _if_result_52 = (el_str_concat(el_str_concat(parts, EL_STR("\nGap-direction: ")), gap)); } else { _if_result_52 = (parts); } _if_result_52; });
  parts = ({ el_val_t _if_result_53 = 0; if (!str_eq(legacy, EL_STR(""))) { _if_result_53 = (el_str_concat(el_str_concat(parts, EL_STR("\n")), legacy)); } else { _if_result_53 = (parts); } _if_result_53; });
  el_val_t ts = time_now();
  el_val_t boot = state_get(EL_STR("soul_boot_count"));
  el_val_t tags = EL_STR("[\"internal-state\",\"InternalStateEvent\",\"pre-reasoning\"]");
  el_val_t id = engram_node_full(parts, EL_STR("InternalStateEvent"), EL_STR("state-event:manual"), el_from_float(0.85), el_from_float(0.85), el_from_float(0.9), EL_STR("Episodic"), tags);
  if (!api_persisted(id)) {
    return api_not_persisted(id);
  }
  return el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"ok\":true,\"id\":\""), id), EL_STR("\",\"boot\":\"")), boot), EL_STR("\"}"));
  return 0;
}

el_val_t handle_api_list_state_events(el_val_t method, el_val_t path, el_val_t body) {
  el_val_t q = ({ el_val_t _if_result_54 = 0; if (str_eq(method, EL_STR("GET"))) { _if_result_54 = (api_query_param(path, EL_STR("query"))); } else { _if_result_54 = (json_get(body, EL_STR("query"))); } _if_result_54; });
  el_val_t limit = api_query_int(path, EL_STR("limit"), 20);
  if (!str_eq(q, EL_STR(""))) {
    return api_or_empty(engram_search_json(el_str_concat(EL_STR("internal state "), q), limit));
  }
  return api_or_empty(engram_scan_nodes_by_type_json(EL_STR("InternalStateEvent"), limit, 0));
  return 0;
}

el_val_t handle_api_inspect_config(el_val_t path, el_val_t body) {
  el_val_t key = api_query_param(path, EL_STR("key"));
  key = ({ el_val_t _if_result_55 = 0; if (str_eq(key, EL_STR(""))) { _if_result_55 = (json_get(body, EL_STR("key"))); } else { _if_result_55 = (key); } _if_result_55; });
  if (str_eq(key, EL_STR(""))) {
    return EL_STR("{\"hint\":\"pass ?key=<name>\",\"known\":[\"neuron.self.traversal_root\",\"neuron.self.values_hub\"]}");
  }
  if (str_eq(key, EL_STR("neuron.self.traversal_root"))) {
    return EL_STR("{\"key\":\"neuron.self.traversal_root\",\"value\":\"kn-efeb4a5b-5aff-4759-8a97-7233099be6ee\"}");
  }
  if (str_eq(key, EL_STR("neuron.self.values_hub"))) {
    return EL_STR("{\"key\":\"neuron.self.values_hub\",\"value\":\"kn-5b606390-a52d-4ca2-8e0e-eba141d13440\"}");
  }
  el_val_t results = engram_search_json(el_str_concat(EL_STR("config:"), key), 5);
  if (!api_nonempty(results)) {
    return el_str_concat(el_str_concat(EL_STR("{\"key\":\""), key), EL_STR("\",\"value\":null}"));
  }
  el_val_t node = json_array_get(results, 0);
  el_val_t content = json_get(node, EL_STR("content"));
  el_val_t prefix = el_str_concat(el_str_concat(EL_STR("config:"), key), EL_STR("="));
  el_val_t value = ({ el_val_t _if_result_56 = 0; if (str_starts_with(content, prefix)) { _if_result_56 = (str_slice(content, str_len(prefix), str_len(content))); } else { _if_result_56 = (content); } _if_result_56; });
  return el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"key\":\""), key), EL_STR("\",\"value\":\"")), value), EL_STR("\"}"));
  return 0;
}

el_val_t handle_api_tune_config(el_val_t body) {
  el_val_t key = json_get(body, EL_STR("key"));
  el_val_t value = json_get(body, EL_STR("value"));
  if (str_eq(key, EL_STR(""))) {
    return api_err(EL_STR("key is required"));
  }
  el_val_t content = el_str_concat(el_str_concat(el_str_concat(EL_STR("config:"), key), EL_STR("=")), value);
  el_val_t tags = EL_STR("[\"ConfigEntry\",\"config\"]");
  el_val_t id = engram_node_full(content, EL_STR("ConfigEntry"), key, el_from_float(0.85), el_from_float(0.85), el_from_float(0.9), EL_STR("Canonical"), tags);
  if (!api_persisted(id)) {
    return api_not_persisted(id);
  }
  return el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"ok\":true,\"key\":\""), key), EL_STR("\",\"value\":\"")), value), EL_STR("\",\"id\":\"")), id), EL_STR("\"}"));
  return 0;
}

el_val_t handle_api_inspect_graph(el_val_t method, el_val_t path, el_val_t body) {
  el_val_t entity_id = ({ el_val_t _if_result_57 = 0; if (str_eq(method, EL_STR("GET"))) { _if_result_57 = (api_query_param(path, EL_STR("id"))); } else { _if_result_57 = (json_get(body, EL_STR("entity_id"))); } _if_result_57; });
  el_val_t name = ({ el_val_t _if_result_58 = 0; if (str_eq(method, EL_STR("GET"))) { _if_result_58 = (api_query_param(path, EL_STR("name"))); } else { _if_result_58 = (json_get(body, EL_STR("name"))); } _if_result_58; });
  el_val_t depth = api_query_int(path, EL_STR("depth"), 0);
  depth = ({ el_val_t _if_result_59 = 0; if ((depth == 0)) { _if_result_59 = (json_get_int(body, EL_STR("max_depth"))); } else { _if_result_59 = (depth); } _if_result_59; });
  depth = ({ el_val_t _if_result_60 = 0; if ((depth == 0)) { _if_result_60 = (1); } else { _if_result_60 = (depth); } _if_result_60; });
  el_val_t resolved = entity_id;
  resolved = ({ el_val_t _if_result_61 = 0; if (str_eq(resolved, EL_STR(""))) { _if_result_61 = (({ el_val_t _if_result_62 = 0; if ((str_eq(name, EL_STR("self")) || str_eq(name, EL_STR("neuron")))) { _if_result_62 = (EL_STR("kn-efeb4a5b-5aff-4759-8a97-7233099be6ee")); } else { _if_result_62 = (({ el_val_t _if_result_63 = 0; if ((str_eq(name, EL_STR("values")) || str_eq(name, EL_STR("values_hub")))) { _if_result_63 = (EL_STR("kn-5b606390-a52d-4ca2-8e0e-eba141d13440")); } else { _if_result_63 = (EL_STR("")); } _if_result_63; })); } _if_result_62; })); } else { _if_result_61 = (resolved); } _if_result_61; });
  if (str_eq(resolved, EL_STR(""))) {
    return api_err(EL_STR("entity_id or name required. Known names: self, neuron, values, values_hub"));
  }
  el_val_t results = engram_neighbors_json(resolved, depth, EL_STR("both"));
  return api_or_empty(results);
  return 0;
}

el_val_t handle_api_link_entities(el_val_t body) {
  el_val_t from_id = json_get(body, EL_STR("from_id"));
  el_val_t to_id = json_get(body, EL_STR("to_id"));
  if (str_eq(from_id, EL_STR(""))) {
    return api_err(EL_STR("from_id is required"));
  }
  if (str_eq(to_id, EL_STR(""))) {
    return api_err(EL_STR("to_id is required"));
  }
  if (is_protected_node(to_id)) {
    return api_err_protected(to_id);
  }
  el_val_t relation = json_get(body, EL_STR("relation"));
  el_val_t eff_relation = ({ el_val_t _if_result_64 = 0; if (str_eq(relation, EL_STR(""))) { _if_result_64 = (EL_STR("associates")); } else { _if_result_64 = (relation); } _if_result_64; });
  engram_connect(from_id, to_id, el_from_float(0.5), eff_relation);
  return el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"ok\":true,\"from_id\":\""), from_id), EL_STR("\",\"to_id\":\"")), to_id), EL_STR("\",\"relation\":\"")), eff_relation), EL_STR("\"}"));
  return 0;
}

el_val_t handle_api_forget(el_val_t body) {
  el_val_t node_id = json_get(body, EL_STR("id"));
  if (str_eq(node_id, EL_STR(""))) {
    return api_err(EL_STR("id is required"));
  }
  if (is_protected_node(node_id)) {
    return api_err_protected(node_id);
  }
  mem_forget(node_id);
  return el_str_concat(el_str_concat(EL_STR("{\"ok\":true,\"id\":\""), node_id), EL_STR("\",\"tombstoned\":true}"));
  return 0;
}

el_val_t handle_api_evolve_memory(el_val_t body) {
  el_val_t prior_id = json_get(body, EL_STR("id"));
  el_val_t content = json_get(body, EL_STR("content"));
  if (str_eq(content, EL_STR(""))) {
    return api_err(EL_STR("content is required"));
  }
  if (!str_eq(prior_id, EL_STR("")) && is_protected_node(prior_id)) {
    return api_err_protected(prior_id);
  }
  el_val_t importance = json_get(body, EL_STR("importance"));
  el_val_t sal_str = ({ el_val_t _if_result_65 = 0; if (str_eq(importance, EL_STR("critical"))) { _if_result_65 = (EL_STR("0.95")); } else { _if_result_65 = (({ el_val_t _if_result_66 = 0; if (str_eq(importance, EL_STR("high"))) { _if_result_66 = (EL_STR("0.75")); } else { _if_result_66 = (({ el_val_t _if_result_67 = 0; if (str_eq(importance, EL_STR("low"))) { _if_result_67 = (EL_STR("0.25")); } else { _if_result_67 = (EL_STR("0.50")); } _if_result_67; })); } _if_result_66; })); } _if_result_65; });
  el_val_t sal = ({ el_val_t _if_result_68 = 0; if (str_eq(sal_str, EL_STR("0.95"))) { _if_result_68 = (el_from_float(0.95)); } else { _if_result_68 = (({ el_val_t _if_result_69 = 0; if (str_eq(sal_str, EL_STR("0.75"))) { _if_result_69 = (el_from_float(0.75)); } else { _if_result_69 = (({ el_val_t _if_result_70 = 0; if (str_eq(sal_str, EL_STR("0.25"))) { _if_result_70 = (el_from_float(0.25)); } else { _if_result_70 = (el_from_float(0.5)); } _if_result_70; })); } _if_result_69; })); } _if_result_68; });
  el_val_t tags = EL_STR("[\"Memory\",\"evolved\"]");
  el_val_t new_id = engram_node_full(content, EL_STR("Memory"), EL_STR("memory:evolved"), sal, sal, el_from_float(0.9), EL_STR("Episodic"), tags);
  if (!str_eq(prior_id, EL_STR("")) && !str_eq(new_id, EL_STR(""))) {
    engram_connect(new_id, prior_id, el_from_float(0.9), EL_STR("supersedes"));
  }
  return el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"id\":\""), new_id), EL_STR("\",\"supersedes\":\"")), prior_id), EL_STR("\",\"ok\":true}"));
  return 0;
}

el_val_t handle_api_memory_delete(el_val_t body) {
  el_val_t node_id = json_get(body, EL_STR("id"));
  if (str_eq(node_id, EL_STR(""))) {
    return api_err(EL_STR("id is required"));
  }
  if (is_protected_node(node_id)) {
    return api_err_protected(node_id);
  }
  el_val_t existing = engram_get_node_json(node_id);
  if (str_eq(existing, EL_STR("{}"))) {
    return api_err(el_str_concat(EL_STR("memory not found: "), node_id));
  }
  el_val_t marker = tombstone_node(node_id);
  if (str_eq(marker, EL_STR(""))) {
    return api_err(el_str_concat(EL_STR("tombstone failed: "), node_id));
  }
  return el_str_concat(el_str_concat(EL_STR("{\"ok\":true,\"id\":\""), node_id), EL_STR("\",\"tombstoned\":true}"));
  return 0;
}

el_val_t handle_api_memory_update(el_val_t body) {
  el_val_t prior_id = json_get(body, EL_STR("id"));
  el_val_t content = json_get(body, EL_STR("content"));
  if (str_eq(prior_id, EL_STR(""))) {
    return api_err(EL_STR("id is required"));
  }
  if (str_eq(content, EL_STR(""))) {
    return api_err(EL_STR("content is required"));
  }
  if (is_protected_node(prior_id)) {
    return api_err_protected(prior_id);
  }
  el_val_t existing = engram_get_node_json(prior_id);
  if (str_eq(existing, EL_STR("{}"))) {
    return api_err(el_str_concat(EL_STR("memory not found: "), prior_id));
  }
  return handle_api_evolve_memory(body);
  return 0;
}

el_val_t handle_api_cultivate(el_val_t body) {
  el_val_t op = json_get(body, EL_STR("operation"));
  if (str_eq(op, EL_STR(""))) {
    return api_err(EL_STR("operation is required"));
  }
  if (str_eq(op, EL_STR("evolve_knowledge"))) {
    el_val_t prior_id = json_get(body, EL_STR("id"));
    el_val_t content = json_get(body, EL_STR("content"));
    if (str_eq(content, EL_STR(""))) {
      return api_err(EL_STR("content is required"));
    }
    el_val_t tags = EL_STR("[\"Knowledge\",\"evolved\",\"cultivated\"]");
    el_val_t new_id = engram_node_full(content, EL_STR("Knowledge"), EL_STR("knowledge:cultivated"), el_from_float(0.75), el_from_float(0.75), el_from_float(0.9), EL_STR("Episodic"), tags);
    if (!str_eq(prior_id, EL_STR("")) && !str_eq(new_id, EL_STR(""))) {
      engram_connect(new_id, prior_id, el_from_float(0.9), EL_STR("supersedes"));
    }
    return el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"id\":\""), new_id), EL_STR("\",\"supersedes\":\"")), prior_id), EL_STR("\",\"ok\":true,\"cultivated\":true}"));
  }
  if (str_eq(op, EL_STR("evolve_memory"))) {
    el_val_t prior_id = json_get(body, EL_STR("id"));
    el_val_t content = json_get(body, EL_STR("content"));
    if (str_eq(content, EL_STR(""))) {
      return api_err(EL_STR("content is required"));
    }
    el_val_t importance = json_get(body, EL_STR("importance"));
    el_val_t sal = ({ el_val_t _if_result_71 = 0; if (str_eq(importance, EL_STR("critical"))) { _if_result_71 = (el_from_float(0.95)); } else { _if_result_71 = (({ el_val_t _if_result_72 = 0; if (str_eq(importance, EL_STR("high"))) { _if_result_72 = (el_from_float(0.75)); } else { _if_result_72 = (({ el_val_t _if_result_73 = 0; if (str_eq(importance, EL_STR("low"))) { _if_result_73 = (el_from_float(0.25)); } else { _if_result_73 = (el_from_float(0.5)); } _if_result_73; })); } _if_result_72; })); } _if_result_71; });
    el_val_t tags = EL_STR("[\"Memory\",\"evolved\",\"cultivated\"]");
    el_val_t new_id = engram_node_full(content, EL_STR("Memory"), EL_STR("memory:cultivated"), sal, sal, el_from_float(0.9), EL_STR("Episodic"), tags);
    if (!str_eq(prior_id, EL_STR("")) && !str_eq(new_id, EL_STR(""))) {
      engram_connect(new_id, prior_id, el_from_float(0.9), EL_STR("supersedes"));
    }
    return el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"id\":\""), new_id), EL_STR("\",\"supersedes\":\"")), prior_id), EL_STR("\",\"ok\":true,\"cultivated\":true}"));
  }
  if (str_eq(op, EL_STR("forget"))) {
    el_val_t node_id = json_get(body, EL_STR("id"));
    if (str_eq(node_id, EL_STR(""))) {
      return api_err(EL_STR("id is required"));
    }
    mem_forget(node_id);
    return el_str_concat(el_str_concat(EL_STR("{\"ok\":true,\"id\":\""), node_id), EL_STR("\",\"tombstoned\":true,\"cultivated\":true}"));
  }
  if (str_eq(op, EL_STR("link_entities"))) {
    el_val_t from_id = json_get(body, EL_STR("from_id"));
    el_val_t to_id = json_get(body, EL_STR("to_id"));
    if (str_eq(from_id, EL_STR(""))) {
      return api_err(EL_STR("from_id is required"));
    }
    if (str_eq(to_id, EL_STR(""))) {
      return api_err(EL_STR("to_id is required"));
    }
    el_val_t relation = json_get(body, EL_STR("relation"));
    el_val_t eff_relation = ({ el_val_t _if_result_74 = 0; if (str_eq(relation, EL_STR(""))) { _if_result_74 = (EL_STR("associates")); } else { _if_result_74 = (relation); } _if_result_74; });
    engram_connect(from_id, to_id, el_from_float(0.5), eff_relation);
    return el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"ok\":true,\"from_id\":\""), from_id), EL_STR("\",\"to_id\":\"")), to_id), EL_STR("\",\"relation\":\"")), eff_relation), EL_STR("\",\"cultivated\":true}"));
  }
  return api_err(el_str_concat(el_str_concat(EL_STR("unknown operation: "), op), EL_STR(" (valid: evolve_knowledge, evolve_memory, forget, link_entities)")));
  return 0;
}

el_val_t handle_api_list_typed(el_val_t node_type, el_val_t path, el_val_t body) {
  el_val_t limit = api_query_int(path, EL_STR("limit"), 50);
  el_val_t raw = api_or_empty(engram_scan_nodes_by_type_json(node_type, limit, 0));
  return memory_hide_tombstoned(raw, path);
  return 0;
}

el_val_t handle_api_consolidate(el_val_t body) {
  el_val_t summary = json_get(body, EL_STR("summary"));
  el_val_t snap = state_get(EL_STR("soul_snapshot_path"));
  if (!str_eq(snap, EL_STR(""))) {
    el_val_t saved = engram_save(snap);
    if (saved == 0) {
      println(el_str_concat(el_str_concat(EL_STR("[api] consolidate: engram_save failed for "), snap), EL_STR(" \xe2\x80\x94 snapshot may be out of sync")));
    }
  }
  if (!str_eq(summary, EL_STR(""))) {
    el_val_t safe_summary = str_replace(summary, EL_STR("\""), EL_STR("'"));
    el_val_t tags = EL_STR("[\"SessionSummary\",\"consolidate\"]");
    el_val_t summary_id = engram_node_full(el_str_concat(EL_STR("[session-summary] "), safe_summary), EL_STR("SessionSummary"), EL_STR("session:summary"), el_from_float(0.7), el_from_float(0.7), el_from_float(0.9), EL_STR("Episodic"), tags);
    if (str_eq(summary_id, EL_STR(""))) {
      println(EL_STR("[api] consolidate: session summary engram write failed \xe2\x80\x94 summary node lost"));
    }
  }
  return el_str_concat(el_str_concat(EL_STR("{\"ok\":true,\"snapshot\":\""), snap), EL_STR("\"}"));
  return 0;
}

