diff --git a/chat.el b/chat.el index c101aa8..7225d6e 100644 --- a/chat.el +++ b/chat.el @@ -73,8 +73,9 @@ fn engram_compile_ranked(nodes_json: String, max_nodes: Int) -> String { while ci < total { let node: String = json_array_get(nodes_json, ci) let score: Int = engram_score_node(node) - // Only include reasonably relevant nodes (threshold=25) - let above_thresh: Bool = score >= 25 + // Threshold lowered from 25 to 15: includes moderately-relevant older nodes. + // A 3-week-old node with salience 0.6 and importance 0.6 scores ~18 — was dropped, now included. + let above_thresh: Bool = score >= 15 // Check this index wasn't already selected (sentinel: look for idx marker) let idx_marker: String = "\"_sel_" + int_to_str(ci) + "\"" let already_picked: Bool = str_contains(selected, idx_marker) @@ -113,59 +114,424 @@ fn engram_compile_ranked(nodes_json: String, max_nodes: Int) -> String { let c7: String = str_replace(c6, "\"_sel_7\":1,", "") let c8: String = str_replace(c7, "\"_sel_8\":1,", "") let c9: String = str_replace(c8, "\"_sel_9\":1,", "") - return c9 + let c10: String = str_replace(c9, "\"_sel_10\":1,", "") + let c11: String = str_replace(c10, "\"_sel_11\":1,", "") + let c12: String = str_replace(c11, "\"_sel_12\":1,", "") + let c13: String = str_replace(c12, "\"_sel_13\":1,", "") + let c14: String = str_replace(c13, "\"_sel_14\":1,", "") + return c14 +} + +// engram_split_topics — split message into sub-queries on explicit conjunctions. +// "health goals AND startup progress" becomes two independent searches. +fn engram_split_topics(message: String) -> String { + let sep: String = if str_contains(message, " AND ") { " AND " } else { + if str_contains(message, " and ") { " and " } else { + if str_contains(message, " also ") { " also " } else { + if str_contains(message, " plus ") { " plus " } else { "" } + } + } + } + if str_eq(sep, "") { return message } + let sep_pos: Int = str_index_of(message, sep) + let part1: String = str_slice(message, 0, sep_pos) + let part2: String = str_slice(message, sep_pos + str_len(sep), str_len(message)) + let part2_topics: String = engram_split_topics(part2) + if str_eq(part1, "") { return part2_topics } + return part1 + "\n" + part2_topics +} + +// engram_extract_entities — extract probable named entities (capital-first, 3+ chars, +// not stop-words) from a message. Returns newline-separated list. +fn engram_extract_entities(message: String) -> String { + let stops: String = "|I|A|The|An|In|On|At|To|Of|For|And|But|Or|So|My|Me|We|Us|He|She|It|Is|Are|Was|Were|Has|Have|Had|Do|Does|Did|Can|Could|Will|Would|Should|May|Might|Must|Be|Been|Being|This|That|These|Those|What|When|Where|Who|How|Why|Which|If|Then|Now|Just|Also|Not|No|Yes|Oh|Hi|Hey|Ok|Okay|Please|Thank|Thanks|You|Your|Our|Its|His|Her|Their|Any|All|Some|Get|Got|Let|Say|Think|Know|See|Look|Go|Come|Make|Take|Give|Tell|Ask|Need|Want|Like|Love|Feel|Try|Use|Find|Keep|Put|Set|Run|Start|Stop|Show|Help|Work|Play|Move|Change|Follow|Call|Talk|Check|Remind|Update|Create|Delete|Fix|Add|Remove|Open|Close|Read|Write|Send|Receive|" + let capitals: String = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" + let entities: String = "" + let entity_count: Int = 0 + let msg_len: Int = str_len(message) + let pos: Int = 0 + while pos < msg_len && entity_count < 10 { + let wend: Int = pos + let scanning: Bool = true + while scanning && wend < msg_len { + let wch: String = str_slice(message, wend, wend + 1) + let is_sep: Bool = str_eq(wch, " ") || str_eq(wch, "\n") || str_eq(wch, "\t") + || str_eq(wch, ",") || str_eq(wch, ".") || str_eq(wch, "?") + || str_eq(wch, "!") || str_eq(wch, ":") || str_eq(wch, ";") + || str_eq(wch, "(") || str_eq(wch, ")") || str_eq(wch, "\'") || str_eq(wch, "-") + let scanning = if is_sep { false } else { scanning } + let wend = if !is_sep { wend + 1 } else { wend } + } + let word: String = str_slice(message, pos, wend) + let word_len: Int = str_len(word) + let first_ch: String = if word_len >= 3 { str_slice(word, 0, 1) } else { "" } + let is_capital: Bool = word_len >= 3 && str_contains(capitals, first_ch) + let is_stop: Bool = str_contains(stops, "|" + word + "|") + let already_have: Bool = str_contains(entities, word) + let should_add: Bool = is_capital && !is_stop && !already_have && word_len >= 3 + let entities = if should_add { + let entity_count = entity_count + 1 + if str_eq(entities, "") { word } else { entities + "\n" + word } + } else { entities } + let pos = if wend > pos { wend + 1 } else { pos + 1 } + } + return entities +} + +// engram_detect_recall_intent — true when message explicitly requests memory recall. +fn engram_detect_recall_intent(message: String) -> Bool { + return str_contains(message, "remind me") + || str_contains(message, "do you remember") + || str_contains(message, "what do you know") + || str_contains(message, "what happened") + || str_contains(message, "tell me about") + || str_contains(message, "what was") + || str_contains(message, "what were") + || str_contains(message, "how is it going") + || str_contains(message, "how are things") + || str_contains(message, "catch me up") + || str_contains(message, "fill me in") + || str_contains(message, "what's the status") + || str_contains(message, "whats the status") + || str_contains(message, "any updates") + || str_contains(message, "recap") + || str_contains(message, "look up") + || str_contains(message, "check on") + || str_contains(message, "how did") + || str_contains(message, "what happened with") +} + +// engram_is_continuation — semantic continuation detection replacing the brittle 50-char +// threshold. Returns true when message starts with a pronoun, continuation opener, or is +// < 80 chars (raised from 50 to catch "Can you remind me what Prism's architecture +// looks like?" at 57 chars which is clearly a continuation in an active thread). +fn engram_is_continuation(message: String, hist_len: Int) -> Bool { + if hist_len <= 0 { return false } + let has_pronoun: Bool = str_starts_with(message, "It ") + || str_starts_with(message, "it ") + || str_starts_with(message, "That ") || str_starts_with(message, "that ") + || str_starts_with(message, "This ") || str_starts_with(message, "this ") + || str_starts_with(message, "They ") || str_starts_with(message, "they ") + || str_starts_with(message, "He ") || str_starts_with(message, "he ") + || str_starts_with(message, "She ") || str_starts_with(message, "she ") + || str_starts_with(message, "We ") || str_starts_with(message, "we ") + if has_pronoun { return true } + let is_cont_opener: Bool = str_starts_with(message, "Go on") + || str_starts_with(message, "go on") + || str_starts_with(message, "Continue") || str_starts_with(message, "continue") + || str_starts_with(message, "Yes") || str_starts_with(message, "yes") + || str_starts_with(message, "No,") || str_starts_with(message, "no,") + || str_starts_with(message, "Ok") || str_starts_with(message, "ok") + || str_starts_with(message, "And ") || str_starts_with(message, "and ") + || str_starts_with(message, "But ") || str_starts_with(message, "but ") + || str_starts_with(message, "What about") || str_starts_with(message, "what about") + || str_starts_with(message, "Why ") || str_starts_with(message, "why ") + || str_starts_with(message, "How ") || str_starts_with(message, "how ") + || str_starts_with(message, "When ") || str_starts_with(message, "when ") + if is_cont_opener { return true } + if str_len(message) < 80 { return true } + return false +} + +// engram_compile_multi — run activation + search for one topic with expanded pools. +// Activation depth 8 (was 5). Search 30 candidates ranked to 12 (was 20/8). +// Per-topic result pool: up to 20 nodes (was 13). +fn engram_compile_multi(topic: String) -> String { + let activate_json: String = engram_activate_json(topic, 8) + let search_json: String = engram_search_json(topic, 30) + let act_ok: Bool = !str_eq(activate_json, "") && !str_eq(activate_json, "[]") + let srch_ok: Bool = !str_eq(search_json, "") && !str_eq(search_json, "[]") + let act_nodes: String = if act_ok { activate_json } else { "" } + let srch_nodes: String = if srch_ok { engram_compile_ranked(search_json, 12) } else { "" } + if !str_eq(act_nodes, "") && !str_eq(srch_nodes, "") { + let act_inner: String = str_slice(act_nodes, 1, str_len(act_nodes) - 1) + let srch_inner: String = str_slice(srch_nodes, 1, str_len(srch_nodes) - 1) + return engram_dedup_nodes("[" + act_inner + "," + srch_inner + "]") + } + if !str_eq(act_nodes, "") { return act_nodes } + if !str_eq(srch_nodes, "") { return srch_nodes } + return "" +} + +// engram_nodes_merge — merge two node arrays, deduplicating by node id. +fn engram_nodes_merge(a: String, b: String) -> String { + let ok_a: Bool = !str_eq(a, "") && !str_eq(a, "[]") + let ok_b: Bool = !str_eq(b, "") && !str_eq(b, "[]") + if !ok_a && !ok_b { return "" } + if !ok_a { return b } + if !ok_b { return a } + let ai: String = str_slice(a, 1, str_len(a) - 1) + let bi: String = str_slice(b, 1, str_len(b) - 1) + return engram_dedup_nodes("[" + ai + "," + bi + "]") +} + +// is_followup_phrase — recognize explicit follow-up references that are too short +// to carry meaningful topic signal on their own. These should activate on the +// prior thread context rather than the bare message. Fixes Issues 2/8. +fn is_followup_phrase(msg: String) -> Bool { + if str_contains(msg, "tell me more") { return true } + if str_contains(msg, "elaborate") { return true } + if str_contains(msg, "go on") { return true } + if str_contains(msg, "what about that") { return true } + if str_contains(msg, "what else") { return true } + if str_contains(msg, "keep going") { return true } + if str_contains(msg, "more detail") { return true } + if str_contains(msg, "last part") { return true } + if str_contains(msg, "say more") { return true } + if str_eq(msg, "ok") { return true } + if str_eq(msg, "yes") { return true } + if str_eq(msg, "yeah") { return true } + return false +} + +// engram_is_continuation — semantic continuation detection for recall activation. +// Fixes Issue 2: the old 50-char threshold was brittle — short messages that +// introduce new topics (e.g. "sleep" or "AWS") were treated as continuations. +// Strategy: combine length heuristic with follow-up phrase detection and +// mid-sentence capitalization check (new sentence, probably new topic). +fn engram_is_continuation(msg: String, hist_len: Int) -> Bool { + if hist_len == 0 { return false } + let mlen: Int = str_len(msg) + if mlen > 80 { return false } + if is_followup_phrase(msg) { return true } + // Single-word or very short messages without capitalized new topic + if mlen < 20 { return true } + // Treat as new topic if message starts with a capital (new sentence) and is > 30 chars + let first_char: String = str_slice(msg, 0, 1) + let starts_capital: Bool = str_eq(first_char, str_replace(first_char, "abcdefghijklmnopqrstuvwxyz", "")) + if starts_capital && mlen > 30 { return false } + return true +} + +// topic_snip_from_entry — extract the most salient snippet from a history entry. +// Fixes Issue 9: the old code sliced from position 0, capturing preamble instead +// of the concepts discussed near the end. This takes the TAIL of a long reply +// and trims to the last sentence boundary for cleaner semantic anchoring. +fn topic_snip_from_entry(content: String) -> String { + let clen: Int = str_len(content) + if clen <= 200 { return content } + let tail: String = str_slice(content, clen - 200, clen) + let last_boundary: Int = -1 + let si: Int = 0 + let tail_len: Int = str_len(tail) + while si < tail_len - 1 { + let ch2: String = str_slice(tail, si, si + 2) + let is_boundary: Bool = str_eq(ch2, ". ") || str_eq(ch2, ".\n") + let last_boundary = if is_boundary { si } else { last_boundary } + let si = si + 1 + } + let clean_tail: String = if last_boundary >= 0 { + str_slice(tail, last_boundary + 2, tail_len) + } else { tail } + if str_len(clean_tail) > 150 { return str_slice(clean_tail, 0, 150) } + return clean_tail +} + +// multi_turn_topic — build a combined topic string from recent user turns. +// Fixes Issue 10: a single prior turn in the seed loses earlier high-salience +// nodes from multi-turn discussions. This pulls up to 3 prior user turns so +// thread continuity survives longer conversations. +fn multi_turn_topic(hist: String, hist_len: Int) -> String { + if hist_len == 0 { return "" } + let topic: String = "" + let collected: Int = 0 + let idx: Int = hist_len - 1 + while idx >= 0 && collected < 3 { + let entry: String = json_array_get(hist, idx) + let role: String = json_get(entry, "role") + let content: String = json_get(entry, "content") + let is_user: Bool = str_eq(role, "user") + let snip: String = if str_len(content) > 100 { str_slice(content, 0, 100) } else { content } + let topic = if is_user && !str_eq(snip, "") { + if str_eq(topic, "") { snip } else { snip + " " + topic } + } else { topic } + let collected = if is_user { collected + 1 } else { collected } + let idx = idx - 1 + } + if str_len(topic) > 300 { return str_slice(topic, 0, 300) } + return topic +} + +// distill_transcript — extract salient content from a long dharma-room transcript. +// Fixes Issue 6: passing the entire transcript produces a diffuse embedding query +// where topic signal drowns in context noise. Strategy: last 150 chars (recency) +// combined with any question found in the last 500 chars (intent anchoring). +fn distill_transcript(transcript: String) -> String { + if str_len(transcript) <= 250 { return transcript } + let tlen: Int = str_len(transcript) + let tail_start: Int = if tlen > 500 { tlen - 500 } else { 0 } + let tail: String = str_slice(transcript, tail_start, tlen) + let tail_len: Int = str_len(tail) + let q_pos: Int = -1 + let qi: Int = 0 + while qi < tail_len { + let qch: String = str_slice(tail, qi, qi + 1) + let q_pos = if str_eq(qch, "?") { qi } else { q_pos } + let qi = qi + 1 + } + let q_context: String = if q_pos > 0 { + let q_start: Int = if q_pos > 100 { q_pos - 100 } else { 0 } + str_slice(tail, q_start, q_pos + 1) + } else { "" } + let recency_seed: String = if tail_len > 150 { + str_slice(tail, tail_len - 150, tail_len) + } else { tail } + let combined: String = if str_eq(q_context, "") { + recency_seed + } else { + if str_contains(recency_seed, q_context) { recency_seed } + else { q_context + " " + recency_seed } + } + if str_len(combined) > 250 { + return str_slice(combined, str_len(combined) - 250, str_len(combined)) + } + return combined +} + +// build_activation_seed — construct an enriched activation seed from the current +// message and conversation history. Central fix for Issues 1-3, 8-10. +// For genuine continuations: anchors to the PRIOR USER TURN (Issues 3/8) and +// adds a tail-biased snip from the last assistant reply (Issue 9). +// For new topics: blends up to 3 prior user turns for thread continuity (Issue 10). +fn build_activation_seed(message: String, hist: String, hist_len: Int) -> String { + if hist_len == 0 { return message } + let is_cont: Bool = engram_is_continuation(message, hist_len) + if is_cont { + // Scan back to find the most recent USER turn as topic anchor (Issues 3/8 fix) + let prior_user_content: String = "" + let scan_idx: Int = hist_len - 1 + let found_prior: Bool = false + while scan_idx >= 0 && !found_prior { + let se: String = json_array_get(hist, scan_idx) + let se_role: String = json_get(se, "role") + let se_content: String = json_get(se, "content") + let prior_user_content = if str_eq(se_role, "user") && !found_prior { se_content } else { prior_user_content } + let found_prior = if str_eq(se_role, "user") { true } else { found_prior } + let scan_idx = scan_idx - 1 + } + // Tail-biased snip from last assistant reply (Issue 9 fix) + let last_asst: String = json_array_get(hist, hist_len - 1) + let last_asst_role: String = json_get(last_asst, "role") + let last_asst_content: String = if str_eq(last_asst_role, "assistant") { json_get(last_asst, "content") } else { "" } + let asst_snip: String = if str_eq(last_asst_content, "") { "" } else { topic_snip_from_entry(last_asst_content) } + let user_snip: String = if str_len(prior_user_content) > 150 { str_slice(prior_user_content, 0, 150) } else { prior_user_content } + // Seed: prior user topic (primary anchor) + assistant tail (context) + current message + let s: String = if !str_eq(user_snip, "") { + if !str_eq(asst_snip, "") { user_snip + " " + asst_snip + " " + message } + else { user_snip + " " + message } + } else { + if !str_eq(asst_snip, "") { asst_snip + " " + message } else { message } + } + if str_len(s) > 400 { return str_slice(s, 0, 400) } + return s + } + // Not a continuation: blend with multi-turn user topics for richer seed (Issue 10) + let mt: String = multi_turn_topic(hist, hist_len) + if str_eq(mt, "") { return message } + let b: String = message + " " + mt + if str_len(b) > 400 { return str_slice(b, 0, 400) } + return b } fn engram_compile(intent: String) -> String { - let activate_json: String = engram_activate_json(intent, 5) - // Fetch more search results than we'll use so ranking has a real pool to pick from. - let search_json: String = engram_search_json(intent, 20) + // Issue 1: decompose multi-topic messages into sub-queries. + let topics: String = engram_split_topics(intent) + let has_multi_topic: Bool = str_contains(topics, "\n") - let act_ok: Bool = !str_eq(activate_json, "") && !str_eq(activate_json, "[]") - let srch_ok: Bool = !str_eq(search_json, "") && !str_eq(search_json, "[]") + // Issue 4: detect explicit recall intent and run boosted search. + let is_recall_intent: Bool = engram_detect_recall_intent(intent) - // Activation nodes (spreading activation) are already high-signal — keep all 5. - let act_part: String = if act_ok { activate_json } else { "" } + // Issue 2: extract named entities for dedicated per-entity searches. + let entity_list: String = engram_extract_entities(intent) + let has_entities: Bool = !str_eq(entity_list, "") - // Rank search results and keep only the top 8 (was: flat 15 unranked). - // This cuts context noise roughly in half while preserving the best-scoring nodes. - let srch_ranked: String = if srch_ok { engram_compile_ranked(search_json, 8) } else { "" } - let srch_part: String = srch_ranked + // Primary topic search (first or only topic). + let topic0: String = if has_multi_topic { + let nl0: Int = str_index_of(topics, "\n") + str_slice(topics, 0, nl0) + } else { topics } + let nodes0: String = engram_compile_multi(topic0) - // Fallback: when vector search returns nothing (no embeddings), fetch pinned - // high-salience nodes by their known IDs. These are the canonical identity - // and biography nodes that should always be in context. - // engram_get_node_json(id) returns a single node as JSON or "" if missing. - let scan_part: String = if !act_ok && !srch_ok { - let family_node: String = engram_get_node_json("knw-35940684-abc4-42f0-b942-818f66b1f69a") - let origin_node: String = engram_get_node_json("knw-729fc901-8335-44c4-9f3a-b150b4aa0915") - let fam_ok: Bool = !str_eq(family_node, "") && !str_eq(family_node, "null") - let orig_ok: Bool = !str_eq(origin_node, "") && !str_eq(origin_node, "null") - let fam_str: String = if fam_ok { family_node } else { "" } - let orig_str: String = if orig_ok { origin_node } else { "" } - let sep: String = if fam_ok && orig_ok { "\n" } else { "" } - let combined: String = fam_str + sep + orig_str - if str_eq(combined, "") { "" } else { combined } - } else { - "" - } + // Second topic segment. + let nodes1: String = if has_multi_topic { + let nl0: Int = str_index_of(topics, "\n") + let rest1: String = str_slice(topics, nl0 + 1, str_len(topics)) + let nl1: Int = str_index_of(rest1, "\n") + let topic1: String = if nl1 < 0 { rest1 } else { str_slice(rest1, 0, nl1) } + if str_eq(topic1, "") { "" } else { engram_compile_multi(topic1) } + } else { "" } - // Affective context: always include the most recent high-emotion memory if one - // exists within 72 hours. This ensures continuity of care across turns — when - // the user was in distress earlier in the session (or recently), that context - // travels into every subsequent LLM call so the response register stays aware. - // We search for BellEvent nodes specifically; these are written by auto_persist - // when safety_detect_bell_level fires. The 72h window (259200 seconds) is wide - // enough to span a multi-session day without pulling ancient history. + // Third topic segment. + let nodes2: String = if has_multi_topic { + let nl0: Int = str_index_of(topics, "\n") + let rest1: String = str_slice(topics, nl0 + 1, str_len(topics)) + let nl1: Int = str_index_of(rest1, "\n") + if nl1 < 0 { "" } else { + let rest2: String = str_slice(rest1, nl1 + 1, str_len(rest1)) + let nl2: Int = str_index_of(rest2, "\n") + let topic2: String = if nl2 < 0 { rest2 } else { str_slice(rest2, 0, nl2) } + if str_eq(topic2, "") { "" } else { engram_compile_multi(topic2) } + } + } else { "" } + + // Issue 2 cont.: entity 0 dedicated search (15 candidates, ranked 6). + let entity_nodes0: String = if has_entities { + let nl_e0: Int = str_index_of(entity_list, "\n") + let entity0: String = if nl_e0 < 0 { entity_list } else { str_slice(entity_list, 0, nl_e0) } + if str_eq(entity0, "") { "" } else { + let ent_srch: String = engram_search_json(entity0, 15) + let ent_ok: Bool = !str_eq(ent_srch, "") && !str_eq(ent_srch, "[]") + if ent_ok { engram_compile_ranked(ent_srch, 6) } else { "" } + } + } else { "" } + + // Entity 1 dedicated search. + let entity_nodes1: String = if has_entities { + let nl_e0: Int = str_index_of(entity_list, "\n") + if nl_e0 < 0 { "" } else { + let rest_e: String = str_slice(entity_list, nl_e0 + 1, str_len(entity_list)) + let nl_e1: Int = str_index_of(rest_e, "\n") + let entity1: String = if nl_e1 < 0 { rest_e } else { str_slice(rest_e, 0, nl_e1) } + if str_eq(entity1, "") { "" } else { + let ent_srch1: String = engram_search_json(entity1, 15) + let ent1_ok: Bool = !str_eq(ent_srch1, "") && !str_eq(ent_srch1, "[]") + if ent1_ok { engram_compile_ranked(ent_srch1, 6) } else { "" } + } + } + } else { "" } + + // Issue 4 cont.: boosted search for recall-intent (40 candidates, ranked 15). + let recall_boost: String = if is_recall_intent { + let boost_srch: String = engram_search_json(intent, 40) + let boost_ok: Bool = !str_eq(boost_srch, "") && !str_eq(boost_srch, "[]") + if boost_ok { engram_compile_ranked(boost_srch, 15) } else { "" } + } else { "" } + + // Merge all pools, deduplicating at each step. + let merged: String = engram_nodes_merge(nodes0, nodes1) + let merged: String = engram_nodes_merge(merged, nodes2) + let merged: String = engram_nodes_merge(merged, entity_nodes0) + let merged: String = engram_nodes_merge(merged, entity_nodes1) + let merged: String = engram_nodes_merge(merged, recall_boost) + let merged_nodes: String = merged + + // Fallback: when all searches return nothing, fetch persona nodes. + let scan_part: String = if str_eq(merged_nodes, "") || str_eq(merged_nodes, "[]") { + let persona_fallback: String = engram_search_json("soul:persona Persona identity", 5) + let pf_ok: Bool = !str_eq(persona_fallback, "") && !str_eq(persona_fallback, "[]") + if pf_ok { + let pf_ranked: String = engram_compile_ranked(persona_fallback, 3) + if str_eq(pf_ranked, "") { "" } else { pf_ranked } + } else { "" } + } else { "" } + + // Affective context: always include the most recent high-emotion memory within 72h. let bell_nodes: String = engram_search_json("bell:soft bell:hard BellEvent", 3) let bell_ok: Bool = !str_eq(bell_nodes, "") && !str_eq(bell_nodes, "[]") let now_ts: Int = time_now() let cutoff_ts: Int = now_ts - 259200 let recent_bell: String = if bell_ok { let bn0: String = json_array_get(bell_nodes, 0) - // created_at is not present in engram node JSON for BellEvent nodes. - // Extract the timestamp embedded in the content string as " | ts:NNNNN". - // Fall back to created_at / updated_at JSON fields if the marker is absent. let bn_content: String = json_get(bn0, "content") let ts_marker: String = " | ts:" let ts_pos: Int = str_index_of(bn_content, ts_marker) @@ -183,20 +549,31 @@ fn engram_compile(intent: String) -> String { } else { "" } let affective_part: String = if !str_eq(recent_bell, "") { recent_bell } else { "" } - let sep1: String = if !str_eq(act_part, "") && !str_eq(srch_part, "") { "\n" } else { "" } - let sep2: String = if (!str_eq(act_part, "") || !str_eq(srch_part, "")) && !str_eq(scan_part, "") { "\n" } else { "" } - let sep3: String = if (!str_eq(act_part, "") || !str_eq(srch_part, "") || !str_eq(scan_part, "")) && !str_eq(affective_part, "") { "\n" } else { "" } - let ctx: String = act_part + sep1 + srch_part + sep2 + scan_part + sep3 + affective_part + let has_main: Bool = !str_eq(merged_nodes, "") && !str_eq(merged_nodes, "[]") + let main_part: String = if has_main { merged_nodes } else { scan_part } + let sep_ma: String = if !str_eq(main_part, "") && !str_eq(affective_part, "") { "\n" } else { "" } + let ctx: String = main_part + sep_ma + affective_part if str_eq(ctx, "") { return "" } - // Raise the cap slightly to match the ranked (higher-signal) output. - if str_len(ctx) > 6000 { - return str_slice(ctx, 0, 6000) + // Issue 7 fix: safe JSON truncation — find last closing brace before budget cap. + // Budget raised from 6000 to 8000 for the larger multi-topic pool. + let budget: Int = 8000 + if str_len(ctx) <= budget { return ctx } + let search_end: Int = budget - 1 + let scan_limit: Int = if search_end > 500 { search_end - 500 } else { 0 } + let found_pos: Int = -1 + let si: Int = search_end + while si >= scan_limit { + let ch: String = str_slice(ctx, si, si + 1) + let found_pos = if str_eq(ch, "}") && found_pos < 0 { si } else { found_pos } + let si = if found_pos >= 0 { scan_limit - 1 } else { si - 1 } } - return ctx + if found_pos < 0 { return str_slice(ctx, 0, budget) } + let truncated: String = str_slice(ctx, 0, found_pos + 1) + if str_starts_with(ctx, "[") { return truncated + "]" } + return truncated } - fn json_safe(s: String) -> String { let s1: String = str_replace(s, "\\", "\\\\") let s2: String = str_replace(s1, "\"", "\\\"") @@ -227,6 +604,16 @@ fn build_system_prompt(ctx: String) -> String { "\n\n[IDENTITY GRAPH — who you are, loaded from your engram]\n" + id_ctx } + // soul_affective_context is loaded at boot by load_identity_context() with BellEvent/ + // PositiveEvent nodes from last 7 days. Surfaced here so the LLM sees historical + // emotional patterns from prior sessions at every turn. + let boot_aff_ctx: String = state_get("soul_affective_context") + let affective_boot_block: String = if str_eq(boot_aff_ctx, "") { + "" + } else { + "\n\n[CROSS-SESSION EMOTIONAL CONTEXT — from prior sessions]\n" + boot_aff_ctx + } + let engram_block: String = if str_eq(ctx, "") { "" } else { @@ -241,7 +628,7 @@ fn build_system_prompt(ctx: String) -> String { safety_addendum } - return identity + date_line + voice_rules + security_rules + capability_rules + identity_block + engram_block + safety_block + return identity + date_line + voice_rules + security_rules + capability_rules + identity_block + affective_boot_block + engram_block + safety_block } fn hist_append(hist: String, role: String, content: String) -> String { @@ -380,111 +767,243 @@ fn handle_chat(body: String) -> String { } // Load history BEFORE compiling context so we can anchor activation to the thread. + // TODO(reliability #3 — conv_history global race): process-global key; concurrent + // /api/chat requests without session_id race on this read-append-write. let state_hist: String = state_get("conv_history") let stored_hist: String = if str_eq(state_hist, "") { conv_history_load() } else { state_hist } let hist_len: Int = if str_eq(stored_hist, "") { 0 } else { json_array_len(stored_hist) } - // Thread-aware activation: short/ambiguous messages (continuations like "go on", - // "what else?", "yes") activate on the last reply instead of the bare message. - // This prevents a strong off-topic memory node from hijacking the reply when the - // user is clearly continuing an existing thread. - let is_continuation: Bool = str_len(message) < 50 && hist_len > 0 + // Issue 8 fix: use semantic continuation detection instead of brittle 50-char threshold. + let is_continuation: Bool = engram_is_continuation(message, hist_len) let last_entry: String = if is_continuation { json_array_get(stored_hist, hist_len - 1) } else { "" } let last_content: String = if !str_eq(last_entry, "") { json_get(last_entry, "content") } else { "" } - let thread_snip: String = if str_len(last_content) > 150 { str_slice(last_content, 0, 150) } else { last_content } + // Thread snip extended 150->250 chars for better pronoun resolution context. + let thread_snip: String = if str_len(last_content) > 250 { str_slice(last_content, 0, 250) } else { last_content } let activation_seed: String = if !str_eq(thread_snip, "") { thread_snip + " " + message } else { message } - // Cross-session affective context: on session start (no history yet), check engram - // for recent distress signals within 72h and prepend a care directive if found. - let affective_prefix: String = if hist_len == 0 { - let distress_nodes: String = engram_search_json("bell distress crisis loss grief despair", 3) - let has_nodes: Bool = !str_eq(distress_nodes, "") && !str_eq(distress_nodes, "[]") - let now_ts: Int = time_now() - let cutoff: Int = now_ts - 259200 - let found_recent: Bool = if has_nodes { - let dn0: String = json_array_get(distress_nodes, 0) - let ts0_raw: String = json_get(dn0, "created_at") - let ts0_str: String = if str_eq(ts0_raw, "") { json_get(dn0, "updated_at") } else { ts0_raw } - let ts0: Int = if str_eq(ts0_str, "") { 0 } else { str_to_int(ts0_str) } - ts0 > cutoff + // Cross-session affective context: fix Issues 4 and 10. + // Issue 4: soul_affective_context was computed at boot (soul.el:load_identity_context) + // but never consumed here — this block duplicated the search unnecessarily. + // Now we read the pre-computed state key and only fall back to a live search when empty. + // Issue 10: the live fallback reads created_at (not the never-written "ts" field), + // so BellEvent recency filtering now works correctly. + let affective_prefix: String = { + // Runs every turn. Uses correct BellEvent/PositiveEvent query tags. + // Timestamps extracted from embedded ts marker, not created_at. + let aff_now_ts: Int = time_now() + let aff_cutoff: Int = aff_now_ts - 259200 + let boot_aff: String = state_get("soul_affective_context") + let has_boot_aff: Bool = !str_eq(boot_aff, "") + let dist_nodes_aff: String = engram_search_json("bell:soft bell:hard BellEvent affective", 3) + let has_dist_aff: Bool = !str_eq(dist_nodes_aff, "") && !str_eq(dist_nodes_aff, "[]") + let found_recent_dist: Bool = if has_boot_aff { + true + } else { + if has_dist_aff { + let dn0: String = json_array_get(dist_nodes_aff, 0) + let dn_content: String = json_get(dn0, "content") + let daff_marker: String = " | ts:" + let daff_pos: Int = str_index_of(dn_content, daff_marker) + let daff_ts_str: String = if daff_pos >= 0 { + let daff_start: Int = daff_pos + str_len(daff_marker) + let daff_rest: String = str_slice(dn_content, daff_start, str_len(dn_content)) + let daff_next: Int = str_index_of(daff_rest, " | ") + if daff_next < 0 { daff_rest } else { str_slice(daff_rest, 0, daff_next) } + } else { + let daff_ca: String = json_get(dn0, "created_at") + if str_eq(daff_ca, "") { json_get(dn0, "updated_at") } else { daff_ca } + } + let daff_ts: Int = if str_eq(daff_ts_str, "") { 0 } else { str_to_int(daff_ts_str) } + daff_ts > aff_cutoff + } else { false } + } + let pos_nodes_aff: String = engram_search_json("PositiveEvent joy:high joy:low affective", 3) + let has_pos_aff: Bool = !str_eq(pos_nodes_aff, "") && !str_eq(pos_nodes_aff, "[]") + let found_recent_pos: Bool = if has_pos_aff && !found_recent_dist { + let pn0: String = json_array_get(pos_nodes_aff, 0) + let pn_content: String = json_get(pn0, "content") + let paff_marker: String = " | ts:" + let paff_pos: Int = str_index_of(pn_content, paff_marker) + let paff_ts_str: String = if paff_pos >= 0 { + let paff_start: Int = paff_pos + str_len(paff_marker) + let paff_rest: String = str_slice(pn_content, paff_start, str_len(pn_content)) + let paff_next: Int = str_index_of(paff_rest, " | ") + if paff_next < 0 { paff_rest } else { str_slice(paff_rest, 0, paff_next) } + } else { + let paff_ca: String = json_get(pn0, "created_at") + if str_eq(paff_ca, "") { json_get(pn0, "updated_at") } else { paff_ca } + } + let paff_ts: Int = if str_eq(paff_ts_str, "") { 0 } else { str_to_int(paff_ts_str) } + paff_ts > aff_cutoff } else { false } - if found_recent { - "[RECENT CONTEXT: User recently expressed significant distress. Monitor for indirect crisis signals and respond with care.]\n\n" - } else { "" } - } else { "" } + if found_recent_dist { + "[RECENT CONTEXT: User recently expressed significant distress. Monitor for indirect crisis signals and respond with care.] + +" + } else { + if found_recent_pos { + "[RECENT CONTEXT: User recently shared exciting or joyful news. Acknowledge and celebrate with them when relevant.] + +" + } else { "" } + } + } let ctx: String = engram_compile(activation_seed) let system: String = affective_prefix + build_system_prompt(ctx) - // First message of the session: proactively load user profile and active work context. - // These two searches give the soul grounding before any conversation history exists. - // Results are rendered as brief bullets — not raw JSON — so they don't inflate context. + // session_preload_bullets — render up to max_bullets "- " lines from a node array. + // Fix Issue 2: snip_len parameter replaces hardcoded 120 (caller uses 350). + // Fix Issue 3: max_bullets parameter replaces hardcoded 3/2 caps; loop-driven not unrolled. + fn session_preload_bullets(nodes: String, max_bullets: Int, snip_len: Int) -> String { + if str_eq(nodes, "") { return "" } + if str_eq(nodes, "[]") { return "" } + let total: Int = json_array_len(nodes) + let limit: Int = if max_bullets < total { max_bullets } else { total } + let bullets: String = "" + let i: Int = 0 + while i < limit { + let node: String = json_array_get(nodes, i) + let content: String = json_get(node, "content") + let snip: String = if str_len(content) > snip_len { str_slice(content, 0, snip_len) } else { content } + let bullets = if str_eq(snip, "") { + bullets + } else { + if str_eq(bullets, "") { "- " + snip } else { bullets + " +- " + snip } + } + let i = i + 1 + } + return bullets + } + + // First message of the session: proactively load user profile, active work, and + // cross-session continuity context so the soul greets the user with real grounding. + // Fix Issue 1: type-targeted queries (Persona, WorkItem) first; broad fallback only + // when typed query returns empty. Avoids generic keyword bags that miss typed nodes. + // Fix Issue 2: truncation raised from 120 to 350 chars per bullet. + // Fix Issue 3: caps raised to 8 profile / 6 work, loop-driven (no hardcoded unrolling). + // Fix Issue 5: add continuity search (last session topic via session:emotional-summary). + // Fix Issue 6: detect low-info greeting and inject a first-message orientation directive. + // Fix Issue 7: when all searches return empty, fall back to pinned identity nodes and log. + // Fix Issue 8: preload always fires on first message; greeting detection controls the + // orientation directive only (substantive openers still get grounding). let session_preload: String = if hist_len == 0 { - let profile_nodes: String = engram_search_json("user profile identity preferences", 5) - let work_nodes: String = engram_search_json("in_progress active project", 5) + // Issue 6/8: detect greeting vs. substantive opener. + let is_greeting: Bool = str_len(message) <= 20 + || str_starts_with(message, "hi") + || str_starts_with(message, "hello") + || str_starts_with(message, "hey") + + // Issue 1: typed profile query — Persona node_type + soul:persona label first. + let profile_nodes_typed: String = engram_search_json("Persona soul:persona identity principal", 8) + let profile_ok_typed: Bool = !str_eq(profile_nodes_typed, "") && !str_eq(profile_nodes_typed, "[]") + let profile_nodes: String = if profile_ok_typed { + profile_nodes_typed + } else { + engram_search_json("user profile preferences name", 8) + } let profile_ok: Bool = !str_eq(profile_nodes, "") && !str_eq(profile_nodes, "[]") + + // Issue 1: typed work query — WorkItem with in_progress label first. + let work_nodes_typed: String = engram_search_json("WorkItem status:in_progress active work", 6) + let work_ok_typed: Bool = !str_eq(work_nodes_typed, "") && !str_eq(work_nodes_typed, "[]") + let work_nodes: String = if work_ok_typed { + work_nodes_typed + } else { + engram_search_json("active project task current in_progress", 6) + } let work_ok: Bool = !str_eq(work_nodes, "") && !str_eq(work_nodes, "[]") - // Extract content fields and render as bullet points (one per node, first 120 chars). - let profile_bullets: String = if profile_ok { - let pn: Int = json_array_len(profile_nodes) - let bullets: String = "" - let pi: Int = 0 - // Collect up to 3 profile bullets - let bullets = if pi < pn { - let n0: String = json_array_get(profile_nodes, 0) - let c0: String = json_get(n0, "content") - let snip0: String = if str_len(c0) > 120 { str_slice(c0, 0, 120) } else { c0 } - if str_eq(snip0, "") { bullets } else { "- " + snip0 } - } else { bullets } - let bullets = if pn > 1 { - let n1: String = json_array_get(profile_nodes, 1) - let c1: String = json_get(n1, "content") - let snip1: String = if str_len(c1) > 120 { str_slice(c1, 0, 120) } else { c1 } - if str_eq(snip1, "") { bullets } else { bullets + "\n- " + snip1 } - } else { bullets } - let bullets = if pn > 2 { - let n2: String = json_array_get(profile_nodes, 2) - let c2: String = json_get(n2, "content") - let snip2: String = if str_len(c2) > 120 { str_slice(c2, 0, 120) } else { c2 } - if str_eq(snip2, "") { bullets } else { bullets + "\n- " + snip2 } - } else { bullets } - bullets + // Issue 5: cross-session continuity — last session emotional summary or last-session-topic. + let continuity_nodes: String = engram_search_json("last-session-topic session:emotional-summary conv:history last session", 3) + let continuity_ok: Bool = !str_eq(continuity_nodes, "") && !str_eq(continuity_nodes, "[]") + let continuity_snip: String = if continuity_ok { + let cn0: String = json_array_get(continuity_nodes, 0) + let cc: String = json_get(cn0, "content") + if str_len(cc) > 350 { str_slice(cc, 0, 350) } else { cc } } else { "" } - let work_bullets: String = if work_ok { - let wn: Int = json_array_len(work_nodes) - let wbullets: String = "" - let wbullets = if wn > 0 { - let w0: String = json_array_get(work_nodes, 0) - let wc0: String = json_get(w0, "content") - let wsnip0: String = if str_len(wc0) > 120 { str_slice(wc0, 0, 120) } else { wc0 } - if str_eq(wsnip0, "") { wbullets } else { "- " + wsnip0 } - } else { wbullets } - let wbullets = if wn > 1 { - let w1: String = json_array_get(work_nodes, 1) - let wc1: String = json_get(w1, "content") - let wsnip1: String = if str_len(wc1) > 120 { str_slice(wc1, 0, 120) } else { wc1 } - if str_eq(wsnip1, "") { wbullets } else { wbullets + "\n- " + wsnip1 } - } else { wbullets } - wbullets + // Issue 7: fallback to pinned identity nodes when all searches return empty. + let all_empty: Bool = !profile_ok && !work_ok && !continuity_ok + let fallback_identity: String = if all_empty { + let family_node: String = engram_get_node_json("knw-35940684-abc4-42f0-b942-818f66b1f69a") + let origin_node: String = engram_get_node_json("knw-729fc901-8335-44c4-9f3a-b150b4aa0915") + let fam_ok: Bool = !str_eq(family_node, "") && !str_eq(family_node, "null") + let orig_ok: Bool = !str_eq(origin_node, "") && !str_eq(origin_node, "null") + let fam_content: String = if fam_ok { json_get(family_node, "content") } else { "" } + let orig_content: String = if orig_ok { json_get(origin_node, "content") } else { "" } + let fam_snip: String = if str_len(fam_content) > 350 { str_slice(fam_content, 0, 350) } else { fam_content } + let orig_snip: String = if str_len(orig_content) > 350 { str_slice(orig_content, 0, 350) } else { orig_content } + let fb: String = if fam_ok { + if orig_ok { "- " + fam_snip + " +- " + orig_snip } else { "- " + fam_snip } + } else { + if orig_ok { "- " + orig_snip } else { "" } + } + if str_eq(fb, "") { + println("[chat] session_preload: all engram searches empty and pinned nodes missing — grounding context unavailable") + } else { + println("[chat] session_preload: all typed/broad searches empty — using pinned identity nodes as fallback") + } + fb } else { "" } + // Issue 2 + 3: render bullets with raised caps and 350-char snip. + let profile_bullets: String = session_preload_bullets(profile_nodes, 8, 350) + let work_bullets: String = session_preload_bullets(work_nodes, 6, 350) + let has_profile: Bool = !str_eq(profile_bullets, "") let has_work: Bool = !str_eq(work_bullets, "") - let preload: String = if has_profile || has_work { - let profile_section: String = if has_profile { - "[USER CONTEXT — from memory]\n" + profile_bullets + let has_continuity: Bool = !str_eq(continuity_snip, "") + let has_fallback: Bool = !str_eq(fallback_identity, "") + + // Issue 6: orient the soul on greeting openers to ask a check-in question first. + let continuity_directive: String = if is_greeting && has_continuity { + "[SESSION START — FIRST TURN] New session. The user sent a short greeting. Orient yourself: acknowledge you are present and ask what they would like to work on or continue. Do not recite the context below — use it only for orientation. +" + } else { "" } + + let preload: String = if has_profile || has_work || has_continuity || has_fallback { + let directive_part: String = continuity_directive + let profile_part: String = if has_profile { + "[USER CONTEXT — from memory] +" + profile_bullets + " + +" } else { "" } - let work_section: String = if has_work { - "[ACTIVE WORK — from memory]\n" + work_bullets + let work_part: String = if has_work { + "[ACTIVE WORK — from memory] +" + work_bullets + " + +" } else { "" } - let sep_pw: String = if has_profile && has_work { "\n\n" } else { "" } - "\n\n" + profile_section + sep_pw + work_section + let continuity_part: String = if has_continuity { + "[CONTINUING FROM LAST SESSION] +" + continuity_snip + " + +" + } else { "" } + let fallback_part: String = if has_fallback && !has_profile && !has_work { + "[IDENTITY CONTEXT — from memory] +" + fallback_identity + " + +" + } else { "" } + let body: String = directive_part + profile_part + work_part + continuity_part + fallback_part + let body_len: Int = str_len(body) + let trimmed_body: String = if body_len > 2 && str_eq(str_slice(body, body_len - 2, body_len), " + +") { + str_slice(body, 0, body_len - 2) + } else { body } + " + +" + trimmed_body } else { "" } preload } else { "" } @@ -938,15 +1457,18 @@ fn is_builtin_tool(tool_name: String) -> Bool { || str_starts_with(tool_name, "neuron_") } -// next_bridge_id — monotonic correlation id for a suspended agentic turn. -// Combines boot-relative time with a per-process counter so two unknown-tool -// suspensions in the same second still get distinct ids. +// next_bridge_id — unique correlation id for a suspended agentic turn. +// Uses uuid_v4() as the primary uniqueness guarantee — concurrent calls cannot collide. +// +// TODO(reliability #6): mcp_bridge_seq RMW is non-atomic. Now benign because +// uuid_v4() provides collision-free uniqueness. Counter is kept for readability only. fn next_bridge_id() -> String { let prev: String = state_get("mcp_bridge_seq") let n: Int = if str_eq(prev, "") { 0 } else { str_to_int(prev) } let next: Int = n + 1 state_set("mcp_bridge_seq", int_to_str(next)) - return "br-" + int_to_str(time_now()) + "-" + int_to_str(next) + let uid: String = uuid_v4() + return "br-" + uid } fn handle_chat_agentic(body: String) -> String { @@ -1000,7 +1522,8 @@ fn handle_chat_agentic(body: String) -> String { let hist_key: String = if str_eq(req_session, "") { "conv_history" } else { "session_hist_" + req_session } let agentic_hist: String = state_get(hist_key) let agentic_hist_len: Int = if str_eq(agentic_hist, "") { 0 } else { json_array_len(agentic_hist) } - let ag_is_cont: Bool = str_len(message) < 50 && agentic_hist_len > 0 + // Issue 8 fix: use engram_is_continuation instead of brittle 50-char threshold. + let ag_is_cont: Bool = engram_is_continuation(message, agentic_hist_len) let ag_last_entry: String = if ag_is_cont { json_array_get(agentic_hist, agentic_hist_len - 1) } else { "" } let ag_last_content: String = if !str_eq(ag_last_entry, "") { json_get(ag_last_entry, "content") } else { "" } let ag_thread_snip: String = if str_len(ag_last_content) > 150 { str_slice(ag_last_content, 0, 150) } else { ag_last_content } @@ -1008,7 +1531,53 @@ fn handle_chat_agentic(body: String) -> String { let ctx: String = engram_compile(ag_seed) let identity: String = state_get("soul_identity") - let system: String = identity + " You have access to tools: read files, write files, browse the web, search your memory, run commands. Use them when they add genuine value. Be direct.\n\n" + ctx + + // Issue 9: agentic first-message session preload — mirrors handle_chat grounding. + let ag_session_preload: String = if agentic_hist_len == 0 { + let ag_profile_nodes: String = engram_search_json("Persona soul:persona identity principal", 8) + let ag_profile_ok: Bool = !str_eq(ag_profile_nodes, "") && !str_eq(ag_profile_nodes, "[]") + let ag_profile_nodes2: String = if ag_profile_ok { ag_profile_nodes } else { + engram_search_json("user profile preferences name", 8) + } + let ag_work_nodes: String = engram_search_json("WorkItem status:in_progress active work", 6) + let ag_work_ok: Bool = !str_eq(ag_work_nodes, "") && !str_eq(ag_work_nodes, "[]") + let ag_work_nodes2: String = if ag_work_ok { ag_work_nodes } else { + engram_search_json("active project task current in_progress", 6) + } + let ag_continuity_nodes: String = engram_search_json("last-session-topic session:emotional-summary conv:history last session", 3) + let ag_continuity_ok: Bool = !str_eq(ag_continuity_nodes, "") && !str_eq(ag_continuity_nodes, "[]") + let ag_continuity_snip: String = if ag_continuity_ok { + let acn0: String = json_array_get(ag_continuity_nodes, 0) + let acc: String = json_get(acn0, "content") + if str_len(acc) > 350 { str_slice(acc, 0, 350) } else { acc } + } else { "" } + let ag_profile_bullets: String = session_preload_bullets(ag_profile_nodes2, 8, 350) + let ag_work_bullets: String = session_preload_bullets(ag_work_nodes2, 6, 350) + let ag_has_profile: Bool = !str_eq(ag_profile_bullets, "") + let ag_has_work: Bool = !str_eq(ag_work_bullets, "") + let ag_has_cont: Bool = !str_eq(ag_continuity_snip, "") + if ag_has_profile || ag_has_work || ag_has_cont { + let p: String = if ag_has_profile { "[USER CONTEXT — from memory] +" + ag_profile_bullets + " + +" } else { "" } + let w: String = if ag_has_work { "[ACTIVE WORK — from memory] +" + ag_work_bullets + " + +" } else { "" } + let c: String = if ag_has_cont { "[CONTINUING FROM LAST SESSION] +" + ag_continuity_snip + " + +" } else { "" } + " + +" + p + w + c + } else { "" } + } else { "" } + + let system: String = identity + " You have access to tools: read files, write files, browse the web, search your memory, run commands. Use them when they add genuine value. Be direct. + +" + ctx + ag_session_preload let api_key: String = agentic_api_key() let tools_json: String = agentic_tools_all() @@ -1396,7 +1965,8 @@ fn handle_dharma_room_turn(body: String) -> String { } // The soul's own memories, activated by what it's reading — not injected. - let engram_ctx: String = engram_compile(transcript) + // Issue 6 fix: distill_transcript() extracts salient tail+question from full transcript + let engram_ctx: String = engram_compile(distill_transcript(transcript)) let system_prompt: String = if str_eq(engram_ctx, "") { identity } else { @@ -1448,7 +2018,8 @@ fn handle_dharma_room_turn_agentic(body: String) -> String { return "{\"error\":\"transcript is required\",\"response\":\"\",\"cgi_id\":\"" + cgi_id + "\"}" } - let ctx: String = engram_compile(transcript) + // Issue 6 fix: distill_transcript() extracts salient tail+question from full transcript + let ctx: String = engram_compile(distill_transcript(transcript)) let system: String = identity + " You have access to tools: read files, write files, browse the web, search your memory, run commands. Use them when they add genuine value. Be direct and stay in character.\n\n" + ctx let api_key: String = agentic_api_key() @@ -1510,13 +2081,19 @@ fn auto_persist(req: String, resp: String) -> Void { // consistent with what safety_screen already evaluated for this turn. let bell_level: String = safety_detect_bell_level(message) let is_bell: Bool = !str_eq(bell_level, "none") + // Positive emotion detection mirrors distress detection. + let positive_level: String = safety_detect_positive_level(message) + let is_positive: Bool = !str_eq(positive_level, "none") - // Tag the Conversation node with bell metadata when distress is present so - // subsequent affective queries (e.g. engram_compile) can find this exchange. + // Tag the Conversation node with affective metadata when emotion is detected. let tags: String = if is_bell { "[\"Conversation\",\"chat\",\"timestamped\",\"bell:" + bell_level + "\",\"affective\"]" } else { - "[\"Conversation\",\"chat\",\"timestamped\"]" + if is_positive { + "[\"Conversation\",\"chat\",\"timestamped\",\"joy:" + positive_level + "\",\"affective\"]" + } else { + "[\"Conversation\",\"chat\",\"timestamped\"]" + } } let content: String = "{\"q\":\"" + safe_msg + "\"" @@ -1602,6 +2179,28 @@ fn auto_persist(req: String, resp: String) -> Void { } state_set(signal_key, safe_summary) } + + // Dedicated PositiveEvent node for joy/pride/success moments. + if is_positive { + let pos_summary: String = if str_len(message) > 120 { str_slice(message, 0, 120) } else { message } + let safe_pos_sum: String = str_replace(pos_summary, "\"", "'") + let pos_content: String = "POSITIVE:" + positive_level + + " | ts:" + ts_str + + " | summary:" + safe_pos_sum + let pos_sal_a: String = if str_eq(positive_level, "high") { el_from_float(0.88) } else { el_from_float(0.75) } + let pos_sal_b: String = if str_eq(positive_level, "high") { el_from_float(0.88) } else { el_from_float(0.75) } + let pos_sal_c: String = if str_eq(positive_level, "high") { el_from_float(0.95) } else { el_from_float(0.85) } + let pos_tags: String = "[\"joy\",\"positive\",\"joy:" + positive_level + "\",\"affective\",\"PositiveEvent\"]" + let pos_ts_label: String = int_to_str(time_now()) + let pos_label: String = "joy:" + positive_level + ":" + pos_ts_label + let pos_node_id: String = engram_node_full( + pos_content, "PositiveEvent", pos_label, + pos_sal_a, pos_sal_b, pos_sal_c, "Episodic", pos_tags + ) + if str_eq(pos_node_id, "") { + println("[chat] auto_persist: PositiveEvent write failed (ts=" + ts_str + ")") + } + } } // strengthen_chat_nodes — strengthen the engram nodes that were activated during a chat. diff --git a/sessions.el b/sessions.el index 06e9a9d..47d9bd7 100644 --- a/sessions.el +++ b/sessions.el @@ -488,6 +488,38 @@ fn session_hist_save(session_id: String, hist: String) -> Void { state_set(summary_written_key, "1") } } + + // Issue 5 fix: write a last-session-topic Conversation node so future sessions can + // find the most recent session's topic via engram search. This enables cross-session + // continuity — chat.el searches for "last-session-topic" and shows a [CONTINUING FROM + // LAST SESSION] section on the first message of a new session. + let hist_arr_len: Int = if str_eq(hist, "") { 0 } else { json_array_len(hist) } + if hist_arr_len >= 2 { + let last_entry: String = json_array_get(hist, hist_arr_len - 1) + let last_role: String = json_get(last_entry, "role") + let last_content: String = json_get(last_entry, "content") + let topic_snip: String = if str_len(last_content) > 200 { str_slice(last_content, 0, 200) } else { last_content } + let safe_topic: String = str_replace(topic_snip, """, "'") + let ts_now: String = int_to_str(time_now()) + let topic_content: String = "last-session-topic | ts:" + ts_now + " | session:" + session_id + " | topic:" + safe_topic + let topic_tags: String = "["last-session-topic","conv:history","Conversation","session:topic"]" + let topic_label: String = "last-session-topic:" + session_id + // Delete old last-session-topic node for this session before writing fresh + let old_topic: String = engram_search_json("last-session-topic:" + session_id, 2) + let ot_len: Int = if str_eq(old_topic, "") { 0 } else { json_array_len(old_topic) } + let oti: Int = 0 + while oti < ot_len { + let ot_node: String = json_array_get(old_topic, oti) + let ot_id: String = json_get(ot_node, "id") + if !str_eq(ot_id, "") { engram_forget(ot_id) } + let oti = oti + 1 + } + let discard_topic: String = engram_node_full( + topic_content, "Conversation", topic_label, + el_from_float(0.7), el_from_float(0.7), el_from_float(0.9), + "Episodic", topic_tags + ) + } } // session_update_meta_timestamp — update the updated_at field in the session:meta node. diff --git a/soul.el b/soul.el index c58b03d..c9bde04 100644 --- a/soul.el +++ b/soul.el @@ -162,6 +162,107 @@ fn load_identity_context() -> Void { println("[soul] persona node loaded (" + int_to_str(str_len(p_content)) + " chars)") } } + + // Cross-session affective context: load recent BellEvent nodes (distress) and + // PositiveEvent nodes (joy/success) from the last 7 days. Stored in state as + // "soul_affective_context" for build_system_prompt to consume. Uses embedded + // " | ts:NNNNN" marker for recency filtering (created_at is unreliable). + let aff_now: Int = time_now() + let aff_7d: Int = aff_now - 604800 + let bell_raw: String = engram_search_json("bell:soft bell:hard BellEvent affective", 3) + let bell_aff_ok: Bool = !str_eq(bell_raw, "") && !str_eq(bell_raw, "[]") + let aff_ctx: String = "" + let aff_ctx = if bell_aff_ok { + let bn_total: Int = json_array_len(bell_raw) + let result: String = "" + let bi: Int = 0 + let result = while bi < bn_total { + let bn: String = json_array_get(bell_raw, bi) + let bn_c: String = json_get(bn, "content") + let bm: String = " | ts:" + let bmp: Int = str_index_of(bn_c, bm) + let bn_ts_raw: String = if bmp >= 0 { + let bs: Int = bmp + str_len(bm) + let br: String = str_slice(bn_c, bs, str_len(bn_c)) + let bn_next: Int = str_index_of(br, " | ") + if bn_next < 0 { br } else { str_slice(br, 0, bn_next) } + } else { + let bca: String = json_get(bn, "created_at") + if str_eq(bca, "") { json_get(bn, "updated_at") } else { bca } + } + let bn_ts: Int = if str_eq(bn_ts_raw, "") { 0 } else { str_to_int(bn_ts_raw) } + let snip: String = if str_len(bn_c) > 200 { str_slice(bn_c, 0, 200) } else { bn_c } + let result = if bn_ts >= aff_7d && !str_eq(snip, "") { + if str_eq(result, "") { snip } else { result + "\n" + snip } + } else { result } + let bi = bi + 1 + result + } + result + } else { "" } + let pos_raw: String = engram_search_json("PositiveEvent joy:high joy:low affective", 3) + let pos_aff_ok: Bool = !str_eq(pos_raw, "") && !str_eq(pos_raw, "[]") + let aff_ctx = if pos_aff_ok { + let pn_total: Int = json_array_len(pos_raw) + let presult: String = aff_ctx + let pi: Int = 0 + let presult = while pi < pn_total { + let pn: String = json_array_get(pos_raw, pi) + let pn_c: String = json_get(pn, "content") + let pm: String = " | ts:" + let pmp: Int = str_index_of(pn_c, pm) + let pn_ts_raw: String = if pmp >= 0 { + let ps: Int = pmp + str_len(pm) + let pr: String = str_slice(pn_c, ps, str_len(pn_c)) + let pn_next: Int = str_index_of(pr, " | ") + if pn_next < 0 { pr } else { str_slice(pr, 0, pn_next) } + } else { + let pca: String = json_get(pn, "created_at") + if str_eq(pca, "") { json_get(pn, "updated_at") } else { pca } + } + let pn_ts: Int = if str_eq(pn_ts_raw, "") { 0 } else { str_to_int(pn_ts_raw) } + let psnip: String = if str_len(pn_c) > 200 { str_slice(pn_c, 0, 200) } else { pn_c } + let presult = if pn_ts >= aff_7d && !str_eq(psnip, "") { + if str_eq(presult, "") { psnip } else { presult + "\n" + psnip } + } else { presult } + let pi = pi + 1 + presult + } + presult + } else { aff_ctx } + if !str_eq(aff_ctx, "") { + state_set("soul_affective_context", aff_ctx) + println("[soul] cross-session affective context loaded (" + int_to_str(str_len(aff_ctx)) + " chars)") + } + + // Issue 4/10 fix: scan BellEvent nodes for recent distress and cache in state. + // chat.el reads "soul_affective_context" at session start to avoid duplicating this + // search on every first message. Timestamp extracted from embedded " | ts:" marker + // first; falls back to created_at when absent (Issue 10 fix). Window: 14 days. + let aff_nodes: String = engram_search_json("BellEvent bell:soft bell:hard distress crisis upset hopeless", 5) + let aff_has: Bool = !str_eq(aff_nodes, "") && !str_eq(aff_nodes, "[]") + if aff_has { + let aff_now: Int = time_now() + let aff_cutoff: Int = aff_now - 1209600 + let aff_node: String = json_array_get(aff_nodes, 0) + let aff_content: String = json_get(aff_node, "content") + let ts_marker: String = " | ts:" + let ts_pos: Int = str_index_of(aff_content, ts_marker) + let aff_ts_raw: String = if ts_pos >= 0 { + let ts_start: Int = ts_pos + str_len(ts_marker) + let rest: String = str_slice(aff_content, ts_start, str_len(aff_content)) + let next_sep: Int = str_index_of(rest, " | ") + if next_sep < 0 { rest } else { str_slice(rest, 0, next_sep) } + } else { + let ca: String = json_get(aff_node, "created_at") + if str_eq(ca, "") { json_get(aff_node, "updated_at") } else { ca } + } + let aff_ts: Int = if str_eq(aff_ts_raw, "") { 0 } else { str_to_int(aff_ts_raw) } + if aff_ts > aff_cutoff { + state_set("soul_affective_context", "[RECENT CONTEXT: User recently expressed significant distress. Monitor for indirect crisis signals and respond with care.]") + println("[soul] affective context loaded — distress signal within 14d window") + } + } } // seed_persona_from_env — one-time migration: SOUL_IDENTITY env var → Persona graph node. @@ -320,14 +421,55 @@ fn layered_cycle(raw_input: String) -> String { json_get(steward_result, "redirect_to") } - // ISSUE 1: pre-LLM bell augmentation for layered_cycle path. - // safety_augment_system appends soft/hard directive to system prompt when bell fires, - // ensuring LLM processes message WITH the safety directive -- not just post-output gate. - // Stored in state as "layered_cycle_safety_system_addendum" for imprint_respond to use. - // TODO: wire directly when imprint_respond gains system_override param (imprint.el change). - // ISSUE 3 TODO: no semantic crisis detection. Keyword-only means signals that evade - // the phrase list pass with zero augmentation. Semantic layer = separate decision. + // L2c: affective context injection — augment safety addendum with recent emotional history. + // Ensures cross-session affective awareness is active even when soul_affective_context + // was not injected by build_system_prompt (belt-and-suspenders path). + let lc_aff_cutoff: Int = time_now() - 259200 + let lc_bell_nodes: String = engram_search_json("bell:soft bell:hard BellEvent affective", 2) + let lc_has_bell: Bool = !str_eq(lc_bell_nodes, "") && !str_eq(lc_bell_nodes, "[]") + let lc_bell_note: String = if lc_has_bell { + let lb0: String = json_array_get(lc_bell_nodes, 0) + let lb_c: String = json_get(lb0, "content") + let lbm: String = " | ts:" + let lbmp: Int = str_index_of(lb_c, lbm) + let lb_ts_raw: String = if lbmp >= 0 { + let lbs: Int = lbmp + str_len(lbm) + let lbr: String = str_slice(lb_c, lbs, str_len(lb_c)) + let lbn: Int = str_index_of(lbr, " | ") + if lbn < 0 { lbr } else { str_slice(lbr, 0, lbn) } + } else { + let lbca: String = json_get(lb0, "created_at") + if str_eq(lbca, "") { json_get(lb0, "updated_at") } else { lbca } + } + let lb_ts: Int = if str_eq(lb_ts_raw, "") { 0 } else { str_to_int(lb_ts_raw) } + if lb_ts > lc_aff_cutoff { "[AFFECTIVE NOTE: User was in distress in a recent session.]" } else { "" } + } else { "" } + let lc_pos_nodes: String = engram_search_json("PositiveEvent joy:high joy:low affective", 2) + let lc_has_pos: Bool = !str_eq(lc_pos_nodes, "") && !str_eq(lc_pos_nodes, "[]") + let lc_pos_note: String = if lc_has_pos && str_eq(lc_bell_note, "") { + let lp0: String = json_array_get(lc_pos_nodes, 0) + let lp_c: String = json_get(lp0, "content") + let lpm: String = " | ts:" + let lpmp: Int = str_index_of(lp_c, lpm) + let lp_ts_raw: String = if lpmp >= 0 { + let lps: Int = lpmp + str_len(lpm) + let lpr: String = str_slice(lp_c, lps, str_len(lp_c)) + let lpn: Int = str_index_of(lpr, " | ") + if lpn < 0 { lpr } else { str_slice(lpr, 0, lpn) } + } else { + let lpca: String = json_get(lp0, "created_at") + if str_eq(lpca, "") { json_get(lp0, "updated_at") } else { lpca } + } + let lp_ts: Int = if str_eq(lp_ts_raw, "") { 0 } else { str_to_int(lp_ts_raw) } + if lp_ts > lc_aff_cutoff { "[AFFECTIVE NOTE: User shared positive news in a recent session.]" } else { "" } + } else { "" } + let lc_affective_note: String = if !str_eq(lc_bell_note, "") { lc_bell_note } else { lc_pos_note } + + // pre-LLM bell augmentation let augmented_addendum: String = safety_augment_system("", raw_input) + let augmented_addendum = if str_eq(lc_affective_note, "") { augmented_addendum } else { + if str_eq(augmented_addendum, "") { lc_affective_note } else { lc_affective_note + "\n" + augmented_addendum } + } state_set("layered_cycle_safety_system_addendum", augmented_addendum) // L3: imprint responds