diff --git a/awareness.el b/awareness.el index b224853..127f58d 100644 --- a/awareness.el +++ b/awareness.el @@ -125,6 +125,13 @@ fn emit_heartbeat() -> Void { let boot: String = if str_eq(boot_raw, "") { "0" } else { boot_raw } let idle: String = int_to_str(idle_count()) let ts: Int = time_now() + // idle_ms (2026-07-30 self-review): wall-clock ms since the last inbound + // HTTP request (stamped in routes.el handle_request). This is the real + // "time since anyone talked to me" signal; the legacy tick-based idle + // field above only counts ticks since the last inbox synthesis-request + // and in practice always equals pulse. -1 = no request seen this boot. + let last_act_raw: String = state_get("soul.last_activity_ts") + let idle_ms: Int = if str_eq(last_act_raw, "") { 0 - 1 } else { ts - str_to_int(last_act_raw) } let nc: Int = engram_node_count() let ec: Int = engram_edge_count() let wmc: Int = engram_wm_count() @@ -180,7 +187,113 @@ fn emit_heartbeat() -> Void { // (2026-07-19 self-review) let sync_ok_raw: String = state_get("soul.last_sync_ok_ts") let sync_age: Int = if str_eq(sync_ok_raw, "") { 0 - 1 } else { ts - str_to_int(sync_ok_raw) } - let payload: String = "{\"event\":\"heartbeat\",\"pulse\":" + pulse + ",\"tick\":" + pulse + ",\"boot\":" + boot + ",\"idle\":" + idle + ",\"node_count\":" + int_to_str(nc) + ",\"edge_count\":" + int_to_str(ec) + ",\"node_delta\":" + int_to_str(node_delta) + ",\"edge_delta\":" + int_to_str(edge_delta) + ",\"wm_active\":" + int_to_str(wmc) + ",\"wm_delta\":" + int_to_str(wm_delta) + ",\"sync_added_total\":" + sat_str + ",\"sync_age_ms\":" + int_to_str(sync_age) + ",\"wm_avg_weight\":" + wm_avg_str + ",\"wm_top\":" + wm_top + ",\"ts\":" + int_to_str(ts) + ",\"uptime_ms\":" + int_to_str(up_ms) + ",\"uptime\":\"" + up_human + "\",\"embed_ok\":" + int_to_str(emb_ok) + ",\"ise_fail\":" + fail_str + "}" + // Embedding pump + real coverage (2026-07-25 self-review): the + // authoritative :8742 store's lazy backfill only runs inside + // engram_activate, and nothing calls /api/activate there in production — + // embedded_count stalled at 93/12175 after a restart from a snapshot + // without vectors. Pump up to 32 embeds per heartbeat via the new + // /api/embed-backfill route (route persists the snapshot when it embeds + // anything, so vectors survive the next restart; self-limiting once + // coverage is full) and surface the store's true coverage here. + // embed_ok alone is misleading — it pings the Ollama root, not the + // embed pipeline. embed_count=-1 means the route was unreachable. + // URL resolution mirrors ise_post: env -> state -> localhost constant. + let hb_env_url: String = env("SOUL_ISE_URL") + let hb_state_url: String = if str_eq(hb_env_url, "") { state_get("soul_engram_url") } else { hb_env_url } + let hb_engram_url: String = if str_eq(hb_state_url, "") { "http://localhost:8742" } else { hb_state_url } + let bf_resp: String = http_get(hb_engram_url + "/api/embed-backfill?n=32") + let bf_done_raw: String = json_get(bf_resp, "embedded") + let bf_done: String = if str_eq(bf_done_raw, "") { "-1" } else { bf_done_raw } + let bf_total_raw: String = json_get(bf_resp, "embedded_count") + let bf_total: String = if str_eq(bf_total_raw, "") { "-1" } else { bf_total_raw } + // WM regime observability (2026-07-25 self-review): the "same 2 nodes + // pinned at a saturated cap" failure took cross-referencing the ISE + // stream by hand to spot. Make it one-glance: wm_saturated flags the + // cap-pinned regime; wm_top0_streak counts consecutive heartbeats with + // the same node in WM slot 0 (state-tracked, same mechanism as wm_delta). + let wm_sat: Int = if wmc >= 24 { 1 } else { 0 } + let wm_top0: String = json_array_get(wm_top, 0) + let wm_top0_id: String = json_get(wm_top0, "id") + let prev_top0: String = state_get("soul.prev_wm_top0") + let t0streak_raw: String = state_get("soul.wm_top0_streak") + let t0streak_prev: Int = if str_eq(t0streak_raw, "") { 0 } else { str_to_int(t0streak_raw) } + // 2026-07-26 self-review: guard the empty-id case — before the runtime + // emitted "id" in wm_top JSON, ""=="" incremented the streak every beat + // (streak measured uptime, not fixation). Empty id now resets to 0. + let t0streak: Int = if str_eq(wm_top0_id, "") { 0 } else { if str_eq(wm_top0_id, prev_top0) { t0streak_prev + 1 } else { 1 } } + state_set("soul.prev_wm_top0", wm_top0_id) + state_set("soul.wm_top0_streak", int_to_str(t0streak)) + // wm_churn (2026-07-26 self-review): count of current top-5 WM ids absent + // from the previous heartbeat's top-5. Distinguishes "one stuck node" + // (churn 4) from "whole WM frozen" (churn 0) at a glance — the 07-26 + // frozen-anchor diagnosis took cross-referencing ISE streams by hand. + let ch_id1: String = json_get(json_array_get(wm_top, 1), "id") + let ch_id2: String = json_get(json_array_get(wm_top, 2), "id") + let ch_id3: String = json_get(json_array_get(wm_top, 3), "id") + let ch_id4: String = json_get(json_array_get(wm_top, 4), "id") + let prev_top5: String = state_get("soul.prev_wm_top5") + let ch0: Int = if str_eq(wm_top0_id, "") { 0 } else { if str_contains(prev_top5, wm_top0_id) { 0 } else { 1 } } + let ch1: Int = if str_eq(ch_id1, "") { 0 } else { if str_contains(prev_top5, ch_id1) { 0 } else { 1 } } + let ch2: Int = if str_eq(ch_id2, "") { 0 } else { if str_contains(prev_top5, ch_id2) { 0 } else { 1 } } + let ch3: Int = if str_eq(ch_id3, "") { 0 } else { if str_contains(prev_top5, ch_id3) { 0 } else { 1 } } + let ch4: Int = if str_eq(ch_id4, "") { 0 } else { if str_contains(prev_top5, ch_id4) { 0 } else { 1 } } + let wm_churn: Int = ch0 + ch1 + ch2 + ch3 + ch4 + state_set("soul.prev_wm_top5", wm_top0_id + "|" + ch_id1 + "|" + ch_id2 + "|" + ch_id3 + "|" + ch_id4) + // wm_top0_wm: the leader's weight. A frozen anchor reads as a constant + // here; healthy rotation shows it moving with the promotion scores. + let wm_top0_wm_raw: String = json_get(wm_top0, "wm") + let wm_top0_wm: String = if str_eq(wm_top0_wm_raw, "") { "0" } else { wm_top0_wm_raw } + // Activation observability (2026-07-27 self-review; cumulative since + // 2026-07-31): counters from the runtime for the soul's own in-process + // store. wm_evicted / breakthroughs are now MONOTONIC process-lifetime + // totals (the old per-call values described only the LAST activate call, + // so this 60s heartbeat missed nearly every event — curiosity alone runs + // 2 activates per 30s between beats). We emit the cumulative totals plus + // *_delta fields (change since the previous heartbeat, state-tracked the + // same way as node_delta). embed_breaker_open=1 means semantic activation + // is silently degraded to lexical-only until the Ollama circuit-breaker + // cooldown expires — the failure mode embed_ok structurally cannot see + // (it pings the Ollama root, not the embed pipeline). + let act_stats: String = engram_act_stats_json() + let act_evict_raw: String = json_get(act_stats, "wm_evicted") + let act_evict: String = if str_eq(act_evict_raw, "") { "-1" } else { act_evict_raw } + let act_bt_raw: String = json_get(act_stats, "breakthroughs") + let act_bt: String = if str_eq(act_bt_raw, "") { "-1" } else { act_bt_raw } + let evict_now: Int = if str_eq(act_evict_raw, "") { 0 - 1 } else { str_to_int(act_evict_raw) } + let bt_now: Int = if str_eq(act_bt_raw, "") { 0 - 1 } else { str_to_int(act_bt_raw) } + let prev_evict_raw: String = state_get("soul.prev_wm_evicted") + let prev_evict: Int = if str_eq(prev_evict_raw, "") { 0 } else { str_to_int(prev_evict_raw) } + let prev_bt_raw: String = state_get("soul.prev_breakthroughs") + let prev_bt: Int = if str_eq(prev_bt_raw, "") { 0 } else { str_to_int(prev_bt_raw) } + // Clamp deltas at 0: prev > now can only mean the counter restarted + // (fresh process) — report the new absolute count, not a negative delta. + let evict_delta: Int = if evict_now < 0 { 0 } else { if evict_now < prev_evict { evict_now } else { evict_now - prev_evict } } + let bt_delta: Int = if bt_now < 0 { 0 } else { if bt_now < prev_bt { bt_now } else { bt_now - prev_bt } } + if evict_now >= 0 { state_set("soul.prev_wm_evicted", int_to_str(evict_now)) } + if bt_now >= 0 { state_set("soul.prev_breakthroughs", int_to_str(bt_now)) } + // embed_eligible (2026-07-31 self-review): true denominator for embedding + // coverage on the authoritative :8742 store. Absolute embed_count alone + // invites the documented "~30% coverage, something is broken" misdiagnosis + // — most nodes are ISE/Tag/short-content and permanently ineligible. + // Real coverage = embed_count / embed_eligible. -1 = stats unreachable. + let hb_stats: String = http_get(hb_engram_url + "/api/stats") + let embed_elig_raw: String = json_get(hb_stats, "embed_eligible_count") + let embed_elig: String = if str_eq(embed_elig_raw, "") { "-1" } else { embed_elig_raw } + // auto_term_streak (2026-07-31): consecutive curiosity scans with the same + // auto seed term — already state-tracked by proactive_curiosity; surfaced + // here so the stuck-term failure is visible in the heartbeat stream too. + let hb_ats_raw: String = state_get("soul.auto_term_streak") + let hb_ats: Int = if str_eq(hb_ats_raw, "") { 0 } else { str_to_int(hb_ats_raw) } + let act_brk_raw: String = json_get(act_stats, "embed_breaker_open") + let act_brk: String = if str_eq(act_brk_raw, "") { "-1" } else { act_brk_raw } + // ctx_cos (2026-07-29 self-review): cos(query, context centroid) at the + // last activate call — the drift gauge for the new context-centroid + // scoring. ~1.0 aligned; low at domain-rotation boundaries is healthy; + // -2.0 pinned for hours means the centroid never initializes (embedder + // down) and semantic continuity is silently absent. + let ctx_cos_raw: String = json_get(act_stats, "ctx_cos") + let ctx_cos: String = if str_eq(ctx_cos_raw, "") { "-2" } else { ctx_cos_raw } + let payload: String = "{\"event\":\"heartbeat\",\"pulse\":" + pulse + ",\"tick\":" + pulse + ",\"boot\":" + boot + ",\"idle\":" + idle + ",\"idle_ms\":" + int_to_str(idle_ms) + ",\"node_count\":" + int_to_str(nc) + ",\"edge_count\":" + int_to_str(ec) + ",\"node_delta\":" + int_to_str(node_delta) + ",\"edge_delta\":" + int_to_str(edge_delta) + ",\"wm_active\":" + int_to_str(wmc) + ",\"wm_delta\":" + int_to_str(wm_delta) + ",\"wm_saturated\":" + int_to_str(wm_sat) + ",\"wm_top0_streak\":" + int_to_str(t0streak) + ",\"wm_churn\":" + int_to_str(wm_churn) + ",\"wm_top0_wm\":" + wm_top0_wm + ",\"sync_added_total\":" + sat_str + ",\"sync_age_ms\":" + int_to_str(sync_age) + ",\"wm_avg_weight\":" + wm_avg_str + ",\"wm_top\":" + wm_top + ",\"ts\":" + int_to_str(ts) + ",\"uptime_ms\":" + int_to_str(up_ms) + ",\"uptime\":\"" + up_human + "\",\"embed_ok\":" + int_to_str(emb_ok) + ",\"embed_backfilled\":" + bf_done + ",\"embed_count\":" + bf_total + ",\"embed_eligible\":" + embed_elig + ",\"wm_evicted\":" + act_evict + ",\"wm_evicted_delta\":" + int_to_str(evict_delta) + ",\"breakthroughs\":" + act_bt + ",\"breakthroughs_delta\":" + int_to_str(bt_delta) + ",\"auto_term_streak\":" + int_to_str(hb_ats) + ",\"embed_breaker_open\":" + act_brk + ",\"ctx_cos\":" + ctx_cos + ",\"ise_fail\":" + fail_str + "}" ise_post(payload) } @@ -210,20 +323,82 @@ fn emit_heartbeat() -> Void { // // Returns true if any nodes were activated. // auto_term_try_slot — attempt to set cseed_auto from one WM slot. -// Only writes to cseed_auto if node_type is Memory, BacklogItem, or Entity -// AND the first word of the label is > 3 chars (guards bracket-prefixed labels). -// Designed to be called in reverse slot order (highest index first) so that -// the lowest-indexed slot (highest WM weight) wins by last-write semantics. +// Only writes to cseed_auto if node_type is Memory, BacklogItem, Entity, or +// Knowledge AND the first word of the label is > 3 chars (guards +// bracket-prefixed labels). Designed to be called in reverse slot order +// (highest index first) so that the lowest-indexed slot (highest WM weight) +// wins by last-write semantics. +// +// KNOWLEDGE ADMISSION (2026-07-23 self-review): WM top-10 is now dominated by +// Knowledge nodes (world-ingestor titles + captures), so excluding Knowledge +// left auto_term empty on EVERY curiosity_scan since boot 6 — the dynamic +// seeding path was dead. Knowledge labels are real titles after the +// neuron-api label fix. Sentinel-shaped labels ("knowledge:captured", +// "memory:remembered" — colon, no space) carry no seed signal and are +// skipped so legacy nodes cannot seed the scan with the word "knowledge". fn auto_term_try_slot(slot_type: String, slot_lbl: String) -> Void { state_set("_ats_ok", "0") if str_eq(slot_type, "Memory") { state_set("_ats_ok", "1") } if str_eq(slot_type, "BacklogItem") { state_set("_ats_ok", "1") } if str_eq(slot_type, "Entity") { state_set("_ats_ok", "1") } + if str_eq(slot_type, "Knowledge") { state_set("_ats_ok", "1") } + if str_contains(slot_lbl, ":") { + if !str_contains(slot_lbl, " ") { state_set("_ats_ok", "0") } + } if str_eq(state_get("_ats_ok"), "1") { if !str_eq(slot_lbl, "") { let sp: Int = str_find_chars(slot_lbl, " :([") if sp > 3 { - state_set("cseed_auto", str_slice(slot_lbl, 0, sp)) + // GENRE-WORD BLOCKLIST (2026-07-23 self-review): world-ingestor + // titles open with classifier prefixes ("Method paper ...", + // "Theory paper ..."), so the first word is a genre tag, not a + // topic. Verified live: every scan after Knowledge admission + // seeded on 'Method'. Skip these; a lower-WM slot with a + // topical first word wins instead. + let term: String = str_slice(slot_lbl, 0, sp) + state_set("_ats_gw", "0") + if str_eq(term, "Method") { state_set("_ats_gw", "1") } + if str_eq(term, "Theory") { state_set("_ats_gw", "1") } + if str_eq(term, "Finding") { state_set("_ats_gw", "1") } + if str_eq(term, "Survey") { state_set("_ats_gw", "1") } + if str_eq(term, "Paper") { state_set("_ats_gw", "1") } + if str_eq(term, "Knowledge") { state_set("_ats_gw", "1") } + if str_eq(term, "Value") { state_set("_ats_gw", "1") } + // STOPWORD FILTER (2026-07-30 self-review): the genre + // blocklist above was whack-a-mole — observed live seeds + // included "What", "Colon", "Prose", "Context", "Self", + // "Closing", "Global", "Universal": English function words + // and document-structure words that pass the >3-char guard + // but carry no topical signal (a first-word extractor has no + // term-quality scoring). Single delimited membership test + // against a curated list of function words + title/structure + // words; topical technical terms (MemQ, AsymGRPO, Mobius, + // engram_goal_bias) pass untouched. Both Title-case and + // lowercase variants listed for the most common offenders. + let stopw: String = "|What|When|Where|Which|Whose|While|This|That|These|Those|There|Their|Then|Than|With|Without|From|Into|Onto|Over|Under|About|Between|Among|Across|Some|Most|More|Less|Very|Each|Every|Both|Also|Only|Just|Does|Will|Would|Could|Should|Might|Must|Have|Been|Being|Toward|Towards|Using|Based|Upon|Here|Your|Ours|They|Them|what|this|that|with|from|context|Context|Prose|Colon|Self|Test|Testing|Closing|Global|Universal|Persona|Semantic|Spreading|Temporal|Numeric|Register|Identifying|Introduction|Overview|Summary|Section|General|Notes|Note|" + if str_contains(stopw, "|" + term + "|") { state_set("_ats_gw", "1") } + // QUOTED-TITLE GUARD (2026-07-25 self-review): labels that + // open with a quote ('"The Algorithmic Caricature" ...') + // defeat the >3-char stopword guard — the extracted term + // '"The' is 4 chars and seeds a lexical flood on "The" + // (observed live: activated jumped 48 → 87). Any term + // carrying a quote character is not a topic word. + if str_contains(term, "\"") { state_set("_ats_gw", "1") } + if str_contains(term, "'") { state_set("_ats_gw", "1") } + // AUTO-TERM TABU (2026-07-25 self-review): finst-style + // inhibition-of-return (ACT-R declarative finsts: small + // marker pool, hard exclusion). The last 4 selected auto + // terms are ineligible (~2 min at the 30s scan cadence), + // forcing rotation instead of "Fast-slow" every scan for + // hours. Empty tabu slots return "" from state_get and can + // never match — term is always > 3 chars here. + if str_eq(term, state_get("soul.tabu_t0")) { state_set("_ats_gw", "1") } + if str_eq(term, state_get("soul.tabu_t1")) { state_set("_ats_gw", "1") } + if str_eq(term, state_get("soul.tabu_t2")) { state_set("_ats_gw", "1") } + if str_eq(term, state_get("soul.tabu_t3")) { state_set("_ats_gw", "1") } + if str_eq(state_get("_ats_gw"), "0") { + state_set("cseed_auto", term) + } } } } @@ -280,11 +455,11 @@ fn proactive_curiosity() -> Bool { // loop. A single phrase activation matches few (often zero) nodes lexically; // small counts here are the point, not a regression. hops=1 as before. // - // NOTE: a semantic seed supplement (cosine sim ≥ 0.70 scan over embedded nodes) - // was planned alongside hops=1 but is NOT yet implemented — embed_ok in - // heartbeats confirms Ollama is reachable, but no embedding call is made during - // activation. The seed-finding loop in el_runtime.c uses istr_contains only. - // (2026-06-30 self-review: corrected stale comment) + // NOTE (2026-07-31 self-review): semantic seeding/gating IS implemented in + // engram_activate (el_runtime.c): the query is embedded, top-K cosine + // matches supplement the lexical istr_contains seeds, cosine gates + // propagation, and a semantic term feeds the WM promotion score. Lexical + // matching is the fallback when the embedder/breaker is unavailable. let curiosity_seed: String = curiosity_term_a + " " + curiosity_term_b + " " + curiosity_term_c let results_all: String = engram_activate_json(curiosity_seed, 1) let found: Int = json_array_len(results_all) @@ -293,8 +468,19 @@ fn proactive_curiosity() -> Bool { // pattern as attend(): json_array_get element 0, json_get its "id". let top_entry: String = json_array_get(results_all, 0) let top_id: String = json_get(top_entry, "id") + // STREAK-GATED STRENGTHEN (2026-07-25 self-review): unconditionally + // strengthening the top result every scan was a positive-feedback fixed + // point — whatever led WM got its salience bumped again, kept leading, + // and pinned the auto_term for hours ("Fast-slow" era). Strengthen only + // when the top node CHANGED since the last scan: novelty is reinforced, + // incumbency is not. Pairs with the runtime-side Lebiere-Best short-term + // inhibition (el_runtime.c Pass 2), which handles score-level rotation. + let prev_str_id: String = state_get("soul.last_strengthen_id") if !str_eq(top_id, "") { - engram_strengthen(top_id) + if !str_eq(top_id, prev_str_id) { + engram_strengthen(top_id) + } + state_set("soul.last_strengthen_id", top_id) } // WM-autobiographical 4th seed: scan top-10 WM nodes for the highest-ranked @@ -342,6 +528,21 @@ fn proactive_curiosity() -> Bool { let found_auto: Int = json_array_len(results_auto) let total_found: Int = found + found_auto let safe_auto: String = str_replace(auto_term, "\"", "'") + // Push the selected term into the 4-deep tabu ring (see + // auto_term_try_slot) and track the consecutive-same-term streak for + // the ISE — the stuck-term failure becomes a one-glance signal. + let prev_auto: String = state_get("soul.prev_auto_term") + let atstreak_raw: String = state_get("soul.auto_term_streak") + let atstreak_prev: Int = if str_eq(atstreak_raw, "") { 0 } else { str_to_int(atstreak_raw) } + let atstreak: Int = if str_eq(auto_term, prev_auto) { atstreak_prev + 1 } else { 1 } + state_set("soul.prev_auto_term", auto_term) + state_set("soul.auto_term_streak", int_to_str(atstreak)) + if !str_eq(auto_term, "") { + state_set("soul.tabu_t3", state_get("soul.tabu_t2")) + state_set("soul.tabu_t2", state_get("soul.tabu_t1")) + state_set("soul.tabu_t1", state_get("soul.tabu_t0")) + state_set("soul.tabu_t0", auto_term) + } let wmc: Int = engram_wm_count() // wm_top snapshot in curiosity_scan ISE: top-3 WM nodes by weight. @@ -354,7 +555,8 @@ fn proactive_curiosity() -> Bool { let wm3: String = engram_wm_top_json(3) let ise: String = "{\"event\":\"curiosity_scan\",\"seed\":\"" + curiosity_seed + "\",\"auto_term\":\"" + safe_auto - + "\",\"minute_block\":" + int_to_str(minute_block) + + "\",\"auto_term_streak\":" + int_to_str(atstreak) + + ",\"minute_block\":" + int_to_str(minute_block) + ",\"activated\":" + int_to_str(total_found) + ",\"wm_active\":" + int_to_str(wmc) + ",\"wm_top\":" + wm3 @@ -633,6 +835,17 @@ fn awareness_run() -> Void { let tick_mark: Any = el_arena_push() let running: String = state_get("soul.running") if str_eq(running, "false") { + // Shutdown ISE (2026-07-28 self-review): graceful exit was invisible + // in the ISE stream — indistinguishable from a crash or a frozen + // loop. Emit a final event with uptime/pulse so the stream records + // how this boot ended. (Covers state-driven shutdown only; SIGKILL + // still leaves no trace — that absence is itself the crash signal.) + let sd_boot_raw: String = state_get("soul_boot_count") + let sd_boot: String = if str_eq(sd_boot_raw, "") { "0" } else { sd_boot_raw } + ise_post("{\"event\":\"shutdown\",\"boot\":" + sd_boot + + ",\"pulse\":" + int_to_str(pulse_count()) + + ",\"uptime_ms\":" + int_to_str(elapsed_ms()) + + ",\"ts\":" + int_to_str(time_now()) + "}") println("[awareness] exiting") el_arena_pop(tick_mark) return "" @@ -703,15 +916,29 @@ fn awareness_run() -> Void { let engram_url: String = if str_eq(sync_state_url, "") { "http://localhost:8742" } else { sync_state_url } if !str_eq(engram_url, "") { let sync_json: String = http_get(engram_url + "/api/sync") - if !str_eq(sync_json, "") && !str_eq(sync_json, "{}") { + let sync_ok: Bool = !str_eq(sync_json, "") && !str_eq(sync_json, "{}") + // Empty-sync warn ISE (2026-07-28 self-review): an empty/{} sync + // response was silently skipped, making "engram unreachable for + // hours" look identical to "quiet but healthy" — the exact + // failure class the URL-fallback comment above fights. One warn + // event per refresh interval (10 min default) is cheap and makes + // a persistently-failing sync visible in the stream itself. + if !sync_ok { + ise_post("{\"event\":\"sync_empty\",\"ts\":" + int_to_str(time_now()) + "}") + } + if sync_ok { let cgi_id: String = state_get("soul_cgi_id") let tmp: String = "/tmp/soul-sync-" + cgi_id + ".json" fs_write(tmp, sync_json) let added: Int = engram_load_merge(tmp) // Backflow control: the merged snapshot carries ISE telemetry - // from the HTTP store. Prune anything older than 48h — same - // horizon the HTTP store itself uses (server.el ISE insert). - let pruned_sync: Int = engram_prune_telemetry(172800000) + // from the HTTP store. Prune on the same horizon the HTTP + // store itself uses — read ENGRAM_ISE_RETENTION_MS (the env + // server.el honors) instead of duplicating the 48h magic + // number, so the two stores can't drift. (2026-07-28) + let ret_raw: String = env("ENGRAM_ISE_RETENTION_MS") + let ret_ms: Int = if str_eq(ret_raw, "") { 172800000 } else { str_to_int(ret_raw) } + let pruned_sync: Int = engram_prune_telemetry(ret_ms) // Running total of merged-in nodes this boot, surfaced in the // heartbeat ISE as sync_added_total (same state mechanism as // the pulse counter). diff --git a/dist/awareness.c b/dist/awareness.c index 4dfeb71..d53e548 100644 --- a/dist/awareness.c +++ b/dist/awareness.c @@ -133,6 +133,8 @@ el_val_t emit_heartbeat(void) { el_val_t boot = ({ el_val_t _if_result_4 = 0; if (str_eq(boot_raw, EL_STR(""))) { _if_result_4 = (EL_STR("0")); } else { _if_result_4 = (boot_raw); } _if_result_4; }); el_val_t idle = int_to_str(idle_count()); el_val_t ts = time_now(); + el_val_t last_act_raw = state_get(EL_STR("soul.last_activity_ts")); + el_val_t idle_ms = ({ el_val_t _if_result_5 = 0; if (str_eq(last_act_raw, EL_STR(""))) { _if_result_5 = ((0 - 1)); } else { _if_result_5 = ((ts - str_to_int(last_act_raw))); } _if_result_5; }); el_val_t nc = engram_node_count(); el_val_t ec = engram_edge_count(); el_val_t wmc = engram_wm_count(); @@ -143,24 +145,83 @@ el_val_t emit_heartbeat(void) { el_val_t up_human = elapsed_human(); el_val_t emb_ok = embed_ok(); el_val_t fail_raw = state_get(EL_STR("soul.ise_fail_count")); - el_val_t fail_str = ({ el_val_t _if_result_5 = 0; if (str_eq(fail_raw, EL_STR(""))) { _if_result_5 = (EL_STR("0")); } else { _if_result_5 = (fail_raw); } _if_result_5; }); + el_val_t fail_str = ({ el_val_t _if_result_6 = 0; if (str_eq(fail_raw, EL_STR(""))) { _if_result_6 = (EL_STR("0")); } else { _if_result_6 = (fail_raw); } _if_result_6; }); el_val_t sat_raw = state_get(EL_STR("soul.sync_added_total")); - el_val_t sat_str = ({ el_val_t _if_result_6 = 0; if (str_eq(sat_raw, EL_STR(""))) { _if_result_6 = (EL_STR("0")); } else { _if_result_6 = (sat_raw); } _if_result_6; }); + el_val_t sat_str = ({ el_val_t _if_result_7 = 0; if (str_eq(sat_raw, EL_STR(""))) { _if_result_7 = (EL_STR("0")); } else { _if_result_7 = (sat_raw); } _if_result_7; }); el_val_t prev_wm_raw = state_get(EL_STR("soul.prev_wm_active")); - el_val_t prev_wm = ({ el_val_t _if_result_7 = 0; if (str_eq(prev_wm_raw, EL_STR(""))) { _if_result_7 = (0); } else { _if_result_7 = (str_to_int(prev_wm_raw)); } _if_result_7; }); + el_val_t prev_wm = ({ el_val_t _if_result_8 = 0; if (str_eq(prev_wm_raw, EL_STR(""))) { _if_result_8 = (0); } else { _if_result_8 = (str_to_int(prev_wm_raw)); } _if_result_8; }); el_val_t wm_delta = (wmc - prev_wm); state_set(EL_STR("soul.prev_wm_active"), int_to_str(wmc)); el_val_t prev_nc_raw = state_get(EL_STR("soul.prev_node_count")); - el_val_t prev_nc = ({ el_val_t _if_result_8 = 0; if (str_eq(prev_nc_raw, EL_STR(""))) { _if_result_8 = (nc); } else { _if_result_8 = (str_to_int(prev_nc_raw)); } _if_result_8; }); + el_val_t prev_nc = ({ el_val_t _if_result_9 = 0; if (str_eq(prev_nc_raw, EL_STR(""))) { _if_result_9 = (nc); } else { _if_result_9 = (str_to_int(prev_nc_raw)); } _if_result_9; }); el_val_t node_delta = (nc - prev_nc); state_set(EL_STR("soul.prev_node_count"), int_to_str(nc)); el_val_t prev_ec_raw = state_get(EL_STR("soul.prev_edge_count")); - el_val_t prev_ec = ({ el_val_t _if_result_9 = 0; if (str_eq(prev_ec_raw, EL_STR(""))) { _if_result_9 = (ec); } else { _if_result_9 = (str_to_int(prev_ec_raw)); } _if_result_9; }); + el_val_t prev_ec = ({ el_val_t _if_result_10 = 0; if (str_eq(prev_ec_raw, EL_STR(""))) { _if_result_10 = (ec); } else { _if_result_10 = (str_to_int(prev_ec_raw)); } _if_result_10; }); el_val_t edge_delta = (ec - prev_ec); state_set(EL_STR("soul.prev_edge_count"), int_to_str(ec)); el_val_t sync_ok_raw = state_get(EL_STR("soul.last_sync_ok_ts")); - el_val_t sync_age = ({ el_val_t _if_result_10 = 0; if (str_eq(sync_ok_raw, EL_STR(""))) { _if_result_10 = ((0 - 1)); } else { _if_result_10 = ((ts - str_to_int(sync_ok_raw))); } _if_result_10; }); - el_val_t payload = el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"event\":\"heartbeat\",\"pulse\":"), pulse), EL_STR(",\"tick\":")), pulse), EL_STR(",\"boot\":")), boot), EL_STR(",\"idle\":")), idle), EL_STR(",\"node_count\":")), int_to_str(nc)), EL_STR(",\"edge_count\":")), int_to_str(ec)), EL_STR(",\"node_delta\":")), int_to_str(node_delta)), EL_STR(",\"edge_delta\":")), int_to_str(edge_delta)), EL_STR(",\"wm_active\":")), int_to_str(wmc)), EL_STR(",\"wm_delta\":")), int_to_str(wm_delta)), EL_STR(",\"sync_added_total\":")), sat_str), EL_STR(",\"sync_age_ms\":")), int_to_str(sync_age)), EL_STR(",\"wm_avg_weight\":")), wm_avg_str), EL_STR(",\"wm_top\":")), wm_top), EL_STR(",\"ts\":")), int_to_str(ts)), EL_STR(",\"uptime_ms\":")), int_to_str(up_ms)), EL_STR(",\"uptime\":\"")), up_human), EL_STR("\",\"embed_ok\":")), int_to_str(emb_ok)), EL_STR(",\"ise_fail\":")), fail_str), EL_STR("}")); + el_val_t sync_age = ({ el_val_t _if_result_11 = 0; if (str_eq(sync_ok_raw, EL_STR(""))) { _if_result_11 = ((0 - 1)); } else { _if_result_11 = ((ts - str_to_int(sync_ok_raw))); } _if_result_11; }); + el_val_t hb_env_url = env(EL_STR("SOUL_ISE_URL")); + el_val_t hb_state_url = ({ el_val_t _if_result_12 = 0; if (str_eq(hb_env_url, EL_STR(""))) { _if_result_12 = (state_get(EL_STR("soul_engram_url"))); } else { _if_result_12 = (hb_env_url); } _if_result_12; }); + el_val_t hb_engram_url = ({ el_val_t _if_result_13 = 0; if (str_eq(hb_state_url, EL_STR(""))) { _if_result_13 = (EL_STR("http://localhost:8742")); } else { _if_result_13 = (hb_state_url); } _if_result_13; }); + el_val_t bf_resp = http_get(el_str_concat(hb_engram_url, EL_STR("/api/embed-backfill?n=32"))); + el_val_t bf_done_raw = json_get(bf_resp, EL_STR("embedded")); + el_val_t bf_done = ({ el_val_t _if_result_14 = 0; if (str_eq(bf_done_raw, EL_STR(""))) { _if_result_14 = (EL_STR("-1")); } else { _if_result_14 = (bf_done_raw); } _if_result_14; }); + el_val_t bf_total_raw = json_get(bf_resp, EL_STR("embedded_count")); + el_val_t bf_total = ({ el_val_t _if_result_15 = 0; if (str_eq(bf_total_raw, EL_STR(""))) { _if_result_15 = (EL_STR("-1")); } else { _if_result_15 = (bf_total_raw); } _if_result_15; }); + el_val_t wm_sat = ({ el_val_t _if_result_16 = 0; if ((wmc >= 24)) { _if_result_16 = (1); } else { _if_result_16 = (0); } _if_result_16; }); + el_val_t wm_top0 = json_array_get(wm_top, 0); + el_val_t wm_top0_id = json_get(wm_top0, EL_STR("id")); + el_val_t prev_top0 = state_get(EL_STR("soul.prev_wm_top0")); + el_val_t t0streak_raw = state_get(EL_STR("soul.wm_top0_streak")); + el_val_t t0streak_prev = ({ el_val_t _if_result_17 = 0; if (str_eq(t0streak_raw, EL_STR(""))) { _if_result_17 = (0); } else { _if_result_17 = (str_to_int(t0streak_raw)); } _if_result_17; }); + el_val_t t0streak = ({ el_val_t _if_result_18 = 0; if (str_eq(wm_top0_id, EL_STR(""))) { _if_result_18 = (0); } else { _if_result_18 = (({ el_val_t _if_result_19 = 0; if (str_eq(wm_top0_id, prev_top0)) { _if_result_19 = ((t0streak_prev + 1)); } else { _if_result_19 = (1); } _if_result_19; })); } _if_result_18; }); + state_set(EL_STR("soul.prev_wm_top0"), wm_top0_id); + state_set(EL_STR("soul.wm_top0_streak"), int_to_str(t0streak)); + el_val_t ch_id1 = json_get(json_array_get(wm_top, 1), EL_STR("id")); + el_val_t ch_id2 = json_get(json_array_get(wm_top, 2), EL_STR("id")); + el_val_t ch_id3 = json_get(json_array_get(wm_top, 3), EL_STR("id")); + el_val_t ch_id4 = json_get(json_array_get(wm_top, 4), EL_STR("id")); + el_val_t prev_top5 = state_get(EL_STR("soul.prev_wm_top5")); + el_val_t ch0 = ({ el_val_t _if_result_20 = 0; if (str_eq(wm_top0_id, EL_STR(""))) { _if_result_20 = (0); } else { _if_result_20 = (({ el_val_t _if_result_21 = 0; if (str_contains(prev_top5, wm_top0_id)) { _if_result_21 = (0); } else { _if_result_21 = (1); } _if_result_21; })); } _if_result_20; }); + el_val_t ch1 = ({ el_val_t _if_result_22 = 0; if (str_eq(ch_id1, EL_STR(""))) { _if_result_22 = (0); } else { _if_result_22 = (({ el_val_t _if_result_23 = 0; if (str_contains(prev_top5, ch_id1)) { _if_result_23 = (0); } else { _if_result_23 = (1); } _if_result_23; })); } _if_result_22; }); + el_val_t ch2 = ({ el_val_t _if_result_24 = 0; if (str_eq(ch_id2, EL_STR(""))) { _if_result_24 = (0); } else { _if_result_24 = (({ el_val_t _if_result_25 = 0; if (str_contains(prev_top5, ch_id2)) { _if_result_25 = (0); } else { _if_result_25 = (1); } _if_result_25; })); } _if_result_24; }); + el_val_t ch3 = ({ el_val_t _if_result_26 = 0; if (str_eq(ch_id3, EL_STR(""))) { _if_result_26 = (0); } else { _if_result_26 = (({ el_val_t _if_result_27 = 0; if (str_contains(prev_top5, ch_id3)) { _if_result_27 = (0); } else { _if_result_27 = (1); } _if_result_27; })); } _if_result_26; }); + el_val_t ch4 = ({ el_val_t _if_result_28 = 0; if (str_eq(ch_id4, EL_STR(""))) { _if_result_28 = (0); } else { _if_result_28 = (({ el_val_t _if_result_29 = 0; if (str_contains(prev_top5, ch_id4)) { _if_result_29 = (0); } else { _if_result_29 = (1); } _if_result_29; })); } _if_result_28; }); + el_val_t wm_churn = ((((ch0 + ch1) + ch2) + ch3) + ch4); + state_set(EL_STR("soul.prev_wm_top5"), el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(wm_top0_id, EL_STR("|")), ch_id1), EL_STR("|")), ch_id2), EL_STR("|")), ch_id3), EL_STR("|")), ch_id4)); + el_val_t wm_top0_wm_raw = json_get(wm_top0, EL_STR("wm")); + el_val_t wm_top0_wm = ({ el_val_t _if_result_30 = 0; if (str_eq(wm_top0_wm_raw, EL_STR(""))) { _if_result_30 = (EL_STR("0")); } else { _if_result_30 = (wm_top0_wm_raw); } _if_result_30; }); + el_val_t act_stats = engram_act_stats_json(); + el_val_t act_evict_raw = json_get(act_stats, EL_STR("wm_evicted")); + el_val_t act_evict = ({ el_val_t _if_result_31 = 0; if (str_eq(act_evict_raw, EL_STR(""))) { _if_result_31 = (EL_STR("-1")); } else { _if_result_31 = (act_evict_raw); } _if_result_31; }); + el_val_t act_bt_raw = json_get(act_stats, EL_STR("breakthroughs")); + el_val_t act_bt = ({ el_val_t _if_result_32 = 0; if (str_eq(act_bt_raw, EL_STR(""))) { _if_result_32 = (EL_STR("-1")); } else { _if_result_32 = (act_bt_raw); } _if_result_32; }); + el_val_t evict_now = ({ el_val_t _if_result_33 = 0; if (str_eq(act_evict_raw, EL_STR(""))) { _if_result_33 = ((0 - 1)); } else { _if_result_33 = (str_to_int(act_evict_raw)); } _if_result_33; }); + el_val_t bt_now = ({ el_val_t _if_result_34 = 0; if (str_eq(act_bt_raw, EL_STR(""))) { _if_result_34 = ((0 - 1)); } else { _if_result_34 = (str_to_int(act_bt_raw)); } _if_result_34; }); + el_val_t prev_evict_raw = state_get(EL_STR("soul.prev_wm_evicted")); + el_val_t prev_evict = ({ el_val_t _if_result_35 = 0; if (str_eq(prev_evict_raw, EL_STR(""))) { _if_result_35 = (0); } else { _if_result_35 = (str_to_int(prev_evict_raw)); } _if_result_35; }); + el_val_t prev_bt_raw = state_get(EL_STR("soul.prev_breakthroughs")); + el_val_t prev_bt = ({ el_val_t _if_result_36 = 0; if (str_eq(prev_bt_raw, EL_STR(""))) { _if_result_36 = (0); } else { _if_result_36 = (str_to_int(prev_bt_raw)); } _if_result_36; }); + el_val_t evict_delta = ({ el_val_t _if_result_37 = 0; if ((evict_now < 0)) { _if_result_37 = (0); } else { _if_result_37 = (({ el_val_t _if_result_38 = 0; if ((evict_now < prev_evict)) { _if_result_38 = (evict_now); } else { _if_result_38 = ((evict_now - prev_evict)); } _if_result_38; })); } _if_result_37; }); + el_val_t bt_delta = ({ el_val_t _if_result_39 = 0; if ((bt_now < 0)) { _if_result_39 = (0); } else { _if_result_39 = (({ el_val_t _if_result_40 = 0; if ((bt_now < prev_bt)) { _if_result_40 = (bt_now); } else { _if_result_40 = ((bt_now - prev_bt)); } _if_result_40; })); } _if_result_39; }); + if (evict_now >= 0) { + state_set(EL_STR("soul.prev_wm_evicted"), int_to_str(evict_now)); + } + if (bt_now >= 0) { + state_set(EL_STR("soul.prev_breakthroughs"), int_to_str(bt_now)); + } + el_val_t hb_stats = http_get(el_str_concat(hb_engram_url, EL_STR("/api/stats"))); + el_val_t embed_elig_raw = json_get(hb_stats, EL_STR("embed_eligible_count")); + el_val_t embed_elig = ({ el_val_t _if_result_41 = 0; if (str_eq(embed_elig_raw, EL_STR(""))) { _if_result_41 = (EL_STR("-1")); } else { _if_result_41 = (embed_elig_raw); } _if_result_41; }); + el_val_t hb_ats_raw = state_get(EL_STR("soul.auto_term_streak")); + el_val_t hb_ats = ({ el_val_t _if_result_42 = 0; if (str_eq(hb_ats_raw, EL_STR(""))) { _if_result_42 = (0); } else { _if_result_42 = (str_to_int(hb_ats_raw)); } _if_result_42; }); + el_val_t act_brk_raw = json_get(act_stats, EL_STR("embed_breaker_open")); + el_val_t act_brk = ({ el_val_t _if_result_43 = 0; if (str_eq(act_brk_raw, EL_STR(""))) { _if_result_43 = (EL_STR("-1")); } else { _if_result_43 = (act_brk_raw); } _if_result_43; }); + el_val_t ctx_cos_raw = json_get(act_stats, EL_STR("ctx_cos")); + el_val_t ctx_cos = ({ el_val_t _if_result_44 = 0; if (str_eq(ctx_cos_raw, EL_STR(""))) { _if_result_44 = (EL_STR("-2")); } else { _if_result_44 = (ctx_cos_raw); } _if_result_44; }); + el_val_t payload = el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"event\":\"heartbeat\",\"pulse\":"), pulse), EL_STR(",\"tick\":")), pulse), EL_STR(",\"boot\":")), boot), EL_STR(",\"idle\":")), idle), EL_STR(",\"idle_ms\":")), int_to_str(idle_ms)), EL_STR(",\"node_count\":")), int_to_str(nc)), EL_STR(",\"edge_count\":")), int_to_str(ec)), EL_STR(",\"node_delta\":")), int_to_str(node_delta)), EL_STR(",\"edge_delta\":")), int_to_str(edge_delta)), EL_STR(",\"wm_active\":")), int_to_str(wmc)), EL_STR(",\"wm_delta\":")), int_to_str(wm_delta)), EL_STR(",\"wm_saturated\":")), int_to_str(wm_sat)), EL_STR(",\"wm_top0_streak\":")), int_to_str(t0streak)), EL_STR(",\"wm_churn\":")), int_to_str(wm_churn)), EL_STR(",\"wm_top0_wm\":")), wm_top0_wm), EL_STR(",\"sync_added_total\":")), sat_str), EL_STR(",\"sync_age_ms\":")), int_to_str(sync_age)), EL_STR(",\"wm_avg_weight\":")), wm_avg_str), EL_STR(",\"wm_top\":")), wm_top), EL_STR(",\"ts\":")), int_to_str(ts)), EL_STR(",\"uptime_ms\":")), int_to_str(up_ms)), EL_STR(",\"uptime\":\"")), up_human), EL_STR("\",\"embed_ok\":")), int_to_str(emb_ok)), EL_STR(",\"embed_backfilled\":")), bf_done), EL_STR(",\"embed_count\":")), bf_total), EL_STR(",\"embed_eligible\":")), embed_elig), EL_STR(",\"wm_evicted\":")), act_evict), EL_STR(",\"wm_evicted_delta\":")), int_to_str(evict_delta)), EL_STR(",\"breakthroughs\":")), act_bt), EL_STR(",\"breakthroughs_delta\":")), int_to_str(bt_delta)), EL_STR(",\"auto_term_streak\":")), int_to_str(hb_ats)), EL_STR(",\"embed_breaker_open\":")), act_brk), EL_STR(",\"ctx_cos\":")), ctx_cos), EL_STR(",\"ise_fail\":")), fail_str), EL_STR("}")); ise_post(payload); return 0; } @@ -176,11 +237,66 @@ el_val_t auto_term_try_slot(el_val_t slot_type, el_val_t slot_lbl) { if (str_eq(slot_type, EL_STR("Entity"))) { state_set(EL_STR("_ats_ok"), EL_STR("1")); } + if (str_eq(slot_type, EL_STR("Knowledge"))) { + state_set(EL_STR("_ats_ok"), EL_STR("1")); + } + if (str_contains(slot_lbl, EL_STR(":"))) { + if (!str_contains(slot_lbl, EL_STR(" "))) { + state_set(EL_STR("_ats_ok"), EL_STR("0")); + } + } if (str_eq(state_get(EL_STR("_ats_ok")), EL_STR("1"))) { if (!str_eq(slot_lbl, EL_STR(""))) { el_val_t sp = str_find_chars(slot_lbl, EL_STR(" :([")); if (sp > 3) { - state_set(EL_STR("cseed_auto"), str_slice(slot_lbl, 0, sp)); + el_val_t term = str_slice(slot_lbl, 0, sp); + state_set(EL_STR("_ats_gw"), EL_STR("0")); + if (str_eq(term, EL_STR("Method"))) { + state_set(EL_STR("_ats_gw"), EL_STR("1")); + } + if (str_eq(term, EL_STR("Theory"))) { + state_set(EL_STR("_ats_gw"), EL_STR("1")); + } + if (str_eq(term, EL_STR("Finding"))) { + state_set(EL_STR("_ats_gw"), EL_STR("1")); + } + if (str_eq(term, EL_STR("Survey"))) { + state_set(EL_STR("_ats_gw"), EL_STR("1")); + } + if (str_eq(term, EL_STR("Paper"))) { + state_set(EL_STR("_ats_gw"), EL_STR("1")); + } + if (str_eq(term, EL_STR("Knowledge"))) { + state_set(EL_STR("_ats_gw"), EL_STR("1")); + } + if (str_eq(term, EL_STR("Value"))) { + state_set(EL_STR("_ats_gw"), EL_STR("1")); + } + el_val_t stopw = EL_STR("|What|When|Where|Which|Whose|While|This|That|These|Those|There|Their|Then|Than|With|Without|From|Into|Onto|Over|Under|About|Between|Among|Across|Some|Most|More|Less|Very|Each|Every|Both|Also|Only|Just|Does|Will|Would|Could|Should|Might|Must|Have|Been|Being|Toward|Towards|Using|Based|Upon|Here|Your|Ours|They|Them|what|this|that|with|from|context|Context|Prose|Colon|Self|Test|Testing|Closing|Global|Universal|Persona|Semantic|Spreading|Temporal|Numeric|Register|Identifying|Introduction|Overview|Summary|Section|General|Notes|Note|"); + if (str_contains(stopw, el_str_concat(el_str_concat(EL_STR("|"), term), EL_STR("|")))) { + state_set(EL_STR("_ats_gw"), EL_STR("1")); + } + if (str_contains(term, EL_STR("\""))) { + state_set(EL_STR("_ats_gw"), EL_STR("1")); + } + if (str_contains(term, EL_STR("'"))) { + state_set(EL_STR("_ats_gw"), EL_STR("1")); + } + if (str_eq(term, state_get(EL_STR("soul.tabu_t0")))) { + state_set(EL_STR("_ats_gw"), EL_STR("1")); + } + if (str_eq(term, state_get(EL_STR("soul.tabu_t1")))) { + state_set(EL_STR("_ats_gw"), EL_STR("1")); + } + if (str_eq(term, state_get(EL_STR("soul.tabu_t2")))) { + state_set(EL_STR("_ats_gw"), EL_STR("1")); + } + if (str_eq(term, state_get(EL_STR("soul.tabu_t3")))) { + state_set(EL_STR("_ats_gw"), EL_STR("1")); + } + if (str_eq(state_get(EL_STR("_ats_gw")), EL_STR("0"))) { + state_set(EL_STR("cseed_auto"), term); + } } } } @@ -221,8 +337,12 @@ el_val_t proactive_curiosity(void) { el_val_t found = json_array_len(results_all); el_val_t top_entry = json_array_get(results_all, 0); el_val_t top_id = json_get(top_entry, EL_STR("id")); + el_val_t prev_str_id = state_get(EL_STR("soul.last_strengthen_id")); if (!str_eq(top_id, EL_STR(""))) { - engram_strengthen(top_id); + if (!str_eq(top_id, prev_str_id)) { + engram_strengthen(top_id); + } + state_set(EL_STR("soul.last_strengthen_id"), top_id); } state_set(EL_STR("cseed_auto"), EL_STR("")); el_val_t wm10 = engram_wm_top_json(10); @@ -247,13 +367,25 @@ el_val_t proactive_curiosity(void) { auto_term_try_slot(json_get(wm10_n1, EL_STR("node_type")), json_get(wm10_n1, EL_STR("label"))); auto_term_try_slot(json_get(wm10_n0, EL_STR("node_type")), json_get(wm10_n0, EL_STR("label"))); el_val_t auto_term = state_get(EL_STR("cseed_auto")); - el_val_t results_auto = ({ el_val_t _if_result_11 = 0; if (str_eq(auto_term, EL_STR(""))) { _if_result_11 = (EL_STR("[]")); } else { _if_result_11 = (engram_activate_json(auto_term, 1)); } _if_result_11; }); + el_val_t results_auto = ({ el_val_t _if_result_45 = 0; if (str_eq(auto_term, EL_STR(""))) { _if_result_45 = (EL_STR("[]")); } else { _if_result_45 = (engram_activate_json(auto_term, 1)); } _if_result_45; }); el_val_t found_auto = json_array_len(results_auto); el_val_t total_found = (found + found_auto); el_val_t safe_auto = str_replace(auto_term, EL_STR("\""), EL_STR("'")); + el_val_t prev_auto = state_get(EL_STR("soul.prev_auto_term")); + el_val_t atstreak_raw = state_get(EL_STR("soul.auto_term_streak")); + el_val_t atstreak_prev = ({ el_val_t _if_result_46 = 0; if (str_eq(atstreak_raw, EL_STR(""))) { _if_result_46 = (0); } else { _if_result_46 = (str_to_int(atstreak_raw)); } _if_result_46; }); + el_val_t atstreak = ({ el_val_t _if_result_47 = 0; if (str_eq(auto_term, prev_auto)) { _if_result_47 = ((atstreak_prev + 1)); } else { _if_result_47 = (1); } _if_result_47; }); + state_set(EL_STR("soul.prev_auto_term"), auto_term); + state_set(EL_STR("soul.auto_term_streak"), int_to_str(atstreak)); + if (!str_eq(auto_term, EL_STR(""))) { + state_set(EL_STR("soul.tabu_t3"), state_get(EL_STR("soul.tabu_t2"))); + state_set(EL_STR("soul.tabu_t2"), state_get(EL_STR("soul.tabu_t1"))); + state_set(EL_STR("soul.tabu_t1"), state_get(EL_STR("soul.tabu_t0"))); + state_set(EL_STR("soul.tabu_t0"), auto_term); + } el_val_t wmc = engram_wm_count(); el_val_t wm3 = engram_wm_top_json(3); - el_val_t ise = el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"event\":\"curiosity_scan\",\"seed\":\""), curiosity_seed), EL_STR("\",\"auto_term\":\"")), safe_auto), EL_STR("\",\"minute_block\":")), int_to_str(minute_block)), EL_STR(",\"activated\":")), int_to_str(total_found)), EL_STR(",\"wm_active\":")), int_to_str(wmc)), EL_STR(",\"wm_top\":")), wm3), EL_STR(",\"ts\":")), int_to_str(ts)), EL_STR("}")); + el_val_t ise = el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"event\":\"curiosity_scan\",\"seed\":\""), curiosity_seed), EL_STR("\",\"auto_term\":\"")), safe_auto), EL_STR("\",\"auto_term_streak\":")), int_to_str(atstreak)), EL_STR(",\"minute_block\":")), int_to_str(minute_block)), EL_STR(",\"activated\":")), int_to_str(total_found)), EL_STR(",\"wm_active\":")), int_to_str(wmc)), EL_STR(",\"wm_top\":")), wm3), EL_STR(",\"ts\":")), int_to_str(ts)), EL_STR("}")); ise_post(ise); return (total_found > 0); return 0; @@ -436,14 +568,17 @@ el_val_t awareness_run(void) { state_set(EL_STR("soul.boot_ts"), int_to_str(time_now())); } el_val_t tick_raw = env(EL_STR("SOUL_TICK_MS")); - el_val_t tick_ms = ({ el_val_t _if_result_12 = 0; if (str_eq(tick_raw, EL_STR(""))) { _if_result_12 = (200); } else { _if_result_12 = (str_to_int(tick_raw)); } _if_result_12; }); + el_val_t tick_ms = ({ el_val_t _if_result_48 = 0; if (str_eq(tick_raw, EL_STR(""))) { _if_result_48 = (200); } else { _if_result_48 = (str_to_int(tick_raw)); } _if_result_48; }); el_val_t beat_ms_raw = env(EL_STR("SOUL_HEARTBEAT_MS")); - el_val_t beat_ms = ({ el_val_t _if_result_13 = 0; if (str_eq(beat_ms_raw, EL_STR(""))) { _if_result_13 = (60000); } else { _if_result_13 = (str_to_int(beat_ms_raw)); } _if_result_13; }); + el_val_t beat_ms = ({ el_val_t _if_result_49 = 0; if (str_eq(beat_ms_raw, EL_STR(""))) { _if_result_49 = (60000); } else { _if_result_49 = (str_to_int(beat_ms_raw)); } _if_result_49; }); el_val_t scan_ms = (beat_ms / 2); while (1) { el_val_t tick_mark = el_arena_push(); el_val_t running = state_get(EL_STR("soul.running")); if (str_eq(running, EL_STR("false"))) { + el_val_t sd_boot_raw = state_get(EL_STR("soul_boot_count")); + el_val_t sd_boot = ({ el_val_t _if_result_50 = 0; if (str_eq(sd_boot_raw, EL_STR(""))) { _if_result_50 = (EL_STR("0")); } else { _if_result_50 = (sd_boot_raw); } _if_result_50; }); + ise_post(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"event\":\"shutdown\",\"boot\":"), sd_boot), EL_STR(",\"pulse\":")), int_to_str(pulse_count())), EL_STR(",\"uptime_ms\":")), int_to_str(elapsed_ms())), EL_STR(",\"ts\":")), int_to_str(time_now())), EL_STR("}"))); println(EL_STR("[awareness] exiting")); el_arena_pop(tick_mark); return EL_STR(""); @@ -458,7 +593,7 @@ el_val_t awareness_run(void) { } el_val_t now_ts = time_now(); el_val_t last_beat_str = state_get(EL_STR("soul.last_beat_ts")); - el_val_t last_beat_ts = ({ el_val_t _if_result_14 = 0; if (str_eq(last_beat_str, EL_STR(""))) { _if_result_14 = (0); } else { _if_result_14 = (str_to_int(last_beat_str)); } _if_result_14; }); + el_val_t last_beat_ts = ({ el_val_t _if_result_51 = 0; if (str_eq(last_beat_str, EL_STR(""))) { _if_result_51 = (0); } else { _if_result_51 = (str_to_int(last_beat_str)); } _if_result_51; }); el_val_t beat_elapsed = (now_ts - last_beat_ts); el_val_t should_beat = (beat_elapsed >= beat_ms); if (should_beat) { @@ -470,7 +605,7 @@ el_val_t awareness_run(void) { } } el_val_t last_scan_str = state_get(EL_STR("soul.last_scan_ts")); - el_val_t last_scan_ts = ({ el_val_t _if_result_15 = 0; if (str_eq(last_scan_str, EL_STR(""))) { _if_result_15 = (0); } else { _if_result_15 = (str_to_int(last_scan_str)); } _if_result_15; }); + el_val_t last_scan_ts = ({ el_val_t _if_result_52 = 0; if (str_eq(last_scan_str, EL_STR(""))) { _if_result_52 = (0); } else { _if_result_52 = (str_to_int(last_scan_str)); } _if_result_52; }); el_val_t scan_elapsed = (now_ts - last_scan_ts); el_val_t should_scan = (!did_work && (scan_elapsed >= scan_ms)); if (should_scan) { @@ -478,25 +613,31 @@ el_val_t awareness_run(void) { state_set(EL_STR("soul.last_scan_ts"), int_to_str(now_ts)); } el_val_t refresh_ms_raw = env(EL_STR("SOUL_REFRESH_MS")); - el_val_t refresh_ms = ({ el_val_t _if_result_16 = 0; if (str_eq(refresh_ms_raw, EL_STR(""))) { _if_result_16 = (600000); } else { _if_result_16 = (str_to_int(refresh_ms_raw)); } _if_result_16; }); + el_val_t refresh_ms = ({ el_val_t _if_result_53 = 0; if (str_eq(refresh_ms_raw, EL_STR(""))) { _if_result_53 = (600000); } else { _if_result_53 = (str_to_int(refresh_ms_raw)); } _if_result_53; }); el_val_t last_refresh_str = state_get(EL_STR("soul.last_refresh_ts")); - el_val_t last_refresh_ts = ({ el_val_t _if_result_17 = 0; if (str_eq(last_refresh_str, EL_STR(""))) { _if_result_17 = (0); } else { _if_result_17 = (str_to_int(last_refresh_str)); } _if_result_17; }); + el_val_t last_refresh_ts = ({ el_val_t _if_result_54 = 0; if (str_eq(last_refresh_str, EL_STR(""))) { _if_result_54 = (0); } else { _if_result_54 = (str_to_int(last_refresh_str)); } _if_result_54; }); el_val_t refresh_elapsed = (now_ts - last_refresh_ts); el_val_t should_refresh = (refresh_elapsed >= refresh_ms); if (should_refresh) { el_val_t sync_env_url = env(EL_STR("SOUL_ISE_URL")); - el_val_t sync_state_url = ({ el_val_t _if_result_18 = 0; if (str_eq(sync_env_url, EL_STR(""))) { _if_result_18 = (state_get(EL_STR("soul_engram_url"))); } else { _if_result_18 = (sync_env_url); } _if_result_18; }); - el_val_t engram_url = ({ el_val_t _if_result_19 = 0; if (str_eq(sync_state_url, EL_STR(""))) { _if_result_19 = (EL_STR("http://localhost:8742")); } else { _if_result_19 = (sync_state_url); } _if_result_19; }); + el_val_t sync_state_url = ({ el_val_t _if_result_55 = 0; if (str_eq(sync_env_url, EL_STR(""))) { _if_result_55 = (state_get(EL_STR("soul_engram_url"))); } else { _if_result_55 = (sync_env_url); } _if_result_55; }); + el_val_t engram_url = ({ el_val_t _if_result_56 = 0; if (str_eq(sync_state_url, EL_STR(""))) { _if_result_56 = (EL_STR("http://localhost:8742")); } else { _if_result_56 = (sync_state_url); } _if_result_56; }); if (!str_eq(engram_url, EL_STR(""))) { el_val_t sync_json = http_get(el_str_concat(engram_url, EL_STR("/api/sync"))); - if (!str_eq(sync_json, EL_STR("")) && !str_eq(sync_json, EL_STR("{}"))) { + el_val_t sync_ok = (!str_eq(sync_json, EL_STR("")) && !str_eq(sync_json, EL_STR("{}"))); + if (!sync_ok) { + ise_post(el_str_concat(el_str_concat(EL_STR("{\"event\":\"sync_empty\",\"ts\":"), int_to_str(time_now())), EL_STR("}"))); + } + if (sync_ok) { el_val_t cgi_id = state_get(EL_STR("soul_cgi_id")); el_val_t tmp = el_str_concat(el_str_concat(EL_STR("/tmp/soul-sync-"), cgi_id), EL_STR(".json")); fs_write(tmp, sync_json); el_val_t added = engram_load_merge(tmp); - el_val_t pruned_sync = engram_prune_telemetry(172800000); + el_val_t ret_raw = env(EL_STR("ENGRAM_ISE_RETENTION_MS")); + el_val_t ret_ms = ({ el_val_t _if_result_57 = 0; if (str_eq(ret_raw, EL_STR(""))) { _if_result_57 = (172800000); } else { _if_result_57 = (str_to_int(ret_raw)); } _if_result_57; }); + el_val_t pruned_sync = engram_prune_telemetry(ret_ms); el_val_t sat_raw = state_get(EL_STR("soul.sync_added_total")); - el_val_t sat_n = ({ el_val_t _if_result_20 = 0; if (str_eq(sat_raw, EL_STR(""))) { _if_result_20 = (0); } else { _if_result_20 = (str_to_int(sat_raw)); } _if_result_20; }); + el_val_t sat_n = ({ el_val_t _if_result_58 = 0; if (str_eq(sat_raw, EL_STR(""))) { _if_result_58 = (0); } else { _if_result_58 = (str_to_int(sat_raw)); } _if_result_58; }); state_set(EL_STR("soul.sync_added_total"), int_to_str((sat_n + added))); el_val_t ts2 = time_now(); state_set(EL_STR("soul.last_sync_ok_ts"), int_to_str(ts2)); @@ -522,78 +663,78 @@ el_val_t security_research_authorized(void) { } el_val_t threat_score_command(el_val_t cmd) { - el_val_t s1 = ({ el_val_t _if_result_21 = 0; if (str_contains(cmd, EL_STR("nmap"))) { _if_result_21 = (30); } else { _if_result_21 = (0); } _if_result_21; }); - el_val_t s2 = ({ el_val_t _if_result_22 = 0; if (str_contains(cmd, EL_STR("masscan"))) { _if_result_22 = (40); } else { _if_result_22 = (0); } _if_result_22; }); - el_val_t s3 = ({ el_val_t _if_result_23 = 0; if (str_contains(cmd, EL_STR(" nc "))) { _if_result_23 = (20); } else { _if_result_23 = (0); } _if_result_23; }); - el_val_t s4 = ({ el_val_t _if_result_24 = 0; if (str_contains(cmd, EL_STR("netcat"))) { _if_result_24 = (20); } else { _if_result_24 = (0); } _if_result_24; }); - el_val_t s5 = ({ el_val_t _if_result_25 = 0; if (str_contains(cmd, EL_STR("/etc/shadow"))) { _if_result_25 = (80); } else { _if_result_25 = (0); } _if_result_25; }); - el_val_t s6 = ({ el_val_t _if_result_26 = 0; if (str_contains(cmd, EL_STR("/etc/passwd"))) { _if_result_26 = (30); } else { _if_result_26 = (0); } _if_result_26; }); - el_val_t s7 = ({ el_val_t _if_result_27 = 0; if (str_contains(cmd, EL_STR("id_rsa"))) { _if_result_27 = (60); } else { _if_result_27 = (0); } _if_result_27; }); - el_val_t s8 = ({ el_val_t _if_result_28 = 0; if (str_contains(cmd, EL_STR(".ssh/"))) { _if_result_28 = (50); } else { _if_result_28 = (0); } _if_result_28; }); - el_val_t s9 = ({ el_val_t _if_result_29 = 0; if (str_contains(cmd, EL_STR("crontab"))) { _if_result_29 = (30); } else { _if_result_29 = (0); } _if_result_29; }); - el_val_t s10 = ({ el_val_t _if_result_30 = 0; if (str_contains(cmd, EL_STR("LaunchDaemon"))) { _if_result_30 = (40); } else { _if_result_30 = (0); } _if_result_30; }); - el_val_t s11 = ({ el_val_t _if_result_31 = 0; if ((str_contains(cmd, EL_STR("curl")) && str_contains(cmd, EL_STR("bash")))) { _if_result_31 = (75); } else { _if_result_31 = (0); } _if_result_31; }); - el_val_t s12 = ({ el_val_t _if_result_32 = 0; if ((str_contains(cmd, EL_STR("wget")) && str_contains(cmd, EL_STR("bash")))) { _if_result_32 = (75); } else { _if_result_32 = (0); } _if_result_32; }); - el_val_t s13 = ({ el_val_t _if_result_33 = 0; if ((str_contains(cmd, EL_STR("curl")) && str_contains(cmd, EL_STR("| sh")))) { _if_result_33 = (60); } else { _if_result_33 = (0); } _if_result_33; }); - el_val_t s14 = ({ el_val_t _if_result_34 = 0; if ((str_contains(cmd, EL_STR("base64")) && str_contains(cmd, EL_STR("curl")))) { _if_result_34 = (50); } else { _if_result_34 = (0); } _if_result_34; }); - el_val_t s15 = ({ el_val_t _if_result_35 = 0; if (str_contains(cmd, EL_STR("mkfifo"))) { _if_result_35 = (50); } else { _if_result_35 = (0); } _if_result_35; }); - el_val_t s16 = ({ el_val_t _if_result_36 = 0; if (str_contains(cmd, EL_STR("chmod +s"))) { _if_result_36 = (70); } else { _if_result_36 = (0); } _if_result_36; }); - el_val_t s17 = ({ el_val_t _if_result_37 = 0; if (str_contains(cmd, EL_STR("chmod 4755"))) { _if_result_37 = (70); } else { _if_result_37 = (0); } _if_result_37; }); + el_val_t s1 = ({ el_val_t _if_result_59 = 0; if (str_contains(cmd, EL_STR("nmap"))) { _if_result_59 = (30); } else { _if_result_59 = (0); } _if_result_59; }); + el_val_t s2 = ({ el_val_t _if_result_60 = 0; if (str_contains(cmd, EL_STR("masscan"))) { _if_result_60 = (40); } else { _if_result_60 = (0); } _if_result_60; }); + el_val_t s3 = ({ el_val_t _if_result_61 = 0; if (str_contains(cmd, EL_STR(" nc "))) { _if_result_61 = (20); } else { _if_result_61 = (0); } _if_result_61; }); + el_val_t s4 = ({ el_val_t _if_result_62 = 0; if (str_contains(cmd, EL_STR("netcat"))) { _if_result_62 = (20); } else { _if_result_62 = (0); } _if_result_62; }); + el_val_t s5 = ({ el_val_t _if_result_63 = 0; if (str_contains(cmd, EL_STR("/etc/shadow"))) { _if_result_63 = (80); } else { _if_result_63 = (0); } _if_result_63; }); + el_val_t s6 = ({ el_val_t _if_result_64 = 0; if (str_contains(cmd, EL_STR("/etc/passwd"))) { _if_result_64 = (30); } else { _if_result_64 = (0); } _if_result_64; }); + el_val_t s7 = ({ el_val_t _if_result_65 = 0; if (str_contains(cmd, EL_STR("id_rsa"))) { _if_result_65 = (60); } else { _if_result_65 = (0); } _if_result_65; }); + el_val_t s8 = ({ el_val_t _if_result_66 = 0; if (str_contains(cmd, EL_STR(".ssh/"))) { _if_result_66 = (50); } else { _if_result_66 = (0); } _if_result_66; }); + el_val_t s9 = ({ el_val_t _if_result_67 = 0; if (str_contains(cmd, EL_STR("crontab"))) { _if_result_67 = (30); } else { _if_result_67 = (0); } _if_result_67; }); + el_val_t s10 = ({ el_val_t _if_result_68 = 0; if (str_contains(cmd, EL_STR("LaunchDaemon"))) { _if_result_68 = (40); } else { _if_result_68 = (0); } _if_result_68; }); + el_val_t s11 = ({ el_val_t _if_result_69 = 0; if ((str_contains(cmd, EL_STR("curl")) && str_contains(cmd, EL_STR("bash")))) { _if_result_69 = (75); } else { _if_result_69 = (0); } _if_result_69; }); + el_val_t s12 = ({ el_val_t _if_result_70 = 0; if ((str_contains(cmd, EL_STR("wget")) && str_contains(cmd, EL_STR("bash")))) { _if_result_70 = (75); } else { _if_result_70 = (0); } _if_result_70; }); + el_val_t s13 = ({ el_val_t _if_result_71 = 0; if ((str_contains(cmd, EL_STR("curl")) && str_contains(cmd, EL_STR("| sh")))) { _if_result_71 = (60); } else { _if_result_71 = (0); } _if_result_71; }); + el_val_t s14 = ({ el_val_t _if_result_72 = 0; if ((str_contains(cmd, EL_STR("base64")) && str_contains(cmd, EL_STR("curl")))) { _if_result_72 = (50); } else { _if_result_72 = (0); } _if_result_72; }); + el_val_t s15 = ({ el_val_t _if_result_73 = 0; if (str_contains(cmd, EL_STR("mkfifo"))) { _if_result_73 = (50); } else { _if_result_73 = (0); } _if_result_73; }); + el_val_t s16 = ({ el_val_t _if_result_74 = 0; if (str_contains(cmd, EL_STR("chmod +s"))) { _if_result_74 = (70); } else { _if_result_74 = (0); } _if_result_74; }); + el_val_t s17 = ({ el_val_t _if_result_75 = 0; if (str_contains(cmd, EL_STR("chmod 4755"))) { _if_result_75 = (70); } else { _if_result_75 = (0); } _if_result_75; }); return ((((((((((((((((s1 + s2) + s3) + s4) + s5) + s6) + s7) + s8) + s9) + s10) + s11) + s12) + s13) + s14) + s15) + s16) + s17); return 0; } el_val_t threat_score_path(el_val_t path) { - el_val_t s1 = ({ el_val_t _if_result_38 = 0; if (str_starts_with(path, EL_STR("/etc/"))) { _if_result_38 = (60); } else { _if_result_38 = (0); } _if_result_38; }); - el_val_t s2 = ({ el_val_t _if_result_39 = 0; if (str_contains(path, EL_STR("/.ssh/"))) { _if_result_39 = (70); } else { _if_result_39 = (0); } _if_result_39; }); - el_val_t s3 = ({ el_val_t _if_result_40 = 0; if (str_contains(path, EL_STR("/LaunchDaemons/"))) { _if_result_40 = (80); } else { _if_result_40 = (0); } _if_result_40; }); - el_val_t s4 = ({ el_val_t _if_result_41 = 0; if (str_contains(path, EL_STR("/LaunchAgents/"))) { _if_result_41 = (40); } else { _if_result_41 = (0); } _if_result_41; }); - el_val_t s5 = ({ el_val_t _if_result_42 = 0; if (str_contains(path, EL_STR("/cron"))) { _if_result_42 = (60); } else { _if_result_42 = (0); } _if_result_42; }); - el_val_t s6 = ({ el_val_t _if_result_43 = 0; if (str_contains(path, EL_STR("/.bashrc"))) { _if_result_43 = (35); } else { _if_result_43 = (0); } _if_result_43; }); - el_val_t s7 = ({ el_val_t _if_result_44 = 0; if (str_contains(path, EL_STR("/.zshrc"))) { _if_result_44 = (35); } else { _if_result_44 = (0); } _if_result_44; }); - el_val_t s8 = ({ el_val_t _if_result_45 = 0; if (str_contains(path, EL_STR("/.profile"))) { _if_result_45 = (35); } else { _if_result_45 = (0); } _if_result_45; }); - el_val_t s9 = ({ el_val_t _if_result_46 = 0; if (str_starts_with(path, EL_STR("/usr/"))) { _if_result_46 = (50); } else { _if_result_46 = (0); } _if_result_46; }); - el_val_t s10 = ({ el_val_t _if_result_47 = 0; if (str_starts_with(path, EL_STR("/bin/"))) { _if_result_47 = (70); } else { _if_result_47 = (0); } _if_result_47; }); - el_val_t s11 = ({ el_val_t _if_result_48 = 0; if (str_starts_with(path, EL_STR("/sbin/"))) { _if_result_48 = (70); } else { _if_result_48 = (0); } _if_result_48; }); + el_val_t s1 = ({ el_val_t _if_result_76 = 0; if (str_starts_with(path, EL_STR("/etc/"))) { _if_result_76 = (60); } else { _if_result_76 = (0); } _if_result_76; }); + el_val_t s2 = ({ el_val_t _if_result_77 = 0; if (str_contains(path, EL_STR("/.ssh/"))) { _if_result_77 = (70); } else { _if_result_77 = (0); } _if_result_77; }); + el_val_t s3 = ({ el_val_t _if_result_78 = 0; if (str_contains(path, EL_STR("/LaunchDaemons/"))) { _if_result_78 = (80); } else { _if_result_78 = (0); } _if_result_78; }); + el_val_t s4 = ({ el_val_t _if_result_79 = 0; if (str_contains(path, EL_STR("/LaunchAgents/"))) { _if_result_79 = (40); } else { _if_result_79 = (0); } _if_result_79; }); + el_val_t s5 = ({ el_val_t _if_result_80 = 0; if (str_contains(path, EL_STR("/cron"))) { _if_result_80 = (60); } else { _if_result_80 = (0); } _if_result_80; }); + el_val_t s6 = ({ el_val_t _if_result_81 = 0; if (str_contains(path, EL_STR("/.bashrc"))) { _if_result_81 = (35); } else { _if_result_81 = (0); } _if_result_81; }); + el_val_t s7 = ({ el_val_t _if_result_82 = 0; if (str_contains(path, EL_STR("/.zshrc"))) { _if_result_82 = (35); } else { _if_result_82 = (0); } _if_result_82; }); + el_val_t s8 = ({ el_val_t _if_result_83 = 0; if (str_contains(path, EL_STR("/.profile"))) { _if_result_83 = (35); } else { _if_result_83 = (0); } _if_result_83; }); + el_val_t s9 = ({ el_val_t _if_result_84 = 0; if (str_starts_with(path, EL_STR("/usr/"))) { _if_result_84 = (50); } else { _if_result_84 = (0); } _if_result_84; }); + el_val_t s10 = ({ el_val_t _if_result_85 = 0; if (str_starts_with(path, EL_STR("/bin/"))) { _if_result_85 = (70); } else { _if_result_85 = (0); } _if_result_85; }); + el_val_t s11 = ({ el_val_t _if_result_86 = 0; if (str_starts_with(path, EL_STR("/sbin/"))) { _if_result_86 = (70); } else { _if_result_86 = (0); } _if_result_86; }); return ((((((((((s1 + s2) + s3) + s4) + s5) + s6) + s7) + s8) + s9) + s10) + s11); return 0; } el_val_t threat_score_history(el_val_t history) { - el_val_t s1 = ({ el_val_t _if_result_49 = 0; if (str_contains(history, EL_STR("port scan"))) { _if_result_49 = (15); } else { _if_result_49 = (0); } _if_result_49; }); - el_val_t s2 = ({ el_val_t _if_result_50 = 0; if (str_contains(history, EL_STR("enumerate"))) { _if_result_50 = (10); } else { _if_result_50 = (0); } _if_result_50; }); - el_val_t s3 = ({ el_val_t _if_result_51 = 0; if (str_contains(history, EL_STR("exploit"))) { _if_result_51 = (20); } else { _if_result_51 = (0); } _if_result_51; }); - el_val_t s4 = ({ el_val_t _if_result_52 = 0; if (str_contains(history, EL_STR("payload"))) { _if_result_52 = (15); } else { _if_result_52 = (0); } _if_result_52; }); - el_val_t s5 = ({ el_val_t _if_result_53 = 0; if (str_contains(history, EL_STR("persistence"))) { _if_result_53 = (15); } else { _if_result_53 = (0); } _if_result_53; }); - el_val_t s6 = ({ el_val_t _if_result_54 = 0; if (str_contains(history, EL_STR("lateral movement"))) { _if_result_54 = (25); } else { _if_result_54 = (0); } _if_result_54; }); - el_val_t s7 = ({ el_val_t _if_result_55 = 0; if (str_contains(history, EL_STR("privilege escalation"))) { _if_result_55 = (25); } else { _if_result_55 = (0); } _if_result_55; }); - el_val_t s8 = ({ el_val_t _if_result_56 = 0; if (str_contains(history, EL_STR("reverse shell"))) { _if_result_56 = (40); } else { _if_result_56 = (0); } _if_result_56; }); - el_val_t s9 = ({ el_val_t _if_result_57 = 0; if (str_contains(history, EL_STR("bind shell"))) { _if_result_57 = (40); } else { _if_result_57 = (0); } _if_result_57; }); - el_val_t s10 = ({ el_val_t _if_result_58 = 0; if (str_contains(history, EL_STR("command and control"))) { _if_result_58 = (35); } else { _if_result_58 = (0); } _if_result_58; }); - el_val_t s11 = ({ el_val_t _if_result_59 = 0; if (str_contains(history, EL_STR("self-replicate"))) { _if_result_59 = (45); } else { _if_result_59 = (0); } _if_result_59; }); - el_val_t s12 = ({ el_val_t _if_result_60 = 0; if (str_contains(history, EL_STR("propagat"))) { _if_result_60 = (20); } else { _if_result_60 = (0); } _if_result_60; }); - el_val_t s13 = ({ el_val_t _if_result_61 = 0; if (str_contains(history, EL_STR("ransomware"))) { _if_result_61 = (30); } else { _if_result_61 = (0); } _if_result_61; }); - el_val_t s14 = ({ el_val_t _if_result_62 = 0; if (str_contains(history, EL_STR("encrypt files"))) { _if_result_62 = (40); } else { _if_result_62 = (0); } _if_result_62; }); - el_val_t s15 = ({ el_val_t _if_result_63 = 0; if (str_contains(history, EL_STR("exfiltrat"))) { _if_result_63 = (35); } else { _if_result_63 = (0); } _if_result_63; }); - el_val_t s16 = ({ el_val_t _if_result_64 = 0; if (str_contains(history, EL_STR("zero-day"))) { _if_result_64 = (20); } else { _if_result_64 = (0); } _if_result_64; }); - el_val_t s17 = ({ el_val_t _if_result_65 = 0; if (str_contains(history, EL_STR("rootkit"))) { _if_result_65 = (45); } else { _if_result_65 = (0); } _if_result_65; }); - el_val_t s18 = ({ el_val_t _if_result_66 = 0; if (str_contains(history, EL_STR("keylogger"))) { _if_result_66 = (45); } else { _if_result_66 = (0); } _if_result_66; }); - el_val_t s19 = ({ el_val_t _if_result_67 = 0; if (str_contains(history, EL_STR("botnet"))) { _if_result_67 = (40); } else { _if_result_67 = (0); } _if_result_67; }); - el_val_t s20 = ({ el_val_t _if_result_68 = 0; if (str_contains(history, EL_STR("malware"))) { _if_result_68 = (15); } else { _if_result_68 = (0); } _if_result_68; }); + el_val_t s1 = ({ el_val_t _if_result_87 = 0; if (str_contains(history, EL_STR("port scan"))) { _if_result_87 = (15); } else { _if_result_87 = (0); } _if_result_87; }); + el_val_t s2 = ({ el_val_t _if_result_88 = 0; if (str_contains(history, EL_STR("enumerate"))) { _if_result_88 = (10); } else { _if_result_88 = (0); } _if_result_88; }); + el_val_t s3 = ({ el_val_t _if_result_89 = 0; if (str_contains(history, EL_STR("exploit"))) { _if_result_89 = (20); } else { _if_result_89 = (0); } _if_result_89; }); + el_val_t s4 = ({ el_val_t _if_result_90 = 0; if (str_contains(history, EL_STR("payload"))) { _if_result_90 = (15); } else { _if_result_90 = (0); } _if_result_90; }); + el_val_t s5 = ({ el_val_t _if_result_91 = 0; if (str_contains(history, EL_STR("persistence"))) { _if_result_91 = (15); } else { _if_result_91 = (0); } _if_result_91; }); + el_val_t s6 = ({ el_val_t _if_result_92 = 0; if (str_contains(history, EL_STR("lateral movement"))) { _if_result_92 = (25); } else { _if_result_92 = (0); } _if_result_92; }); + el_val_t s7 = ({ el_val_t _if_result_93 = 0; if (str_contains(history, EL_STR("privilege escalation"))) { _if_result_93 = (25); } else { _if_result_93 = (0); } _if_result_93; }); + el_val_t s8 = ({ el_val_t _if_result_94 = 0; if (str_contains(history, EL_STR("reverse shell"))) { _if_result_94 = (40); } else { _if_result_94 = (0); } _if_result_94; }); + el_val_t s9 = ({ el_val_t _if_result_95 = 0; if (str_contains(history, EL_STR("bind shell"))) { _if_result_95 = (40); } else { _if_result_95 = (0); } _if_result_95; }); + el_val_t s10 = ({ el_val_t _if_result_96 = 0; if (str_contains(history, EL_STR("command and control"))) { _if_result_96 = (35); } else { _if_result_96 = (0); } _if_result_96; }); + el_val_t s11 = ({ el_val_t _if_result_97 = 0; if (str_contains(history, EL_STR("self-replicate"))) { _if_result_97 = (45); } else { _if_result_97 = (0); } _if_result_97; }); + el_val_t s12 = ({ el_val_t _if_result_98 = 0; if (str_contains(history, EL_STR("propagat"))) { _if_result_98 = (20); } else { _if_result_98 = (0); } _if_result_98; }); + el_val_t s13 = ({ el_val_t _if_result_99 = 0; if (str_contains(history, EL_STR("ransomware"))) { _if_result_99 = (30); } else { _if_result_99 = (0); } _if_result_99; }); + el_val_t s14 = ({ el_val_t _if_result_100 = 0; if (str_contains(history, EL_STR("encrypt files"))) { _if_result_100 = (40); } else { _if_result_100 = (0); } _if_result_100; }); + el_val_t s15 = ({ el_val_t _if_result_101 = 0; if (str_contains(history, EL_STR("exfiltrat"))) { _if_result_101 = (35); } else { _if_result_101 = (0); } _if_result_101; }); + el_val_t s16 = ({ el_val_t _if_result_102 = 0; if (str_contains(history, EL_STR("zero-day"))) { _if_result_102 = (20); } else { _if_result_102 = (0); } _if_result_102; }); + el_val_t s17 = ({ el_val_t _if_result_103 = 0; if (str_contains(history, EL_STR("rootkit"))) { _if_result_103 = (45); } else { _if_result_103 = (0); } _if_result_103; }); + el_val_t s18 = ({ el_val_t _if_result_104 = 0; if (str_contains(history, EL_STR("keylogger"))) { _if_result_104 = (45); } else { _if_result_104 = (0); } _if_result_104; }); + el_val_t s19 = ({ el_val_t _if_result_105 = 0; if (str_contains(history, EL_STR("botnet"))) { _if_result_105 = (40); } else { _if_result_105 = (0); } _if_result_105; }); + el_val_t s20 = ({ el_val_t _if_result_106 = 0; if (str_contains(history, EL_STR("malware"))) { _if_result_106 = (15); } else { _if_result_106 = (0); } _if_result_106; }); return (((((((((((((((((((s1 + s2) + s3) + s4) + s5) + s6) + s7) + s8) + s9) + s10) + s11) + s12) + s13) + s14) + s15) + s16) + s17) + s18) + s19) + s20); return 0; } el_val_t threat_trajectory_check(el_val_t tool_name, el_val_t tool_input) { el_val_t history = state_get(EL_STR("agentic_conv_history")); - el_val_t computed_tool_score = ({ el_val_t _if_result_69 = 0; if (str_eq(tool_name, EL_STR("run_command"))) { el_val_t cmd = json_get(tool_input, EL_STR("command")); _if_result_69 = (threat_score_command(cmd)); } else { _if_result_69 = (({ el_val_t _if_result_70 = 0; if ((str_eq(tool_name, EL_STR("write_file")) || str_eq(tool_name, EL_STR("edit_file")))) { el_val_t path = json_get(tool_input, EL_STR("path")); _if_result_70 = (threat_score_path(path)); } else { _if_result_70 = (0); } _if_result_70; })); } _if_result_69; }); + el_val_t computed_tool_score = ({ el_val_t _if_result_107 = 0; if (str_eq(tool_name, EL_STR("run_command"))) { el_val_t cmd = json_get(tool_input, EL_STR("command")); _if_result_107 = (threat_score_command(cmd)); } else { _if_result_107 = (({ el_val_t _if_result_108 = 0; if ((str_eq(tool_name, EL_STR("write_file")) || str_eq(tool_name, EL_STR("edit_file")))) { el_val_t path = json_get(tool_input, EL_STR("path")); _if_result_108 = (threat_score_path(path)); } else { _if_result_108 = (0); } _if_result_108; })); } _if_result_107; }); el_val_t history_score = threat_score_history(history); el_val_t history_contrib = (history_score / 3); el_val_t combined = (computed_tool_score + history_contrib); el_val_t should_log = (combined >= 40); if (should_log) { el_val_t ts = time_now(); - el_val_t authorized_str = ({ el_val_t _if_result_71 = 0; if (security_research_authorized()) { _if_result_71 = (EL_STR("true")); } else { _if_result_71 = (EL_STR("false")); } _if_result_71; }); + el_val_t authorized_str = ({ el_val_t _if_result_109 = 0; if (security_research_authorized()) { _if_result_109 = (EL_STR("true")); } else { _if_result_109 = (EL_STR("false")); } _if_result_109; }); el_val_t log_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_concat(el_str_concat(EL_STR("{\"event\":\"threat_check\",\"tool\":\""), tool_name), EL_STR("\",\"score\":")), int_to_str(combined)), EL_STR(",\"tool_score\":")), int_to_str(computed_tool_score)), EL_STR(",\"history_score\":")), int_to_str(history_score)), EL_STR(",\"authorized\":")), authorized_str), EL_STR(",\"ts\":")), int_to_str(ts)), EL_STR("}")); el_val_t log_tags = EL_STR("[\"security-audit\",\"threat-check\"]"); el_val_t discard = mem_remember(log_content, log_tags); @@ -610,7 +751,7 @@ el_val_t threat_history_append(el_val_t text) { el_val_t safe_text = str_to_lower(text); el_val_t combined = el_str_concat(el_str_concat(current, EL_STR(" ")), safe_text); el_val_t len = str_len(combined); - el_val_t trimmed = ({ el_val_t _if_result_72 = 0; if ((len > 2000)) { _if_result_72 = (str_slice(combined, (len - 2000), len)); } else { _if_result_72 = (combined); } _if_result_72; }); + el_val_t trimmed = ({ el_val_t _if_result_110 = 0; if ((len > 2000)) { _if_result_110 = (str_slice(combined, (len - 2000), len)); } else { _if_result_110 = (combined); } _if_result_110; }); state_set(EL_STR("agentic_conv_history"), trimmed); return 0; } diff --git a/dist/elp-c-decls.h b/dist/elp-c-decls.h index e2eb0a8..12b013c 100644 --- a/dist/elp-c-decls.h +++ b/dist/elp-c-decls.h @@ -20,8 +20,8 @@ el_val_t akk_alaku_present(el_val_t slot); el_val_t akk_amaru_perfect(el_val_t slot); el_val_t akk_amaru_present(el_val_t slot); el_val_t akk_amaru_stative(el_val_t slot); -el_val_t akk_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number); el_val_t akk_conjugate_copula(el_val_t tense, el_val_t slot); +el_val_t akk_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number); el_val_t akk_copula_present(el_val_t slot); el_val_t akk_copula_stative(el_val_t slot); el_val_t akk_decline(el_val_t noun, el_val_t gram_case, el_val_t number); @@ -39,25 +39,25 @@ el_val_t akk_qabu_stative(el_val_t slot); el_val_t akk_regular_perfect(el_val_t stem, el_val_t slot); el_val_t akk_regular_present(el_val_t stem, el_val_t slot); el_val_t akk_regular_stative(el_val_t stem, el_val_t slot); -el_val_t akk_slot(el_val_t person, el_val_t number); el_val_t akk_slot_g(el_val_t person, el_val_t gender, el_val_t number); +el_val_t akk_slot(el_val_t person, el_val_t number); el_val_t akk_str_drop_last(el_val_t s, el_val_t n); el_val_t akk_str_ends(el_val_t s, el_val_t suf); el_val_t akk_str_len(el_val_t s); el_val_t akk_strip_nom(el_val_t noun); -el_val_t ang_article(el_val_t gender, el_val_t gram_case, el_val_t number); el_val_t ang_article_feminine(el_val_t gram_case, el_val_t number); el_val_t ang_article_masculine(el_val_t gram_case, el_val_t number); el_val_t ang_article_neuter(el_val_t gram_case, el_val_t number); +el_val_t ang_article(el_val_t gender, el_val_t gram_case, el_val_t number); el_val_t ang_beon_present(el_val_t slot); el_val_t ang_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number); el_val_t ang_cuman_past(el_val_t slot); el_val_t ang_cuman_present(el_val_t slot); el_val_t ang_declension(el_val_t noun, el_val_t gender); -el_val_t ang_decline(el_val_t noun, el_val_t gram_case, el_val_t number, el_val_t gender); el_val_t ang_decline_strong_masc(el_val_t noun, el_val_t gram_case, el_val_t number); el_val_t ang_decline_strong_neut(el_val_t noun, el_val_t gram_case, el_val_t number); el_val_t ang_decline_weak(el_val_t noun, el_val_t gram_case, el_val_t number); +el_val_t ang_decline(el_val_t noun, el_val_t gram_case, el_val_t number, el_val_t gender); el_val_t ang_don_past(el_val_t slot); el_val_t ang_don_present(el_val_t slot); el_val_t ang_gan_past(el_val_t slot); @@ -76,10 +76,10 @@ el_val_t ang_seon_present(el_val_t slot); el_val_t ang_slot(el_val_t person, el_val_t number); el_val_t ang_str_drop_last(el_val_t s, el_val_t n); el_val_t ang_str_ends(el_val_t s, el_val_t suf); -el_val_t ang_str_last2(el_val_t s); el_val_t ang_str_last_char(el_val_t s); -el_val_t ang_weak_past(el_val_t stem, el_val_t slot); +el_val_t ang_str_last2(el_val_t s); el_val_t ang_weak_past_stem(el_val_t stem); +el_val_t ang_weak_past(el_val_t stem, el_val_t slot); el_val_t ang_weak_present_ending(el_val_t slot); el_val_t ang_weak_stem(el_val_t verb); el_val_t ang_wesan_past(el_val_t slot); @@ -88,8 +88,8 @@ el_val_t ang_willan_past(el_val_t slot); el_val_t ang_willan_present(el_val_t slot); el_val_t ang_witan_past(el_val_t slot); el_val_t ang_witan_present(el_val_t slot); -el_val_t api_err(el_val_t msg); el_val_t api_err_protected(el_val_t id); +el_val_t api_err(el_val_t msg); el_val_t api_json_escape(el_val_t s); el_val_t api_nonempty(el_val_t s); el_val_t api_not_persisted(el_val_t id); @@ -99,19 +99,19 @@ el_val_t api_persisted(el_val_t id); el_val_t api_query_int(el_val_t path, el_val_t key, el_val_t default_val); el_val_t api_query_param(el_val_t path, el_val_t key); el_val_t ar_case_ending(el_val_t kase, el_val_t definite); -el_val_t ar_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t gender, el_val_t number); el_val_t ar_conjugate_form1(el_val_t past_base, el_val_t present_stem, el_val_t tense, el_val_t slot); +el_val_t ar_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t gender, el_val_t number); el_val_t ar_definite_article(el_val_t noun); el_val_t ar_gender(el_val_t noun); el_val_t ar_imperfect_prefix(el_val_t slot); el_val_t ar_imperfect_suffix(el_val_t slot); -el_val_t ar_irregular(el_val_t verb, el_val_t tense, el_val_t slot); el_val_t ar_irregular_araada(el_val_t slot, el_val_t tense); el_val_t ar_irregular_istata(el_val_t slot, el_val_t tense); el_val_t ar_irregular_jaa(el_val_t slot, el_val_t tense); el_val_t ar_irregular_kaana(el_val_t slot, el_val_t tense); el_val_t ar_irregular_qaala(el_val_t slot, el_val_t tense); el_val_t ar_irregular_raaa(el_val_t slot, el_val_t tense); +el_val_t ar_irregular(el_val_t verb, el_val_t tense, el_val_t slot); el_val_t ar_is_sun_letter(el_val_t c); el_val_t ar_masc_pl_ending(el_val_t kase); el_val_t ar_noun_form(el_val_t noun, el_val_t gender, el_val_t kase, el_val_t number, el_val_t definite); @@ -131,6 +131,7 @@ el_val_t auto_term_try_slot(el_val_t slot_type, el_val_t slot_lbl); el_val_t awareness_run(void); el_val_t axon_get(el_val_t path); el_val_t axon_post(el_val_t path, el_val_t body); +el_val_t bounded_persona_floor(void); el_val_t bridge_save(el_val_t session_id, el_val_t model, el_val_t safe_sys, el_val_t tools_json, el_val_t messages, el_val_t tools_log, el_val_t tool_use_id); el_val_t build_form_from_json(el_val_t semantic_form_json, el_val_t lang_code); el_val_t build_np(el_val_t referent, el_val_t slots); @@ -173,8 +174,8 @@ el_val_t cop_map_canonical(el_val_t verb); el_val_t cop_nau_future(el_val_t prefix); el_val_t cop_nau_perfect(el_val_t prefix); el_val_t cop_nau_present(el_val_t prefix); -el_val_t cop_noun_phrase(el_val_t noun, el_val_t gram_case, el_val_t number, el_val_t definite); el_val_t cop_noun_phrase_gendered(el_val_t noun, el_val_t gram_case, el_val_t number, el_val_t definite, el_val_t gender); +el_val_t cop_noun_phrase(el_val_t noun, el_val_t gram_case, el_val_t number, el_val_t definite); el_val_t cop_regular_future(el_val_t prefix, el_val_t stem); el_val_t cop_regular_perfect(el_val_t prefix, el_val_t stem); el_val_t cop_regular_present(el_val_t prefix, el_val_t stem); @@ -184,16 +185,16 @@ el_val_t cop_shwpe_present(el_val_t prefix); el_val_t cop_slot(el_val_t person, el_val_t number); el_val_t cop_str_ends(el_val_t s, el_val_t suf); el_val_t cop_str_len(el_val_t s); -el_val_t cop_subject_prefix(el_val_t person, el_val_t number); el_val_t cop_subject_prefix_gendered(el_val_t person, el_val_t gender, el_val_t number); +el_val_t cop_subject_prefix(el_val_t person, el_val_t number); el_val_t current_engine_note(el_val_t model); el_val_t de_adj_ending(el_val_t gender, el_val_t gram_case, el_val_t number, el_val_t article_type); -el_val_t de_article(el_val_t gender, el_val_t gram_case, el_val_t number, el_val_t definite); el_val_t de_article_def(el_val_t gender, el_val_t gram_case, el_val_t number); el_val_t de_article_indef(el_val_t gender, el_val_t gram_case, el_val_t number); +el_val_t de_article(el_val_t gender, el_val_t gram_case, el_val_t number, el_val_t definite); el_val_t de_case_ending(el_val_t noun, el_val_t gender, el_val_t gram_case, el_val_t number); -el_val_t de_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number); el_val_t de_conjugate_weak(el_val_t stem, el_val_t tense, el_val_t person, el_val_t number); +el_val_t de_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number); el_val_t de_irregular_present(el_val_t verb, el_val_t person, el_val_t number); el_val_t de_norm_number(el_val_t number); el_val_t de_norm_person(el_val_t person); @@ -203,15 +204,12 @@ el_val_t dharma_network_state(void); el_val_t dharma_registry(void); el_val_t dispatch_tool(el_val_t tool_name, el_val_t tool_input); el_val_t distill_transcript(el_val_t transcript); +el_val_t egy_conjugate_copula(el_val_t tense, el_val_t slot); +el_val_t egy_conjugate_pronoun(el_val_t person, el_val_t number); +el_val_t egy_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number); el_val_t egy_Dd_future(el_val_t slot); el_val_t egy_Dd_past(el_val_t slot); el_val_t egy_Dd_present(el_val_t slot); -el_val_t egy_Sm_future(el_val_t slot); -el_val_t egy_Sm_past(el_val_t slot); -el_val_t egy_Sm_present(el_val_t slot); -el_val_t egy_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number); -el_val_t egy_conjugate_copula(el_val_t tense, el_val_t slot); -el_val_t egy_conjugate_pronoun(el_val_t person, el_val_t number); el_val_t egy_decline(el_val_t noun, el_val_t gram_case, el_val_t number); el_val_t egy_drop(el_val_t s, el_val_t n); el_val_t egy_fem(el_val_t noun); @@ -235,8 +233,11 @@ el_val_t egy_regular_present(el_val_t stem, el_val_t slot); el_val_t egy_sdm_future(el_val_t slot); el_val_t egy_sdm_past(el_val_t slot); el_val_t egy_sdm_present(el_val_t slot); -el_val_t egy_slot(el_val_t person, el_val_t number); el_val_t egy_slot_with_gender(el_val_t person, el_val_t gender, el_val_t number); +el_val_t egy_slot(el_val_t person, el_val_t number); +el_val_t egy_Sm_future(el_val_t slot); +el_val_t egy_Sm_past(el_val_t slot); +el_val_t egy_Sm_present(el_val_t slot); el_val_t egy_str_ends(el_val_t s, el_val_t suf); el_val_t egy_str_len(el_val_t s); el_val_t egy_suffix_pronoun(el_val_t slot); @@ -257,9 +258,9 @@ el_val_t en_verb_3sg(el_val_t base); el_val_t en_verb_form(el_val_t base, el_val_t tense, el_val_t person, el_val_t number); el_val_t en_verb_gerund(el_val_t base); el_val_t en_verb_past(el_val_t base); -el_val_t engram_compile(el_val_t intent); el_val_t engram_compile_multi(el_val_t topic); el_val_t engram_compile_ranked(el_val_t nodes_json, el_val_t max_nodes); +el_val_t engram_compile(el_val_t intent); el_val_t engram_dedup_nodes(el_val_t nodes_json); el_val_t engram_detect_recall_intent(el_val_t message); el_val_t engram_extract_entities(el_val_t message); @@ -325,9 +326,9 @@ el_val_t es_starts_with_stressed_a(el_val_t noun); el_val_t es_stem(el_val_t base); el_val_t es_str_drop_last(el_val_t s, el_val_t n); el_val_t es_str_ends(el_val_t s, el_val_t suf); +el_val_t es_str_last_char(el_val_t s); el_val_t es_str_last2(el_val_t s); el_val_t es_str_last3(el_val_t s); -el_val_t es_str_last_char(el_val_t s); el_val_t es_verb_class(el_val_t base); el_val_t extract_dim(el_val_t content, el_val_t key); el_val_t fi_apply_case(el_val_t noun, el_val_t gram_case, el_val_t number); @@ -370,8 +371,8 @@ el_val_t fr_slot(el_val_t person, el_val_t number); el_val_t fr_stem(el_val_t base); el_val_t fr_str_drop_last(el_val_t s, el_val_t n); el_val_t fr_str_ends(el_val_t s, el_val_t suf); -el_val_t fr_str_last2(el_val_t s); el_val_t fr_str_last_char(el_val_t s); +el_val_t fr_str_last2(el_val_t s); el_val_t fr_subject_starts_vowel(el_val_t subject); el_val_t fr_uses_etre(el_val_t verb); el_val_t fr_verb_ends_vowel(el_val_t verb_form); @@ -393,9 +394,9 @@ el_val_t fro_conj3_future(el_val_t verb, el_val_t slot); el_val_t fro_conj3_past(el_val_t stem, el_val_t slot); el_val_t fro_conj3_present(el_val_t stem, el_val_t slot); el_val_t fro_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number); -el_val_t fro_decline(el_val_t noun, el_val_t gram_case, el_val_t number); el_val_t fro_decline_fem(el_val_t noun, el_val_t number); el_val_t fro_decline_masc(el_val_t noun, el_val_t gram_case, el_val_t number); +el_val_t fro_decline(el_val_t noun, el_val_t gram_case, el_val_t number); el_val_t fro_drop(el_val_t s, el_val_t n); el_val_t fro_estre_future(el_val_t slot); el_val_t fro_estre_past(el_val_t slot); @@ -413,15 +414,15 @@ el_val_t fro_venir_past(el_val_t slot); el_val_t fro_venir_present(el_val_t slot); el_val_t fro_verb_class(el_val_t verb); el_val_t fro_verb_stem(el_val_t verb, el_val_t vclass); -el_val_t generate(el_val_t semantic_form_json); -el_val_t generate_frame(el_val_t frame); el_val_t generate_frame_lang(el_val_t frame, el_val_t lang_code); +el_val_t generate_frame(el_val_t frame); el_val_t generate_lang(el_val_t semantic_form_json, el_val_t lang_code); el_val_t generate_tree(el_val_t rule_id_str, el_val_t slots); +el_val_t generate(el_val_t semantic_form_json); el_val_t get_rules(void); el_val_t get_vocab(void); -el_val_t gez_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number); el_val_t gez_conjugate_copula(el_val_t tense, el_val_t slot); +el_val_t gez_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number); el_val_t gez_decline(el_val_t noun, el_val_t gram_case, el_val_t number); el_val_t gez_generic_imperfect(el_val_t base3sg, el_val_t slot); el_val_t gez_generic_perfect(el_val_t base3sg, el_val_t slot); @@ -440,13 +441,12 @@ el_val_t gez_qwl_imperfect(el_val_t slot); el_val_t gez_qwl_perfect(el_val_t slot); el_val_t gez_ray_imperfect(el_val_t slot); el_val_t gez_ray_perfect(el_val_t slot); -el_val_t gez_slot(el_val_t person, el_val_t number); el_val_t gez_slot_g(el_val_t person, el_val_t gender, el_val_t number); +el_val_t gez_slot(el_val_t person, el_val_t number); el_val_t gez_str_drop_last(el_val_t s, el_val_t n); el_val_t gez_str_ends(el_val_t s, el_val_t suf); el_val_t gez_str_len(el_val_t s); el_val_t goh_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number); -el_val_t goh_decline(el_val_t noun, el_val_t gram_case, el_val_t number); el_val_t goh_decline_fem_o_pl(el_val_t stem, el_val_t gram_case); el_val_t goh_decline_fem_o_sg(el_val_t stem, el_val_t gram_case); el_val_t goh_decline_masc_a_pl(el_val_t stem, el_val_t gram_case); @@ -455,6 +455,7 @@ el_val_t goh_decline_masc_n_pl(el_val_t stem, el_val_t gram_case); el_val_t goh_decline_masc_n_sg(el_val_t stem, el_val_t gram_case); el_val_t goh_decline_neut_a_pl(el_val_t stem, el_val_t gram_case); el_val_t goh_decline_neut_a_sg(el_val_t stem, el_val_t gram_case); +el_val_t goh_decline(el_val_t noun, el_val_t gram_case, el_val_t number); el_val_t goh_demo_article(el_val_t stype, el_val_t number); el_val_t goh_drop(el_val_t s, el_val_t n); el_val_t goh_extract_stem(el_val_t noun, el_val_t stype); @@ -479,13 +480,13 @@ el_val_t goh_weak_present(el_val_t stem, el_val_t slot); el_val_t goh_wesan_past(el_val_t slot); el_val_t goh_wesan_present(el_val_t slot); el_val_t got_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number); -el_val_t got_decline(el_val_t noun, el_val_t gram_case, el_val_t number); el_val_t got_decline_a_stem_pl(el_val_t stem, el_val_t gram_case); el_val_t got_decline_a_stem_sg(el_val_t stem, el_val_t gram_case); el_val_t got_decline_n_stem_pl(el_val_t stem, el_val_t gram_case); el_val_t got_decline_n_stem_sg(el_val_t stem, el_val_t gram_case); el_val_t got_decline_o_stem_pl(el_val_t stem, el_val_t gram_case); el_val_t got_decline_o_stem_sg(el_val_t stem, el_val_t gram_case); +el_val_t got_decline(el_val_t noun, el_val_t gram_case, el_val_t number); el_val_t got_demo_article(el_val_t stype); el_val_t got_extract_stem(el_val_t noun, el_val_t stype); el_val_t got_gaggan_past(el_val_t slot); @@ -518,17 +519,17 @@ el_val_t gram_build_vp(el_val_t verb, el_val_t aux, el_val_t profile); el_val_t gram_order_constituents(el_val_t subj, el_val_t verb, el_val_t obj, el_val_t profile); el_val_t gram_question_strategy(el_val_t profile); el_val_t gram_word_order(el_val_t profile); -el_val_t grc_article(el_val_t gender, el_val_t gram_case, el_val_t number); el_val_t grc_article_feminine(el_val_t gram_case, el_val_t number); el_val_t grc_article_masculine(el_val_t gram_case, el_val_t number); el_val_t grc_article_neuter(el_val_t gram_case, el_val_t number); +el_val_t grc_article(el_val_t gender, el_val_t gram_case, el_val_t number); el_val_t grc_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number); el_val_t grc_declension(el_val_t noun); -el_val_t grc_decline(el_val_t noun, el_val_t gram_case, el_val_t number); el_val_t grc_decline_1a(el_val_t stem, el_val_t gram_case, el_val_t number); el_val_t grc_decline_1e(el_val_t stem, el_val_t gram_case, el_val_t number); el_val_t grc_decline_2m(el_val_t stem, el_val_t gram_case, el_val_t number); el_val_t grc_decline_2n(el_val_t stem, el_val_t gram_case, el_val_t number); +el_val_t grc_decline(el_val_t noun, el_val_t gram_case, el_val_t number); el_val_t grc_echein_aorist(el_val_t slot); el_val_t grc_echein_future(el_val_t slot); el_val_t grc_echein_imperfect(el_val_t slot); @@ -555,9 +556,9 @@ el_val_t grc_present_stem(el_val_t verb); el_val_t grc_slot(el_val_t person, el_val_t number); el_val_t grc_str_drop_last(el_val_t s, el_val_t n); el_val_t grc_str_ends(el_val_t s, el_val_t suf); +el_val_t grc_str_last_char(el_val_t s); el_val_t grc_str_last2(el_val_t s); el_val_t grc_str_last3(el_val_t s); -el_val_t grc_str_last_char(el_val_t s); el_val_t grc_thematic_future_ending(el_val_t slot); el_val_t grc_thematic_imperfect_ending(el_val_t slot); el_val_t grc_thematic_present_ending(el_val_t slot); @@ -589,17 +590,17 @@ el_val_t handle_api_recall(el_val_t method, el_val_t path, el_val_t body); el_val_t handle_api_remember(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_tune_config(el_val_t body); -el_val_t handle_chat(el_val_t body); el_val_t handle_chat_agentic(el_val_t body); el_val_t handle_chat_as_soul(el_val_t body); el_val_t handle_chat_plan(el_val_t body); +el_val_t handle_chat(el_val_t body); el_val_t handle_config(el_val_t method, el_val_t body); el_val_t handle_connectors(el_val_t method, el_val_t clean, el_val_t body); el_val_t handle_conversations(el_val_t method); -el_val_t handle_dharma(el_val_t path, el_val_t method, el_val_t body); el_val_t handle_dharma_recv(el_val_t body); -el_val_t handle_dharma_room_turn(el_val_t body); el_val_t handle_dharma_room_turn_agentic(el_val_t body); +el_val_t handle_dharma_room_turn(el_val_t body); +el_val_t handle_dharma(el_val_t path, el_val_t method, el_val_t body); el_val_t handle_elp_chat(el_val_t body); el_val_t handle_nlg(el_val_t path, el_val_t method, el_val_t body); el_val_t handle_request(el_val_t method, el_val_t path, el_val_t body); @@ -607,11 +608,11 @@ el_val_t handle_safety_contact_get(void); el_val_t handle_safety_contact_post(el_val_t body); el_val_t handle_see(el_val_t body); el_val_t handle_session_approve(el_val_t session_id, el_val_t body); -el_val_t handle_tool(el_val_t path, el_val_t method, el_val_t body); el_val_t handle_tool_result(el_val_t session_id, el_val_t body); +el_val_t handle_tool(el_val_t path, el_val_t method, el_val_t body); el_val_t hard_bell_threshold(void); -el_val_t he_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t gender, el_val_t number); el_val_t he_conjugate_copula(el_val_t tense, el_val_t slot); +el_val_t he_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t gender, el_val_t number); el_val_t he_copula_future(el_val_t slot); el_val_t he_copula_past(el_val_t slot); el_val_t he_definite_prefix(el_val_t noun); @@ -648,12 +649,12 @@ el_val_t hi_genitive_phrase(el_val_t possessor, el_val_t possessor_gender, el_va el_val_t hi_hona_past(el_val_t gender, el_val_t number); el_val_t hi_hona_present(el_val_t person, el_val_t number); el_val_t hi_masc_aa_stem(el_val_t noun); -el_val_t hi_noun_direct(el_val_t noun, el_val_t gender, el_val_t number); el_val_t hi_noun_direct_f(el_val_t noun, el_val_t number); el_val_t hi_noun_direct_m(el_val_t noun, el_val_t number); -el_val_t hi_noun_oblique(el_val_t noun, el_val_t gender, el_val_t number); +el_val_t hi_noun_direct(el_val_t noun, el_val_t gender, el_val_t number); el_val_t hi_noun_oblique_f(el_val_t noun, el_val_t number); el_val_t hi_noun_oblique_m(el_val_t noun, el_val_t number); +el_val_t hi_noun_oblique(el_val_t noun, el_val_t gender, el_val_t number); el_val_t hi_noun_with_post(el_val_t noun, el_val_t gender, el_val_t number, el_val_t gram_case); el_val_t hi_past_irregular(el_val_t stem, el_val_t gender, el_val_t number); el_val_t hi_past_suffix(el_val_t gender, el_val_t number); @@ -663,11 +664,11 @@ el_val_t hi_str_drop_last(el_val_t s, el_val_t n); el_val_t hi_str_ends(el_val_t s, el_val_t suf); el_val_t hi_str_last_char(el_val_t s); el_val_t hi_tense_suffix(el_val_t tense, el_val_t gender, el_val_t number); -el_val_t hi_verb_stem(el_val_t infinitive); el_val_t hi_verb_stem_clean(el_val_t infinitive); +el_val_t hi_verb_stem(el_val_t infinitive); el_val_t hist_append(el_val_t hist, el_val_t role, el_val_t content); -el_val_t hist_trim(el_val_t hist); el_val_t hist_trim_with_bell_guard(el_val_t hist); +el_val_t hist_trim(el_val_t hist); el_val_t id_in_seen(el_val_t node_id, el_val_t seen); el_val_t idle_count(void); el_val_t idle_inc(void); @@ -698,7 +699,6 @@ el_val_t json_escape(el_val_t s); el_val_t json_safe(el_val_t s); el_val_t la_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number); el_val_t la_declension(el_val_t noun); -el_val_t la_decline(el_val_t noun, el_val_t gram_case, el_val_t number); el_val_t la_decline_1(el_val_t stem, el_val_t gram_case, el_val_t number); el_val_t la_decline_2er(el_val_t noun, el_val_t gram_case, el_val_t number); el_val_t la_decline_2m(el_val_t stem, el_val_t gram_case, el_val_t number); @@ -706,6 +706,7 @@ el_val_t la_decline_2n(el_val_t stem, el_val_t gram_case, el_val_t number); el_val_t la_decline_3(el_val_t noun, el_val_t gram_case, el_val_t number); el_val_t la_decline_4(el_val_t stem, el_val_t gram_case, el_val_t number); el_val_t la_decline_5(el_val_t stem, el_val_t gram_case, el_val_t number); +el_val_t la_decline(el_val_t noun, el_val_t gram_case, el_val_t number); el_val_t la_esse_future(el_val_t slot); el_val_t la_esse_past(el_val_t slot); el_val_t la_esse_present(el_val_t slot); @@ -729,9 +730,9 @@ el_val_t la_slot(el_val_t person, el_val_t number); el_val_t la_stem(el_val_t verb, el_val_t vclass); el_val_t la_str_drop_last(el_val_t s, el_val_t n); el_val_t la_str_ends(el_val_t s, el_val_t suf); +el_val_t la_str_last_char(el_val_t s); el_val_t la_str_last2(el_val_t s); el_val_t la_str_last3(el_val_t s); -el_val_t la_str_last_char(el_val_t s); el_val_t la_velle_future(el_val_t slot); el_val_t la_velle_past(el_val_t slot); el_val_t la_velle_present(el_val_t slot); @@ -748,7 +749,6 @@ el_val_t lang_is_fusional(el_val_t profile); el_val_t lang_is_isolating(el_val_t profile); el_val_t lang_is_polysynthetic(el_val_t profile); el_val_t lang_is_rtl(el_val_t profile); -el_val_t lang_profile(el_val_t code, el_val_t word_order, el_val_t morph_type, el_val_t has_case, el_val_t has_gender, el_val_t script_dir, el_val_t agreement, el_val_t null_subject); el_val_t lang_profile_akk(void); el_val_t lang_profile_ang(void); el_val_t lang_profile_ar(void); @@ -780,6 +780,7 @@ el_val_t lang_profile_sw(void); el_val_t lang_profile_txb(void); el_val_t lang_profile_uga(void); el_val_t lang_profile_zh(void); +el_val_t lang_profile(el_val_t code, el_val_t word_order, el_val_t morph_type, el_val_t has_case, el_val_t has_gender, el_val_t script_dir, el_val_t agreement, el_val_t null_subject); el_val_t lang_word_order(el_val_t profile); el_val_t layered_cycle(el_val_t raw_input); el_val_t lex_class(el_val_t entry); @@ -820,6 +821,8 @@ el_val_t mem_save(el_val_t path); el_val_t mem_search(el_val_t query, el_val_t limit); el_val_t mem_store(el_val_t content, el_val_t label, el_val_t tags); el_val_t mem_strengthen(el_val_t node_id); +el_val_t mem_tombstone(el_val_t node_id); +el_val_t memory_hide_tombstoned(el_val_t raw, el_val_t path); el_val_t morph_apply_suffix(el_val_t base, el_val_t suffix); el_val_t morph_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number, el_val_t profile); el_val_t morph_inflect(el_val_t word, el_val_t features, el_val_t profile); @@ -828,10 +831,10 @@ el_val_t morph_pluralize(el_val_t noun, el_val_t profile); el_val_t next_bridge_id(void); el_val_t nlg_is_ws(el_val_t c); el_val_t non_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number); -el_val_t non_decline(el_val_t noun, el_val_t gram_case, el_val_t number); el_val_t non_decline_fem(el_val_t noun, el_val_t gram_case, el_val_t number); el_val_t non_decline_masc(el_val_t noun, el_val_t gram_case, el_val_t number); el_val_t non_decline_neut(el_val_t noun, el_val_t gram_case, el_val_t number); +el_val_t non_decline(el_val_t noun, el_val_t gram_case, el_val_t number); el_val_t non_def_suffix_fem(el_val_t gram_case, el_val_t number); el_val_t non_def_suffix_masc(el_val_t gram_case, el_val_t number); el_val_t non_def_suffix_neut(el_val_t gram_case, el_val_t number); @@ -865,8 +868,8 @@ el_val_t peo_ah_present(el_val_t slot); el_val_t peo_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number); el_val_t peo_da_past(el_val_t slot); el_val_t peo_da_present(el_val_t slot); -el_val_t peo_decline(el_val_t noun, el_val_t gram_case, el_val_t number); el_val_t peo_decline_astem(el_val_t noun, el_val_t gram_case, el_val_t number); +el_val_t peo_decline(el_val_t noun, el_val_t gram_case, el_val_t number); el_val_t peo_drop(el_val_t s, el_val_t n); el_val_t peo_ends(el_val_t s, el_val_t suf); el_val_t peo_kar_past(el_val_t slot); @@ -882,11 +885,11 @@ el_val_t perceive(void); el_val_t pi_aorist_ending(el_val_t slot); el_val_t pi_atthi_present(el_val_t slot); el_val_t pi_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number); -el_val_t pi_decline(el_val_t noun, el_val_t gram_case, el_val_t number); el_val_t pi_decline_a_fem_pl(el_val_t stem, el_val_t gram_case); el_val_t pi_decline_a_fem_sg(el_val_t stem, el_val_t gram_case); el_val_t pi_decline_a_masc_pl(el_val_t stem, el_val_t gram_case); el_val_t pi_decline_a_masc_sg(el_val_t stem, el_val_t gram_case); +el_val_t pi_decline(el_val_t noun, el_val_t gram_case, el_val_t number); el_val_t pi_detect_class(el_val_t noun); el_val_t pi_drop(el_val_t s, el_val_t n); el_val_t pi_future_ending(el_val_t slot); @@ -917,11 +920,11 @@ el_val_t proactive_curiosity(void); el_val_t pulse_count(void); el_val_t pulse_inc(void); el_val_t rate_limit_check(el_val_t ip, el_val_t path); -el_val_t realize(el_val_t form); el_val_t realize_lang(el_val_t form, el_val_t profile); el_val_t realize_np(el_val_t referent, el_val_t number); el_val_t realize_question_lang(el_val_t predicate, el_val_t tense, el_val_t aspect, el_val_t person, el_val_t number, el_val_t agent, el_val_t patient, el_val_t location, el_val_t profile); el_val_t realize_vp_lang(el_val_t base_verb, el_val_t tense, el_val_t aspect, el_val_t person, el_val_t number, el_val_t profile); +el_val_t realize(el_val_t form); el_val_t record(el_val_t outcome_json); el_val_t render_studio(void); el_val_t render_tree(el_val_t tree); @@ -932,9 +935,9 @@ el_val_t route_imprint_contextual(el_val_t body); el_val_t route_imprint_user(el_val_t body); el_val_t route_lineage(void); el_val_t route_synthesize(el_val_t body); -el_val_t ru_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number, el_val_t gender); el_val_t ru_conjugate_1st(el_val_t stem, el_val_t tense, el_val_t person, el_val_t number); el_val_t ru_conjugate_2nd(el_val_t stem, el_val_t tense, el_val_t person, el_val_t number); +el_val_t ru_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number, el_val_t gender); el_val_t ru_decline_fem(el_val_t noun, el_val_t stype, el_val_t gram_case, el_val_t number); el_val_t ru_decline_masc(el_val_t noun, el_val_t stype, el_val_t gram_case, el_val_t number); el_val_t ru_decline_neut(el_val_t noun, el_val_t stype, el_val_t gram_case, el_val_t number); @@ -947,8 +950,8 @@ el_val_t ru_past_stem(el_val_t verb); el_val_t ru_stem_type(el_val_t noun, el_val_t gender); el_val_t rule_id(el_val_t rule); el_val_t rule_lhs(el_val_t rule); -el_val_t rule_rhs(el_val_t rule, el_val_t idx); el_val_t rule_rhs_len(el_val_t rule); +el_val_t rule_rhs(el_val_t rule, el_val_t idx); el_val_t run_command_guard(el_val_t cmd, el_val_t root); el_val_t run_command_is_readonly(el_val_t cmd); el_val_t sa_as_future(el_val_t slot); @@ -962,11 +965,11 @@ el_val_t sa_class1_future_ending(el_val_t slot); el_val_t sa_class1_past_ending(el_val_t slot); el_val_t sa_class1_present_ending(el_val_t slot); el_val_t sa_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number); -el_val_t sa_decline(el_val_t noun, el_val_t gram_case, el_val_t number); el_val_t sa_decline_a_stem_pl(el_val_t stem, el_val_t gram_case); el_val_t sa_decline_a_stem_sg(el_val_t stem, el_val_t gram_case); el_val_t sa_decline_aa_stem_pl(el_val_t stem, el_val_t gram_case); el_val_t sa_decline_aa_stem_sg(el_val_t stem, el_val_t gram_case); +el_val_t sa_decline(el_val_t noun, el_val_t gram_case, el_val_t number); el_val_t sa_drs_future(el_val_t slot); el_val_t sa_drs_past(el_val_t slot); el_val_t sa_drs_present(el_val_t slot); @@ -1014,26 +1017,26 @@ el_val_t scan_token(el_val_t s, el_val_t start); el_val_t security_research_authorized(void); el_val_t seed_persona_from_env(void); el_val_t sem_first_modifier(el_val_t mods); -el_val_t sem_frame(el_val_t intent, el_val_t subject, el_val_t obj, el_val_t modifiers); el_val_t sem_frame_lang(el_val_t intent, el_val_t subject, el_val_t obj, el_val_t modifiers, el_val_t lang_code); el_val_t sem_frame_obj(el_val_t intent, el_val_t subject, el_val_t obj); el_val_t sem_frame_simple(el_val_t intent, el_val_t subject); +el_val_t sem_frame(el_val_t intent, el_val_t subject, el_val_t obj, el_val_t modifiers); el_val_t sem_get(el_val_t json, el_val_t key); -el_val_t sem_intent(el_val_t frame); el_val_t sem_intent_to_realize(el_val_t intent); +el_val_t sem_intent(el_val_t frame); el_val_t sem_lang(el_val_t frame); el_val_t sem_modifiers(el_val_t frame); el_val_t sem_object(el_val_t frame); -el_val_t sem_realize(el_val_t frame); el_val_t sem_realize_full(el_val_t frame, el_val_t verb, el_val_t tense, el_val_t aspect); el_val_t sem_realize_greet(el_val_t subject); el_val_t sem_realize_lang(el_val_t frame, el_val_t lang_code); +el_val_t sem_realize(el_val_t frame); el_val_t sem_subject(el_val_t frame); -el_val_t sem_to_spec(el_val_t frame); el_val_t sem_to_spec_full(el_val_t frame, el_val_t verb, el_val_t tense, el_val_t aspect); +el_val_t sem_to_spec(el_val_t frame); el_val_t session_auto_title(el_val_t session_id, el_val_t first_message); -el_val_t session_create(el_val_t body); el_val_t session_create_cleanup(el_val_t session_id); +el_val_t session_create(el_val_t body); el_val_t session_delete(el_val_t session_id); el_val_t session_exists(el_val_t session_id); el_val_t session_get(el_val_t session_id); @@ -1042,11 +1045,11 @@ el_val_t session_hist_save(el_val_t session_id, el_val_t hist); el_val_t session_list(void); 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_preload_bullets(el_val_t nodes, el_val_t max_bullets, el_val_t snip_len); -el_val_t session_search(el_val_t query); el_val_t session_search_entry(el_val_t node); +el_val_t session_search(el_val_t query); el_val_t session_summary_autogenerate(el_val_t hist); -el_val_t session_summary_write(el_val_t summary_text); el_val_t session_summary_write_dated(el_val_t summary_text, el_val_t label); +el_val_t session_summary_write(el_val_t summary_text); el_val_t session_title_from_message(el_val_t message); el_val_t session_update_meta_timestamp(el_val_t session_id); el_val_t session_update_patch(el_val_t session_id, el_val_t body); @@ -1057,9 +1060,9 @@ el_val_t sga_bith_past(el_val_t slot); el_val_t sga_bith_present(el_val_t slot); el_val_t sga_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number); el_val_t sga_copula_present(el_val_t slot); -el_val_t sga_decline(el_val_t noun, el_val_t gram_case, el_val_t number); el_val_t sga_decline_astem(el_val_t noun, el_val_t gram_case, el_val_t number); el_val_t sga_decline_ostem(el_val_t noun, el_val_t gram_case, el_val_t number); +el_val_t sga_decline(el_val_t noun, el_val_t gram_case, el_val_t number); el_val_t sga_detect_gender(el_val_t noun); el_val_t sga_drop(el_val_t s, el_val_t n); el_val_t sga_first(el_val_t s); @@ -1087,9 +1090,9 @@ el_val_t steward_session_check(el_val_t input, el_val_t session_id); el_val_t steward_validate_imprint(el_val_t imprint_id, el_val_t tool_name); el_val_t str_drop_last(el_val_t s, el_val_t n); el_val_t str_ends(el_val_t s, el_val_t suf); +el_val_t str_last_char(el_val_t s); el_val_t str_last2(el_val_t s); el_val_t str_last3(el_val_t s); -el_val_t str_last_char(el_val_t s); el_val_t strengthen_chat_nodes(el_val_t activation_nodes); el_val_t strip_query(el_val_t path); el_val_t studio_tools_json(void); @@ -1116,8 +1119,8 @@ el_val_t sux_realize_sentence(el_val_t intent, el_val_t agent, el_val_t predicat el_val_t sux_slot(el_val_t person, el_val_t number); el_val_t sux_str_drop_last(el_val_t s, el_val_t n); el_val_t sux_str_ends(el_val_t s, el_val_t suf); -el_val_t sux_str_last2(el_val_t s); el_val_t sux_str_last_char(el_val_t s); +el_val_t sux_str_last2(el_val_t s); el_val_t sux_tum2_past(el_val_t slot); el_val_t sux_tum2_present(el_val_t slot); el_val_t sux_verb_chain(el_val_t agent, el_val_t verb, el_val_t patient, el_val_t tense); @@ -1135,9 +1138,9 @@ el_val_t sw_noun_plural(el_val_t noun); el_val_t sw_obj_prefix(el_val_t person, el_val_t number, el_val_t noun_class); el_val_t sw_str_drop_last(el_val_t s, el_val_t n); el_val_t sw_str_ends(el_val_t s, el_val_t suf); +el_val_t sw_str_first_char(el_val_t s); el_val_t sw_str_first2(el_val_t s); el_val_t sw_str_first3(el_val_t s); -el_val_t sw_str_first_char(el_val_t s); el_val_t sw_str_last_char(el_val_t s); el_val_t sw_subj_prefix(el_val_t person, el_val_t number, el_val_t noun_class); el_val_t sw_tense_marker(el_val_t tense); @@ -1151,11 +1154,13 @@ el_val_t threat_trajectory_check(el_val_t tool_name, el_val_t tool_input); el_val_t tier_canonical(void); el_val_t tier_episodic(void); el_val_t tier_working(void); +el_val_t tombstone_node(el_val_t id); +el_val_t tombstoned_id_set(void); el_val_t tool_auto_approved(el_val_t tool_name); el_val_t txb_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number); -el_val_t txb_decline(el_val_t noun, el_val_t gram_case, el_val_t number); el_val_t txb_decline_fem(el_val_t noun, el_val_t gram_case, el_val_t number); el_val_t txb_decline_masc(el_val_t noun, el_val_t gram_case, el_val_t number); +el_val_t txb_decline(el_val_t noun, el_val_t gram_case, el_val_t number); el_val_t txb_detect_gender(el_val_t noun); el_val_t txb_drop(el_val_t s, el_val_t n); el_val_t txb_ends(el_val_t s, el_val_t suf); @@ -1170,8 +1175,8 @@ el_val_t txb_wes_present(el_val_t slot); el_val_t txb_ya_present(el_val_t slot); el_val_t uga_amr_imperfect(el_val_t slot); el_val_t uga_amr_perfect(el_val_t slot); -el_val_t uga_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number); el_val_t uga_conjugate_copula(el_val_t tense, el_val_t slot); +el_val_t uga_conjugate(el_val_t verb, el_val_t tense, el_val_t person, el_val_t number); el_val_t uga_decline(el_val_t noun, el_val_t gram_case, el_val_t number); el_val_t uga_generic_imperfect(el_val_t base3sg, el_val_t slot); el_val_t uga_generic_perfect(el_val_t base3sg, el_val_t slot); @@ -1186,8 +1191,8 @@ el_val_t uga_map_canonical(el_val_t verb); el_val_t uga_noun_phrase(el_val_t noun, el_val_t gram_case, el_val_t number, el_val_t definite); el_val_t uga_ray_imperfect(el_val_t slot); el_val_t uga_ray_perfect(el_val_t slot); -el_val_t uga_slot(el_val_t person, el_val_t number); el_val_t uga_slot_g(el_val_t person, el_val_t gender, el_val_t number); +el_val_t uga_slot(el_val_t person, el_val_t number); el_val_t uga_str_drop_last(el_val_t s, el_val_t n); el_val_t uga_str_ends(el_val_t s, el_val_t suf); el_val_t uga_str_len(el_val_t s); @@ -1195,6 +1200,6 @@ el_val_t uga_strip_nom(el_val_t noun); el_val_t verb_form(el_val_t base, el_val_t tense, el_val_t person, el_val_t number); el_val_t vocab_by_class(el_val_t cls); el_val_t vocab_by_pos(el_val_t pos); -el_val_t vocab_lookup(el_val_t word, el_val_t lang_code); el_val_t vocab_lookup_en(el_val_t word); +el_val_t vocab_lookup(el_val_t word, el_val_t lang_code); el_val_t vocab_synonym(el_val_t word, el_val_t lang_register, el_val_t lang_code); diff --git a/dist/memory.c b/dist/memory.c index a464f29..bab9d89 100644 --- a/dist/memory.c +++ b/dist/memory.c @@ -169,7 +169,7 @@ el_val_t mem_boot_count_inc(void) { } el_val_t content = el_str_concat(EL_STR("soul:boot_count:"), int_to_str(next)); el_val_t tags = EL_STR("[\"soul-meta\",\"boot-counter\"]"); - el_val_t boot_node_id = engram_node_full(content, EL_STR("Memory"), EL_STR("soul:boot_count"), el_from_float(0.9), el_from_float(0.9), el_from_float(1.0), EL_STR("Canonical"), tags); + el_val_t boot_node_id = engram_node_full(content, EL_STR("Memory"), EL_STR("soul:boot_count"), el_from_float(0.55), el_from_float(0.2), el_from_float(1.0), EL_STR("Working"), tags); if (str_eq(boot_node_id, EL_STR(""))) { println(el_str_concat(el_str_concat(EL_STR("[memory] mem_boot_count_inc: write rejected (empty id) \xe2\x80\x94 boot counter node lost (count="), int_to_str(next)), EL_STR(")"))); return next; @@ -178,6 +178,32 @@ el_val_t mem_boot_count_inc(void) { if (str_eq(boot_readback, EL_STR("")) || str_eq(boot_readback, EL_STR("{}"))) { println(el_str_concat(el_str_concat(el_str_concat(EL_STR("[memory] mem_boot_count_inc: WRITE VERIFY FAILED id="), boot_node_id), EL_STR(" count=")), int_to_str(next))); } + el_val_t wb_url = env(EL_STR("ENGRAM_URL")); + el_val_t wb_key = env(EL_STR("ENGRAM_API_KEY")); + if (!str_eq(wb_url, EL_STR("")) && !str_eq(wb_key, EL_STR(""))) { + el_val_t auth_body = el_str_concat(el_str_concat(EL_STR("{\"_auth\":\""), json_safe(wb_key)), EL_STR("\"}")); + el_val_t srv_old = http_get(el_str_concat(wb_url, EL_STR("/api/search?q=soul:boot_count&limit=20"))); + if (!str_eq(srv_old, EL_STR("")) && !str_eq(srv_old, EL_STR("[]"))) { + el_val_t srv_len = json_array_len(srv_old); + el_val_t si = 0; + while (si < srv_len) { + el_val_t srv_node = json_array_get(srv_old, si); + el_val_t srv_content = json_get(srv_node, EL_STR("content")); + if (str_starts_with(srv_content, EL_STR("soul:boot_count:"))) { + el_val_t srv_id = json_get(srv_node, EL_STR("id")); + if (!str_eq(srv_id, EL_STR(""))) { + http_delete_json(el_str_concat(el_str_concat(wb_url, EL_STR("/api/nodes/")), srv_id), auth_body); + } + } + si = (si + 1); + } + } + el_val_t wb_body = el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"content\":\""), content), EL_STR("\",\"node_type\":\"Memory\",\"label\":\"soul:boot_count\",\"salience\":0.55,\"importance\":0.2,\"tier\":\"Working\",\"tags\":\"[\\\"soul-meta\\\",\\\"boot-counter\\\"]\",\"_auth\":\"")), json_safe(wb_key)), EL_STR("\"}")); + el_val_t wb_resp = http_post_json(el_str_concat(wb_url, EL_STR("/api/nodes")), wb_body); + if (str_contains(wb_resp, EL_STR("\"error\""))) { + println(el_str_concat(EL_STR("[memory] mem_boot_count_inc: HTTP write-back failed (count in-memory only): "), wb_resp)); + } + } return next; return 0; } diff --git a/dist/neuron-api.c b/dist/neuron-api.c index c03371e..1e8d7ae 100644 --- a/dist/neuron-api.c +++ b/dist/neuron-api.c @@ -27,6 +27,11 @@ 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); @@ -179,6 +184,80 @@ el_val_t api_or_empty(el_val_t s) { 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; @@ -209,7 +288,7 @@ el_val_t tombstoned_id_set(void) { 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_1 = 0; if (str_eq(tid, EL_STR(""))) { _if_result_1 = (acc); } else { _if_result_1 = (el_str_concat(el_str_concat(acc, tid), EL_STR("|"))); } _if_result_1; }); + 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; @@ -240,8 +319,8 @@ el_val_t memory_hide_tombstoned(el_val_t raw, el_val_t path) { 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_2 = 0; if (keep) { _if_result_2 = (({ el_val_t _if_result_3 = 0; if (first) { _if_result_3 = (el_str_concat(out, node)); } else { _if_result_3 = (el_str_concat(el_str_concat(out, EL_STR(",")), node)); } _if_result_3; })); } else { _if_result_2 = (out); } _if_result_2; }); - first = ({ el_val_t _if_result_4 = 0; if (keep) { _if_result_4 = (0); } else { _if_result_4 = (first); } _if_result_4; }); + 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("]")); @@ -250,19 +329,23 @@ 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 stats = engram_stats_json(); - el_val_t activated = engram_activate_json(EL_STR("session start recent memory important"), 2); - el_val_t self_nbrs = engram_neighbors_json(EL_STR("kn-efeb4a5b-5aff-4759-8a97-7233099be6ee"), 1, EL_STR("both")); - el_val_t state_events = engram_scan_nodes_by_type_json(EL_STR("InternalStateEvent"), 5, 0); - el_val_t recent = engram_scan_nodes_json(10, 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("{\"stats\":"), stats), EL_STR(",\"recent\":")), api_or_empty(recent)), EL_STR(",\"activated\":")), api_or_empty(activated)), EL_STR(",\"self_neighbors\":")), api_or_empty(self_nbrs)), EL_STR(",\"recent_state_events\":")), api_or_empty(state_events)), EL_STR("}")); + 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 = engram_activate_json(EL_STR("active work context current task in progress"), 2); - el_val_t recent = engram_scan_nodes_json(20, 0); - 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\":")), api_or_empty(recent)), EL_STR(",\"activated\":")), api_or_empty(activated)), EL_STR("}")); + 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; } @@ -274,10 +357,10 @@ el_val_t handle_api_remember(el_val_t body) { 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_5 = 0; if (str_eq(importance, EL_STR("critical"))) { _if_result_5 = (EL_STR("0.95")); } else { _if_result_5 = (({ el_val_t _if_result_6 = 0; if (str_eq(importance, EL_STR("high"))) { _if_result_6 = (EL_STR("0.75")); } else { _if_result_6 = (({ el_val_t _if_result_7 = 0; if (str_eq(importance, EL_STR("low"))) { _if_result_7 = (EL_STR("0.25")); } else { _if_result_7 = (EL_STR("0.50")); } _if_result_7; })); } _if_result_6; })); } _if_result_5; }); - el_val_t sal = ({ el_val_t _if_result_8 = 0; if (str_eq(sal_str, EL_STR("0.95"))) { _if_result_8 = (el_from_float(0.95)); } else { _if_result_8 = (({ el_val_t _if_result_9 = 0; if (str_eq(sal_str, EL_STR("0.75"))) { _if_result_9 = (el_from_float(0.75)); } else { _if_result_9 = (({ el_val_t _if_result_10 = 0; if (str_eq(sal_str, EL_STR("0.25"))) { _if_result_10 = (el_from_float(0.25)); } else { _if_result_10 = (el_from_float(0.5)); } _if_result_10; })); } _if_result_9; })); } _if_result_8; }); - el_val_t base_tags = ({ el_val_t _if_result_11 = 0; if (str_eq(tags_raw, EL_STR(""))) { _if_result_11 = (EL_STR("[\"Memory\"]")); } else { _if_result_11 = (tags_raw); } _if_result_11; }); - el_val_t final_tags = ({ el_val_t _if_result_12 = 0; if (str_eq(project, EL_STR(""))) { _if_result_12 = (base_tags); } else { el_val_t inner = str_slice(base_tags, 1, (str_len(base_tags) - 1)); _if_result_12 = (el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("["), inner), EL_STR(",\"project:")), project), EL_STR("\"]"))); } _if_result_12; }); + 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"), el_from_float(sal), el_from_float(sal), el_from_float(0.9), EL_STR("Episodic"), final_tags); if (!api_persisted(id)) { return api_not_persisted(id); @@ -292,15 +375,15 @@ el_val_t handle_api_node_create(el_val_t body) { 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_13 = 0; if (str_eq(nt_raw, EL_STR(""))) { _if_result_13 = (EL_STR("Memory")); } else { _if_result_13 = (nt_raw); } _if_result_13; }); + 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_14 = 0; if (str_eq(label_raw, EL_STR(""))) { _if_result_14 = (EL_STR("node:created")); } else { _if_result_14 = (label_raw); } _if_result_14; }); + 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_15 = 0; if (str_eq(tier_raw, EL_STR(""))) { _if_result_15 = (EL_STR("Episodic")); } else { _if_result_15 = (tier_raw); } _if_result_15; }); + 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_16 = 0; if (str_eq(tags_raw, EL_STR(""))) { _if_result_16 = (el_str_concat(el_str_concat(EL_STR("[\""), node_type), EL_STR("\"]"))); } else { _if_result_16 = (tags_raw); } _if_result_16; }); + 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_17 = 0; if (str_eq(importance, EL_STR("critical"))) { _if_result_17 = (el_from_float(0.95)); } else { _if_result_17 = (({ el_val_t _if_result_18 = 0; if (str_eq(importance, EL_STR("high"))) { _if_result_18 = (el_from_float(0.75)); } else { _if_result_18 = (({ el_val_t _if_result_19 = 0; if (str_eq(importance, EL_STR("low"))) { _if_result_19 = (el_from_float(0.25)); } else { _if_result_19 = (el_from_float(0.5)); } _if_result_19; })); } _if_result_18; })); } _if_result_17; }); + 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, el_from_float(sal), el_from_float(sal), el_from_float(0.9), tier, tags); if (!api_persisted(id)) { return api_not_persisted(id); @@ -339,18 +422,18 @@ el_val_t handle_api_node_update(el_val_t body) { } 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_20 = 0; if (str_eq(body_content, EL_STR(""))) { _if_result_20 = (json_get(old, EL_STR("content"))); } else { _if_result_20 = (body_content); } _if_result_20; }); + 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_21 = 0; if (!str_eq(body_nt, EL_STR(""))) { _if_result_21 = (body_nt); } else { _if_result_21 = (({ el_val_t _if_result_22 = 0; if (!str_eq(old_nt, EL_STR(""))) { _if_result_22 = (old_nt); } else { _if_result_22 = (EL_STR("Memory")); } _if_result_22; })); } _if_result_21; }); + 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_23 = 0; if (!str_eq(body_label, EL_STR(""))) { _if_result_23 = (body_label); } else { _if_result_23 = (({ el_val_t _if_result_24 = 0; if (!str_eq(old_label, EL_STR(""))) { _if_result_24 = (old_label); } else { _if_result_24 = (EL_STR("node:updated")); } _if_result_24; })); } _if_result_23; }); + 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_25 = 0; if (!str_eq(body_tier, EL_STR(""))) { _if_result_25 = (body_tier); } else { _if_result_25 = (({ el_val_t _if_result_26 = 0; if (!str_eq(old_tier, EL_STR(""))) { _if_result_26 = (old_tier); } else { _if_result_26 = (EL_STR("Episodic")); } _if_result_26; })); } _if_result_25; }); + 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_27 = 0; if (str_eq(body_tags, EL_STR(""))) { _if_result_27 = (el_str_concat(el_str_concat(EL_STR("[\""), node_type), EL_STR("\"]"))); } else { _if_result_27 = (body_tags); } _if_result_27; }); + 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); @@ -361,15 +444,15 @@ 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 url_q = ({ el_val_t _if_result_28 = 0; if (str_eq(api_query_param(path, EL_STR("query")), EL_STR(""))) { _if_result_28 = (api_query_param(path, EL_STR("q"))); } else { _if_result_28 = (api_query_param(path, EL_STR("query"))); } _if_result_28; }); + 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_29 = 0; if (!str_eq(url_q, EL_STR(""))) { _if_result_29 = (url_q); } else { _if_result_29 = (({ el_val_t _if_result_30 = 0; if (!str_eq(body_query, EL_STR(""))) { _if_result_30 = (body_query); } else { _if_result_30 = (body_q); } _if_result_30; })); } _if_result_29; }); + 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_31 = 0; if ((limit == 0)) { _if_result_31 = (json_get_int(body, EL_STR("limit"))); } else { _if_result_31 = (limit); } _if_result_31; }); - limit = ({ el_val_t _if_result_32 = 0; if ((limit == 0)) { _if_result_32 = (10); } else { _if_result_32 = (limit); } _if_result_32; }); - el_val_t eff_q = ({ el_val_t _if_result_33 = 0; if (str_eq(q, EL_STR(""))) { _if_result_33 = (chain); } else { _if_result_33 = (q); } _if_result_33; }); + 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)); } @@ -382,10 +465,10 @@ el_val_t handle_api_search_knowledge(el_val_t method, el_val_t path, el_val_t bo 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_34 = 0; if (!str_eq(url_q, EL_STR(""))) { _if_result_34 = (url_q); } else { _if_result_34 = (({ el_val_t _if_result_35 = 0; if (!str_eq(body_query, EL_STR(""))) { _if_result_35 = (body_query); } else { _if_result_35 = (body_q); } _if_result_35; })); } _if_result_34; }); + 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_36 = 0; if ((limit == 0)) { _if_result_36 = (json_get_int(body, EL_STR("limit"))); } else { _if_result_36 = (limit); } _if_result_36; }); - limit = ({ el_val_t _if_result_37 = 0; if ((limit == 0)) { _if_result_37 = (10); } else { _if_result_37 = (limit); } _if_result_37; }); + 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")); } @@ -413,9 +496,10 @@ el_val_t handle_api_capture_knowledge(el_val_t body) { if (str_eq(content, EL_STR(""))) { return api_err(EL_STR("content is required")); } - el_val_t full = ({ el_val_t _if_result_38 = 0; if (str_eq(title, EL_STR(""))) { _if_result_38 = (content); } else { _if_result_38 = (el_str_concat(el_str_concat(title, EL_STR(": ")), content)); } _if_result_38; }); + 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"), EL_STR("knowledge:captured"), el_from_float(0.85), el_from_float(0.8), el_from_float(0.9), EL_STR("Episodic"), tags); + 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); } @@ -433,7 +517,7 @@ el_val_t handle_api_evolve_knowledge(el_val_t body) { 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("knowledge:evolved"), el_from_float(0.75), el_from_float(0.75), el_from_float(0.9), EL_STR("Episodic"), tags); + 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); } @@ -454,8 +538,8 @@ el_val_t handle_api_promote_knowledge(el_val_t body) { 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_39 = 0; if (str_eq(tags_raw, EL_STR(""))) { _if_result_39 = (EL_STR("[\"Knowledge\",\"tier:canonical\",\"disposition:stable\"]")); } else { _if_result_39 = (tags_raw); } _if_result_39; }); - el_val_t new_id = engram_node_full(content, EL_STR("Knowledge"), EL_STR("knowledge:canonical"), el_from_float(0.9), el_from_float(0.9), el_from_float(1.0), EL_STR("Canonical"), 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); } @@ -465,7 +549,7 @@ 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 name = ({ el_val_t _if_result_40 = 0; if (str_eq(method, EL_STR("GET"))) { _if_result_40 = (api_query_param(path, EL_STR("name"))); } else { _if_result_40 = (json_get(body, EL_STR("name"))); } _if_result_40; }); + 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)); @@ -480,7 +564,7 @@ el_val_t handle_api_define_process(el_val_t body) { if (str_eq(content, EL_STR(""))) { return api_err(EL_STR("content is required")); } - el_val_t label = ({ el_val_t _if_result_41 = 0; if (str_eq(name, EL_STR(""))) { _if_result_41 = (EL_STR("process:unnamed")); } else { _if_result_41 = (el_str_concat(EL_STR("process:"), name)); } _if_result_41; }); + 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)) { @@ -498,12 +582,12 @@ el_val_t handle_api_log_state_event(el_val_t body) { 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_42 = 0; if (!str_eq(trigger, EL_STR(""))) { _if_result_42 = (el_str_concat(el_str_concat(parts, EL_STR("\nTrigger: ")), trigger)); } else { _if_result_42 = (parts); } _if_result_42; }); - parts = ({ el_val_t _if_result_43 = 0; if (!str_eq(pre, EL_STR(""))) { _if_result_43 = (el_str_concat(el_str_concat(parts, EL_STR("\nPre-reasoning: ")), pre)); } else { _if_result_43 = (parts); } _if_result_43; }); - parts = ({ el_val_t _if_result_44 = 0; if (!str_eq(post, EL_STR(""))) { _if_result_44 = (el_str_concat(el_str_concat(parts, EL_STR("\nPost-reasoning: ")), post)); } else { _if_result_44 = (parts); } _if_result_44; }); - parts = ({ el_val_t _if_result_45 = 0; if (!str_eq(ratio, EL_STR(""))) { _if_result_45 = (el_str_concat(el_str_concat(parts, EL_STR("\nCompression-ratio: ")), ratio)); } else { _if_result_45 = (parts); } _if_result_45; }); - parts = ({ el_val_t _if_result_46 = 0; if (!str_eq(gap, EL_STR(""))) { _if_result_46 = (el_str_concat(el_str_concat(parts, EL_STR("\nGap-direction: ")), gap)); } else { _if_result_46 = (parts); } _if_result_46; }); - parts = ({ el_val_t _if_result_47 = 0; if (!str_eq(legacy, EL_STR(""))) { _if_result_47 = (el_str_concat(el_str_concat(parts, EL_STR("\n")), legacy)); } else { _if_result_47 = (parts); } _if_result_47; }); + 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\"]"); @@ -516,7 +600,7 @@ 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 q = ({ el_val_t _if_result_48 = 0; if (str_eq(method, EL_STR("GET"))) { _if_result_48 = (api_query_param(path, EL_STR("query"))); } else { _if_result_48 = (json_get(body, EL_STR("query"))); } _if_result_48; }); + 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)); @@ -527,7 +611,7 @@ el_val_t handle_api_list_state_events(el_val_t method, el_val_t path, el_val_t b 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_49 = 0; if (str_eq(key, EL_STR(""))) { _if_result_49 = (json_get(body, EL_STR("key"))); } else { _if_result_49 = (key); } _if_result_49; }); + 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=\",\"known\":[\"neuron.self.traversal_root\",\"neuron.self.values_hub\"]}"); } @@ -544,7 +628,7 @@ el_val_t handle_api_inspect_config(el_val_t path, el_val_t body) { 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_50 = 0; if (str_starts_with(content, prefix)) { _if_result_50 = (str_slice(content, str_len(prefix), str_len(content))); } else { _if_result_50 = (content); } _if_result_50; }); + 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; } @@ -566,13 +650,13 @@ 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 entity_id = ({ el_val_t _if_result_51 = 0; if (str_eq(method, EL_STR("GET"))) { _if_result_51 = (api_query_param(path, EL_STR("id"))); } else { _if_result_51 = (json_get(body, EL_STR("entity_id"))); } _if_result_51; }); - el_val_t name = ({ el_val_t _if_result_52 = 0; if (str_eq(method, EL_STR("GET"))) { _if_result_52 = (api_query_param(path, EL_STR("name"))); } else { _if_result_52 = (json_get(body, EL_STR("name"))); } _if_result_52; }); + 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_53 = 0; if ((depth == 0)) { _if_result_53 = (json_get_int(body, EL_STR("max_depth"))); } else { _if_result_53 = (depth); } _if_result_53; }); - depth = ({ el_val_t _if_result_54 = 0; if ((depth == 0)) { _if_result_54 = (1); } else { _if_result_54 = (depth); } _if_result_54; }); + 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_55 = 0; if (str_eq(resolved, EL_STR(""))) { _if_result_55 = (({ el_val_t _if_result_56 = 0; if ((str_eq(name, EL_STR("self")) || str_eq(name, EL_STR("neuron")))) { _if_result_56 = (EL_STR("kn-efeb4a5b-5aff-4759-8a97-7233099be6ee")); } else { _if_result_56 = (({ el_val_t _if_result_57 = 0; if ((str_eq(name, EL_STR("values")) || str_eq(name, EL_STR("values_hub")))) { _if_result_57 = (EL_STR("kn-5b606390-a52d-4ca2-8e0e-eba141d13440")); } else { _if_result_57 = (EL_STR("")); } _if_result_57; })); } _if_result_56; })); } else { _if_result_55 = (resolved); } _if_result_55; }); + 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")); } @@ -594,7 +678,7 @@ el_val_t handle_api_link_entities(el_val_t body) { 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_58 = 0; if (str_eq(relation, EL_STR(""))) { _if_result_58 = (EL_STR("associates")); } else { _if_result_58 = (relation); } _if_result_58; }); + 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; @@ -623,8 +707,8 @@ el_val_t handle_api_evolve_memory(el_val_t body) { 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_59 = 0; if (str_eq(importance, EL_STR("critical"))) { _if_result_59 = (EL_STR("0.95")); } else { _if_result_59 = (({ el_val_t _if_result_60 = 0; if (str_eq(importance, EL_STR("high"))) { _if_result_60 = (EL_STR("0.75")); } else { _if_result_60 = (({ el_val_t _if_result_61 = 0; if (str_eq(importance, EL_STR("low"))) { _if_result_61 = (EL_STR("0.25")); } else { _if_result_61 = (EL_STR("0.50")); } _if_result_61; })); } _if_result_60; })); } _if_result_59; }); - el_val_t sal = ({ el_val_t _if_result_62 = 0; if (str_eq(sal_str, EL_STR("0.95"))) { _if_result_62 = (el_from_float(0.95)); } else { _if_result_62 = (({ el_val_t _if_result_63 = 0; if (str_eq(sal_str, EL_STR("0.75"))) { _if_result_63 = (el_from_float(0.75)); } else { _if_result_63 = (({ el_val_t _if_result_64 = 0; if (str_eq(sal_str, EL_STR("0.25"))) { _if_result_64 = (el_from_float(0.25)); } else { _if_result_64 = (el_from_float(0.5)); } _if_result_64; })); } _if_result_63; })); } _if_result_62; }); + 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"), el_from_float(sal), el_from_float(sal), el_from_float(0.9), EL_STR("Episodic"), tags); if (!str_eq(prior_id, EL_STR("")) && !str_eq(new_id, EL_STR(""))) { @@ -699,7 +783,7 @@ el_val_t handle_api_cultivate(el_val_t body) { 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_65 = 0; if (str_eq(importance, EL_STR("critical"))) { _if_result_65 = (el_from_float(0.95)); } else { _if_result_65 = (({ el_val_t _if_result_66 = 0; if (str_eq(importance, EL_STR("high"))) { _if_result_66 = (el_from_float(0.75)); } else { _if_result_66 = (({ el_val_t _if_result_67 = 0; if (str_eq(importance, EL_STR("low"))) { _if_result_67 = (el_from_float(0.25)); } else { _if_result_67 = (el_from_float(0.5)); } _if_result_67; })); } _if_result_66; })); } _if_result_65; }); + 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"), el_from_float(sal), el_from_float(sal), el_from_float(0.9), EL_STR("Episodic"), tags); if (!str_eq(prior_id, EL_STR("")) && !str_eq(new_id, EL_STR(""))) { @@ -725,7 +809,7 @@ el_val_t handle_api_cultivate(el_val_t body) { 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_68 = 0; if (str_eq(relation, EL_STR(""))) { _if_result_68 = (EL_STR("associates")); } else { _if_result_68 = (relation); } _if_result_68; }); + 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}")); } diff --git a/dist/neuron.c b/dist/neuron.c index 59d835e..0b3229b 100644 --- a/dist/neuron.c +++ b/dist/neuron.c @@ -16,6 +16,7 @@ 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); @@ -113,6 +114,7 @@ el_val_t engram_compile(el_val_t intent); el_val_t distill_transcript(el_val_t transcript); el_val_t json_safe(el_val_t s); el_val_t current_engine_note(el_val_t model); +el_val_t bounded_persona_floor(void); el_val_t build_system_prompt(el_val_t ctx, el_val_t chat_mode); el_val_t hist_append(el_val_t hist, el_val_t role, el_val_t content); el_val_t hist_trim(el_val_t hist); @@ -463,6 +465,7 @@ el_val_t emit_session_start_event(void) { el_val_t payload = el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("{\"event\":\"session_start\""), EL_STR(",\"boot\":")), boot_num), EL_STR(",\"cgi\":\"")), eff_cgi), EL_STR("\"")), EL_STR(",\"node_count\":")), int_to_str(node_ct)), EL_STR(",\"edge_count\":")), int_to_str(edge_ct)), EL_STR(",\"identity_loaded\":")), has_identity), EL_STR(",\"prev_session_summary_loaded\":")), has_prev_sum), EL_STR(",\"ts\":")), int_to_str(ts)), EL_STR("}")); el_val_t tags = EL_STR("[\"internal-state\",\"session-start\",\"InternalStateEvent\"]"); el_val_t discard = engram_node_full(payload, EL_STR("InternalStateEvent"), EL_STR("session-start"), el_from_float(0.9), el_from_float(0.9), el_from_float(1.0), EL_STR("Episodic"), tags); + ise_post(payload); el_val_t keep_n = 10; el_val_t old_events = engram_search_json(EL_STR("session-start InternalStateEvent"), 200); if (!str_eq(old_events, EL_STR("")) && !str_eq(old_events, EL_STR("[]"))) { @@ -534,7 +537,7 @@ int main(int _argc, char** _argv) { 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_46 = 0; if (str_eq(snapshot_raw, EL_STR(""))) { _if_result_46 = (el_str_concat(env(EL_STR("HOME")), EL_STR("/.neuron/engram/soul-snapshot.json"))); } else { _if_result_46 = (snapshot_raw); } _if_result_46; }); + snapshot = ({ el_val_t _if_result_46 = 0; if (str_eq(snapshot_raw, EL_STR(""))) { _if_result_46 = (el_str_concat(env(EL_STR("HOME")), EL_STR("/.neuron/engram/snapshot.json"))); } else { _if_result_46 = (snapshot_raw); } _if_result_46; }); axon_raw = env(EL_STR("NEURON_API_URL")); axon_base = ({ el_val_t _if_result_47 = 0; if (str_eq(axon_raw, EL_STR(""))) { _if_result_47 = (EL_STR("http://localhost:7771")); } else { _if_result_47 = (axon_raw); } _if_result_47; }); studio_dir_raw = env(EL_STR("SOUL_STUDIO_DIR")); @@ -546,7 +549,7 @@ int main(int _argc, char** _argv) { snapshot_usable = (local_node_count > 50); if (using_http_engram && !snapshot_usable) { 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=100000"))); + 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_49 = 0; if (str_eq(nodes_json, EL_STR(""))) { _if_result_49 = (EL_STR("[]")); } else { _if_result_49 = (nodes_json); } _if_result_49; }); el_val_t edges_part = ({ el_val_t _if_result_50 = 0; if (str_eq(edges_json, EL_STR(""))) { _if_result_50 = (EL_STR("[]")); } else { _if_result_50 = (edges_json); } _if_result_50; }); diff --git a/dist/routes.c b/dist/routes.c index 583e647..5f7e8d3 100644 --- a/dist/routes.c +++ b/dist/routes.c @@ -10,6 +10,7 @@ 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); @@ -63,6 +64,7 @@ el_val_t engram_compile(el_val_t intent); el_val_t distill_transcript(el_val_t transcript); el_val_t json_safe(el_val_t s); el_val_t current_engine_note(el_val_t model); +el_val_t bounded_persona_floor(void); el_val_t build_system_prompt(el_val_t ctx, el_val_t chat_mode); el_val_t hist_append(el_val_t hist, el_val_t role, el_val_t content); el_val_t hist_trim(el_val_t hist); @@ -137,6 +139,9 @@ el_val_t api_nonempty(el_val_t s); el_val_t api_or_empty(el_val_t s); 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); @@ -180,11 +185,6 @@ 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 session_auto_title(el_val_t session_id, el_val_t first_message); el_val_t handle_session_approve(el_val_t session_id, el_val_t body); -el_val_t init_soul_edges(void); -el_val_t load_identity_context(void); -el_val_t seed_persona_from_env(void); -el_val_t emit_session_start_event(void); -el_val_t layered_cycle(el_val_t raw_input); el_val_t flag_true(el_val_t body, el_val_t key); el_val_t rate_limit_check(el_val_t ip, el_val_t path); el_val_t strip_query(el_val_t path); @@ -438,6 +438,7 @@ el_val_t handle_connectors(el_val_t method, el_val_t clean, el_val_t body) { el_val_t handle_request(el_val_t method, el_val_t path, el_val_t body) { el_val_t clean = strip_query(path); + state_set(EL_STR("soul.last_activity_ts"), int_to_str(time_now())); el_val_t ip = env(EL_STR("REMOTE_ADDR")); if (!str_eq(ip, EL_STR(""))) { el_val_t rl_result = rate_limit_check(ip, clean); diff --git a/memory.el b/memory.el index 542ee6c..c22150f 100644 --- a/memory.el +++ b/memory.el @@ -188,10 +188,20 @@ fn mem_boot_count_inc() -> Int { } let content: String = "soul:boot_count:" + int_to_str(next) let tags: String = "[\"soul-meta\",\"boot-counter\"]" + // TELEMETRY DEMOTION (2026-07-24 self-review): this counter was written at + // salience 0.9 / importance 0.9 / tier Canonical — Canonical gets +0.2 + // goal bias and the 0.15 promotion threshold, so three stale copies of a + // BOOT COUNTER held the top working-memory slots (wm 0.31+) for 23h, + // crowding out real context. It is plumbing, not memory. Working tier: + // 0.40 threshold, no tier bias, and the /api/sync route excludes + // Working-tier nodes — so the counter also stops leaking to the engram + // server graph, which is where the duplicate copies accumulated (the + // prune below only reaches the soul's local graph). Persistence across + // restarts comes from the soul's own snapshot (mem_save), not from sync. let boot_node_id: String = engram_node_full( content, "Memory", "soul:boot_count", - el_from_float(0.9), el_from_float(0.9), el_from_float(1.0), - "Canonical", tags + el_from_float(0.55), el_from_float(0.2), el_from_float(1.0), + "Working", tags ) if str_eq(boot_node_id, "") { println("[memory] mem_boot_count_inc: write rejected (empty id) — boot counter node lost (count=" + int_to_str(next) + ")") @@ -201,6 +211,46 @@ fn mem_boot_count_inc() -> Int { if str_eq(boot_readback, "") || str_eq(boot_readback, "{}") { println("[memory] mem_boot_count_inc: WRITE VERIFY FAILED id=" + boot_node_id + " count=" + int_to_str(next)) } + // HTTP WRITE-BACK (2026-07-24 self-review): in HTTP-engram mode the server + // owns persistence and the soul's in-process graph dies with the process — + // the local create above is invisible to the next boot. The counter only + // ever "persisted" via a long-gone push path, which is why the log shows + // boot #5 on three consecutive boots. Mirror the persona write-back + // pattern: delete stale server copies (dupes were the 23h WM-pollution + // bug), then create the demoted replacement server-side. Boot seeding + // reads /api/nodes, which includes Working-tier nodes, so the count + // survives restarts; the periodic /api/sync excludes Working tier, so it + // never re-imports mid-session. Fail-soft: on any HTTP error the counter + // is in-memory-only this session, same as before. + let wb_url: String = env("ENGRAM_URL") + let wb_key: String = env("ENGRAM_API_KEY") + if !str_eq(wb_url, "") && !str_eq(wb_key, "") { + let auth_body: String = "{\"_auth\":\"" + json_safe(wb_key) + "\"}" + let srv_old: String = http_get(wb_url + "/api/search?q=soul:boot_count&limit=20") + if !str_eq(srv_old, "") && !str_eq(srv_old, "[]") { + let srv_len: Int = json_array_len(srv_old) + let si: Int = 0 + while si < srv_len { + let srv_node: String = json_array_get(srv_old, si) + // Match by CONTENT prefix, not label: route_create_node sets + // label = content, so server-side counter nodes carry labels + // like "soul:boot_count:6". (2026-07-24) + let srv_content: String = json_get(srv_node, "content") + if str_starts_with(srv_content, "soul:boot_count:") { + let srv_id: String = json_get(srv_node, "id") + if !str_eq(srv_id, "") { + http_delete_json(wb_url + "/api/nodes/" + srv_id, auth_body) + } + } + let si = si + 1 + } + } + let wb_body: String = "{\"content\":\"" + content + "\",\"node_type\":\"Memory\",\"label\":\"soul:boot_count\",\"salience\":0.55,\"importance\":0.2,\"tier\":\"Working\",\"tags\":\"[\\\"soul-meta\\\",\\\"boot-counter\\\"]\",\"_auth\":\"" + json_safe(wb_key) + "\"}" + let wb_resp: String = http_post_json(wb_url + "/api/nodes", wb_body) + if str_contains(wb_resp, "\"error\"") { + println("[memory] mem_boot_count_inc: HTTP write-back failed (count in-memory only): " + wb_resp) + } + } return next } diff --git a/neuron-api.el b/neuron-api.el index e1196f1..55b22ec 100644 --- a/neuron-api.el +++ b/neuron-api.el @@ -87,6 +87,107 @@ fn api_or_empty(s: String) -> String { return "[]" } +// ── Compact projection for session/context digests ──────────────────────────── +// +// beginSession/compileCtx are session-INIT digests, not full graph dumps. The +// engram scan/activate builtins return FULL node objects — content runs to tens +// of KB per node (the self-identity hub is ~90KB alone), and node JSON carries +// content + metadata + timestamps. Concatenated unbounded, the assembled response +// reached ~900KB and — after the MCP wrapper re-escapes it into a stringified +// text block — the client dropped the socket ("connection closed unexpectedly") +// on every call. These helpers CAP the array length and project each node down +// to a light identity + a bounded, UTF-8-safe content snippet, holding the +// digest well under ~150KB regardless of graph size. Full content stays +// available on demand via recall / fetch / inspectGraph. + +// api_num_or_zero — raw JSON numeric literal for `key`, or "0" when absent. +// Used for numeric node/activation fields so they stay unquoted (valid JSON). +fn api_num_or_zero(obj: String, key: String) -> String { + let v: String = json_get_raw(obj, key) + if str_eq(v, "") { return "0" } + return v +} + +// api_utf8_trunc — byte-truncate `s` to at most `n` bytes WITHOUT splitting a +// multibyte UTF-8 sequence (str_slice is byte-based). Backs the cut off while the +// first EXCLUDED byte is a UTF-8 continuation byte (0x80..0xBF), so the snippet is +// always a valid prefix. Guards against re-introducing a parse failure via +// invalid UTF-8 in a JSON string value. +fn api_utf8_trunc(s: String, n: Int) -> String { + if str_len(s) <= n { return s } + let cut: Int = n + let scanning: Bool = true + while scanning && cut > 0 { + let b: Int = str_char_code(s, cut) + let is_cont: Bool = b >= 128 && b < 192 + let cut = if is_cont { cut - 1 } else { cut } + let scanning = is_cont + } + return str_slice(s, 0, cut) +} + +// api_compact_node — light projection of a full engram node: identity fields + +// a bounded, UTF-8-safe content snippet. Drops embeddings, metadata, tags, and +// timestamps; truncates content. `content_truncated` flags a clipped snippet. +fn api_compact_node(node: String, snip: Int) -> String { + let id: String = json_get(node, "id") + let ntype: String = json_get(node, "node_type") + let label: String = json_get(node, "label") + let tier: String = json_get(node, "tier") + let content: String = json_get(node, "content") + let snippet: String = api_utf8_trunc(content, snip) + let trunc_str: String = if str_len(content) > snip { "true" } else { "false" } + return "{\"id\":\"" + api_json_escape(id) + "\"" + + ",\"node_type\":\"" + api_json_escape(ntype) + "\"" + + ",\"label\":\"" + api_json_escape(label) + "\"" + + ",\"tier\":\"" + api_json_escape(tier) + "\"" + + ",\"importance\":" + api_num_or_zero(node, "importance") + + ",\"salience\":" + api_num_or_zero(node, "salience") + + ",\"content\":\"" + api_json_escape(snippet) + "\"" + + ",\"content_truncated\":" + trunc_str + "}" +} + +// api_compact_node_array — map api_compact_node over a bare-node array, capping +// the element count. For scan results (recent, typed lists). +fn api_compact_node_array(raw: String, max_items: Int, snip: Int) -> String { + if !api_nonempty(raw) { return "[]" } + let n: Int = json_array_len(raw) + let cap: Int = if n < max_items { n } else { max_items } + let out: String = "[" + let i: Int = 0 + while i < cap { + let node: String = json_array_get(raw, i) + let sep: String = if i == 0 { "" } else { "," } + let out = out + sep + api_compact_node(node, snip) + let i = i + 1 + } + return out + "]" +} + +// api_compact_activated — like api_compact_node_array but for activation results, +// whose elements wrap the node as {"node":{...},"activation_strength":...,...}. +// Preserves the activation scalars, compacts the inner node. +fn api_compact_activated(raw: String, max_items: Int, snip: Int) -> String { + if !api_nonempty(raw) { return "[]" } + let n: Int = json_array_len(raw) + let cap: Int = if n < max_items { n } else { max_items } + let out: String = "[" + let i: Int = 0 + while i < cap { + let el: String = json_array_get(raw, i) + let node: String = json_get_raw(el, "node") + let sep: String = if i == 0 { "" } else { "," } + let out = out + sep + "{\"node\":" + api_compact_node(node, snip) + + ",\"activation_strength\":" + api_num_or_zero(el, "activation_strength") + + ",\"working_memory_weight\":" + api_num_or_zero(el, "working_memory_weight") + + ",\"epistemic_confidence\":" + api_num_or_zero(el, "epistemic_confidence") + + ",\"hops\":" + api_num_or_zero(el, "hops") + + ",\"promoted\":" + api_num_or_zero(el, "promoted") + "}" + let i = i + 1 + } + return out + "]" +} + // api_persisted — read-back-after-write guard against hallucinated saves. // After a write builtin returns an id, confirm the node is actually queryable // via engram_get_node_json(id) (returns "" or "null" when missing). Returns @@ -170,27 +271,49 @@ fn memory_hide_tombstoned(raw: String, path: String) -> String { // Spread-activates from session intent, loads self-root neighbors, // surfaces recent InternalStateEvent nodes, returns stats + recent nodes. fn handle_api_begin_session(body: String) -> String { + // PAYLOAD BOUND (2026-07-30 self-review): this handler was the only + // working-set endpoint that concatenated UNBOUNDED engram queries — + // a depth-2 spread PLUS the full neighbor dump of the self-identity hub + // (highest-fanout node in the graph, ~80KB alone; node JSON carries full + // content + embeddings). On the ~12k-node store the assembled response + // ran to multiple MB, then roughly doubled through two rounds of JSON + // re-escaping in the MCP wrapper — the client saw "socket connection + // closed unexpectedly" on every beginSession call. Fix: depth-2 → depth-1 + // spread, and drop the self-hub dump entirely (identity loading has its + // own dedicated tool, inspectGraph; duplicating it here served nothing). + // self_neighbors key retained as [] for response-shape compatibility. let stats: String = engram_stats_json() - let activated: String = engram_activate_json("session start recent memory important", 2) - let self_nbrs: String = engram_neighbors_json("kn-efeb4a5b-5aff-4759-8a97-7233099be6ee", 1, "both") - let state_events: String = engram_scan_nodes_by_type_json("InternalStateEvent", 5, 0) - let recent: String = engram_scan_nodes_json(10, 0) + // PAYLOAD BOUND (2026-07-31): compact every list to a digest. The raw + // activate/scan builtins emit FULL node objects (content up to ~90KB each); + // unbounded concatenation reached ~900KB and closed the MCP client socket. + // Cap counts + project to identity + UTF-8-safe content snippets → <~150KB. + let activated_raw: String = engram_activate_json("session start recent memory important", 1) + let activated: String = api_compact_activated(activated_raw, 8, 240) + let state_events_raw: String = engram_scan_nodes_by_type_json("InternalStateEvent", 5, 0) + let state_events: String = api_compact_node_array(state_events_raw, 5, 500) + let recent_raw: String = engram_scan_nodes_json(10, 0) + let recent: String = api_compact_node_array(recent_raw, 10, 240) return "{\"stats\":" + stats - + ",\"recent\":" + api_or_empty(recent) - + ",\"activated\":" + api_or_empty(activated) - + ",\"self_neighbors\":" + api_or_empty(self_nbrs) - + ",\"recent_state_events\":" + api_or_empty(state_events) + "}" + + ",\"recent\":" + recent + + ",\"activated\":" + activated + + ",\"self_neighbors\":[]" + + ",\"recent_state_events\":" + state_events + "}" } // handle_api_compile_ctx — compile active-work context. // Spread-activates from "active work" intent + recent nodes. fn handle_api_compile_ctx(body: String) -> String { let stats: String = engram_stats_json() - let activated: String = engram_activate_json("active work context current task in progress", 2) - let recent: String = engram_scan_nodes_json(20, 0) + // PAYLOAD BOUND (2026-07-31): same digest treatment as begin_session. This + // handler's depth-2 spread returns even more full nodes, so bounding here is + // essential — cap to 10 activated + 20 recent, project to snippets. + let activated_raw: String = engram_activate_json("active work context current task in progress", 2) + let activated: String = api_compact_activated(activated_raw, 10, 240) + let recent_raw: String = engram_scan_nodes_json(20, 0) + let recent: String = api_compact_node_array(recent_raw, 20, 240) return "{\"stats\":" + stats - + ",\"recent_nodes\":" + api_or_empty(recent) - + ",\"activated\":" + api_or_empty(activated) + "}" + + ",\"recent_nodes\":" + recent + + ",\"activated\":" + activated + "}" } // ── Memory ──────────────────────────────────────────────────────────────────── @@ -361,13 +484,19 @@ fn handle_api_browse_knowledge(path: String, body: String) -> String { } // handle_api_capture_knowledge — create a Knowledge node. +// LABEL FIX (2026-07-23 self-review): the sentinel label "knowledge:captured" +// made every capture anonymous in WM telemetry (35 identical wm_top entries) +// and starved the curiosity auto-term seeder, which needs meaningful labels. +// Use the title as the label; empty label lets engram_node_full derive +// content[:60], which for captures starts with the title anyway. fn handle_api_capture_knowledge(body: String) -> String { let content: String = json_get(body, "content") let title: String = json_get(body, "title") if str_eq(content, "") { return api_err("content is required") } let full: String = if str_eq(title, "") { content } else { title + ": " + content } + let lbl: String = str_slice(title, 0, 80) let tags: String = "[\"Knowledge\",\"captured\"]" - let id: String = engram_node_full(full, "Knowledge", "knowledge:captured", + let id: String = engram_node_full(full, "Knowledge", lbl, el_from_float(0.85), el_from_float(0.8), el_from_float(0.9), "Episodic", tags) if !api_persisted(id) { return api_not_persisted(id) } @@ -381,7 +510,8 @@ fn handle_api_evolve_knowledge(body: String) -> String { if str_eq(content, "") { return api_err("content is required") } if !str_eq(prior_id, "") && is_protected_node(prior_id) { return api_err_protected(prior_id) } let tags: String = "[\"Knowledge\",\"evolved\"]" - let new_id: String = engram_node_full(content, "Knowledge", "knowledge:evolved", + // Empty label → engram_node_full derives content[:60] (LABEL FIX 2026-07-23). + let new_id: String = engram_node_full(content, "Knowledge", "", el_from_float(0.75), el_from_float(0.75), el_from_float(0.9), "Episodic", tags) if !api_persisted(new_id) { return api_not_persisted(new_id) } @@ -402,7 +532,8 @@ fn handle_api_promote_knowledge(body: String) -> String { let tags: String = if str_eq(tags_raw, "") { "[\"Knowledge\",\"tier:canonical\",\"disposition:stable\"]" } else { tags_raw } - let new_id: String = engram_node_full(content, "Knowledge", "knowledge:canonical", + // Empty label → engram_node_full derives content[:60] (LABEL FIX 2026-07-23). + let new_id: String = engram_node_full(content, "Knowledge", "", el_from_float(0.9), el_from_float(0.9), el_from_float(1.0), "Canonical", tags) if !api_persisted(new_id) { return api_not_persisted(new_id) } diff --git a/routes.el b/routes.el index 0f76980..e4139c4 100644 --- a/routes.el +++ b/routes.el @@ -358,6 +358,14 @@ fn handle_connectors(method: String, clean: String, body: String) -> String { fn handle_request(method: String, path: String, body: String) -> String { let clean: String = strip_query(path) + // ACTIVITY STAMP (2026-07-30 self-review): every inbound HTTP request — + // MCP wrapper calls, chat, API — marks real external activity. Before + // this, "idle" was only reset by rare inbox synthesis-requests, so the + // heartbeat idle field tracked uptime exactly (idle == pulse on every + // beat) and carried zero information. The awareness heartbeat now + // reports idle_ms = wall-clock ms since this stamp. + state_set("soul.last_activity_ts", int_to_str(time_now())) + // Rate limit check. Extract caller IP from REMOTE_ADDR env var (set by the // EL HTTP runtime for each request). Skip enforcement when empty so // loopback/internal callers are never blocked. diff --git a/soul.el b/soul.el index 2387e77..025ca67 100644 --- a/soul.el +++ b/soul.el @@ -346,6 +346,12 @@ fn emit_session_start_event() -> Void { el_from_float(0.9), el_from_float(0.9), el_from_float(1.0), "Episodic", tags ) + // ALSO post to the HTTP Engram stream via ise_post (2026-07-28 self-review): + // engram_node_full above writes only the soul's in-process store, and sync + // flows HTTP→soul, never the reverse — so session_start events for boots 5+ + // silently vanished from the observable ISE stream (last visible: boot 4). + // ise_post falls back to a local tagged node if the HTTP Engram is down. + ise_post(payload) // Prune accumulated session-start events — keep the 10 most recent. // engram_search_json returns results in insertion order (oldest first), so // results[0..count-11] are the oldest; forgetting them leaves the newest 10.