diff --git a/chat.el b/chat.el index f1cf363..eb0cb8f 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 + // (3-week-old node, salience 0.6, 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,258 @@ 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 a message into sub-queries on explicit conjunctions. +// "health goals AND startup progress" becomes two independent search queries. +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 from a message. +// Capital-letter words 3+ chars, not stop-words. Returns newline-separated list. +// Catches project names (Prism, Neuron), person names, product names. +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 57-char queries like "Can you remind me what +// Prism's architecture looks like?" which are clearly continuations 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 pool: 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 + "]") } 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 ("remind me about X") and boost the pool. + 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 explicit 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 +383,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 to support larger multi-topic node pools. + 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, "\"", "\\\"") @@ -467,107 +678,130 @@ fn handle_chat(body: String) -> String { 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 the 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 } + // Extended thread snip: 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. + // Fix for Issue 2: call engram_compile first so it can cache the bell node result + // in state "engram_compile_bell_node". affective_prefix then reads that cached + // result instead of firing a second, overlapping engram query. + let ctx: String = engram_compile(activation_seed) + + // Cross-session affective context: on session start (no history yet), emit a care + // directive if engram_compile found a recent bell node (within 72h). + // Fix for Issue 2: reuses the cached result from engram_compile — no second + // engram query for "bell distress crisis loss grief despair" needed. 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 - } else { false } - if found_recent { + let cached_bell: String = state_get("engram_compile_bell_node") + if !str_eq(cached_bell, "") { "[RECENT CONTEXT: User recently expressed significant distress. Monitor for indirect crisis signals and respond with care.]\n\n" } else { "" } } 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. + // Issue 9 fix: session preload adds project-specific and session-summary searches. + // The old hardcoded "user profile" and "in_progress active project" queries miss nodes + // stored under project names (e.g. "Prism") unless those exact words appear in content. 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) + let work_nodes: String = engram_search_json("in_progress active project work", 5) + let project_nodes: String = engram_search_json("project status current ongoing active", 5) + let summary_nodes: String = engram_search_json("SessionSummary session:summary previous-session recent", 3) + let profile_ok: Bool = !str_eq(profile_nodes, "") && !str_eq(profile_nodes, "[]") let work_ok: Bool = !str_eq(work_nodes, "") && !str_eq(work_nodes, "[]") + let project_ok: Bool = !str_eq(project_nodes, "") && !str_eq(project_nodes, "[]") + let summary_ok: Bool = !str_eq(summary_nodes, "") && !str_eq(summary_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 bullets = if pn > 0 { 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 } + let s0: String = if str_len(c0) > 120 { str_slice(c0, 0, 120) } else { c0 } + if str_eq(s0, "") { bullets } else { "- " + s0 } } 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 } + let s1: String = if str_len(c1) > 120 { str_slice(c1, 0, 120) } else { c1 } + if str_eq(s1, "") { bullets } else { bullets + "\n- " + s1 } } 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 } + let s2: String = if str_len(c2) > 120 { str_slice(c2, 0, 120) } else { c2 } + if str_eq(s2, "") { bullets } else { bullets + "\n- " + s2 } } else { bullets } bullets } 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 wb: String = "" + let wb = 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 ws0: String = if str_len(wc0) > 120 { str_slice(wc0, 0, 120) } else { wc0 } + if str_eq(ws0, "") { wb } else { "- " + ws0 } + } else { wb } + let wb = 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 + let ws1: String = if str_len(wc1) > 120 { str_slice(wc1, 0, 120) } else { wc1 } + if str_eq(ws1, "") { wb } else { wb + "\n- " + ws1 } + } else { wb } + wb } else { "" } - 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 - } else { "" } - let work_section: String = if has_work { - "[ACTIVE WORK — from memory]\n" + work_bullets - } else { "" } - let sep_pw: String = if has_profile && has_work { "\n\n" } else { "" } - "\n\n" + profile_section + sep_pw + work_section + let project_bullets: String = if project_ok { + let prn: Int = json_array_len(project_nodes) + let pb: String = "" + let pb = if prn > 0 { + let pr0: String = json_array_get(project_nodes, 0) + let prc0: String = json_get(pr0, "content") + let ps0: String = if str_len(prc0) > 120 { str_slice(prc0, 0, 120) } else { prc0 } + if str_eq(ps0, "") { pb } else { "- " + ps0 } + } else { pb } + let pb = if prn > 1 { + let pr1: String = json_array_get(project_nodes, 1) + let prc1: String = json_get(pr1, "content") + let ps1: String = if str_len(prc1) > 120 { str_slice(prc1, 0, 120) } else { prc1 } + if str_eq(ps1, "") { pb } else { pb + "\n- " + ps1 } + } else { pb } + pb + } else { "" } + + let summary_bullet: String = if summary_ok { + let sn0: String = json_array_get(summary_nodes, 0) + let sc0: String = json_get(sn0, "content") + let ss0: String = if str_len(sc0) > 200 { str_slice(sc0, 0, 200) } else { sc0 } + if str_eq(ss0, "") { "" } else { "- " + ss0 } + } else { "" } + + let hp: Bool = !str_eq(profile_bullets, "") + let hw: Bool = !str_eq(work_bullets, "") + let hpr: Bool = !str_eq(project_bullets, "") + let hs: Bool = !str_eq(summary_bullet, "") + let preload: String = if hp || hw || hpr || hs { + let sec_p: String = if hp { "[USER CONTEXT — from memory]\n" + profile_bullets } else { "" } + let sec_w: String = if hw { "[ACTIVE WORK — from memory]\n" + work_bullets } else { "" } + let sec_pr: String = if hpr { "[PROJECTS — from memory]\n" + project_bullets } else { "" } + let sec_s: String = if hs { "[PREVIOUS SESSION — from memory]\n" + summary_bullet } else { "" } + let sep1: String = if hp && (hw || hpr || hs) { "\n\n" } else { "" } + let sep2: String = if hw && (hpr || hs) { "\n\n" } else { "" } + let sep3: String = if hpr && hs { "\n\n" } else { "" } + "\n\n" + sec_p + sep1 + sec_w + sep2 + sec_pr + sep3 + sec_s } else { "" } preload } else { "" } @@ -1147,7 +1381,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 }