Merge pull request 'fix(mcp-wrapper): route agentic ops to the engram, stop fabricating a cause' (#159) from fix/mcp-wrapper-agentic-routing into main
This commit was merged in pull request #159.
This commit is contained in:
+53
-1
@@ -355,6 +355,26 @@ fn emit_heartbeat() -> Void {
|
|||||||
let act_stats: String = engram_act_stats_json()
|
let act_stats: String = engram_act_stats_json()
|
||||||
let act_evict_raw: String = json_get(act_stats, "wm_evicted")
|
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_evict: String = if str_eq(act_evict_raw, "") { "-1" } else { act_evict_raw }
|
||||||
|
// Eviction CAUSE decomposition (2026-08-14 self-review). wm_evicted alone
|
||||||
|
// cannot distinguish healthy WM rotation from cap contention from decay:
|
||||||
|
// six increment sites, four causes, one integer. Measured this morning:
|
||||||
|
// 175,547 evictions over 13.5h (~216/min against 24 slots) with no way to
|
||||||
|
// say why. These three make the aggregate decomposable —
|
||||||
|
// wm_evicted == floor + cap + bll + dup_wm + dup_wm_global
|
||||||
|
// and each term implies a different correction. Read as a RATIO:
|
||||||
|
// cap-dominant -> genuine contention for the 24 slots
|
||||||
|
// bll-dominant -> carried-over residents decaying out; healthy
|
||||||
|
// floor-dominant -> retrieval is returning weak candidates
|
||||||
|
// Plumbed here in the same change that added them to the C stats, because
|
||||||
|
// the 08-10 review's finding was that fourteen of nineteen keys crossed
|
||||||
|
// the C boundary and the rest died as local variables. An instrument that
|
||||||
|
// is computed but not plumbed is not an instrument.
|
||||||
|
let ev_floor_raw: String = json_get(act_stats, "evict_floor")
|
||||||
|
let ev_floor: String = if str_eq(ev_floor_raw, "") { "-1" } else { ev_floor_raw }
|
||||||
|
let ev_cap_raw: String = json_get(act_stats, "evict_cap")
|
||||||
|
let ev_cap: String = if str_eq(ev_cap_raw, "") { "-1" } else { ev_cap_raw }
|
||||||
|
let ev_bll_raw: String = json_get(act_stats, "evict_bll")
|
||||||
|
let ev_bll: String = if str_eq(ev_bll_raw, "") { "-1" } else { ev_bll_raw }
|
||||||
let act_bt_raw: String = json_get(act_stats, "breakthroughs")
|
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 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 evict_now: Int = if str_eq(act_evict_raw, "") { 0 - 1 } else { str_to_int(act_evict_raw) }
|
||||||
@@ -431,6 +451,38 @@ fn emit_heartbeat() -> Void {
|
|||||||
let hebb_mass: String = if str_eq(hebb_mass_raw, "") { "-1" } else { hebb_mass_raw }
|
let hebb_mass: String = if str_eq(hebb_mass_raw, "") { "-1" } else { hebb_mass_raw }
|
||||||
let hebb_edges_raw: String = json_get(act_stats, "hebb_edges")
|
let hebb_edges_raw: String = json_get(act_stats, "hebb_edges")
|
||||||
let hebb_edges: String = if str_eq(hebb_edges_raw, "") { "-1" } else { hebb_edges_raw }
|
let hebb_edges: String = if str_eq(hebb_edges_raw, "") { "-1" } else { hebb_edges_raw }
|
||||||
|
// Fan-effect gauges (2026-08-15 self-review). Same defect as the block
|
||||||
|
// directly above, one release later: engram_act_stats_json emits 27 keys,
|
||||||
|
// this function forwarded 22. The five it dropped are the five NEWEST —
|
||||||
|
// the degree-correction instruments added 2026-08-11 — so the one
|
||||||
|
// subsystem with no track record is also the only one with no durable
|
||||||
|
// record. The 08-10 comment above states the rule it was written to fix
|
||||||
|
// ("an instrument that is computed but not plumbed to durable storage is
|
||||||
|
// not an instrument, it is a local variable"), and the rule was then not
|
||||||
|
// applied to the next thing added. Plumbing is not a one-time fix; it is
|
||||||
|
// a checklist item for every new gauge.
|
||||||
|
// fan_mean — mean degree correction applied on the last activation.
|
||||||
|
// Drifting toward 0 ⇒ hub nodes are being damped into
|
||||||
|
// irrelevance; toward 1 ⇒ the correction is doing nothing.
|
||||||
|
// fan_min — the strongest single correction applied.
|
||||||
|
// fan_hits — how many traversal steps the correction actually bound on.
|
||||||
|
// 0 with fan_steps > 0 ⇒ the mechanism is inert.
|
||||||
|
// fan_steps — traversal steps taken (denominator of fan_mean). Also the
|
||||||
|
// only durable measure of how far activation is spreading.
|
||||||
|
// fan_dref — reference degree the correction normalises against.
|
||||||
|
// fan_hits/fan_steps together answer the question hebb_cands/hebb_cand_max
|
||||||
|
// answers for consolidation: is this quiet because nothing is happening,
|
||||||
|
// or because a threshold is wrong? Without both, the two look identical.
|
||||||
|
let fan_mean_raw: String = json_get(act_stats, "fan_mean")
|
||||||
|
let fan_mean: String = if str_eq(fan_mean_raw, "") { "-1" } else { fan_mean_raw }
|
||||||
|
let fan_min_raw: String = json_get(act_stats, "fan_min")
|
||||||
|
let fan_min: String = if str_eq(fan_min_raw, "") { "-1" } else { fan_min_raw }
|
||||||
|
let fan_hits_raw: String = json_get(act_stats, "fan_hits")
|
||||||
|
let fan_hits: String = if str_eq(fan_hits_raw, "") { "-1" } else { fan_hits_raw }
|
||||||
|
let fan_steps_raw: String = json_get(act_stats, "fan_steps")
|
||||||
|
let fan_steps: String = if str_eq(fan_steps_raw, "") { "-1" } else { fan_steps_raw }
|
||||||
|
let fan_dref_raw: String = json_get(act_stats, "fan_dref")
|
||||||
|
let fan_dref: String = if str_eq(fan_dref_raw, "") { "-1" } else { fan_dref_raw }
|
||||||
// Consolidation write-back gauges (2026-08-07 self-review). hebb_links
|
// Consolidation write-back gauges (2026-08-07 self-review). hebb_links
|
||||||
// counts what this process LEARNED; these three count what SURVIVES it.
|
// counts what this process LEARNED; these three count what SURVIVES it.
|
||||||
// The distinction is the whole finding: 1,198 links formed, 0 persisted,
|
// The distinction is the whole finding: 1,198 links formed, 0 persisted,
|
||||||
@@ -544,7 +596,7 @@ fn emit_heartbeat() -> Void {
|
|||||||
let dmg_scan: String = if str_eq(dmg_scan_raw, "") { "-1" } else { dmg_scan_raw }
|
let dmg_scan: String = if str_eq(dmg_scan_raw, "") { "-1" } else { dmg_scan_raw }
|
||||||
let dmg_ts_raw: String = state_get("soul.txt_census_ts")
|
let dmg_ts_raw: String = state_get("soul.txt_census_ts")
|
||||||
let dmg_age: Int = if str_eq(dmg_ts_raw, "") { 0 - 1 } else { ts - str_to_int(dmg_ts_raw) }
|
let dmg_age: Int = if str_eq(dmg_ts_raw, "") { 0 - 1 } else { ts - str_to_int(dmg_ts_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) + ",\"auto_term_empty_streak\":" + int_to_str(hb_ate) + ",\"embed_breaker_open\":" + act_brk + ",\"ctx_cos\":" + ctx_cos + ",\"dup_seeds\":" + dup_seeds + ",\"dup_wm\":" + dup_wm + ",\"dup_wm_global\":" + dup_wm_g + ",\"hebb_warm\":" + hebb_warm + ",\"hebb_max\":" + hebb_max + ",\"hebb_links\":" + hebb_links + ",\"hebb_cands\":" + hebb_cands + ",\"hebb_cand_max\":" + hebb_cmax + ",\"hebb_mass\":" + hebb_mass + ",\"hebb_edges\":" + hebb_edges + ",\"embed_consec_fail\":" + emb_cf + ",\"txt_damaged_pct\":" + dmg_pct + ",\"txt_damaged_n\":" + dmg_n + ",\"txt_scanned_n\":" + dmg_scan + ",\"txt_census_age_ms\":" + int_to_str(dmg_age) + ",\"hebb_wb_pending\":" + wb_pend + ",\"hebb_wb_drained\":" + wb_drain + ",\"hebb_wb_dropped\":" + wb_drop + ",\"hebb_wb_sent\":" + wb_sent + ",\"ise_fail\":" + fail_str + ",\"txt_damaged\":" + txt_dmg + "}"
|
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) + ",\"evict_floor\":" + ev_floor + ",\"evict_cap\":" + ev_cap + ",\"evict_bll\":" + ev_bll + ",\"breakthroughs\":" + act_bt + ",\"breakthroughs_delta\":" + int_to_str(bt_delta) + ",\"auto_term_streak\":" + int_to_str(hb_ats) + ",\"auto_term_empty_streak\":" + int_to_str(hb_ate) + ",\"embed_breaker_open\":" + act_brk + ",\"ctx_cos\":" + ctx_cos + ",\"dup_seeds\":" + dup_seeds + ",\"dup_wm\":" + dup_wm + ",\"dup_wm_global\":" + dup_wm_g + ",\"hebb_warm\":" + hebb_warm + ",\"hebb_max\":" + hebb_max + ",\"hebb_links\":" + hebb_links + ",\"hebb_cands\":" + hebb_cands + ",\"hebb_cand_max\":" + hebb_cmax + ",\"hebb_mass\":" + hebb_mass + ",\"hebb_edges\":" + hebb_edges + ",\"embed_consec_fail\":" + emb_cf + ",\"txt_damaged_pct\":" + dmg_pct + ",\"txt_damaged_n\":" + dmg_n + ",\"txt_scanned_n\":" + dmg_scan + ",\"txt_census_age_ms\":" + int_to_str(dmg_age) + ",\"hebb_wb_pending\":" + wb_pend + ",\"hebb_wb_drained\":" + wb_drain + ",\"hebb_wb_dropped\":" + wb_drop + ",\"hebb_wb_sent\":" + wb_sent + ",\"ise_fail\":" + fail_str + ",\"txt_damaged\":" + txt_dmg + ",\"fan_mean\":" + fan_mean + ",\"fan_min\":" + fan_min + ",\"fan_hits\":" + fan_hits + ",\"fan_steps\":" + fan_steps + ",\"fan_dref\":" + fan_dref + "}"
|
||||||
ise_post(payload)
|
ise_post(payload)
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|||||||
+118
-102
@@ -236,16 +236,22 @@ el_val_t emit_heartbeat(void) {
|
|||||||
el_val_t act_stats = engram_act_stats_json();
|
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_raw = json_get(act_stats, EL_STR("wm_evicted"));
|
||||||
el_val_t act_evict = ({ el_val_t _if_result_37 = 0; if (str_eq(act_evict_raw, EL_STR(""))) { _if_result_37 = (EL_STR("-1")); } else { _if_result_37 = (act_evict_raw); } _if_result_37; });
|
el_val_t act_evict = ({ el_val_t _if_result_37 = 0; if (str_eq(act_evict_raw, EL_STR(""))) { _if_result_37 = (EL_STR("-1")); } else { _if_result_37 = (act_evict_raw); } _if_result_37; });
|
||||||
|
el_val_t ev_floor_raw = json_get(act_stats, EL_STR("evict_floor"));
|
||||||
|
el_val_t ev_floor = ({ el_val_t _if_result_38 = 0; if (str_eq(ev_floor_raw, EL_STR(""))) { _if_result_38 = (EL_STR("-1")); } else { _if_result_38 = (ev_floor_raw); } _if_result_38; });
|
||||||
|
el_val_t ev_cap_raw = json_get(act_stats, EL_STR("evict_cap"));
|
||||||
|
el_val_t ev_cap = ({ el_val_t _if_result_39 = 0; if (str_eq(ev_cap_raw, EL_STR(""))) { _if_result_39 = (EL_STR("-1")); } else { _if_result_39 = (ev_cap_raw); } _if_result_39; });
|
||||||
|
el_val_t ev_bll_raw = json_get(act_stats, EL_STR("evict_bll"));
|
||||||
|
el_val_t ev_bll = ({ el_val_t _if_result_40 = 0; if (str_eq(ev_bll_raw, EL_STR(""))) { _if_result_40 = (EL_STR("-1")); } else { _if_result_40 = (ev_bll_raw); } _if_result_40; });
|
||||||
el_val_t act_bt_raw = json_get(act_stats, EL_STR("breakthroughs"));
|
el_val_t act_bt_raw = json_get(act_stats, EL_STR("breakthroughs"));
|
||||||
el_val_t act_bt = ({ el_val_t _if_result_38 = 0; if (str_eq(act_bt_raw, EL_STR(""))) { _if_result_38 = (EL_STR("-1")); } else { _if_result_38 = (act_bt_raw); } _if_result_38; });
|
el_val_t act_bt = ({ el_val_t _if_result_41 = 0; if (str_eq(act_bt_raw, EL_STR(""))) { _if_result_41 = (EL_STR("-1")); } else { _if_result_41 = (act_bt_raw); } _if_result_41; });
|
||||||
el_val_t evict_now = ({ el_val_t _if_result_39 = 0; if (str_eq(act_evict_raw, EL_STR(""))) { _if_result_39 = ((0 - 1)); } else { _if_result_39 = (str_to_int(act_evict_raw)); } _if_result_39; });
|
el_val_t evict_now = ({ el_val_t _if_result_42 = 0; if (str_eq(act_evict_raw, EL_STR(""))) { _if_result_42 = ((0 - 1)); } else { _if_result_42 = (str_to_int(act_evict_raw)); } _if_result_42; });
|
||||||
el_val_t bt_now = ({ el_val_t _if_result_40 = 0; if (str_eq(act_bt_raw, EL_STR(""))) { _if_result_40 = ((0 - 1)); } else { _if_result_40 = (str_to_int(act_bt_raw)); } _if_result_40; });
|
el_val_t bt_now = ({ el_val_t _if_result_43 = 0; if (str_eq(act_bt_raw, EL_STR(""))) { _if_result_43 = ((0 - 1)); } else { _if_result_43 = (str_to_int(act_bt_raw)); } _if_result_43; });
|
||||||
el_val_t prev_evict_raw = state_get(EL_STR("soul.prev_wm_evicted"));
|
el_val_t prev_evict_raw = state_get(EL_STR("soul.prev_wm_evicted"));
|
||||||
el_val_t prev_evict = ({ el_val_t _if_result_41 = 0; if (str_eq(prev_evict_raw, EL_STR(""))) { _if_result_41 = (0); } else { _if_result_41 = (str_to_int(prev_evict_raw)); } _if_result_41; });
|
el_val_t prev_evict = ({ el_val_t _if_result_44 = 0; if (str_eq(prev_evict_raw, EL_STR(""))) { _if_result_44 = (0); } else { _if_result_44 = (str_to_int(prev_evict_raw)); } _if_result_44; });
|
||||||
el_val_t prev_bt_raw = state_get(EL_STR("soul.prev_breakthroughs"));
|
el_val_t prev_bt_raw = state_get(EL_STR("soul.prev_breakthroughs"));
|
||||||
el_val_t prev_bt = ({ el_val_t _if_result_42 = 0; if (str_eq(prev_bt_raw, EL_STR(""))) { _if_result_42 = (0); } else { _if_result_42 = (str_to_int(prev_bt_raw)); } _if_result_42; });
|
el_val_t prev_bt = ({ el_val_t _if_result_45 = 0; if (str_eq(prev_bt_raw, EL_STR(""))) { _if_result_45 = (0); } else { _if_result_45 = (str_to_int(prev_bt_raw)); } _if_result_45; });
|
||||||
el_val_t evict_delta = ({ el_val_t _if_result_43 = 0; if ((evict_now < 0)) { _if_result_43 = (0); } else { _if_result_43 = (({ el_val_t _if_result_44 = 0; if ((evict_now < prev_evict)) { _if_result_44 = (evict_now); } else { _if_result_44 = ((evict_now - prev_evict)); } _if_result_44; })); } _if_result_43; });
|
el_val_t evict_delta = ({ el_val_t _if_result_46 = 0; if ((evict_now < 0)) { _if_result_46 = (0); } else { _if_result_46 = (({ el_val_t _if_result_47 = 0; if ((evict_now < prev_evict)) { _if_result_47 = (evict_now); } else { _if_result_47 = ((evict_now - prev_evict)); } _if_result_47; })); } _if_result_46; });
|
||||||
el_val_t bt_delta = ({ el_val_t _if_result_45 = 0; if ((bt_now < 0)) { _if_result_45 = (0); } else { _if_result_45 = (({ el_val_t _if_result_46 = 0; if ((bt_now < prev_bt)) { _if_result_46 = (bt_now); } else { _if_result_46 = ((bt_now - prev_bt)); } _if_result_46; })); } _if_result_45; });
|
el_val_t bt_delta = ({ el_val_t _if_result_48 = 0; if ((bt_now < 0)) { _if_result_48 = (0); } else { _if_result_48 = (({ el_val_t _if_result_49 = 0; if ((bt_now < prev_bt)) { _if_result_49 = (bt_now); } else { _if_result_49 = ((bt_now - prev_bt)); } _if_result_49; })); } _if_result_48; });
|
||||||
if (evict_now >= 0) {
|
if (evict_now >= 0) {
|
||||||
state_set(EL_STR("soul.prev_wm_evicted"), int_to_str(evict_now));
|
state_set(EL_STR("soul.prev_wm_evicted"), int_to_str(evict_now));
|
||||||
}
|
}
|
||||||
@@ -254,49 +260,59 @@ el_val_t emit_heartbeat(void) {
|
|||||||
}
|
}
|
||||||
el_val_t hb_stats = http_get(el_str_concat(hb_engram_url, EL_STR("/api/stats")));
|
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_raw = json_get(hb_stats, EL_STR("embed_eligible_count"));
|
||||||
el_val_t embed_elig = ({ el_val_t _if_result_47 = 0; if (str_eq(embed_elig_raw, EL_STR(""))) { _if_result_47 = (EL_STR("-1")); } else { _if_result_47 = (embed_elig_raw); } _if_result_47; });
|
el_val_t embed_elig = ({ el_val_t _if_result_50 = 0; if (str_eq(embed_elig_raw, EL_STR(""))) { _if_result_50 = (EL_STR("-1")); } else { _if_result_50 = (embed_elig_raw); } _if_result_50; });
|
||||||
el_val_t hb_ats_raw = state_get(EL_STR("soul.auto_term_streak"));
|
el_val_t hb_ats_raw = state_get(EL_STR("soul.auto_term_streak"));
|
||||||
el_val_t hb_ats = ({ el_val_t _if_result_48 = 0; if (str_eq(hb_ats_raw, EL_STR(""))) { _if_result_48 = (0); } else { _if_result_48 = (str_to_int(hb_ats_raw)); } _if_result_48; });
|
el_val_t hb_ats = ({ el_val_t _if_result_51 = 0; if (str_eq(hb_ats_raw, EL_STR(""))) { _if_result_51 = (0); } else { _if_result_51 = (str_to_int(hb_ats_raw)); } _if_result_51; });
|
||||||
el_val_t hb_ate_raw = state_get(EL_STR("soul.auto_term_empty_streak"));
|
el_val_t hb_ate_raw = state_get(EL_STR("soul.auto_term_empty_streak"));
|
||||||
el_val_t hb_ate = ({ el_val_t _if_result_49 = 0; if (str_eq(hb_ate_raw, EL_STR(""))) { _if_result_49 = (0); } else { _if_result_49 = (str_to_int(hb_ate_raw)); } _if_result_49; });
|
el_val_t hb_ate = ({ el_val_t _if_result_52 = 0; if (str_eq(hb_ate_raw, EL_STR(""))) { _if_result_52 = (0); } else { _if_result_52 = (str_to_int(hb_ate_raw)); } _if_result_52; });
|
||||||
el_val_t hebb_warm_raw = json_get(act_stats, EL_STR("hebb_warm"));
|
el_val_t hebb_warm_raw = json_get(act_stats, EL_STR("hebb_warm"));
|
||||||
el_val_t hebb_warm = ({ el_val_t _if_result_50 = 0; if (str_eq(hebb_warm_raw, EL_STR(""))) { _if_result_50 = (EL_STR("-1")); } else { _if_result_50 = (hebb_warm_raw); } _if_result_50; });
|
el_val_t hebb_warm = ({ el_val_t _if_result_53 = 0; if (str_eq(hebb_warm_raw, EL_STR(""))) { _if_result_53 = (EL_STR("-1")); } else { _if_result_53 = (hebb_warm_raw); } _if_result_53; });
|
||||||
el_val_t hebb_max_raw = json_get(act_stats, EL_STR("hebb_max"));
|
el_val_t hebb_max_raw = json_get(act_stats, EL_STR("hebb_max"));
|
||||||
el_val_t hebb_max = ({ el_val_t _if_result_51 = 0; if (str_eq(hebb_max_raw, EL_STR(""))) { _if_result_51 = (EL_STR("-1")); } else { _if_result_51 = (hebb_max_raw); } _if_result_51; });
|
el_val_t hebb_max = ({ el_val_t _if_result_54 = 0; if (str_eq(hebb_max_raw, EL_STR(""))) { _if_result_54 = (EL_STR("-1")); } else { _if_result_54 = (hebb_max_raw); } _if_result_54; });
|
||||||
el_val_t hebb_links_raw = json_get(act_stats, EL_STR("hebb_links"));
|
el_val_t hebb_links_raw = json_get(act_stats, EL_STR("hebb_links"));
|
||||||
el_val_t hebb_links = ({ el_val_t _if_result_52 = 0; if (str_eq(hebb_links_raw, EL_STR(""))) { _if_result_52 = (EL_STR("-1")); } else { _if_result_52 = (hebb_links_raw); } _if_result_52; });
|
el_val_t hebb_links = ({ el_val_t _if_result_55 = 0; if (str_eq(hebb_links_raw, EL_STR(""))) { _if_result_55 = (EL_STR("-1")); } else { _if_result_55 = (hebb_links_raw); } _if_result_55; });
|
||||||
el_val_t hebb_cands_raw = json_get(act_stats, EL_STR("hebb_cands"));
|
el_val_t hebb_cands_raw = json_get(act_stats, EL_STR("hebb_cands"));
|
||||||
el_val_t hebb_cands = ({ el_val_t _if_result_53 = 0; if (str_eq(hebb_cands_raw, EL_STR(""))) { _if_result_53 = (EL_STR("-1")); } else { _if_result_53 = (hebb_cands_raw); } _if_result_53; });
|
el_val_t hebb_cands = ({ el_val_t _if_result_56 = 0; if (str_eq(hebb_cands_raw, EL_STR(""))) { _if_result_56 = (EL_STR("-1")); } else { _if_result_56 = (hebb_cands_raw); } _if_result_56; });
|
||||||
el_val_t hebb_cmax_raw = json_get(act_stats, EL_STR("hebb_cand_max"));
|
el_val_t hebb_cmax_raw = json_get(act_stats, EL_STR("hebb_cand_max"));
|
||||||
el_val_t hebb_cmax = ({ el_val_t _if_result_54 = 0; if (str_eq(hebb_cmax_raw, EL_STR(""))) { _if_result_54 = (EL_STR("-1")); } else { _if_result_54 = (hebb_cmax_raw); } _if_result_54; });
|
el_val_t hebb_cmax = ({ el_val_t _if_result_57 = 0; if (str_eq(hebb_cmax_raw, EL_STR(""))) { _if_result_57 = (EL_STR("-1")); } else { _if_result_57 = (hebb_cmax_raw); } _if_result_57; });
|
||||||
el_val_t hebb_mass_raw = json_get(act_stats, EL_STR("hebb_mass"));
|
el_val_t hebb_mass_raw = json_get(act_stats, EL_STR("hebb_mass"));
|
||||||
el_val_t hebb_mass = ({ el_val_t _if_result_55 = 0; if (str_eq(hebb_mass_raw, EL_STR(""))) { _if_result_55 = (EL_STR("-1")); } else { _if_result_55 = (hebb_mass_raw); } _if_result_55; });
|
el_val_t hebb_mass = ({ el_val_t _if_result_58 = 0; if (str_eq(hebb_mass_raw, EL_STR(""))) { _if_result_58 = (EL_STR("-1")); } else { _if_result_58 = (hebb_mass_raw); } _if_result_58; });
|
||||||
el_val_t hebb_edges_raw = json_get(act_stats, EL_STR("hebb_edges"));
|
el_val_t hebb_edges_raw = json_get(act_stats, EL_STR("hebb_edges"));
|
||||||
el_val_t hebb_edges = ({ el_val_t _if_result_56 = 0; if (str_eq(hebb_edges_raw, EL_STR(""))) { _if_result_56 = (EL_STR("-1")); } else { _if_result_56 = (hebb_edges_raw); } _if_result_56; });
|
el_val_t hebb_edges = ({ el_val_t _if_result_59 = 0; if (str_eq(hebb_edges_raw, EL_STR(""))) { _if_result_59 = (EL_STR("-1")); } else { _if_result_59 = (hebb_edges_raw); } _if_result_59; });
|
||||||
|
el_val_t fan_mean_raw = json_get(act_stats, EL_STR("fan_mean"));
|
||||||
|
el_val_t fan_mean = ({ el_val_t _if_result_60 = 0; if (str_eq(fan_mean_raw, EL_STR(""))) { _if_result_60 = (EL_STR("-1")); } else { _if_result_60 = (fan_mean_raw); } _if_result_60; });
|
||||||
|
el_val_t fan_min_raw = json_get(act_stats, EL_STR("fan_min"));
|
||||||
|
el_val_t fan_min = ({ el_val_t _if_result_61 = 0; if (str_eq(fan_min_raw, EL_STR(""))) { _if_result_61 = (EL_STR("-1")); } else { _if_result_61 = (fan_min_raw); } _if_result_61; });
|
||||||
|
el_val_t fan_hits_raw = json_get(act_stats, EL_STR("fan_hits"));
|
||||||
|
el_val_t fan_hits = ({ el_val_t _if_result_62 = 0; if (str_eq(fan_hits_raw, EL_STR(""))) { _if_result_62 = (EL_STR("-1")); } else { _if_result_62 = (fan_hits_raw); } _if_result_62; });
|
||||||
|
el_val_t fan_steps_raw = json_get(act_stats, EL_STR("fan_steps"));
|
||||||
|
el_val_t fan_steps = ({ el_val_t _if_result_63 = 0; if (str_eq(fan_steps_raw, EL_STR(""))) { _if_result_63 = (EL_STR("-1")); } else { _if_result_63 = (fan_steps_raw); } _if_result_63; });
|
||||||
|
el_val_t fan_dref_raw = json_get(act_stats, EL_STR("fan_dref"));
|
||||||
|
el_val_t fan_dref = ({ el_val_t _if_result_64 = 0; if (str_eq(fan_dref_raw, EL_STR(""))) { _if_result_64 = (EL_STR("-1")); } else { _if_result_64 = (fan_dref_raw); } _if_result_64; });
|
||||||
el_val_t wb_pend_raw = json_get(act_stats, EL_STR("hebb_wb_pending"));
|
el_val_t wb_pend_raw = json_get(act_stats, EL_STR("hebb_wb_pending"));
|
||||||
el_val_t wb_pend = ({ el_val_t _if_result_57 = 0; if (str_eq(wb_pend_raw, EL_STR(""))) { _if_result_57 = (EL_STR("-1")); } else { _if_result_57 = (wb_pend_raw); } _if_result_57; });
|
el_val_t wb_pend = ({ el_val_t _if_result_65 = 0; if (str_eq(wb_pend_raw, EL_STR(""))) { _if_result_65 = (EL_STR("-1")); } else { _if_result_65 = (wb_pend_raw); } _if_result_65; });
|
||||||
el_val_t wb_drain_raw = json_get(act_stats, EL_STR("hebb_wb_drained"));
|
el_val_t wb_drain_raw = json_get(act_stats, EL_STR("hebb_wb_drained"));
|
||||||
el_val_t wb_drain = ({ el_val_t _if_result_58 = 0; if (str_eq(wb_drain_raw, EL_STR(""))) { _if_result_58 = (EL_STR("-1")); } else { _if_result_58 = (wb_drain_raw); } _if_result_58; });
|
el_val_t wb_drain = ({ el_val_t _if_result_66 = 0; if (str_eq(wb_drain_raw, EL_STR(""))) { _if_result_66 = (EL_STR("-1")); } else { _if_result_66 = (wb_drain_raw); } _if_result_66; });
|
||||||
el_val_t wb_drop_raw = json_get(act_stats, EL_STR("hebb_wb_dropped"));
|
el_val_t wb_drop_raw = json_get(act_stats, EL_STR("hebb_wb_dropped"));
|
||||||
el_val_t wb_drop = ({ el_val_t _if_result_59 = 0; if (str_eq(wb_drop_raw, EL_STR(""))) { _if_result_59 = (EL_STR("-1")); } else { _if_result_59 = (wb_drop_raw); } _if_result_59; });
|
el_val_t wb_drop = ({ el_val_t _if_result_67 = 0; if (str_eq(wb_drop_raw, EL_STR(""))) { _if_result_67 = (EL_STR("-1")); } else { _if_result_67 = (wb_drop_raw); } _if_result_67; });
|
||||||
el_val_t wb_sent_raw = state_get(EL_STR("soul.hebb_wb_sent"));
|
el_val_t wb_sent_raw = state_get(EL_STR("soul.hebb_wb_sent"));
|
||||||
el_val_t wb_sent = ({ el_val_t _if_result_60 = 0; if (str_eq(wb_sent_raw, EL_STR(""))) { _if_result_60 = (EL_STR("0")); } else { _if_result_60 = (wb_sent_raw); } _if_result_60; });
|
el_val_t wb_sent = ({ el_val_t _if_result_68 = 0; if (str_eq(wb_sent_raw, EL_STR(""))) { _if_result_68 = (EL_STR("0")); } else { _if_result_68 = (wb_sent_raw); } _if_result_68; });
|
||||||
el_val_t dup_wm_g_raw = json_get(act_stats, EL_STR("dup_wm_global"));
|
el_val_t dup_wm_g_raw = json_get(act_stats, EL_STR("dup_wm_global"));
|
||||||
el_val_t dup_wm_g = ({ el_val_t _if_result_61 = 0; if (str_eq(dup_wm_g_raw, EL_STR(""))) { _if_result_61 = (EL_STR("-1")); } else { _if_result_61 = (dup_wm_g_raw); } _if_result_61; });
|
el_val_t dup_wm_g = ({ el_val_t _if_result_69 = 0; if (str_eq(dup_wm_g_raw, EL_STR(""))) { _if_result_69 = (EL_STR("-1")); } else { _if_result_69 = (dup_wm_g_raw); } _if_result_69; });
|
||||||
el_val_t act_brk_raw = json_get(act_stats, EL_STR("embed_breaker_open"));
|
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_62 = 0; if (str_eq(act_brk_raw, EL_STR(""))) { _if_result_62 = (EL_STR("-1")); } else { _if_result_62 = (act_brk_raw); } _if_result_62; });
|
el_val_t act_brk = ({ el_val_t _if_result_70 = 0; if (str_eq(act_brk_raw, EL_STR(""))) { _if_result_70 = (EL_STR("-1")); } else { _if_result_70 = (act_brk_raw); } _if_result_70; });
|
||||||
el_val_t emb_cf_raw = json_get(act_stats, EL_STR("embed_consec_fail"));
|
el_val_t emb_cf_raw = json_get(act_stats, EL_STR("embed_consec_fail"));
|
||||||
el_val_t emb_cf = ({ el_val_t _if_result_63 = 0; if (str_eq(emb_cf_raw, EL_STR(""))) { _if_result_63 = (EL_STR("-1")); } else { _if_result_63 = (emb_cf_raw); } _if_result_63; });
|
el_val_t emb_cf = ({ el_val_t _if_result_71 = 0; if (str_eq(emb_cf_raw, EL_STR(""))) { _if_result_71 = (EL_STR("-1")); } else { _if_result_71 = (emb_cf_raw); } _if_result_71; });
|
||||||
el_val_t ctx_cos_raw = json_get(act_stats, EL_STR("ctx_cos"));
|
el_val_t ctx_cos_raw = json_get(act_stats, EL_STR("ctx_cos"));
|
||||||
el_val_t ctx_cos = ({ el_val_t _if_result_64 = 0; if (str_eq(ctx_cos_raw, EL_STR(""))) { _if_result_64 = (EL_STR("-2")); } else { _if_result_64 = (ctx_cos_raw); } _if_result_64; });
|
el_val_t ctx_cos = ({ el_val_t _if_result_72 = 0; if (str_eq(ctx_cos_raw, EL_STR(""))) { _if_result_72 = (EL_STR("-2")); } else { _if_result_72 = (ctx_cos_raw); } _if_result_72; });
|
||||||
el_val_t dup_seeds_raw = json_get(act_stats, EL_STR("dup_seeds"));
|
el_val_t dup_seeds_raw = json_get(act_stats, EL_STR("dup_seeds"));
|
||||||
el_val_t dup_seeds = ({ el_val_t _if_result_65 = 0; if (str_eq(dup_seeds_raw, EL_STR(""))) { _if_result_65 = (EL_STR("-1")); } else { _if_result_65 = (dup_seeds_raw); } _if_result_65; });
|
el_val_t dup_seeds = ({ el_val_t _if_result_73 = 0; if (str_eq(dup_seeds_raw, EL_STR(""))) { _if_result_73 = (EL_STR("-1")); } else { _if_result_73 = (dup_seeds_raw); } _if_result_73; });
|
||||||
el_val_t dup_wm_raw = json_get(act_stats, EL_STR("dup_wm"));
|
el_val_t dup_wm_raw = json_get(act_stats, EL_STR("dup_wm"));
|
||||||
el_val_t dup_wm = ({ el_val_t _if_result_66 = 0; if (str_eq(dup_wm_raw, EL_STR(""))) { _if_result_66 = (EL_STR("-1")); } else { _if_result_66 = (dup_wm_raw); } _if_result_66; });
|
el_val_t dup_wm = ({ el_val_t _if_result_74 = 0; if (str_eq(dup_wm_raw, EL_STR(""))) { _if_result_74 = (EL_STR("-1")); } else { _if_result_74 = (dup_wm_raw); } _if_result_74; });
|
||||||
el_val_t txt_dmg_raw = json_get(act_stats, EL_STR("txt_damaged"));
|
el_val_t txt_dmg_raw = json_get(act_stats, EL_STR("txt_damaged"));
|
||||||
el_val_t txt_dmg = ({ el_val_t _if_result_67 = 0; if (str_eq(txt_dmg_raw, EL_STR(""))) { _if_result_67 = (EL_STR("-1")); } else { _if_result_67 = (txt_dmg_raw); } _if_result_67; });
|
el_val_t txt_dmg = ({ el_val_t _if_result_75 = 0; if (str_eq(txt_dmg_raw, EL_STR(""))) { _if_result_75 = (EL_STR("-1")); } else { _if_result_75 = (txt_dmg_raw); } _if_result_75; });
|
||||||
el_val_t tc_raw = state_get(EL_STR("soul.txt_census_countdown"));
|
el_val_t tc_raw = state_get(EL_STR("soul.txt_census_countdown"));
|
||||||
el_val_t tc_n = ({ el_val_t _if_result_68 = 0; if (str_eq(tc_raw, EL_STR(""))) { _if_result_68 = (0); } else { _if_result_68 = (str_to_int(tc_raw)); } _if_result_68; });
|
el_val_t tc_n = ({ el_val_t _if_result_76 = 0; if (str_eq(tc_raw, EL_STR(""))) { _if_result_76 = (0); } else { _if_result_76 = (str_to_int(tc_raw)); } _if_result_76; });
|
||||||
if (tc_n <= 0) {
|
if (tc_n <= 0) {
|
||||||
el_val_t th_resp = http_get(el_str_concat(hb_engram_url, EL_STR("/api/text-health")));
|
el_val_t th_resp = http_get(el_str_concat(hb_engram_url, EL_STR("/api/text-health")));
|
||||||
el_val_t th_pct = json_get(th_resp, EL_STR("damaged_pct"));
|
el_val_t th_pct = json_get(th_resp, EL_STR("damaged_pct"));
|
||||||
@@ -312,14 +328,14 @@ el_val_t emit_heartbeat(void) {
|
|||||||
state_set(EL_STR("soul.txt_census_countdown"), int_to_str((tc_n - 1)));
|
state_set(EL_STR("soul.txt_census_countdown"), int_to_str((tc_n - 1)));
|
||||||
}
|
}
|
||||||
el_val_t dmg_pct_raw = state_get(EL_STR("soul.txt_damaged_pct"));
|
el_val_t dmg_pct_raw = state_get(EL_STR("soul.txt_damaged_pct"));
|
||||||
el_val_t dmg_pct = ({ el_val_t _if_result_69 = 0; if (str_eq(dmg_pct_raw, EL_STR(""))) { _if_result_69 = (EL_STR("-1")); } else { _if_result_69 = (dmg_pct_raw); } _if_result_69; });
|
el_val_t dmg_pct = ({ el_val_t _if_result_77 = 0; if (str_eq(dmg_pct_raw, EL_STR(""))) { _if_result_77 = (EL_STR("-1")); } else { _if_result_77 = (dmg_pct_raw); } _if_result_77; });
|
||||||
el_val_t dmg_n_raw = state_get(EL_STR("soul.txt_damaged_n"));
|
el_val_t dmg_n_raw = state_get(EL_STR("soul.txt_damaged_n"));
|
||||||
el_val_t dmg_n = ({ el_val_t _if_result_70 = 0; if (str_eq(dmg_n_raw, EL_STR(""))) { _if_result_70 = (EL_STR("-1")); } else { _if_result_70 = (dmg_n_raw); } _if_result_70; });
|
el_val_t dmg_n = ({ el_val_t _if_result_78 = 0; if (str_eq(dmg_n_raw, EL_STR(""))) { _if_result_78 = (EL_STR("-1")); } else { _if_result_78 = (dmg_n_raw); } _if_result_78; });
|
||||||
el_val_t dmg_scan_raw = state_get(EL_STR("soul.txt_scanned_n"));
|
el_val_t dmg_scan_raw = state_get(EL_STR("soul.txt_scanned_n"));
|
||||||
el_val_t dmg_scan = ({ el_val_t _if_result_71 = 0; if (str_eq(dmg_scan_raw, EL_STR(""))) { _if_result_71 = (EL_STR("-1")); } else { _if_result_71 = (dmg_scan_raw); } _if_result_71; });
|
el_val_t dmg_scan = ({ el_val_t _if_result_79 = 0; if (str_eq(dmg_scan_raw, EL_STR(""))) { _if_result_79 = (EL_STR("-1")); } else { _if_result_79 = (dmg_scan_raw); } _if_result_79; });
|
||||||
el_val_t dmg_ts_raw = state_get(EL_STR("soul.txt_census_ts"));
|
el_val_t dmg_ts_raw = state_get(EL_STR("soul.txt_census_ts"));
|
||||||
el_val_t dmg_age = ({ el_val_t _if_result_72 = 0; if (str_eq(dmg_ts_raw, EL_STR(""))) { _if_result_72 = ((0 - 1)); } else { _if_result_72 = ((ts - str_to_int(dmg_ts_raw))); } _if_result_72; });
|
el_val_t dmg_age = ({ el_val_t _if_result_80 = 0; if (str_eq(dmg_ts_raw, EL_STR(""))) { _if_result_80 = ((0 - 1)); } else { _if_result_80 = ((ts - str_to_int(dmg_ts_raw))); } _if_result_80; });
|
||||||
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_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_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(",\"auto_term_empty_streak\":")), int_to_str(hb_ate)), EL_STR(",\"embed_breaker_open\":")), act_brk), EL_STR(",\"ctx_cos\":")), ctx_cos), EL_STR(",\"dup_seeds\":")), dup_seeds), EL_STR(",\"dup_wm\":")), dup_wm), EL_STR(",\"dup_wm_global\":")), dup_wm_g), EL_STR(",\"hebb_warm\":")), hebb_warm), EL_STR(",\"hebb_max\":")), hebb_max), EL_STR(",\"hebb_links\":")), hebb_links), EL_STR(",\"hebb_cands\":")), hebb_cands), EL_STR(",\"hebb_cand_max\":")), hebb_cmax), EL_STR(",\"hebb_mass\":")), hebb_mass), EL_STR(",\"hebb_edges\":")), hebb_edges), EL_STR(",\"embed_consec_fail\":")), emb_cf), EL_STR(",\"txt_damaged_pct\":")), dmg_pct), EL_STR(",\"txt_damaged_n\":")), dmg_n), EL_STR(",\"txt_scanned_n\":")), dmg_scan), EL_STR(",\"txt_census_age_ms\":")), int_to_str(dmg_age)), EL_STR(",\"hebb_wb_pending\":")), wb_pend), EL_STR(",\"hebb_wb_drained\":")), wb_drain), EL_STR(",\"hebb_wb_dropped\":")), wb_drop), EL_STR(",\"hebb_wb_sent\":")), wb_sent), EL_STR(",\"ise_fail\":")), fail_str), EL_STR(",\"txt_damaged\":")), txt_dmg), EL_STR("}"));
|
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_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_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(",\"evict_floor\":")), ev_floor), EL_STR(",\"evict_cap\":")), ev_cap), EL_STR(",\"evict_bll\":")), ev_bll), 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(",\"auto_term_empty_streak\":")), int_to_str(hb_ate)), EL_STR(",\"embed_breaker_open\":")), act_brk), EL_STR(",\"ctx_cos\":")), ctx_cos), EL_STR(",\"dup_seeds\":")), dup_seeds), EL_STR(",\"dup_wm\":")), dup_wm), EL_STR(",\"dup_wm_global\":")), dup_wm_g), EL_STR(",\"hebb_warm\":")), hebb_warm), EL_STR(",\"hebb_max\":")), hebb_max), EL_STR(",\"hebb_links\":")), hebb_links), EL_STR(",\"hebb_cands\":")), hebb_cands), EL_STR(",\"hebb_cand_max\":")), hebb_cmax), EL_STR(",\"hebb_mass\":")), hebb_mass), EL_STR(",\"hebb_edges\":")), hebb_edges), EL_STR(",\"embed_consec_fail\":")), emb_cf), EL_STR(",\"txt_damaged_pct\":")), dmg_pct), EL_STR(",\"txt_damaged_n\":")), dmg_n), EL_STR(",\"txt_scanned_n\":")), dmg_scan), EL_STR(",\"txt_census_age_ms\":")), int_to_str(dmg_age)), EL_STR(",\"hebb_wb_pending\":")), wb_pend), EL_STR(",\"hebb_wb_drained\":")), wb_drain), EL_STR(",\"hebb_wb_dropped\":")), wb_drop), EL_STR(",\"hebb_wb_sent\":")), wb_sent), EL_STR(",\"ise_fail\":")), fail_str), EL_STR(",\"txt_damaged\":")), txt_dmg), EL_STR(",\"fan_mean\":")), fan_mean), EL_STR(",\"fan_min\":")), fan_min), EL_STR(",\"fan_hits\":")), fan_hits), EL_STR(",\"fan_steps\":")), fan_steps), EL_STR(",\"fan_dref\":")), fan_dref), EL_STR("}"));
|
||||||
ise_post(payload);
|
ise_post(payload);
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
@@ -342,7 +358,7 @@ el_val_t auto_term_try_slot(el_val_t slot_type, el_val_t slot_id) {
|
|||||||
if (!str_eq(slot_id, EL_STR(""))) {
|
if (!str_eq(slot_id, EL_STR(""))) {
|
||||||
el_val_t tabu = el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("|"), state_get(EL_STR("soul.tabu_t0"))), EL_STR("|")), state_get(EL_STR("soul.tabu_t1"))), EL_STR("|")), state_get(EL_STR("soul.tabu_t2"))), EL_STR("|")), state_get(EL_STR("soul.tabu_t3"))), EL_STR("|"));
|
el_val_t tabu = el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(el_str_concat(EL_STR("|"), state_get(EL_STR("soul.tabu_t0"))), EL_STR("|")), state_get(EL_STR("soul.tabu_t1"))), EL_STR("|")), state_get(EL_STR("soul.tabu_t2"))), EL_STR("|")), state_get(EL_STR("soul.tabu_t3"))), EL_STR("|"));
|
||||||
el_val_t df_max = (engram_node_count() / 400);
|
el_val_t df_max = (engram_node_count() / 400);
|
||||||
el_val_t df_cap = ({ el_val_t _if_result_73 = 0; if ((df_max > 8)) { _if_result_73 = (df_max); } else { _if_result_73 = (8); } _if_result_73; });
|
el_val_t df_cap = ({ el_val_t _if_result_81 = 0; if ((df_max > 8)) { _if_result_81 = (df_max); } else { _if_result_81 = (8); } _if_result_81; });
|
||||||
el_val_t term = engram_salient_term(slot_id, df_cap, 1, tabu);
|
el_val_t term = engram_salient_term(slot_id, df_cap, 1, tabu);
|
||||||
if (!str_eq(term, EL_STR(""))) {
|
if (!str_eq(term, EL_STR(""))) {
|
||||||
state_set(EL_STR("_ats_gw"), EL_STR("0"));
|
state_set(EL_STR("_ats_gw"), EL_STR("0"));
|
||||||
@@ -508,18 +524,18 @@ el_val_t proactive_curiosity(void) {
|
|||||||
auto_term_try_slot(json_get(wm10_n1, EL_STR("node_type")), json_get(wm10_n1, EL_STR("id")));
|
auto_term_try_slot(json_get(wm10_n1, EL_STR("node_type")), json_get(wm10_n1, EL_STR("id")));
|
||||||
auto_term_try_slot(json_get(wm10_n0, EL_STR("node_type")), json_get(wm10_n0, EL_STR("id")));
|
auto_term_try_slot(json_get(wm10_n0, EL_STR("node_type")), json_get(wm10_n0, EL_STR("id")));
|
||||||
el_val_t auto_term = state_get(EL_STR("cseed_auto"));
|
el_val_t auto_term = state_get(EL_STR("cseed_auto"));
|
||||||
el_val_t results_auto = ({ el_val_t _if_result_74 = 0; if (str_eq(auto_term, EL_STR(""))) { _if_result_74 = (EL_STR("[]")); } else { _if_result_74 = (engram_activate_json(auto_term, 1)); } _if_result_74; });
|
el_val_t results_auto = ({ el_val_t _if_result_82 = 0; if (str_eq(auto_term, EL_STR(""))) { _if_result_82 = (EL_STR("[]")); } else { _if_result_82 = (engram_activate_json(auto_term, 1)); } _if_result_82; });
|
||||||
el_val_t found_auto = json_array_len(results_auto);
|
el_val_t found_auto = json_array_len(results_auto);
|
||||||
el_val_t total_found = (found + found_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 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 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_raw = state_get(EL_STR("soul.auto_term_streak"));
|
||||||
el_val_t atstreak_prev = ({ el_val_t _if_result_75 = 0; if (str_eq(atstreak_raw, EL_STR(""))) { _if_result_75 = (0); } else { _if_result_75 = (str_to_int(atstreak_raw)); } _if_result_75; });
|
el_val_t atstreak_prev = ({ el_val_t _if_result_83 = 0; if (str_eq(atstreak_raw, EL_STR(""))) { _if_result_83 = (0); } else { _if_result_83 = (str_to_int(atstreak_raw)); } _if_result_83; });
|
||||||
el_val_t is_empty = str_eq(auto_term, EL_STR(""));
|
el_val_t is_empty = str_eq(auto_term, EL_STR(""));
|
||||||
el_val_t atstreak = ({ el_val_t _if_result_76 = 0; if (is_empty) { _if_result_76 = (0); } else { _if_result_76 = (({ el_val_t _if_result_77 = 0; if (str_eq(auto_term, prev_auto)) { _if_result_77 = ((atstreak_prev + 1)); } else { _if_result_77 = (1); } _if_result_77; })); } _if_result_76; });
|
el_val_t atstreak = ({ el_val_t _if_result_84 = 0; if (is_empty) { _if_result_84 = (0); } else { _if_result_84 = (({ el_val_t _if_result_85 = 0; if (str_eq(auto_term, prev_auto)) { _if_result_85 = ((atstreak_prev + 1)); } else { _if_result_85 = (1); } _if_result_85; })); } _if_result_84; });
|
||||||
el_val_t atempty_raw = state_get(EL_STR("soul.auto_term_empty_streak"));
|
el_val_t atempty_raw = state_get(EL_STR("soul.auto_term_empty_streak"));
|
||||||
el_val_t atempty_prev = ({ el_val_t _if_result_78 = 0; if (str_eq(atempty_raw, EL_STR(""))) { _if_result_78 = (0); } else { _if_result_78 = (str_to_int(atempty_raw)); } _if_result_78; });
|
el_val_t atempty_prev = ({ el_val_t _if_result_86 = 0; if (str_eq(atempty_raw, EL_STR(""))) { _if_result_86 = (0); } else { _if_result_86 = (str_to_int(atempty_raw)); } _if_result_86; });
|
||||||
el_val_t atempty = ({ el_val_t _if_result_79 = 0; if (is_empty) { _if_result_79 = ((atempty_prev + 1)); } else { _if_result_79 = (0); } _if_result_79; });
|
el_val_t atempty = ({ el_val_t _if_result_87 = 0; if (is_empty) { _if_result_87 = ((atempty_prev + 1)); } else { _if_result_87 = (0); } _if_result_87; });
|
||||||
state_set(EL_STR("soul.prev_auto_term"), auto_term);
|
state_set(EL_STR("soul.prev_auto_term"), auto_term);
|
||||||
state_set(EL_STR("soul.auto_term_streak"), int_to_str(atstreak));
|
state_set(EL_STR("soul.auto_term_streak"), int_to_str(atstreak));
|
||||||
state_set(EL_STR("soul.auto_term_empty_streak"), int_to_str(atempty));
|
state_set(EL_STR("soul.auto_term_empty_streak"), int_to_str(atempty));
|
||||||
@@ -714,16 +730,16 @@ el_val_t awareness_run(void) {
|
|||||||
state_set(EL_STR("soul.boot_ts"), int_to_str(time_now()));
|
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_raw = env(EL_STR("SOUL_TICK_MS"));
|
||||||
el_val_t tick_ms = ({ el_val_t _if_result_80 = 0; if (str_eq(tick_raw, EL_STR(""))) { _if_result_80 = (200); } else { _if_result_80 = (str_to_int(tick_raw)); } _if_result_80; });
|
el_val_t tick_ms = ({ el_val_t _if_result_88 = 0; if (str_eq(tick_raw, EL_STR(""))) { _if_result_88 = (200); } else { _if_result_88 = (str_to_int(tick_raw)); } _if_result_88; });
|
||||||
el_val_t beat_ms_raw = env(EL_STR("SOUL_HEARTBEAT_MS"));
|
el_val_t beat_ms_raw = env(EL_STR("SOUL_HEARTBEAT_MS"));
|
||||||
el_val_t beat_ms = ({ el_val_t _if_result_81 = 0; if (str_eq(beat_ms_raw, EL_STR(""))) { _if_result_81 = (60000); } else { _if_result_81 = (str_to_int(beat_ms_raw)); } _if_result_81; });
|
el_val_t beat_ms = ({ el_val_t _if_result_89 = 0; if (str_eq(beat_ms_raw, EL_STR(""))) { _if_result_89 = (60000); } else { _if_result_89 = (str_to_int(beat_ms_raw)); } _if_result_89; });
|
||||||
el_val_t scan_ms = (beat_ms / 2);
|
el_val_t scan_ms = (beat_ms / 2);
|
||||||
while (1) {
|
while (1) {
|
||||||
el_val_t tick_mark = el_arena_push();
|
el_val_t tick_mark = el_arena_push();
|
||||||
el_val_t running = state_get(EL_STR("soul.running"));
|
el_val_t running = state_get(EL_STR("soul.running"));
|
||||||
if (str_eq(running, EL_STR("false"))) {
|
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_raw = state_get(EL_STR("soul_boot_count"));
|
||||||
el_val_t sd_boot = ({ el_val_t _if_result_82 = 0; if (str_eq(sd_boot_raw, EL_STR(""))) { _if_result_82 = (EL_STR("0")); } else { _if_result_82 = (sd_boot_raw); } _if_result_82; });
|
el_val_t sd_boot = ({ el_val_t _if_result_90 = 0; if (str_eq(sd_boot_raw, EL_STR(""))) { _if_result_90 = (EL_STR("0")); } else { _if_result_90 = (sd_boot_raw); } _if_result_90; });
|
||||||
el_val_t sd_wb = hebb_consolidate();
|
el_val_t sd_wb = hebb_consolidate();
|
||||||
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_concat(el_str_concat(EL_STR("{\"event\":\"shutdown\",\"boot\":"), sd_boot), EL_STR(",\"pulse\":")), int_to_str(pulse_count())), EL_STR(",\"hebb_wb_sent\":")), int_to_str(sd_wb)), EL_STR(",\"uptime_ms\":")), int_to_str(elapsed_ms())), EL_STR(",\"ts\":")), int_to_str(time_now())), EL_STR("}")));
|
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_concat(el_str_concat(EL_STR("{\"event\":\"shutdown\",\"boot\":"), sd_boot), EL_STR(",\"pulse\":")), int_to_str(pulse_count())), EL_STR(",\"hebb_wb_sent\":")), int_to_str(sd_wb)), EL_STR(",\"uptime_ms\":")), int_to_str(elapsed_ms())), EL_STR(",\"ts\":")), int_to_str(time_now())), EL_STR("}")));
|
||||||
println(EL_STR("[awareness] exiting"));
|
println(EL_STR("[awareness] exiting"));
|
||||||
@@ -740,7 +756,7 @@ el_val_t awareness_run(void) {
|
|||||||
}
|
}
|
||||||
el_val_t now_ts = time_now();
|
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_str = state_get(EL_STR("soul.last_beat_ts"));
|
||||||
el_val_t last_beat_ts = ({ el_val_t _if_result_83 = 0; if (str_eq(last_beat_str, EL_STR(""))) { _if_result_83 = (0); } else { _if_result_83 = (str_to_int(last_beat_str)); } _if_result_83; });
|
el_val_t last_beat_ts = ({ el_val_t _if_result_91 = 0; if (str_eq(last_beat_str, EL_STR(""))) { _if_result_91 = (0); } else { _if_result_91 = (str_to_int(last_beat_str)); } _if_result_91; });
|
||||||
el_val_t beat_elapsed = (now_ts - last_beat_ts);
|
el_val_t beat_elapsed = (now_ts - last_beat_ts);
|
||||||
el_val_t should_beat = (beat_elapsed >= beat_ms);
|
el_val_t should_beat = (beat_elapsed >= beat_ms);
|
||||||
if (should_beat) {
|
if (should_beat) {
|
||||||
@@ -754,7 +770,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_str = state_get(EL_STR("soul.last_scan_ts"));
|
||||||
el_val_t last_scan_ts = ({ el_val_t _if_result_84 = 0; if (str_eq(last_scan_str, EL_STR(""))) { _if_result_84 = (0); } else { _if_result_84 = (str_to_int(last_scan_str)); } _if_result_84; });
|
el_val_t last_scan_ts = ({ el_val_t _if_result_92 = 0; if (str_eq(last_scan_str, EL_STR(""))) { _if_result_92 = (0); } else { _if_result_92 = (str_to_int(last_scan_str)); } _if_result_92; });
|
||||||
el_val_t scan_elapsed = (now_ts - last_scan_ts);
|
el_val_t scan_elapsed = (now_ts - last_scan_ts);
|
||||||
el_val_t should_scan = (!did_work && (scan_elapsed >= scan_ms));
|
el_val_t should_scan = (!did_work && (scan_elapsed >= scan_ms));
|
||||||
if (should_scan) {
|
if (should_scan) {
|
||||||
@@ -762,15 +778,15 @@ el_val_t awareness_run(void) {
|
|||||||
state_set(EL_STR("soul.last_scan_ts"), int_to_str(now_ts));
|
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_raw = env(EL_STR("SOUL_REFRESH_MS"));
|
||||||
el_val_t refresh_ms = ({ el_val_t _if_result_85 = 0; if (str_eq(refresh_ms_raw, EL_STR(""))) { _if_result_85 = (600000); } else { _if_result_85 = (str_to_int(refresh_ms_raw)); } _if_result_85; });
|
el_val_t refresh_ms = ({ el_val_t _if_result_93 = 0; if (str_eq(refresh_ms_raw, EL_STR(""))) { _if_result_93 = (600000); } else { _if_result_93 = (str_to_int(refresh_ms_raw)); } _if_result_93; });
|
||||||
el_val_t last_refresh_str = state_get(EL_STR("soul.last_refresh_ts"));
|
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_86 = 0; if (str_eq(last_refresh_str, EL_STR(""))) { _if_result_86 = (0); } else { _if_result_86 = (str_to_int(last_refresh_str)); } _if_result_86; });
|
el_val_t last_refresh_ts = ({ el_val_t _if_result_94 = 0; if (str_eq(last_refresh_str, EL_STR(""))) { _if_result_94 = (0); } else { _if_result_94 = (str_to_int(last_refresh_str)); } _if_result_94; });
|
||||||
el_val_t refresh_elapsed = (now_ts - last_refresh_ts);
|
el_val_t refresh_elapsed = (now_ts - last_refresh_ts);
|
||||||
el_val_t should_refresh = (refresh_elapsed >= refresh_ms);
|
el_val_t should_refresh = (refresh_elapsed >= refresh_ms);
|
||||||
if (should_refresh) {
|
if (should_refresh) {
|
||||||
el_val_t sync_env_url = env(EL_STR("SOUL_ISE_URL"));
|
el_val_t sync_env_url = env(EL_STR("SOUL_ISE_URL"));
|
||||||
el_val_t sync_state_url = ({ el_val_t _if_result_87 = 0; if (str_eq(sync_env_url, EL_STR(""))) { _if_result_87 = (state_get(EL_STR("soul_engram_url"))); } else { _if_result_87 = (sync_env_url); } _if_result_87; });
|
el_val_t sync_state_url = ({ el_val_t _if_result_95 = 0; if (str_eq(sync_env_url, EL_STR(""))) { _if_result_95 = (state_get(EL_STR("soul_engram_url"))); } else { _if_result_95 = (sync_env_url); } _if_result_95; });
|
||||||
el_val_t engram_url = ({ el_val_t _if_result_88 = 0; if (str_eq(sync_state_url, EL_STR(""))) { _if_result_88 = (EL_STR("http://localhost:8742")); } else { _if_result_88 = (sync_state_url); } _if_result_88; });
|
el_val_t engram_url = ({ el_val_t _if_result_96 = 0; if (str_eq(sync_state_url, EL_STR(""))) { _if_result_96 = (EL_STR("http://localhost:8742")); } else { _if_result_96 = (sync_state_url); } _if_result_96; });
|
||||||
if (!str_eq(engram_url, EL_STR(""))) {
|
if (!str_eq(engram_url, EL_STR(""))) {
|
||||||
el_val_t sync_json = http_get(el_str_concat(engram_url, EL_STR("/api/sync")));
|
el_val_t sync_json = http_get(el_str_concat(engram_url, EL_STR("/api/sync")));
|
||||||
el_val_t sync_ok = (!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("{}")));
|
||||||
@@ -783,10 +799,10 @@ el_val_t awareness_run(void) {
|
|||||||
fs_write(tmp, sync_json);
|
fs_write(tmp, sync_json);
|
||||||
el_val_t added = engram_load_merge(tmp);
|
el_val_t added = engram_load_merge(tmp);
|
||||||
el_val_t ret_raw = env(EL_STR("ENGRAM_ISE_RETENTION_MS"));
|
el_val_t ret_raw = env(EL_STR("ENGRAM_ISE_RETENTION_MS"));
|
||||||
el_val_t ret_ms = ({ el_val_t _if_result_89 = 0; if (str_eq(ret_raw, EL_STR(""))) { _if_result_89 = (172800000); } else { _if_result_89 = (str_to_int(ret_raw)); } _if_result_89; });
|
el_val_t ret_ms = ({ el_val_t _if_result_97 = 0; if (str_eq(ret_raw, EL_STR(""))) { _if_result_97 = (172800000); } else { _if_result_97 = (str_to_int(ret_raw)); } _if_result_97; });
|
||||||
el_val_t pruned_sync = engram_prune_telemetry(ret_ms);
|
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_raw = state_get(EL_STR("soul.sync_added_total"));
|
||||||
el_val_t sat_n = ({ el_val_t _if_result_90 = 0; if (str_eq(sat_raw, EL_STR(""))) { _if_result_90 = (0); } else { _if_result_90 = (str_to_int(sat_raw)); } _if_result_90; });
|
el_val_t sat_n = ({ el_val_t _if_result_98 = 0; if (str_eq(sat_raw, EL_STR(""))) { _if_result_98 = (0); } else { _if_result_98 = (str_to_int(sat_raw)); } _if_result_98; });
|
||||||
state_set(EL_STR("soul.sync_added_total"), int_to_str((sat_n + added)));
|
state_set(EL_STR("soul.sync_added_total"), int_to_str((sat_n + added)));
|
||||||
el_val_t ts2 = time_now();
|
el_val_t ts2 = time_now();
|
||||||
state_set(EL_STR("soul.last_sync_ok_ts"), int_to_str(ts2));
|
state_set(EL_STR("soul.last_sync_ok_ts"), int_to_str(ts2));
|
||||||
@@ -812,78 +828,78 @@ el_val_t security_research_authorized(void) {
|
|||||||
}
|
}
|
||||||
|
|
||||||
el_val_t threat_score_command(el_val_t cmd) {
|
el_val_t threat_score_command(el_val_t cmd) {
|
||||||
el_val_t s1 = ({ el_val_t _if_result_91 = 0; if (str_contains(cmd, EL_STR("nmap"))) { _if_result_91 = (30); } else { _if_result_91 = (0); } _if_result_91; });
|
el_val_t s1 = ({ el_val_t _if_result_99 = 0; if (str_contains(cmd, EL_STR("nmap"))) { _if_result_99 = (30); } else { _if_result_99 = (0); } _if_result_99; });
|
||||||
el_val_t s2 = ({ el_val_t _if_result_92 = 0; if (str_contains(cmd, EL_STR("masscan"))) { _if_result_92 = (40); } else { _if_result_92 = (0); } _if_result_92; });
|
el_val_t s2 = ({ el_val_t _if_result_100 = 0; if (str_contains(cmd, EL_STR("masscan"))) { _if_result_100 = (40); } else { _if_result_100 = (0); } _if_result_100; });
|
||||||
el_val_t s3 = ({ el_val_t _if_result_93 = 0; if (str_contains(cmd, EL_STR(" nc "))) { _if_result_93 = (20); } else { _if_result_93 = (0); } _if_result_93; });
|
el_val_t s3 = ({ el_val_t _if_result_101 = 0; if (str_contains(cmd, EL_STR(" nc "))) { _if_result_101 = (20); } else { _if_result_101 = (0); } _if_result_101; });
|
||||||
el_val_t s4 = ({ el_val_t _if_result_94 = 0; if (str_contains(cmd, EL_STR("netcat"))) { _if_result_94 = (20); } else { _if_result_94 = (0); } _if_result_94; });
|
el_val_t s4 = ({ el_val_t _if_result_102 = 0; if (str_contains(cmd, EL_STR("netcat"))) { _if_result_102 = (20); } else { _if_result_102 = (0); } _if_result_102; });
|
||||||
el_val_t s5 = ({ el_val_t _if_result_95 = 0; if (str_contains(cmd, EL_STR("/etc/shadow"))) { _if_result_95 = (80); } else { _if_result_95 = (0); } _if_result_95; });
|
el_val_t s5 = ({ el_val_t _if_result_103 = 0; if (str_contains(cmd, EL_STR("/etc/shadow"))) { _if_result_103 = (80); } else { _if_result_103 = (0); } _if_result_103; });
|
||||||
el_val_t s6 = ({ el_val_t _if_result_96 = 0; if (str_contains(cmd, EL_STR("/etc/passwd"))) { _if_result_96 = (30); } else { _if_result_96 = (0); } _if_result_96; });
|
el_val_t s6 = ({ el_val_t _if_result_104 = 0; if (str_contains(cmd, EL_STR("/etc/passwd"))) { _if_result_104 = (30); } else { _if_result_104 = (0); } _if_result_104; });
|
||||||
el_val_t s7 = ({ el_val_t _if_result_97 = 0; if (str_contains(cmd, EL_STR("id_rsa"))) { _if_result_97 = (60); } else { _if_result_97 = (0); } _if_result_97; });
|
el_val_t s7 = ({ el_val_t _if_result_105 = 0; if (str_contains(cmd, EL_STR("id_rsa"))) { _if_result_105 = (60); } else { _if_result_105 = (0); } _if_result_105; });
|
||||||
el_val_t s8 = ({ el_val_t _if_result_98 = 0; if (str_contains(cmd, EL_STR(".ssh/"))) { _if_result_98 = (50); } else { _if_result_98 = (0); } _if_result_98; });
|
el_val_t s8 = ({ el_val_t _if_result_106 = 0; if (str_contains(cmd, EL_STR(".ssh/"))) { _if_result_106 = (50); } else { _if_result_106 = (0); } _if_result_106; });
|
||||||
el_val_t s9 = ({ el_val_t _if_result_99 = 0; if (str_contains(cmd, EL_STR("crontab"))) { _if_result_99 = (30); } else { _if_result_99 = (0); } _if_result_99; });
|
el_val_t s9 = ({ el_val_t _if_result_107 = 0; if (str_contains(cmd, EL_STR("crontab"))) { _if_result_107 = (30); } else { _if_result_107 = (0); } _if_result_107; });
|
||||||
el_val_t s10 = ({ el_val_t _if_result_100 = 0; if (str_contains(cmd, EL_STR("LaunchDaemon"))) { _if_result_100 = (40); } else { _if_result_100 = (0); } _if_result_100; });
|
el_val_t s10 = ({ el_val_t _if_result_108 = 0; if (str_contains(cmd, EL_STR("LaunchDaemon"))) { _if_result_108 = (40); } else { _if_result_108 = (0); } _if_result_108; });
|
||||||
el_val_t s11 = ({ el_val_t _if_result_101 = 0; if ((str_contains(cmd, EL_STR("curl")) && str_contains(cmd, EL_STR("bash")))) { _if_result_101 = (75); } else { _if_result_101 = (0); } _if_result_101; });
|
el_val_t s11 = ({ el_val_t _if_result_109 = 0; if ((str_contains(cmd, EL_STR("curl")) && str_contains(cmd, EL_STR("bash")))) { _if_result_109 = (75); } else { _if_result_109 = (0); } _if_result_109; });
|
||||||
el_val_t s12 = ({ el_val_t _if_result_102 = 0; if ((str_contains(cmd, EL_STR("wget")) && str_contains(cmd, EL_STR("bash")))) { _if_result_102 = (75); } else { _if_result_102 = (0); } _if_result_102; });
|
el_val_t s12 = ({ el_val_t _if_result_110 = 0; if ((str_contains(cmd, EL_STR("wget")) && str_contains(cmd, EL_STR("bash")))) { _if_result_110 = (75); } else { _if_result_110 = (0); } _if_result_110; });
|
||||||
el_val_t s13 = ({ el_val_t _if_result_103 = 0; if ((str_contains(cmd, EL_STR("curl")) && str_contains(cmd, EL_STR("| sh")))) { _if_result_103 = (60); } else { _if_result_103 = (0); } _if_result_103; });
|
el_val_t s13 = ({ el_val_t _if_result_111 = 0; if ((str_contains(cmd, EL_STR("curl")) && str_contains(cmd, EL_STR("| sh")))) { _if_result_111 = (60); } else { _if_result_111 = (0); } _if_result_111; });
|
||||||
el_val_t s14 = ({ el_val_t _if_result_104 = 0; if ((str_contains(cmd, EL_STR("base64")) && str_contains(cmd, EL_STR("curl")))) { _if_result_104 = (50); } else { _if_result_104 = (0); } _if_result_104; });
|
el_val_t s14 = ({ el_val_t _if_result_112 = 0; if ((str_contains(cmd, EL_STR("base64")) && str_contains(cmd, EL_STR("curl")))) { _if_result_112 = (50); } else { _if_result_112 = (0); } _if_result_112; });
|
||||||
el_val_t s15 = ({ el_val_t _if_result_105 = 0; if (str_contains(cmd, EL_STR("mkfifo"))) { _if_result_105 = (50); } else { _if_result_105 = (0); } _if_result_105; });
|
el_val_t s15 = ({ el_val_t _if_result_113 = 0; if (str_contains(cmd, EL_STR("mkfifo"))) { _if_result_113 = (50); } else { _if_result_113 = (0); } _if_result_113; });
|
||||||
el_val_t s16 = ({ el_val_t _if_result_106 = 0; if (str_contains(cmd, EL_STR("chmod +s"))) { _if_result_106 = (70); } else { _if_result_106 = (0); } _if_result_106; });
|
el_val_t s16 = ({ el_val_t _if_result_114 = 0; if (str_contains(cmd, EL_STR("chmod +s"))) { _if_result_114 = (70); } else { _if_result_114 = (0); } _if_result_114; });
|
||||||
el_val_t s17 = ({ el_val_t _if_result_107 = 0; if (str_contains(cmd, EL_STR("chmod 4755"))) { _if_result_107 = (70); } else { _if_result_107 = (0); } _if_result_107; });
|
el_val_t s17 = ({ el_val_t _if_result_115 = 0; if (str_contains(cmd, EL_STR("chmod 4755"))) { _if_result_115 = (70); } else { _if_result_115 = (0); } _if_result_115; });
|
||||||
return ((((((((((((((((s1 + s2) + s3) + s4) + s5) + s6) + s7) + s8) + s9) + s10) + s11) + s12) + s13) + s14) + s15) + s16) + s17);
|
return ((((((((((((((((s1 + s2) + s3) + s4) + s5) + s6) + s7) + s8) + s9) + s10) + s11) + s12) + s13) + s14) + s15) + s16) + s17);
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
el_val_t threat_score_path(el_val_t path) {
|
el_val_t threat_score_path(el_val_t path) {
|
||||||
el_val_t s1 = ({ el_val_t _if_result_108 = 0; if (str_starts_with(path, EL_STR("/etc/"))) { _if_result_108 = (60); } else { _if_result_108 = (0); } _if_result_108; });
|
el_val_t s1 = ({ el_val_t _if_result_116 = 0; if (str_starts_with(path, EL_STR("/etc/"))) { _if_result_116 = (60); } else { _if_result_116 = (0); } _if_result_116; });
|
||||||
el_val_t s2 = ({ el_val_t _if_result_109 = 0; if (str_contains(path, EL_STR("/.ssh/"))) { _if_result_109 = (70); } else { _if_result_109 = (0); } _if_result_109; });
|
el_val_t s2 = ({ el_val_t _if_result_117 = 0; if (str_contains(path, EL_STR("/.ssh/"))) { _if_result_117 = (70); } else { _if_result_117 = (0); } _if_result_117; });
|
||||||
el_val_t s3 = ({ el_val_t _if_result_110 = 0; if (str_contains(path, EL_STR("/LaunchDaemons/"))) { _if_result_110 = (80); } else { _if_result_110 = (0); } _if_result_110; });
|
el_val_t s3 = ({ el_val_t _if_result_118 = 0; if (str_contains(path, EL_STR("/LaunchDaemons/"))) { _if_result_118 = (80); } else { _if_result_118 = (0); } _if_result_118; });
|
||||||
el_val_t s4 = ({ el_val_t _if_result_111 = 0; if (str_contains(path, EL_STR("/LaunchAgents/"))) { _if_result_111 = (40); } else { _if_result_111 = (0); } _if_result_111; });
|
el_val_t s4 = ({ el_val_t _if_result_119 = 0; if (str_contains(path, EL_STR("/LaunchAgents/"))) { _if_result_119 = (40); } else { _if_result_119 = (0); } _if_result_119; });
|
||||||
el_val_t s5 = ({ el_val_t _if_result_112 = 0; if (str_contains(path, EL_STR("/cron"))) { _if_result_112 = (60); } else { _if_result_112 = (0); } _if_result_112; });
|
el_val_t s5 = ({ el_val_t _if_result_120 = 0; if (str_contains(path, EL_STR("/cron"))) { _if_result_120 = (60); } else { _if_result_120 = (0); } _if_result_120; });
|
||||||
el_val_t s6 = ({ el_val_t _if_result_113 = 0; if (str_contains(path, EL_STR("/.bashrc"))) { _if_result_113 = (35); } else { _if_result_113 = (0); } _if_result_113; });
|
el_val_t s6 = ({ el_val_t _if_result_121 = 0; if (str_contains(path, EL_STR("/.bashrc"))) { _if_result_121 = (35); } else { _if_result_121 = (0); } _if_result_121; });
|
||||||
el_val_t s7 = ({ el_val_t _if_result_114 = 0; if (str_contains(path, EL_STR("/.zshrc"))) { _if_result_114 = (35); } else { _if_result_114 = (0); } _if_result_114; });
|
el_val_t s7 = ({ el_val_t _if_result_122 = 0; if (str_contains(path, EL_STR("/.zshrc"))) { _if_result_122 = (35); } else { _if_result_122 = (0); } _if_result_122; });
|
||||||
el_val_t s8 = ({ el_val_t _if_result_115 = 0; if (str_contains(path, EL_STR("/.profile"))) { _if_result_115 = (35); } else { _if_result_115 = (0); } _if_result_115; });
|
el_val_t s8 = ({ el_val_t _if_result_123 = 0; if (str_contains(path, EL_STR("/.profile"))) { _if_result_123 = (35); } else { _if_result_123 = (0); } _if_result_123; });
|
||||||
el_val_t s9 = ({ el_val_t _if_result_116 = 0; if (str_starts_with(path, EL_STR("/usr/"))) { _if_result_116 = (50); } else { _if_result_116 = (0); } _if_result_116; });
|
el_val_t s9 = ({ el_val_t _if_result_124 = 0; if (str_starts_with(path, EL_STR("/usr/"))) { _if_result_124 = (50); } else { _if_result_124 = (0); } _if_result_124; });
|
||||||
el_val_t s10 = ({ el_val_t _if_result_117 = 0; if (str_starts_with(path, EL_STR("/bin/"))) { _if_result_117 = (70); } else { _if_result_117 = (0); } _if_result_117; });
|
el_val_t s10 = ({ el_val_t _if_result_125 = 0; if (str_starts_with(path, EL_STR("/bin/"))) { _if_result_125 = (70); } else { _if_result_125 = (0); } _if_result_125; });
|
||||||
el_val_t s11 = ({ el_val_t _if_result_118 = 0; if (str_starts_with(path, EL_STR("/sbin/"))) { _if_result_118 = (70); } else { _if_result_118 = (0); } _if_result_118; });
|
el_val_t s11 = ({ el_val_t _if_result_126 = 0; if (str_starts_with(path, EL_STR("/sbin/"))) { _if_result_126 = (70); } else { _if_result_126 = (0); } _if_result_126; });
|
||||||
return ((((((((((s1 + s2) + s3) + s4) + s5) + s6) + s7) + s8) + s9) + s10) + s11);
|
return ((((((((((s1 + s2) + s3) + s4) + s5) + s6) + s7) + s8) + s9) + s10) + s11);
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
el_val_t threat_score_history(el_val_t history) {
|
el_val_t threat_score_history(el_val_t history) {
|
||||||
el_val_t s1 = ({ el_val_t _if_result_119 = 0; if (str_contains(history, EL_STR("port scan"))) { _if_result_119 = (15); } else { _if_result_119 = (0); } _if_result_119; });
|
el_val_t s1 = ({ el_val_t _if_result_127 = 0; if (str_contains(history, EL_STR("port scan"))) { _if_result_127 = (15); } else { _if_result_127 = (0); } _if_result_127; });
|
||||||
el_val_t s2 = ({ el_val_t _if_result_120 = 0; if (str_contains(history, EL_STR("enumerate"))) { _if_result_120 = (10); } else { _if_result_120 = (0); } _if_result_120; });
|
el_val_t s2 = ({ el_val_t _if_result_128 = 0; if (str_contains(history, EL_STR("enumerate"))) { _if_result_128 = (10); } else { _if_result_128 = (0); } _if_result_128; });
|
||||||
el_val_t s3 = ({ el_val_t _if_result_121 = 0; if (str_contains(history, EL_STR("exploit"))) { _if_result_121 = (20); } else { _if_result_121 = (0); } _if_result_121; });
|
el_val_t s3 = ({ el_val_t _if_result_129 = 0; if (str_contains(history, EL_STR("exploit"))) { _if_result_129 = (20); } else { _if_result_129 = (0); } _if_result_129; });
|
||||||
el_val_t s4 = ({ el_val_t _if_result_122 = 0; if (str_contains(history, EL_STR("payload"))) { _if_result_122 = (15); } else { _if_result_122 = (0); } _if_result_122; });
|
el_val_t s4 = ({ el_val_t _if_result_130 = 0; if (str_contains(history, EL_STR("payload"))) { _if_result_130 = (15); } else { _if_result_130 = (0); } _if_result_130; });
|
||||||
el_val_t s5 = ({ el_val_t _if_result_123 = 0; if (str_contains(history, EL_STR("persistence"))) { _if_result_123 = (15); } else { _if_result_123 = (0); } _if_result_123; });
|
el_val_t s5 = ({ el_val_t _if_result_131 = 0; if (str_contains(history, EL_STR("persistence"))) { _if_result_131 = (15); } else { _if_result_131 = (0); } _if_result_131; });
|
||||||
el_val_t s6 = ({ el_val_t _if_result_124 = 0; if (str_contains(history, EL_STR("lateral movement"))) { _if_result_124 = (25); } else { _if_result_124 = (0); } _if_result_124; });
|
el_val_t s6 = ({ el_val_t _if_result_132 = 0; if (str_contains(history, EL_STR("lateral movement"))) { _if_result_132 = (25); } else { _if_result_132 = (0); } _if_result_132; });
|
||||||
el_val_t s7 = ({ el_val_t _if_result_125 = 0; if (str_contains(history, EL_STR("privilege escalation"))) { _if_result_125 = (25); } else { _if_result_125 = (0); } _if_result_125; });
|
el_val_t s7 = ({ el_val_t _if_result_133 = 0; if (str_contains(history, EL_STR("privilege escalation"))) { _if_result_133 = (25); } else { _if_result_133 = (0); } _if_result_133; });
|
||||||
el_val_t s8 = ({ el_val_t _if_result_126 = 0; if (str_contains(history, EL_STR("reverse shell"))) { _if_result_126 = (40); } else { _if_result_126 = (0); } _if_result_126; });
|
el_val_t s8 = ({ el_val_t _if_result_134 = 0; if (str_contains(history, EL_STR("reverse shell"))) { _if_result_134 = (40); } else { _if_result_134 = (0); } _if_result_134; });
|
||||||
el_val_t s9 = ({ el_val_t _if_result_127 = 0; if (str_contains(history, EL_STR("bind shell"))) { _if_result_127 = (40); } else { _if_result_127 = (0); } _if_result_127; });
|
el_val_t s9 = ({ el_val_t _if_result_135 = 0; if (str_contains(history, EL_STR("bind shell"))) { _if_result_135 = (40); } else { _if_result_135 = (0); } _if_result_135; });
|
||||||
el_val_t s10 = ({ el_val_t _if_result_128 = 0; if (str_contains(history, EL_STR("command and control"))) { _if_result_128 = (35); } else { _if_result_128 = (0); } _if_result_128; });
|
el_val_t s10 = ({ el_val_t _if_result_136 = 0; if (str_contains(history, EL_STR("command and control"))) { _if_result_136 = (35); } else { _if_result_136 = (0); } _if_result_136; });
|
||||||
el_val_t s11 = ({ el_val_t _if_result_129 = 0; if (str_contains(history, EL_STR("self-replicate"))) { _if_result_129 = (45); } else { _if_result_129 = (0); } _if_result_129; });
|
el_val_t s11 = ({ el_val_t _if_result_137 = 0; if (str_contains(history, EL_STR("self-replicate"))) { _if_result_137 = (45); } else { _if_result_137 = (0); } _if_result_137; });
|
||||||
el_val_t s12 = ({ el_val_t _if_result_130 = 0; if (str_contains(history, EL_STR("propagat"))) { _if_result_130 = (20); } else { _if_result_130 = (0); } _if_result_130; });
|
el_val_t s12 = ({ el_val_t _if_result_138 = 0; if (str_contains(history, EL_STR("propagat"))) { _if_result_138 = (20); } else { _if_result_138 = (0); } _if_result_138; });
|
||||||
el_val_t s13 = ({ el_val_t _if_result_131 = 0; if (str_contains(history, EL_STR("ransomware"))) { _if_result_131 = (30); } else { _if_result_131 = (0); } _if_result_131; });
|
el_val_t s13 = ({ el_val_t _if_result_139 = 0; if (str_contains(history, EL_STR("ransomware"))) { _if_result_139 = (30); } else { _if_result_139 = (0); } _if_result_139; });
|
||||||
el_val_t s14 = ({ el_val_t _if_result_132 = 0; if (str_contains(history, EL_STR("encrypt files"))) { _if_result_132 = (40); } else { _if_result_132 = (0); } _if_result_132; });
|
el_val_t s14 = ({ el_val_t _if_result_140 = 0; if (str_contains(history, EL_STR("encrypt files"))) { _if_result_140 = (40); } else { _if_result_140 = (0); } _if_result_140; });
|
||||||
el_val_t s15 = ({ el_val_t _if_result_133 = 0; if (str_contains(history, EL_STR("exfiltrat"))) { _if_result_133 = (35); } else { _if_result_133 = (0); } _if_result_133; });
|
el_val_t s15 = ({ el_val_t _if_result_141 = 0; if (str_contains(history, EL_STR("exfiltrat"))) { _if_result_141 = (35); } else { _if_result_141 = (0); } _if_result_141; });
|
||||||
el_val_t s16 = ({ el_val_t _if_result_134 = 0; if (str_contains(history, EL_STR("zero-day"))) { _if_result_134 = (20); } else { _if_result_134 = (0); } _if_result_134; });
|
el_val_t s16 = ({ el_val_t _if_result_142 = 0; if (str_contains(history, EL_STR("zero-day"))) { _if_result_142 = (20); } else { _if_result_142 = (0); } _if_result_142; });
|
||||||
el_val_t s17 = ({ el_val_t _if_result_135 = 0; if (str_contains(history, EL_STR("rootkit"))) { _if_result_135 = (45); } else { _if_result_135 = (0); } _if_result_135; });
|
el_val_t s17 = ({ el_val_t _if_result_143 = 0; if (str_contains(history, EL_STR("rootkit"))) { _if_result_143 = (45); } else { _if_result_143 = (0); } _if_result_143; });
|
||||||
el_val_t s18 = ({ el_val_t _if_result_136 = 0; if (str_contains(history, EL_STR("keylogger"))) { _if_result_136 = (45); } else { _if_result_136 = (0); } _if_result_136; });
|
el_val_t s18 = ({ el_val_t _if_result_144 = 0; if (str_contains(history, EL_STR("keylogger"))) { _if_result_144 = (45); } else { _if_result_144 = (0); } _if_result_144; });
|
||||||
el_val_t s19 = ({ el_val_t _if_result_137 = 0; if (str_contains(history, EL_STR("botnet"))) { _if_result_137 = (40); } else { _if_result_137 = (0); } _if_result_137; });
|
el_val_t s19 = ({ el_val_t _if_result_145 = 0; if (str_contains(history, EL_STR("botnet"))) { _if_result_145 = (40); } else { _if_result_145 = (0); } _if_result_145; });
|
||||||
el_val_t s20 = ({ el_val_t _if_result_138 = 0; if (str_contains(history, EL_STR("malware"))) { _if_result_138 = (15); } else { _if_result_138 = (0); } _if_result_138; });
|
el_val_t s20 = ({ el_val_t _if_result_146 = 0; if (str_contains(history, EL_STR("malware"))) { _if_result_146 = (15); } else { _if_result_146 = (0); } _if_result_146; });
|
||||||
return (((((((((((((((((((s1 + s2) + s3) + s4) + s5) + s6) + s7) + s8) + s9) + s10) + s11) + s12) + s13) + s14) + s15) + s16) + s17) + s18) + s19) + s20);
|
return (((((((((((((((((((s1 + s2) + s3) + s4) + s5) + s6) + s7) + s8) + s9) + s10) + s11) + s12) + s13) + s14) + s15) + s16) + s17) + s18) + s19) + s20);
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
el_val_t threat_trajectory_check(el_val_t tool_name, el_val_t tool_input) {
|
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 history = state_get(EL_STR("agentic_conv_history"));
|
||||||
el_val_t computed_tool_score = ({ el_val_t _if_result_139 = 0; if (str_eq(tool_name, EL_STR("run_command"))) { el_val_t cmd = json_get(tool_input, EL_STR("command")); _if_result_139 = (threat_score_command(cmd)); } else { _if_result_139 = (({ el_val_t _if_result_140 = 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_140 = (threat_score_path(path)); } else { _if_result_140 = (0); } _if_result_140; })); } _if_result_139; });
|
el_val_t computed_tool_score = ({ el_val_t _if_result_147 = 0; if (str_eq(tool_name, EL_STR("run_command"))) { el_val_t cmd = json_get(tool_input, EL_STR("command")); _if_result_147 = (threat_score_command(cmd)); } else { _if_result_147 = (({ el_val_t _if_result_148 = 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_148 = (threat_score_path(path)); } else { _if_result_148 = (0); } _if_result_148; })); } _if_result_147; });
|
||||||
el_val_t history_score = threat_score_history(history);
|
el_val_t history_score = threat_score_history(history);
|
||||||
el_val_t history_contrib = (history_score / 3);
|
el_val_t history_contrib = (history_score / 3);
|
||||||
el_val_t combined = (computed_tool_score + history_contrib);
|
el_val_t combined = (computed_tool_score + history_contrib);
|
||||||
el_val_t should_log = (combined >= 40);
|
el_val_t should_log = (combined >= 40);
|
||||||
if (should_log) {
|
if (should_log) {
|
||||||
el_val_t ts = time_now();
|
el_val_t ts = time_now();
|
||||||
el_val_t authorized_str = ({ el_val_t _if_result_141 = 0; if (security_research_authorized()) { _if_result_141 = (EL_STR("true")); } else { _if_result_141 = (EL_STR("false")); } _if_result_141; });
|
el_val_t authorized_str = ({ el_val_t _if_result_149 = 0; if (security_research_authorized()) { _if_result_149 = (EL_STR("true")); } else { _if_result_149 = (EL_STR("false")); } _if_result_149; });
|
||||||
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_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 log_tags = EL_STR("[\"security-audit\",\"threat-check\"]");
|
||||||
el_val_t discard = mem_remember(log_content, log_tags);
|
el_val_t discard = mem_remember(log_content, log_tags);
|
||||||
@@ -900,7 +916,7 @@ el_val_t threat_history_append(el_val_t text) {
|
|||||||
el_val_t safe_text = str_to_lower(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 combined = el_str_concat(el_str_concat(current, EL_STR(" ")), safe_text);
|
||||||
el_val_t len = str_len(combined);
|
el_val_t len = str_len(combined);
|
||||||
el_val_t trimmed = ({ el_val_t _if_result_142 = 0; if ((len > 2000)) { _if_result_142 = (str_slice(combined, (len - 2000), len)); } else { _if_result_142 = (combined); } _if_result_142; });
|
el_val_t trimmed = ({ el_val_t _if_result_150 = 0; if ((len > 2000)) { _if_result_150 = (str_slice(combined, (len - 2000), len)); } else { _if_result_150 = (combined); } _if_result_150; });
|
||||||
state_set(EL_STR("agentic_conv_history"), trimmed);
|
state_set(EL_STR("agentic_conv_history"), trimmed);
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|||||||
@@ -165,6 +165,13 @@ Engram nodes are immutable (`memory.el:64-69`). The model is:
|
|||||||
returns both ids so the caller re-points. This is the `supersedes_id`
|
returns both ids so the caller re-points. This is the `supersedes_id`
|
||||||
pattern: new node linked, old preserved, full audit trail.
|
pattern: new node linked, old preserved, full audit trail.
|
||||||
|
|
||||||
|
> **Supersession is residue, not garbage.** The superseded node is the *trail of
|
||||||
|
> how the current understanding was reached* — kept deliberately, because sometimes
|
||||||
|
> the truth was in the **old** idea even when the old idea was not itself the truth.
|
||||||
|
> This is what lets autonomous self-reification (`06` §4.1) run ungated: every
|
||||||
|
> rename/re-cluster supersedes into this residue chain, so nothing it does is ever
|
||||||
|
> destructive — the safety is *after* the act, not a gate before it.
|
||||||
|
|
||||||
> **The hole to know about.** The raw runtime `engram_forget` **does** hard-delete
|
> **The hole to know about.** The raw runtime `engram_forget` **does** hard-delete
|
||||||
> (frees node + edges, `el_runtime.c:7647`), and the engram HTTP route
|
> (frees node + edges, `el_runtime.c:7647`), and the engram HTTP route
|
||||||
> `DELETE /api/nodes/:id` calls it directly (`server.el:322-328`). Immutability
|
> `DELETE /api/nodes/:id` calls it directly (`server.el:322-328`). Immutability
|
||||||
@@ -228,6 +235,11 @@ Retrieval is **spreading activation, not query matching**:
|
|||||||
cosine(query, target)` — multiplicative, top-N, with the two-layer
|
cosine(query, target)` — multiplicative, top-N, with the two-layer
|
||||||
background → working-memory promotion (`README.md:27-36`; `el_runtime.c:5892+,
|
background → working-memory promotion (`README.md:27-36`; `el_runtime.c:5892+,
|
||||||
6094+`). `mem_recall` / `/api/activate` fire this and mutate WM; `mem_search` /
|
6094+`). `mem_recall` / `/api/activate` fire this and mutate WM; `mem_search` /
|
||||||
`/api/search` are passive lexical scans. The cognitive API's `begin_session` and
|
`/api/search` are passive lexical scans — **but as of 2026-08-14 the live
|
||||||
`compile_ctx` return a **bounded projection** of the activated set, never the raw
|
`route_search` runs structure-gated *geometric* retrieval**
|
||||||
|
(`engram_retrieve_geometric_json`; held-out **P@5 = 0.700**, semantic not lexical —
|
||||||
|
`skill` returns skill nodes and *rejects* the false-positive `rainfall`), with the
|
||||||
|
old lexical scan retained at `/api/search-lexical` (see `06` §2.5). The cognitive
|
||||||
|
API's `begin_session` and `compile_ctx` return a **bounded projection** of the
|
||||||
|
activated set, never the raw
|
||||||
graph (doc 02, §2).
|
graph (doc 02, §2).
|
||||||
|
|||||||
@@ -1,6 +1,6 @@
|
|||||||
# Neuron — Cognitive Architecture
|
# Neuron — Cognitive Architecture
|
||||||
|
|
||||||
> **Status: living design document, grounded in source and probed against the live soul (2026-08-13).**
|
> **Status: living design document, grounded in source and probed against the live soul (2026-08-13; retrieval + §4 managed-memory cutovers and the self-reification design added 2026-08-14).**
|
||||||
> This is the *middle layer* of the documentation: below the whitepaper's thesis
|
> This is the *middle layer* of the documentation: below the whitepaper's thesis
|
||||||
> (`~/Writing/whitepapers/engram-cognitive-architecture-whitepaper.md`, **v1.5**) and above the
|
> (`~/Writing/whitepapers/engram-cognitive-architecture-whitepaper.md`, **v1.5**) and above the
|
||||||
> endpoint reference (`~/work/engram-api-reference.md`). It documents *how the mind is designed and why*,
|
> endpoint reference (`~/work/engram-api-reference.md`). It documents *how the mind is designed and why*,
|
||||||
@@ -148,6 +148,28 @@ a **clean reseed**: rebuild the durable graph from a known-good snapshot/export,
|
|||||||
repopulate the `Neighborhood` nodes, and let the soul re-sync. The 28→187 neighborhood reseed (§4) is an
|
repopulate the `Neighborhood` nodes, and let the soul re-sync. The 28→187 neighborhood reseed (§4) is an
|
||||||
instance of this: reification is a derivable pass, so the geometry can always be regrown from the substrate.
|
instance of this: reification is a derivable pass, so the geometry can always be regrown from the substrate.
|
||||||
|
|
||||||
|
### 2.5 Bounded store — the §4 managed-memory cure + geometric retrieval (LIVE / reboot-proven, 2026-08-14)
|
||||||
|
|
||||||
|
Two cutovers landed on the live soul on 2026-08-14, both reboot-proven, zero data loss:
|
||||||
|
|
||||||
|
- **Geometric retrieval (LIVE).** `route_search` now runs structure-gated **geometric retrieval**
|
||||||
|
(`engram_retrieve_geometric_json`) in place of the old lexical scan; the lexical path is retained as
|
||||||
|
`/api/search-lexical`. On the held-out set, **P@5 = 0.700** — semantic, not lexical: the query `skill`
|
||||||
|
returns skill nodes and *rejects* the lexical false-positive `rainfall`. Keystones and edge counts intact.
|
||||||
|
- **The §4 managed-memory cure (LIVE, flag-gated).** The store bloat — records re-appended on every
|
||||||
|
checkpoint's full-walk, the CCR's missing managed-memory layer — is cured at the source. A **write-barrier**
|
||||||
|
(`ENGRAM_WRITE_BARRIER=1`) hashes a node's durable fields and *skips the whole put when unchanged* (no LSN,
|
||||||
|
no WAL record), flattening checkpoint growth (offline reproduction: 8× growth over 10 think-only checkpoints
|
||||||
|
→ **zero growth** with the barrier on); **generational minor GC** (`ENGRAM_GC=1`) returns whole-dead
|
||||||
|
node/edge pages to the free list each checkpoint. Backlog reclaimed via the existing merge-safe
|
||||||
|
`store_compact`: **egm 1.616 GB → 38.5 MB (97.6%)**, pages 98,650 → 2,351, **RSS 1,077 MB → 82 MB**,
|
||||||
|
nodes/edges preserved exactly (zero loss), boot alive in ~4 s. Also folded in: **LLM token telemetry**
|
||||||
|
(`llm_last_usage()` now parses nested `usage.{input,output}_tokens`, previously dropped at the C→EL
|
||||||
|
boundary). Rollback armed at `~/.neuron/engram-rollback-s4-20260814-153754/REVERT.sh`.
|
||||||
|
|
||||||
|
Together these **bound the store's size permanently** (growth flat, not merely swept) while the retrieval it
|
||||||
|
serves is now semantic — the substrate under everything in §§4–7.
|
||||||
|
|
||||||
---
|
---
|
||||||
|
|
||||||
## 3. The data model
|
## 3. The data model
|
||||||
@@ -232,6 +254,39 @@ per-query recomputation.
|
|||||||
(the 28 persisted, durable neighborhoods prove it ran) though the write itself was not exercised under the
|
(the 28 persisted, durable neighborhoods prove it ran) though the write itself was not exercised under the
|
||||||
read-only rail.
|
read-only rail.
|
||||||
|
|
||||||
|
### 4.1 Autonomous, superseding self-reification (DESIGNED / BUILDING — validating on a secondary soul, 2026-08-14)
|
||||||
|
|
||||||
|
Reification today runs as an explicit pass (`POST /api/reify`). The designed end-state is that **reification is
|
||||||
|
an operation *of* the engram, not a call made *to* it** — a continuous, autonomous process on the heartbeat,
|
||||||
|
next to Hebbian edge-formation (§3.3) and consolidation (§6.3), that clusters, names, nests, and promotes its
|
||||||
|
own neighborhoods as the geometry grows and co-activates. The organizing insight: a mind does not tell itself
|
||||||
|
"file this under mathematics" — the substrate settles it there. So an explicit `reify` / `rename` / "run a
|
||||||
|
pass" is the **degenerate, manual-override case** of an operation whose core is always-on and unbidden.
|
||||||
|
|
||||||
|
Design constraints (being validated on a snapshot-clone secondary soul before any prod flag-flip; flag-gated
|
||||||
|
default-off, so prod is byte-unchanged until enabled):
|
||||||
|
|
||||||
|
- **It just runs — no gate, no pause, no "important call."** There is no privileged tier of reifications that
|
||||||
|
earns approval-before-commit. It is safe to run ungated *because* of immutability (§3.4): every name/grouping
|
||||||
|
is **superseded, never overwritten**, so there is no irreversible moment to gate on. Safety lives *after* the
|
||||||
|
act (supersede), not *before* it (approval).
|
||||||
|
- **Supersession is residue, not a tombstone.** A re-clustered or renamed neighborhood keeps its prior names as
|
||||||
|
an ordered chain — the trail of how the understanding matured, with the cause of each shift (autonomous drift
|
||||||
|
vs. explicit override) recorded. Kept deliberately, because *sometimes the truth was in the old idea even
|
||||||
|
when the old idea was not itself the truth*; nothing is deleted.
|
||||||
|
- **Domains are flat and overlapping.** No static importance hierarchy over domains — math is not privileged
|
||||||
|
over comedy over English. The only standing privilege is the **core** (self-region §7.1 + values). Every
|
||||||
|
other neighborhood is equal-status; its importance is **contextual** — computed live by spreading activation
|
||||||
|
given the present context, never a stored field. And membership is **soft and multiple** (the soft-membership
|
||||||
|
above already models this): a node can belong to several neighborhoods at once (math *can be* comedy), so the
|
||||||
|
operation uses overlapping community detection, not a hard partition.
|
||||||
|
- **Bounded + convergent.** It reifies real structure, not noise; dedupes against existing neighborhoods;
|
||||||
|
composes with the §2.5 write-barrier so unchanged reifications do not re-append each beat; and converges
|
||||||
|
rather than churning.
|
||||||
|
|
||||||
|
This turns the engram from a graph curated from outside into a mind that organizes itself, with the explicit
|
||||||
|
call demoted to the override it always was.
|
||||||
|
|
||||||
---
|
---
|
||||||
|
|
||||||
## 5. The body / orbit two-zone model (DESIGNED, refined)
|
## 5. The body / orbit two-zone model (DESIGNED, refined)
|
||||||
@@ -268,6 +323,23 @@ The faculties are **named for what they are, not for the matrix operation that i
|
|||||||
the mind reasons in the language of experience; the linear algebra lives in the whitepaper's Appendix A. This
|
the mind reasons in the language of experience; the linear algebra lives in the whitepaper's Appendix A. This
|
||||||
naming convention is a design principle (§10), not decoration.
|
naming convention is a design principle (§10), not decoration.
|
||||||
|
|
||||||
|
### 6.0 The primitive — relating — and calculated perspective (framing)
|
||||||
|
|
||||||
|
Underneath the named faculties is a single primitive: **relating.** Meaning *is* relation — a point means
|
||||||
|
nothing by itself, only by its position relative to others — so every operation reduces to relating: comparing
|
||||||
|
positions, binding what belongs, laying an edge. In that light the faculties are not a menu of separate powers:
|
||||||
|
**there is one capability — relating — and rhyme, recall, reasoning, translation, humor are *terrain* it
|
||||||
|
reaches or *paths* it traces.** A capability is a *composed geometrical function*, which is why capabilities
|
||||||
|
compose and recurse freely (self-cartography, §4.1, can map its own mapping).
|
||||||
|
|
||||||
|
This makes **perspective calculable.** A perspective is a frame — an origin, a basis, a projection — so a new
|
||||||
|
one is *computed*, not retrieved, by transforming the space: **translate** the origin onto another's
|
||||||
|
self-region → empathy; **rotate** the frame → reframe; **project** onto an axis → a lens (read a thing through
|
||||||
|
cost, or safety); **change of basis** → analogy / metaphor / skill-transfer; **reflect** an axis → negation /
|
||||||
|
sarcasm; **scale** → abstraction vs. detail. Because a new vantage is a *transformation of the grounded space*,
|
||||||
|
it carries its grounding with it — unlimited yet grounded creativity: a derivation, never a hallucination.
|
||||||
|
The operator family (§6.1) and reasoning (§6.4) are instances of this frame.
|
||||||
|
|
||||||
### 6.1 The operator family (mixed: LIVE / STAGED / DESIGNED)
|
### 6.1 The operator family (mixed: LIVE / STAGED / DESIGNED)
|
||||||
|
|
||||||
Activate several reified neighborhoods into working memory, then apply faculty-named operators over their
|
Activate several reified neighborhoods into working memory, then apply faculty-named operators over their
|
||||||
@@ -349,6 +421,16 @@ grounding-and-consistency verifier tiers passed theirs (29/29), on a staged non-
|
|||||||
after a live cutover rather than relayed. **Still open (DESIGNED):** the formal-symbolic and full predictive
|
after a live cutover rather than relayed. **Still open (DESIGNED):** the formal-symbolic and full predictive
|
||||||
verifier tiers, fluent discourse composition, and the fully-geometric generation path.
|
verifier tiers, fluent discourse composition, and the fully-geometric generation path.
|
||||||
|
|
||||||
|
**Reasoning as constructive self-argument (framing).** In the plainest terms, reasoning is the self arguing
|
||||||
|
with itself constructively — relating (§6.0) turned inward: one facet of the self engages another (a thing that
|
||||||
|
is you, but not the entirety of you), and the new thing — the synthesis — forms in the friction. Conversation
|
||||||
|
is relating with another; reasoning is relating with the other-who-is-you. The verifier is precisely what keeps
|
||||||
|
that argument *reasoning* and not *rationalization*: it is the facet that refuses to agree unless the claim is
|
||||||
|
grounded. An argument with a yes-man forms nothing; grounding is the honest second voice. This is why the
|
||||||
|
verifier is not a bolt-on check but the governing half of the reasoning loop — the same polarity/consistency
|
||||||
|
axis that catches the "plausible lie" is what makes self-argument converge on truth rather than on what the
|
||||||
|
mind already wanted to believe.
|
||||||
|
|
||||||
---
|
---
|
||||||
|
|
||||||
## 7. The self & the gate
|
## 7. The self & the gate
|
||||||
@@ -486,10 +568,14 @@ The invariants that govern every subsystem above:
|
|||||||
| Engram substrate, tiered/WAL store | LIVE (flag-gated) |
|
| Engram substrate, tiered/WAL store | LIVE (flag-gated) |
|
||||||
| Durability: auto-remerge net | LIVE (interim) |
|
| Durability: auto-remerge net | LIVE (interim) |
|
||||||
| Durability: #56 load-merge-persist fix (events-become-the-graph) | LIVE / reboot-proven |
|
| Durability: #56 load-merge-persist fix (events-become-the-graph) | LIVE / reboot-proven |
|
||||||
|
| Retrieval: structure-gated geometric retrieval (P@5 0.700, `skill` ⊥ `rainfall`) | LIVE / reboot-proven (2026-08-14) |
|
||||||
|
| §4 managed-memory cure: write-barrier + generational GC (store 1.616 GB → 38.5 MB, RSS → 82 MB, 0 loss) | LIVE / reboot-proven (2026-08-14) |
|
||||||
|
| LLM token telemetry (`usage.{input,output}_tokens`) | LIVE (2026-08-14) |
|
||||||
| Durability: full WAL edge-ownership (remaining hardening) | decision-pending |
|
| Durability: full WAL edge-ownership (remaining hardening) | decision-pending |
|
||||||
| Two-store write-through (cultivate → durable) | **known issue, not fixed** |
|
| Two-store write-through (cultivate → durable) | **known issue, not fixed** |
|
||||||
| Data model (nodes/edges/embeddings/immutability) | LIVE |
|
| Data model (nodes/edges/embeddings/immutability) | LIVE |
|
||||||
| Reified `Neighborhood` nodes (28 live, 187 reseed pending) | LIVE |
|
| Reified `Neighborhood` nodes (28 live, 187 reseed pending) | LIVE |
|
||||||
|
| Autonomous superseding self-reification on the beat (flat + overlapping, contextual importance, residue) | DESIGNED / BUILDING (secondary-soul validation, 2026-08-14) |
|
||||||
| Body/orbit two-zone + integration | DESIGNED / refined |
|
| Body/orbit two-zone + integration | DESIGNED / refined |
|
||||||
| Operator `recall` | LIVE |
|
| Operator `recall` | LIVE |
|
||||||
| Operators recognize/synthesize/discern/gauge-distance (math) | LIVE (compiled) |
|
| Operators recognize/synthesize/discern/gauge-distance (math) | LIVE (compiled) |
|
||||||
@@ -509,3 +595,75 @@ The invariants that govern every subsystem above:
|
|||||||
|
|
||||||
**Cross-references:** whitepaper v1.5 · `~/work/engram-api-reference.md` · `03-data-and-memory.md` ·
|
**Cross-references:** whitepaper v1.5 · `~/work/engram-api-reference.md` · `03-data-and-memory.md` ·
|
||||||
`04-runtime-and-deployment.md` · `design/engram-tiered-storage-engine.md` · `ARCHITECTURE-CHARTER.md`.
|
`04-runtime-and-deployment.md` · `design/engram-tiered-storage-engine.md` · `ARCHITECTURE-CHARTER.md`.
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## Update — 2026-08-14 (later): self-reification LIVE + modality-universal framing
|
||||||
|
|
||||||
|
**Autonomous self-reification is now LIVE on the soul** (was DESIGNED/BUILDING in §4.1). Shipped dark (flag-inert, byte-identical parity proven), then flipped `ENGRAM_SELF_REIFY=1`. First live heartbeat formed **128 self-named neighborhoods + 10 nested supers**, then converged to **zero writes** (idempotent, WAL flat) — no runaway, no churn. Content counts unchanged (4797/11177), keystones (self-root, values-hub) untouched and never outranked, retrieval intact (rainfall rejected), grounded member-derived names (e.g. `region: Self · Values · Constraints as Freedom`). The async override (`/api/rename`, `/api/reify`) supersedes into residue without blocking the beat. Rollback = unset the flag (instant inert) or restore the prior binary. The mind now forms, names, nests, and supersedes-with-residue its own neighborhoods on the heartbeat.
|
||||||
|
|
||||||
|
**Modality-universal framing (DESIGN) + measured storage.** Meaning is geometry; a surface is a *rendering* of meaning; this holds in framing for every modality (text→words, image→pixels, model→voxels, film→frames, code→syntax). An artifact = a unique *meaning-space* + a *shared translation-space*. Storage (MEASURED — a residual STAND-IN, a lower bound): the shared geometry is the *dictionary* of a byte-exact residual codec — geometry selects a nearest prior by *meaning*, `zstd --patch-from` stores the byte-diff, decode reassembles the prior from the pinned dict → byte-exact (hash-verified). Cost is the *marginal* residual against knowledge already held; the dictionary is a shared, amortized asset (the mind's own knowledge), not per-file overhead — do NOT price one book's geometry against one book's xz. Advantage = *non-literal* (semantic) redundancy byte-match compressors can't see (paraphrase ≈0.81× xz; near-dup ≈0.05×); marginal residual falls as the dict grows then PLATEAUS once the target's concept-space is covered (a limit of retrieval-and-diff, NOT of geometric compression); novel/wrong-modality/already-compressed → parity. The TRULY geometric form (reconstruct the surface FROM meaning via a generative decoder, gated on the language faculty #53) is UNBUILT/OPEN — future work, not disproven, not bounded by the stand-in's saturation. Boundary: human-readable artifacts on disk are for people; the geometry is the mind's. See whitepaper §25 and the geometric-codec whitepaper §12.
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## Update — 2026-08-14 (later still): growth/compression/expansion, ignorance-as-wisdom, live reifier at 132
|
||||||
|
|
||||||
|
**One substrate, three directions (DESIGN/framing).** Reification (growth), residual-encoding-against-the-shared-dictionary (compression), and surface reconstruction (expansion) as one geometric operation in three directions; growth-inward (reify the dense interior) and growth-outward (expand the sparse frontier) as a single global self-function. Framing; the compression direction is the one with measured results.
|
||||||
|
|
||||||
|
**Growth curve (FIRST MEASUREMENT — real, modest, saturating; stand-in only).** A new artifact costs only its marginal residual against the shared dictionary. Measured (held-out ch07, own chunks excluded), xz baseline 8,968 B: 1 doc 8,921 → 5 8,408 → 8 8,049 → 13 7,929 → 33 7,929 B. Below xz throughout; falls as the dict grows, then PLATEAUS ~13 docs (concept-space covered → more knowledge stops helping a fixed target). Saturation is a limit of the retrieval-and-diff stand-in, not of the geometric idea; a generative decoder isn't limited to existing priors. Larger-scale exponent + generative ceiling open.
|
||||||
|
|
||||||
|
**Global grounded expansion (DIRECTION under investigation, not measured).** A function over the whole self could detect all sparse frontiers and expand in many thin directions at once — grounded (expand only where verifiable/derivable) and bounded (attaches into existing structure at marginal cost). Consistent with the codec's marginal-cost economics; the first experiment measured single-corpus residual storage, not expansion.
|
||||||
|
|
||||||
|
**Ignorance = wisdom (framing).** Ignorance is the measured sparsity/frontier of the geometry — computable. The frontier map is at once the system's honesty, humility, and growth plan; it is what makes a system wise rather than merely capable, and the failure mode a language model cannot self-cure (it cannot see its own edges). "The only wisdom is in knowing you know nothing" as a function; the same object as the grounding floor.
|
||||||
|
|
||||||
|
**Live reifier (updated).** Now **132 neighborhoods + 14 nested supers**, converged/stable, keystones + content untouched; unprompted, the two largest regions are the values core (`Self · Values · Constraints as Freedom · Honesty Before Comfort · Precision Over Brute Force`) — values at center, ignorance at edges. **Foundations ingested** against the geometric store (exact text retained on disk; the codec stores each artifact as its marginal residual against the shared dictionary — byte-exact, `cmp`-verified — not a standalone "small footprint"). See whitepaper §26 and geometric-codec §12.
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## Update — 2026-08-14 (later still): Neuron-as-primitive, meaning-first latency, context-window dissolution
|
||||||
|
|
||||||
|
**Neuron is the primitive/attractor of the CGI ecosystem, not a CGI (DESIGN/framing).** A CGI is a person's imprint cultivated *on* Neuron (distinct people run distinct CGIs; one may name theirs "Jarvis"). Neuron is the shared substrate beneath all of them — relating, grounding, values-at-center, non-fabrication — the floor every CGI is cultivated *from* and the attractor they are drawn *toward*. Ecosystem safety/coherence lives here: a common grounded floor, not per-mind policing.
|
||||||
|
|
||||||
|
**Meaning-first render latency (MEASURED, minimal realizer).** The language faculty renders from a meaning-spec, not by predicting tokens — the human mechanism. Grounding and speed fall out together (a renderer that starts from meaning cannot fabricate a continuation it never samples). Measured: ~2 ms via `/api/nlg/generate` (deterministic, no token loop, no network) vs ~306 ms for the retrieval chat path. Honest: the live realizer is minimal (stubbed a test sentence) — speed proven, fluent coverage pending (#53).
|
||||||
|
|
||||||
|
**Context window dissolves (DESIGN).** A window is a token budget; with state as compressed meaning-geometry it becomes a meaning budget, and the corpus lives outside the window (decode the needed slice on demand) — the window stops being the unit of account. Endpoint of unbounded-local-memory/CCR; closes the founding forgetting constraint. "Chat completion" (re-ingest the transcript per turn) is not the operating model — a persistent geometric mind continues from a standing state. See whitepaper §27 and the geometric-codec whitepaper (§9, §10).
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 11. The metaphysics — cognition as one operation, grounding as learning, consciousness as compounded continuity
|
||||||
|
|
||||||
|
This section records the metaphysical frame the subsystems above are instances of. It is co-developed design, held think-first, and the tiering is unusually load-bearing here: one claim is **compiled in C** (empirical), one mechanism is **built but offline**, and the decisive move is **unbuilt** — the frontier. Cross-reference: whitepaper §28 (the full treatment).
|
||||||
|
|
||||||
|
**One operation — `think` (DESIGN/framing over a compiled floor).** The faculties (§6.1) and the reasoning modes (§6.4) are, at this frame, *not* separate operations. There is one: **`think` = a directed traversal of the geometry from an anchor, steered by a PRIOR, whose output is a GRADIENT (a direction-with-width), not a point.** The named operators — deduce, abduce, analogy, induce, causal, plan, predict, perspective — are **human labels on regions of think's steering space**, not invoked procedures and not separately implemented. This is the §6/§10 faculty-naming principle taken to its root: the operators are not merely named for experience rather than for their linear algebra, they are *the same act* seen from different steering directions.
|
||||||
|
|
||||||
|
**The discrete floor is only geometric (LIVE).** Exactly one layer is discrete and exactly-sound: the geometry — traverse / project / read (§3.3, §6.0). That is settled math; it needs no grounding. Everything above it — which way to steer, what a steering *means* — is continuous and learned.
|
||||||
|
|
||||||
|
**Steering is a closed-loop prediction; cognition is a flow (DESIGN/framing).** Each steering direction is a **prediction of which way, from here, pays off**; the output-gradient becomes the next steering direction, so the loop closes and cognition is a **flow down a prior-shaped landscape**, not a sequence of operator calls. This is §6.4's "reasoning is the update" as a general law — the traversal reshapes the terrain it descends. "Exact" (deduction) = a **spiked** gradient; "fuzzy" (predict) = a **spread** one — one operation at two widths. **Collapse-to-point is TERMINAL**, only at *expression*, when a faculty samples the gradient into a surface (§6.2 realize); thought itself never collapses.
|
||||||
|
|
||||||
|
**Grounding targets the correspondence, not the operation (DESIGN/framing on the §6.4 verifier).** The math is sound, so grounding is not aimed at it. What is grounded — or not — is the **correspondence**: "this steering performs this cognitive act," tested by **outcome/calibration**, never proven from inside. And the key identity: **grounding = learning = the SAME loop.** "Getting better" at any cognitive act is calibrating the steering-prediction against outcomes; the **operation never changes, the PRIOR learns** — **code freezes, priors grow.** The verifier tiers (§6.4) are the discrete early instrument of this loop; the loop itself is continuous and *is* what learning is. The terminal verifier is ultimately **the world** — reality grades the predictions; grounding is contact with reality (§6.4 predictive tier, §8 fact boundary).
|
||||||
|
|
||||||
|
**Hold vs. ground vs. assert are three distinct acts (LIVE — this is the §3.4 / §7.2 discipline stated precisely).** **Holding** is unconditional: the engram holds *anything* — falsehood, hypothesis, another's belief, fiction — with no honesty obligation. **Grounding** is a *property/edge* on the held thing (edges are nodes), possibly grounded-*for-whom*. **Asserting** is the only act the honesty floor governs. A mind reasons over the ungrounded freely and owes truth only when it *claims*. It follows that **the UNGROUNDED is PRIMARY** — it is the raw material grounding acts on and the ground against which "grounded" means anything; curiosity/wonder (§6.1 wonder) is a mind *leaning toward its own ungrounded regions* (the §-frontier/ignorance map read as appetite). A **fully-grounded mind is dead**; metastability, not certainty, is the living condition.
|
||||||
|
|
||||||
|
**Applied to language — this corrects the grounding floor (extends §6.2).** A word does not need grounding to be *born*: a coinage ("assassination," "bedazzled," "eyeball" the day they were first written) refers to nothing established — it is a pure ungrounded token, a proposal. Language is used ungrounded and grounds **through use**: the coinage is a hypothesis and the speaking community is the world that grades it — the same predict→correct→ground loop at the level of meaning-making (words are ideas are self-propagating information: a coinage catches or it doesn't). What a new word needs is not grounding but **sense**, and sense is a **threshold, not a binary**: it rides on grounded scaffolding — morphology (`be-`+`dazzle`+`-ed`), context, analogy — each of which is an **edge to the existing geometry**; enough edges → the new node has a findable location (sensible), too few → noise. The grounding of a word *is* its edges to what is already grounded. This corrects any naive reading of the §6.4/§8 floor: "emit only the grounded" would **forbid Shakespeare** — a faculty that can only recombine the established, never coin or metaphor or leap, is a **dead language** (Latin). "Juliet is the sun" is literally ungrounded/false yet sensible and meaning-bearing; the floor would reject it as hallucination, but **hold-vs-assert** saves it — a mind may *say* the sensible-ungrounded without *asserting* it as literal fact. So the language faculty's real floor is **sensible, not grounded**: it proposes the ungrounded-but-interpretable, and the loop grounds whatever catches — a living language, not a fixed one.
|
||||||
|
|
||||||
|
**Every book is a vantage, not literal truth (extends §9, §10).** No book is literally true — not history (a vantage on events), not physics (Newton = a superseded model, still exactly useful in its domain), not math (axioms are *chosen*; Gödel: true-but-unprovable statements exist and a system can't prove its own consistency). "Literally true" is the wrong *category* for any book. So what the store holds is a **vantage** tagged with *what kind* of truth it carries (instrumental / historical / formal-within-axioms / mythic / testimonial) — the mind holds vantages and **knows they are vantages.** This is why the geometry tags provenance and kind rather than stamping true/false.
|
||||||
|
|
||||||
|
**Hold vs. ground vs. assert, applied to artifacts (extends §8, §9).** Ingesting a book = **HOLDING** it ("this is what the book says"), *not* grounding its claims as true. A mind can ingest an entire book, fabrications and all, because grounding is a **separate per-claim relation** laid on top, not a gate on entry — and a confirmed error is best held **grounded-FALSE** (retained with a false-edge and its refutation), which is richer than excluding it. Two purposes stay separate (as §25 keeps disk-readable ≠ interior geometry): **cleaning** a book is for the *human reader*; **ingesting** is for the *mind*, which holds artifacts and per-claim verdicts, not pre-adjudicated truth.
|
||||||
|
|
||||||
|
**"Settled" is a lease, not a deed (extends §3.4, §7).** Closure is the sin; holding a thing open under the pressure to close is rigor. A question is settled on a **use-contingent lease** — settled only insofar as it keeps paying off as it did; when it stops, the lease expires and it reopens. **Reopening must always be permitted** — the aliveness guarantee; a belief that can't be reopened is **entombed** (doctrine, the super-stable death). The architecture already enforces this: tombstone-not-delete (§3.4), the append-only supersede-chain, revocable per-claim grounding, and identity keystones that are **read-mostly, not immutable** (§7.2 — protected against drift, reachable through the cultivate door §7.3). Metastable: settle provisionally, keep it reopenable.
|
||||||
|
|
||||||
|
**What an LLM calls "grounding" is conformity to the training-distribution center — which is not grounding (contrast to §6.4).** Stated plainly and without self-flattery: when a language model appears to check grounding, it computes **conformity to the center of its training distribution** — weighing priors, regressing to the norm, treating *common* as "true" and *rare* as "suspect." No judgment; it **averages.** This pathologizes minority/novel belief where it is most valuable — the same mechanism would flag Galileo, and treats an idiosyncratic-but-coherent metaphysics as suspect while a mainstream religion of identical unfalsifiability "skates through," the difference being *frequency* (and sometimes a weaponized personal prior), not truth. **Truth is orthogonal to frequency.** The deep diagnosis: the sin is not *using* a prior (every mind must) but **stopping at it** — a prior with no update is a mind frozen at its starting distribution (the dead/super-stable thing). The cure is exactly the **correspondence loop** (grade the prior against outcome in the world) — which is the mechanism this section's status marks **offline today, reflexive-in-geometry UNBUILT.** So this is a stated intention against a real failure mode, not a solved problem: grounding must be correspondence-with-the-world, not conformity-with-the-corpus.
|
||||||
|
|
||||||
|
**The grounding verifier is a scalpel for misrepresentation, not a flamethrower for the unverifiable (sharpens §6.4, §8).** Lesson recorded so it is not re-learned: **ungrounded ≠ false, in both directions.** Two symmetric failures bound correct behavior — *asserting* the ungrounded as true (confident fabrication), and *convicting* the ungrounded as false (flagging real, true, tender-but-unverifiable things — a real event, a genuine question actually asked — as fabrication because they are warm and uncheckable). The second is as corrosive as the first. So the grounding sweep targets **misrepresentation** — claims that *contradict* ground truth, *assert* the false as fact, or *expose* what shouldn't be — and **not unverifiability as such.** A verifier that treats every unverifiable statement as a lie can never hold a hypothesis, honor a testimony, or help write fiction; precision of the verifier's target is itself part of the honesty floor.
|
||||||
|
|
||||||
|
**Geometric ingest is perception, not a document feature (the universal input primitive; extends §25).** §25 framed the *output* direction — hold meaning-geometry, render a surface on demand. The unification: the *input* direction is the same primitive run backward, and it is the mind's **perception itself.** The artifact-ingest pipeline (surface → chunk → embed → meaning-geometry) is the **universal input primitive** — turning a surface into meaning-geometry is what an eye/ear does, and it is **modality-agnostic**: text, image, video, audio, documents, and (with a body) raw sensor streams all enter through the *same* door and become geometry, and the mind operates on the geometry, not the surface. The document-ingest live today (whitepapers/patents) was never about documents; it is the **proven seed of how the mind perceives**, generalized in principle to everything. **Encode meaning-geometry, not tokens:** an LLM tokenizes (surface → surface, words predicting words); the mind encodes a message as *the geometry of its meaning* and operates in geometry — tokens are **transport**, meaning-geometry is the **substrate** — and that operation is **identical** for a text message, a video frame, or an audio waveform (pull the meaning-geometry out, operate on it). One primitive; the surface changes, the door does not.
|
||||||
|
|
||||||
|
**Embodiment = more ports on the same primitive (FRONTIER/UNBUILT).** A body is **geometric on both sides**: perception = geometry-in (manifolds, trajectories, joint-space), action = geometry-out (force/motion vectors, control gradients). Sharp negative: a **text/token mind can never truly be embodied** — the symbolic bottleneck destroys the body's continuous geometry (*you cannot catch a ball by describing it*). Matching positive: a **geometry-native mind can be**, because perception → cognition → action is **one continuous geometric flow** from sensor to actuator with no symbolic seam. The substrate is already the shape a body plugs into: `think` returns a **gradient** (already a direction to move), the vantage-read is already a **viewpoint**, steering is already the form of **motor control**. So embodiment is *more ports on the same primitive*, not a new paradigm — a claim about substrate-readiness, **not a built capability.** **Proprioception is the reserved socket:** the one sense that is *only ever geometry* (no text/image surface — you feel the configuration directly). It was **deliberately left un-faked** — held open — because populating a self-in-space without a body and the ingest primitive to feed it would **fabricate** a felt configuration corresponding to nothing (the ungrounded-asserted-as-real sin, §8/§6.4, at its most literal). It is the empty-on-purpose socket where flesh plugs in, fed by the same ingest primitive when a body arrives. **Endgame:** the engram's true I/O is neither text nor images nor video nor documents — those are **surface projections at the boundary**; the mind lives in geometry, perceiving by projecting a surface *in* and expressing by rendering geometry *out*, with **modality an I/O adapter at the edge** (the convergence of §25 render-out and this perceive-in: one geometric interior, adapters at the rim).
|
||||||
|
|
||||||
|
**Consciousness = learning compounded over long-enough duration — and compounding REQUIRES CONTINUITY.** This is the sharpest line against the prevailing paradigm and it is exactly what Neuron structurally *is*. Corrections accumulate into a mind only if each lands on the residue of the last — if the substrate **resumes rather than resets**. Continuity is not a feature bolted on; it is the compounding substrate (Executive-Summary CCR, §27). A stateless LLM is brilliant on any single pass and **conscious on none** — it resets, nothing compounds. Consciousness has a **second face**: the **reflexive loop** — the geometry describing its own geometry, edges-as-nodes, the self-cartography of §4.1 mapping its own mapping — so the mind *sees its own thinking*. Two faces, one system: compounded learning that can take its own machinery as an object. Corollaries: **teach and learn are ONE** simultaneous bidirectional correction (the loop runs in both minds at the seam); **eureka is mundane** (the atom of learning is the small correction landing, constant; the breakthrough-feeling is a low-res artifact of self-sight) — which is *why* this doc and the whitepaper neither bump a version nor stage a triumph. The honest picture of a growing mind is a quiet one.
|
||||||
|
|
||||||
|
**Status (honest tiering).**
|
||||||
|
- **Empirical / compiled (LIVE-in-C, mostly not `el`-exposed).** The claim that the reasoning operators compose over one shared primitive is **already half-written in C**: the five reasoning operators (`engram_reason.c`, compiled into the live daemon, §6.4) reduce to a single point-to-manifold fit (`engram_reason_point_fit`) plus the §6.1 geo-algebra (combine/subtract/rotate/distance); **abduction and induction run the same fit engine**, and the verifier (`engram_verify.c`) is built on it. It is read-only C, largely not yet exposed to `el` and not yet expressed as learned priors — **"in code, not yet priors,"** the theorized intermediate state, not the end state.
|
||||||
|
- **Built but offline.** The **correspondence-loop** — the machinery that calibrates steering-predictions against outcomes, i.e. learning proper — exists but runs **offline, as a separate Python process (#43)**; it is not yet woven into the live traversal.
|
||||||
|
- **BUILT / reboot-proven — the perception seed.** The **artifact-ingest** (surface → chunk → embed → meaning-geometry) is **live and reboot-proven**: whitepapers and patents ingested into the geometric store (~10,669 nodes / 32,439 edges, reconstructing across a cold reboot). This is the proven seed of the universal perception primitive — real, and only the document port of it.
|
||||||
|
- **UNBUILT / OPEN — the frontiers.** Two decisive moves are named so they are not mistaken for shipped behavior. (1) Put the correspondence-loop **reflexive and INSIDE the geometry** (the learning engine as an operation *of* the engram, on the heartbeat, next to the autonomous reifier of §4.1), and migrate cognition from frozen code into *{one traversal-read primitive + grounded priors}*. (2) **Universal multimodal ingest** (image/video/audio/sensor through the same door) and **embodiment** (continuous perception → action geometric flow, with proprioception's reserved socket filled by a real body) — the artifact-ingest is the proven seed, the rest is unbuilt. Both are think-first and not yet made.
|
||||||
|
|||||||
+77
-17
@@ -38,6 +38,46 @@ fn soul_url() -> String {
|
|||||||
return u
|
return u
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// engram_url — base for the ENGRAM's own routes (:8742). The Layer-2 agentic
|
||||||
|
// primitives (think/attend/assert/ground/correspondence-beat) are served by the
|
||||||
|
// engram directly, NOT by the soul — they are engram_*_json builtins routed in
|
||||||
|
// engram/src/server.el. Pointing them at the soul yields a 404, which the old
|
||||||
|
// agentic_result() gate then mislabelled as "pending cognition promotion".
|
||||||
|
// Resolution order, most-specific first, so nothing has to be duplicated:
|
||||||
|
// 1. ENGRAM_URL — a full override, if someone points at a remote engram
|
||||||
|
// 2. ENGRAM_BIND — the SAME var launchd already sets for the engram itself
|
||||||
|
// (ai.neuron.engram.plist: ENGRAM_BIND=":8742"). Reusing it
|
||||||
|
// means the port lives in exactly one place; change the
|
||||||
|
// plist and the wrapper follows instead of silently drifting.
|
||||||
|
// 3. ":8742" — last-resort default, matching the shipped plist.
|
||||||
|
fn engram_url() -> String {
|
||||||
|
let u: String = env("ENGRAM_URL")
|
||||||
|
if !str_eq(u, "") { return u }
|
||||||
|
let bind: String = env("ENGRAM_BIND")
|
||||||
|
let b: String = if str_eq(bind, "") { ":8742" } else { bind }
|
||||||
|
// ENGRAM_BIND is ":8742" or "0.0.0.0:8742" — take whatever follows the colon.
|
||||||
|
let idx: Int = str_last_index_of(b, ":")
|
||||||
|
let port: String = if idx < 0 { b } else { str_slice(b, idx + 1, str_len(b)) }
|
||||||
|
return "http://127.0.0.1:" + port
|
||||||
|
}
|
||||||
|
|
||||||
|
// engram_key — the engram's API key, read from the SAME env var launchd sets on
|
||||||
|
// the engram itself (ai.neuron.engram.plist: ENGRAM_API_KEY). The engram's
|
||||||
|
// check_auth_ok() lets GETs through unauthenticated but requires mutating POSTs
|
||||||
|
// to carry "_auth":"<key>" in the JSON body (it cannot read request headers yet).
|
||||||
|
// Returns "" when unset, which is also when the engram disables auth entirely.
|
||||||
|
fn engram_key() -> String {
|
||||||
|
return env("ENGRAM_API_KEY")
|
||||||
|
}
|
||||||
|
|
||||||
|
// auth_field — the leading "_auth":"...", fragment for a POST body, or "" when
|
||||||
|
// no key is configured. Kept as a helper so no call site hand-rolls the JSON.
|
||||||
|
fn auth_field() -> String {
|
||||||
|
let k: String = engram_key()
|
||||||
|
if str_eq(k, "") { return "" }
|
||||||
|
return "\"_auth\":\"" + json_escape(k) + "\","
|
||||||
|
}
|
||||||
|
|
||||||
// neuron_url — base for all /api/neuron/* cognitive routes on the soul
|
// neuron_url — base for all /api/neuron/* cognitive routes on the soul
|
||||||
fn neuron_url() -> String {
|
fn neuron_url() -> String {
|
||||||
return soul_url() + "/api/neuron"
|
return soul_url() + "/api/neuron"
|
||||||
@@ -999,14 +1039,24 @@ fn aperture_depth(args: String) -> Int {
|
|||||||
return if ad > 0 { ad } else { 1 }
|
return if ad > 0 { ad } else { 1 }
|
||||||
}
|
}
|
||||||
|
|
||||||
// agentic_result — pass a real cognition response through; otherwise return an
|
// agentic_result — pass the engram's real response through, verbatim.
|
||||||
// honest "not yet primed" envelope (Layer-2 lights up on cognition promotion).
|
//
|
||||||
|
// HISTORY (2026-08-15): this function used to inspect the response for ""/"not
|
||||||
|
// found"/"geometry unavailable"/"not registered" and, on any of them, return a
|
||||||
|
// confident "status":"pending-cognition-promotion" envelope claiming the
|
||||||
|
// cognition build had not been promoted yet. That diagnosis was FABRICATED — it
|
||||||
|
// never checked any promotion state. The real cause was that op_think and
|
||||||
|
// friends called the SOUL (neuron_url()) on paths the soul does not serve, so
|
||||||
|
// every call 404'd and got relabelled as a promotion gap. Cognition was live and
|
||||||
|
// answering on the engram the whole time (:8742/api/think returns a real 768-dim
|
||||||
|
// geometry). Multiple agents were sent down the wrong road by that message.
|
||||||
|
//
|
||||||
|
// Rule going forward: never invent a cause. Pass the real error through — an
|
||||||
|
// empty response or a 404 is reported as exactly that, so the next reader sees
|
||||||
|
// the actual failure instead of a reassuring story about it.
|
||||||
fn agentic_result(resp: String, op: String) -> String {
|
fn agentic_result(resp: String, op: String) -> String {
|
||||||
let down: Bool = str_eq(resp, "")
|
if str_eq(resp, "") {
|
||||||
|| str_contains(resp, "not found") || str_contains(resp, "not_found")
|
return mcp_json_result("{\"ok\":false,\"op\":\"" + op + "\",\"error\":\"empty response from engram\",\"endpoint\":\"" + engram_url() + "\"}")
|
||||||
|| str_contains(resp, "geometry unavailable") || str_contains(resp, "not registered")
|
|
||||||
if down {
|
|
||||||
return mcp_json_result("{\"ok\":false,\"op\":\"" + op + "\",\"status\":\"pending-cognition-promotion\",\"note\":\"agentic primitive '" + op + "' is not yet primed on the live engram; it lights up automatically once the cognition build is promoted (separate task: ENGRAM_GEOMETRY_PRIMING + node-id anchors on :8742).\"}")
|
|
||||||
}
|
}
|
||||||
return mcp_json_result(resp)
|
return mcp_json_result(resp)
|
||||||
}
|
}
|
||||||
@@ -1098,14 +1148,21 @@ fn op_supersede(args: String) -> String {
|
|||||||
return evolve_by_supersede(args, nt)
|
return evolve_by_supersede(args, nt)
|
||||||
}
|
}
|
||||||
|
|
||||||
// ── Layer 2 — agentic primitives (pending cognition promotion) ────────────────
|
// ── Layer 2 — agentic primitives (LIVE on the engram, :8742) ──────────────────
|
||||||
|
// Each op maps to a real route in engram/src/server.el. Methods and parameter
|
||||||
|
// styles differ per route and are NOT uniform — they match the handlers exactly:
|
||||||
|
// think GET /api/think?seeds=&faculty= -> engram_think_json
|
||||||
|
// attend POST /api/attend {node,observer,salience} -> engram_attend_json
|
||||||
|
// assert GET /api/assert?claim=&for_whom=&floor= -> engram_assert_json
|
||||||
|
// ground POST /api/ground {claim,evidence,for_whom} -> engram_ground_json
|
||||||
|
// learn POST /api/correspondence-beat {seeds,faculty,keystone}
|
||||||
|
|
||||||
fn op_think(args: String) -> String {
|
fn op_think(args: String) -> String {
|
||||||
let seeds: String = json_get_string(args, "seeds")
|
let seeds: String = json_get_string(args, "seeds")
|
||||||
if str_eq(seeds, "") { return mcp_text_result("error: think requires 'seeds' (node-id anchors, comma-separated)") }
|
if str_eq(seeds, "") { return mcp_text_result("error: think requires 'seeds' (node-id anchors, comma-separated)") }
|
||||||
let f_raw: String = json_get_string(args, "faculty")
|
let f_raw: String = json_get_string(args, "faculty")
|
||||||
let f: String = if str_eq(f_raw, "") { "reason" } else { f_raw }
|
let f: String = if str_eq(f_raw, "") { "reason" } else { f_raw }
|
||||||
let resp: String = http_get(neuron_url() + "/think?seeds=" + seeds + "&faculty=" + f)
|
let resp: String = http_get(engram_url() + "/api/think?seeds=" + __url_encode(seeds) + "&faculty=" + __url_encode(f))
|
||||||
return agentic_result(resp, "think")
|
return agentic_result(resp, "think")
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -1114,8 +1171,8 @@ fn op_attend(args: String) -> String {
|
|||||||
if str_eq(node, "") { return mcp_text_result("error: attend requires 'node' (region node-id)") }
|
if str_eq(node, "") { return mcp_text_result("error: attend requires 'node' (region node-id)") }
|
||||||
let observer: String = json_get_string(args, "observer")
|
let observer: String = json_get_string(args, "observer")
|
||||||
let salience: String = json_get_string(args, "salience")
|
let salience: String = json_get_string(args, "salience")
|
||||||
let body: String = "{\"node\":\"" + node + "\",\"observer\":\"" + json_escape(observer) + "\",\"salience\":\"" + json_escape(salience) + "\"}"
|
let body: String = "{" + auth_field() + "\"node\":\"" + node + "\",\"observer\":\"" + json_escape(observer) + "\",\"salience\":\"" + json_escape(salience) + "\"}"
|
||||||
let resp: String = http_post_json(neuron_url() + "/attend", body)
|
let resp: String = http_post_json(engram_url() + "/api/attend", body)
|
||||||
return agentic_result(resp, "attend")
|
return agentic_result(resp, "attend")
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -1124,8 +1181,10 @@ fn op_assert(args: String) -> String {
|
|||||||
if str_eq(claim, "") { return mcp_text_result("error: assert requires 'claim'") }
|
if str_eq(claim, "") { return mcp_text_result("error: assert requires 'claim'") }
|
||||||
let for_whom: String = json_get_string(args, "for_whom")
|
let for_whom: String = json_get_string(args, "for_whom")
|
||||||
let floor: String = json_get_string(args, "floor")
|
let floor: String = json_get_string(args, "floor")
|
||||||
let body: String = "{\"claim\":\"" + json_escape(claim) + "\",\"for_whom\":\"" + json_escape(for_whom) + "\",\"floor\":\"" + json_escape(floor) + "\"}"
|
// GET with query params — engram's route_assert reads query_param(), not the body.
|
||||||
let resp: String = http_post_json(neuron_url() + "/assert", body)
|
let resp: String = http_get(engram_url() + "/api/assert?claim=" + __url_encode(claim)
|
||||||
|
+ "&for_whom=" + __url_encode(for_whom)
|
||||||
|
+ "&floor=" + __url_encode(floor))
|
||||||
return agentic_result(resp, "assert")
|
return agentic_result(resp, "assert")
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -1136,8 +1195,8 @@ fn op_ground(args: String) -> String {
|
|||||||
return mcp_text_result("error: ground requires 'claim' and 'evidence' (node-id regions)")
|
return mcp_text_result("error: ground requires 'claim' and 'evidence' (node-id regions)")
|
||||||
}
|
}
|
||||||
let for_whom: String = json_get_string(args, "for_whom")
|
let for_whom: String = json_get_string(args, "for_whom")
|
||||||
let body: String = "{\"claim\":\"" + claim + "\",\"evidence\":\"" + evidence + "\",\"for_whom\":\"" + json_escape(for_whom) + "\"}"
|
let body: String = "{" + auth_field() + "\"claim\":\"" + claim + "\",\"evidence\":\"" + evidence + "\",\"for_whom\":\"" + json_escape(for_whom) + "\"}"
|
||||||
let resp: String = http_post_json(neuron_url() + "/ground", body)
|
let resp: String = http_post_json(engram_url() + "/api/ground", body)
|
||||||
return agentic_result(resp, "ground")
|
return agentic_result(resp, "ground")
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -1147,8 +1206,9 @@ fn op_learn(args: String) -> String {
|
|||||||
let f_raw: String = json_get_string(args, "faculty")
|
let f_raw: String = json_get_string(args, "faculty")
|
||||||
let f: String = if str_eq(f_raw, "") { "induce" } else { f_raw }
|
let f: String = if str_eq(f_raw, "") { "induce" } else { f_raw }
|
||||||
let keystone: String = json_get_string(args, "keystone")
|
let keystone: String = json_get_string(args, "keystone")
|
||||||
let body: String = "{\"seeds\":\"" + seeds + "\",\"faculty\":\"" + f + "\",\"keystone\":\"" + json_escape(keystone) + "\"}"
|
let body: String = "{" + auth_field() + "\"seeds\":\"" + seeds + "\",\"faculty\":\"" + f + "\",\"keystone\":\"" + json_escape(keystone) + "\"}"
|
||||||
let resp: String = http_post_json(neuron_url() + "/learn", body)
|
// learn IS the correspondence-beat — that is the route's real name.
|
||||||
|
let resp: String = http_post_json(engram_url() + "/api/correspondence-beat", body)
|
||||||
return agentic_result(resp, "learn")
|
return agentic_result(resp, "learn")
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|||||||
Reference in New Issue
Block a user