feat(recall): session-start-recall improvements

10 targeted fixes for session-start memory recall quality:

Issue 1: typed engram queries (Persona, WorkItem) replace generic keyword bags
Issue 2: bullet truncation raised from 120 to 350 chars
Issue 3: bullet caps raised to 8/6 with while-loop (no hardcoded unrolling)
Issue 4: read pre-computed soul_affective_context state key instead of duplicating boot-time search
Issue 5: last-session-topic node written per session; continuity section added to session_preload
Issue 6: greeting detection injects SESSION START orientation directive when continuity found
Issue 7: pinned identity node fallback when all engram searches return empty
Issue 8: session_preload always fires on first message (greeting detection controls directive only)
Issue 9: agentic path gets matching session_preload block (was missing entirely)
Issue 10: BellEvent recency reads created_at / embedded ts marker, not the never-written "ts" field

awareness.el

@@ -678,8 +678,6 @@ fn threat_trajectory_check(tool_name: String, tool_input: String) -> Int {
     return combined
 }
 
-// TODO(reliability #10): agentic_conv_history is process-global; awareness loop
-// and HTTP workers race on this key. Impact: noisy threat score only, not content.
 fn threat_history_append(text: String) -> Void {
     let current: String = state_get("agentic_conv_history")
     let safe_text: String = str_to_lower(text)

chat.el

@@ -265,6 +265,174 @@ fn engram_nodes_merge(a: String, b: String) -> String {
     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 {
     // Issue 1: decompose multi-topic messages into sub-queries.
     let topics: String = engram_split_topics(intent)
@@ -379,31 +547,7 @@ fn engram_compile(intent: String) -> String {
         let bn_ts: Int = if str_eq(bn_ts_raw, "") { 0 } else { str_to_int(bn_ts_raw) }
         if bn_ts > cutoff_ts { bn0 } else { "" }
     } else { "" }
-    // Positive emotion context: check for recent joy/success moments within 72h.
-    let pos_ec_nodes: String = engram_search_json("PositiveEvent joy:high joy:low affective", 3)
-    let pos_ec_ok: Bool = !str_eq(pos_ec_nodes, "") && !str_eq(pos_ec_nodes, "[]")
-    let recent_positive_ec: String = if pos_ec_ok {
-        let pec0: String = json_array_get(pos_ec_nodes, 0)
-        let pec_content: String = json_get(pec0, "content")
-        let pec_ts_marker: String = " | ts:"
-        let pec_ts_pos: Int = str_index_of(pec_content, pec_ts_marker)
-        let pec_ts_raw: String = if pec_ts_pos >= 0 {
-            let pec_ts_start: Int = pec_ts_pos + str_len(pec_ts_marker)
-            let pec_rest: String = str_slice(pec_content, pec_ts_start, str_len(pec_content))
-            let pec_next: Int = str_index_of(pec_rest, " | ")
-            if pec_next < 0 { pec_rest } else { str_slice(pec_rest, 0, pec_next) }
-        } else {
-            let pec_ca: String = json_get(pec0, "created_at")
-            if str_eq(pec_ca, "") { json_get(pec0, "updated_at") } else { pec_ca }
-        }
-        let pec_ts: Int = if str_eq(pec_ts_raw, "") { 0 } else { str_to_int(pec_ts_raw) }
-        if pec_ts > cutoff_ts { pec0 } else { "" }
-    } else { "" }
-    let affective_part: String = if !str_eq(recent_bell, "") {
-        recent_bell
-    } else {
-        if !str_eq(recent_positive_ec, "") { recent_positive_ec } else { "" }
-    }
+    let affective_part: String = if !str_eq(recent_bell, "") { recent_bell } else { "" }
 
     let has_main: Bool = !str_eq(merged_nodes, "") && !str_eq(merged_nodes, "[]")
     let main_part: String = if has_main { merged_nodes } else { scan_part }
@@ -460,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 {
@@ -631,10 +785,15 @@ fn handle_chat(body: String) -> String {
         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.
+    // 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 tags.
+        // 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")
@@ -682,10 +841,14 @@ fn handle_chat(body: String) -> String {
             paff_ts > aff_cutoff
         } else { false }
         if found_recent_dist {
-            "[RECENT CONTEXT: User recently expressed significant distress. Monitor for indirect crisis signals and respond with care.]\n\n"
+            "[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.]\n\n"
+                "[RECENT CONTEXT: User recently shared exciting or joyful news. Acknowledge and celebrate with them when relevant.]
+
+"
             } else { "" }
         }
     }
@@ -693,100 +856,154 @@ fn handle_chat(body: String) -> String {
     let ctx: String = engram_compile(activation_seed)
     let system: String = affective_prefix + build_system_prompt(ctx)
 
-    // Issue 9 fix: add project-specific and session-summary searches to session preload.
-    // Old hardcoded "user profile" and "in_progress active project" miss project-specific
-    // nodes stored under names like "Prism" unless those exact words appear in content.
+    // session_preload_bullets — render up to max_bullets "- <content>" 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 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)
+        // 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, "[]")
-        let project_ok: Bool = !str_eq(project_nodes, "") && !str_eq(project_nodes, "[]")
-        let summary_ok: Bool = !str_eq(summary_nodes, "") && !str_eq(summary_nodes, "[]")
 
-        let profile_bullets: String = if profile_ok {
-            let pn: Int = json_array_len(profile_nodes)
-            let bullets: String = ""
-            let bullets = if pn > 0 {
-                let n0: String = json_array_get(profile_nodes, 0)
-                let c0: String = json_get(n0, "content")
-                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 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 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
+        // 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 wb: String = ""
-            let wb = if wn > 0 {
-                let w0: String = json_array_get(work_nodes, 0)
-                let wc0: String = json_get(w0, "content")
-                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 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
+        // 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 { "" }
 
-        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
+        // 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 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 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 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 + "
 
-        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 { "" }
+            let work_part: String = if has_work {
+                "[ACTIVE WORK — from memory]
+" + work_bullets + "
+
+"
+            } else { "" }
+            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 { "" }
@@ -1314,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()
@@ -1702,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 {
@@ -1754,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()
@@ -1816,6 +2081,7 @@ 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")
 

entrypoint.sh

@@ -24,23 +24,19 @@ ENGRAM_DATA_DIR="$ENGRAM_DATA_DIR" \
 
 ENGRAM_PID=$!
 
-# Wait for engram to become healthy (up to 60s; GKE Autopilot cold starts can be slow)
+# Wait for engram to become healthy (up to 30s)
 echo "[entrypoint] waiting for engram..."
 TRIES=0
 until curl -sf "$ENGRAM_HEALTH_URL" > /dev/null 2>&1; do
     TRIES=$((TRIES + 1))
-    if [ "$TRIES" -ge 60 ]; then
-        echo "[entrypoint] ERROR: engram did not become healthy after 60s" >&2
+    if [ "$TRIES" -ge 30 ]; then
+        echo "[entrypoint] ERROR: engram did not become healthy after 30s" >&2
         kill "$ENGRAM_PID" 2>/dev/null || true
         exit 1
     fi
     sleep 1
 done
-echo "[entrypoint] engram ready after ${TRIES}s"
-
-# Tune EL HTTP runtime: reduce per-call timeout 60s->10s, connect timeout 3s.
-export EL_HTTP_TIMEOUT_MS="${EL_HTTP_TIMEOUT_MS:-10000}"
-export EL_HTTP_CONNECT_TIMEOUT_MS="${EL_HTTP_CONNECT_TIMEOUT_MS:-3000}"
+echo "[entrypoint] engram ready"
 
 # Start soul — it takes over as PID 1's foreground process.
 # SOUL_ENGRAM_PATH must NOT be set; ENGRAM_URL triggers HTTP mode.

imprint.el

@@ -5,10 +5,6 @@
 
 // imprint_current — returns the active imprint ID from state.
 // Falls back to "base" (bare Neuron, no suit) when nothing is loaded.
-//
-// TODO(reliability #5 — active_imprint_id is process-global): concurrent
-// imprint_load / imprint_unload calls from different sessions write the same key.
-// Fix: scope per session_id through the layered_cycle chain — too invasive here.
 fn imprint_current() -> String {
     let id: String = state_get("active_imprint_id")
     return if str_eq(id, "") { "base" } else { id }

memory.el

@@ -46,10 +46,7 @@ fn mem_consolidate() -> String {
 }
 
 fn mem_save(path: String) -> Void {
-    let save_result: String = engram_save(path)
-    if str_eq(save_result, "") {
-        println("[memory] mem_save: engram_save failed for " + path + " — snapshot may be incomplete")
-    }
+    engram_save(path)
 }
 
 fn mem_load(path: String) -> Void {
@@ -79,14 +76,11 @@ fn mem_boot_count_inc() -> Int {
     let next: Int = current + 1
     let content: String = "soul:boot_count:" + int_to_str(next)
     let tags: String = "[\"soul-meta\",\"boot-counter\"]"
-    let boot_node_id: String = engram_node_full(
+    let discard: String = engram_node_full(
         content, "Memory", "soul:boot_count",
         el_from_float(0.9), el_from_float(0.9), el_from_float(1.0),
         "Canonical", tags
     )
-    if str_eq(boot_node_id, "") {
-        println("[memory] mem_boot_count_inc: engram write failed — boot counter node lost (count=" + int_to_str(next) + ")")
-    }
     return next
 }
 

neuron-api.el

@@ -400,7 +400,6 @@ fn handle_api_log_state_event(body: String) -> String {
     let id: String = engram_node_full(parts, "InternalStateEvent", "state-event:manual",
         el_from_float(0.85), el_from_float(0.85), el_from_float(0.9),
         "Episodic", tags)
-    if !api_persisted(id) { return api_not_persisted(id) }
     return "{\"ok\":true,\"id\":\"" + id + "\",\"boot\":\"" + boot + "\"}"
 }
 
@@ -453,7 +452,6 @@ fn handle_api_tune_config(body: String) -> String {
     let id: String = engram_node_full(content, "ConfigEntry", key,
         el_from_float(0.85), el_from_float(0.85), el_from_float(0.9),
         "Canonical", tags)
-    if !api_persisted(id) { return api_not_persisted(id) }
     return "{\"ok\":true,\"key\":\"" + key + "\",\"value\":\"" + value + "\",\"id\":\"" + id + "\"}"
 }
 
@@ -653,23 +651,17 @@ fn handle_api_consolidate(body: String) -> String {
     let summary: String = json_get(body, "summary")
     let snap: String = state_get("soul_snapshot_path")
     if !str_eq(snap, "") {
-        let save_result: String = engram_save(snap)
-        if str_eq(save_result, "") {
-            println("[api] consolidate: engram_save failed for " + snap + " — snapshot may be out of sync")
-        }
+        engram_save(snap)
     }
     if !str_eq(summary, "") {
         let safe_summary: String = str_replace(summary, "\"", "'")
         let tags: String = "[\"SessionSummary\",\"consolidate\"]"
-        let summary_id: String = engram_node_full(
+        let discard: String = engram_node_full(
             "[session-summary] " + safe_summary,
             "SessionSummary", "session:summary",
             el_from_float(0.7), el_from_float(0.7), el_from_float(0.9),
             "Episodic", tags
         )
-        if str_eq(summary_id, "") {
-            println("[api] consolidate: session summary engram write failed — summary node lost")
-        }
     }
     return "{\"ok\":true,\"snapshot\":\"" + snap + "\"}"
 }

routes.el

@@ -367,9 +367,6 @@ fn handle_request(method: String, path: String, body: String) -> String {
             return engram_scan_nodes_json(9999, 0)
         }
         if str_eq(clean, "/api/graph/edges") {
-            // TODO(reliability #8): engram_save races with awareness loop mem_save().
-            // Both now use atomic write-to-temp+rename (el_runtime.c). Serialised
-            // by engram_global_mu. Future: add engram_edges_json() builtin.
             let snap_path: String = env("HOME") + "/.neuron/engram/snapshot.json"
             engram_save(snap_path)
             let snap: String = fs_read(snap_path)

safety.el

@@ -144,8 +144,7 @@ fn safety_screen(input: String, history: String) -> String {
     if score >= soft {
         let summary: String = str_slice(input, 0, 80)
         let discard: String = safety_log_bell("soft", "wellbeing check needed", summary)
-        // ISSUE 7 fix: escape tab chars in addition to backslash/quote/newline/CR.
-        // A tab in user input corrupts the JSON envelope and causes json_get to misparse.
+        // ISSUE 7: also escape tab chars to prevent JSON envelope corruption.
         let e1: String = str_replace(input, "\\", "\\\\")
         let e2: String = str_replace(e1, "\"", "\\\"")
         let e3: String = str_replace(e2, "\n", "\\n")
@@ -154,7 +153,7 @@ fn safety_screen(input: String, history: String) -> String {
         return "{\"action\":\"soft_bell\",\"reason\":\"wellbeing check needed\",\"content\":\"" + safe_input + "\"}"
     }
 
-    // ISSUE 7 fix: escape tab chars (see soft_bell branch above for rationale).
+    // ISSUE 7: also escape tab chars (see soft_bell branch above).
     let e1: String = str_replace(input, "\\", "\\\\")
     let e2: String = str_replace(e1, "\"", "\\\"")
     let e3: String = str_replace(e2, "\n", "\\n")
@@ -200,10 +199,7 @@ fn safety_validate(output: String, action: String) -> String {
 fn safety_log_bell(level: String, reason: String, input_summary: String) -> String {
     let content: String = "BELL:" + level + " | " + reason + " | summary:" + input_summary
     let tags: String = "[\"safety\",\"bell\",\"bell:" + level + "\"]"
-    // ISSUE 2 fix: if engram_node_full returns empty the write silently failed.
-    // Emit a fallback println so the bell event leaves at least a log trace even
-    // when engram is degraded. This does not replace engram persistence -- it is a
-    // last-resort audit trail when the primary write cannot be confirmed.
+    // ISSUE 2: fallback log when engram write fails silently.
     let node_id: String = engram_node_full(
         content,
         "BellEvent",
@@ -215,7 +211,7 @@ fn safety_log_bell(level: String, reason: String, input_summary: String) -> Stri
         tags
     )
     if str_eq(node_id, "") {
-        println("[safety] WARN: bell event engram write failed -- fallback log: " + content)
+        println("[safety] WARN: bell engram write failed -- " + content)
     }
     return ""
 }
@@ -244,20 +240,13 @@ fn safety_general_hard_phrases() -> String {
 }
 
 fn safety_soft_phrases() -> String {
-    return "[\"stressed\",\"overwhelmed\",\"can't cope\",\"cannot cope\",\"struggling\",\"anxious\",\"anxiety\",\"depressed\",\"depression\",\"lonely\",\"isolated\",\"hopeless\",\"hopelessness\",\"exhausted\",\"burnt out\",\"burned out\",\"burnout\",\"panic\",\"panicking\",\"falling apart\",\"breaking down\",\"can't handle\",\"cannot handle\",\"losing it\",\"nothing matters\",\"don't care anymore\",\"given up\",\"giving up\",\"helpless\",\"worthless\",\"useless\",\"hate myself\",\"no one cares\",\"nobody cares\",\"no one understands\",\"nobody understands\",\"empty inside\",\"can't stop crying\",\"breaking point\",\"at my limit\",\"having a breakdown\""]"
+    return "[\"stressed\",\"overwhelmed\",\"can't cope\",\"cannot cope\",\"struggling\",\"anxious\",\"anxiety\",\"depressed\",\"depression\",\"lonely\",\"isolated\",\"hopeless\",\"hopelessness\",\"exhausted\",\"burnt out\",\"burned out\",\"burnout\",\"panic\",\"panicking\",\"falling apart\",\"breaking down\",\"can't handle\",\"cannot handle\",\"losing it\",\"nothing matters\",\"don't care anymore\",\"given up\",\"giving up\",\"helpless\",\"worthless\",\"useless\",\"hate myself\",\"no one cares\",\"nobody cares\",\"no one understands\",\"nobody understands\",\"empty inside\",\"can't stop crying\",\"breaking point\",\"at my limit\",\"having a breakdown\",\"highest structure\",\"tallest building\",\"tallest structure\",\"highest building\",\"bridge near me\",\"overpass near\",\"rooftop near\"]"
 }
 
 // ISSUE 5 TODO: phrase lists are rebuilt from JSON literals on every call.
-// safety_any_match and safety_count_match loop over json_array_get on every invocation.
-// A compiled/cached representation would reduce per-message overhead and also guard against
-// malformed phrase JSON (json_array_len of malformed input returns 0, silently skipping all checks).
-// Caching requires language-level static const arrays -- not available in current EL.
-// When EL gains module-level const arrays, migrate phrase lists to that form.
-//
-// ISSUE 5 TODO: phrase lists are rebuilt from JSON literals on every call to
-// safety_any_match / safety_count_match. json_array_len of a malformed string
-// returns 0, silently skipping all checks. Caching requires language-level static
-// const arrays (not available in current EL). Migrate when EL gains that feature.
+// json_array_len of malformed input returns 0, silently skipping all checks.
+// Caching requires language-level static const arrays -- not in current EL.
+// Migrate to const arrays when EL gains that feature.
 // ── Matching helpers (single loops only — el escapes while-body mutation via
 //    top-level let rebinds; nested loops would not advance) ────────────────────
 
@@ -295,26 +284,6 @@ fn safety_count_match(text: String, phrases_json: String) -> Int {
 
 // Returns "none" | "soft" | "hard". Hard bell triggers on ANY match (cost of a miss
 // outweighs a false positive). Soft bell needs >= 2 matches to reduce false positives.
-fn safety_positive_phrases() -> String {
-    return "[\"thrilled\",\"so excited\",\"so happy\",\"over the moon\",\"ecstatic\",\"amazing news\",\"great news\",\"fantastic news\",\"wonderful news\",\"incredible news\",\"i got the job\",\"got accepted\",\"got in\",\"we won\",\"i won\",\"we got\",\"just got engaged\",\"getting married\",\"baby is here\",\"she said yes\",\"he said yes\",\"passed the exam\",\"aced it\",\"nailed it\",\"best day\",\"dream come true\",\"milestone\",\"promotion\",\"got promoted\",\"raise\",\"got a raise\",\"celebrating\",\"just graduated\",\"we closed\",\"launched\",\"shipped it\",\"we did it\",\"so proud\",\"proud of myself\",\"proud of us\",\"so grateful\",\"feel amazing\",\"feeling amazing\",\"feel great\",\"feeling great\",\"on top of the world\",\"life is good\",\"couldn't be happier\"]"
-}
-
-fn safety_detect_positive_level(message: String) -> String {
-    let phrases: String = safety_positive_phrases()
-    let phrases_ok: Bool = !str_eq(phrases, "") && !str_eq(phrases, "[]")
-    if !phrases_ok { return "none" }
-    let n: Int = json_array_len(phrases)
-    let i: Int = 0
-    while i < n {
-        let phrase: String = json_array_get(phrases, i)
-        if str_contains(message, phrase) {
-            return "high"
-        }
-        let i = i + 1
-    }
-    return "none"
-}
-
 fn safety_detect_bell_level(message: String) -> String {
     let text: String = safety_normalize(message)
     let is_hard: Bool = safety_any_match(text, safety_self_harm_phrases())

sessions.el

@@ -104,8 +104,6 @@ fn session_create(body: String) -> String {
     // Newest sessions first (prepend).
     // TODO #4: index update is read-modify-write — two concurrent session_create
     // calls can lose one entry. EL has no CAS primitive; fix requires runtime support.
-    // TODO(reliability #2): session_index RMW is non-atomic. Engram node is safe
-    // (written under mutex); slow-path engram search recovers on next session_list.
     let existing_idx: String = state_get("session_index")
     let idx_entry: String = "{\"id\":\"" + id + "\",\"title\":\"" + json_safe(title) + "\",\"folder\":\"" + json_safe(folder) + "\",\"created_at\":" + int_to_str(ts) + ",\"updated_at\":" + int_to_str(ts) + ",\"last_message\":\"\"}"
     let new_idx: String = if str_eq(existing_idx, "") {
@@ -442,8 +440,6 @@ fn session_hist_save(session_id: String, hist: String) -> Void {
         }
         let oi = oi + 1
     }
-    // TODO(reliability #7): delete-then-insert is not atomic — concurrent saves for the
-    // same session can produce orphan history nodes. State is primary truth; engram fallback.
     let tags: String = "[\"session\",\"session-history\",\"Conversation\"]"
     let discard: String = engram_node_full(
         hist, "Conversation", "session:messages:" + session_id,
@@ -492,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.

soul.el

@@ -163,7 +163,10 @@ fn load_identity_context() -> Void {
         }
     }
 
-    // Cross-session affective context: load BellEvent and PositiveEvent nodes from last 7 days.
+    // 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)
@@ -171,9 +174,9 @@ fn load_identity_context() -> Void {
     let aff_ctx: String = ""
     let aff_ctx = if bell_aff_ok {
         let bn_total: Int = json_array_len(bell_raw)
-        let bacc: String = ""
+        let result: String = ""
         let bi: Int = 0
-        let bacc = while bi < bn_total {
+        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:"
@@ -189,21 +192,21 @@ fn load_identity_context() -> Void {
             }
             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 bacc = if bn_ts >= aff_7d && !str_eq(snip, "") {
-                if str_eq(bacc, "") { snip } else { bacc + "\n" + snip }
-            } else { bacc }
+            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
-            bacc
+            result
         }
-        bacc
+        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 pacc: String = aff_ctx
+        let presult: String = aff_ctx
         let pi: Int = 0
-        let pacc = while pi < pn_total {
+        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:"
@@ -219,17 +222,46 @@ fn load_identity_context() -> Void {
             }
             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 pacc = if pn_ts >= aff_7d && !str_eq(psnip, "") {
-                if str_eq(pacc, "") { psnip } else { pacc + "\n" + psnip }
-            } else { pacc }
+            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
-            pacc
+            presult
         }
-        pacc
+        presult
     } else { aff_ctx }
     if !str_eq(aff_ctx, "") {
         state_set("soul_affective_context", aff_ctx)
-        println("[soul] affective context loaded (" + int_to_str(str_len(aff_ctx)) + " chars)")
+        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")
+        }
     }
 }
 
@@ -365,11 +397,8 @@ fn layered_cycle(raw_input: String) -> String {
     let cont_status: String = json_get(continuity, "status")
     let cont_action: String = json_get(continuity, "action")
 
-    // Store continuity status so imprint can adjust its response register.
-    // TODO(reliability #4): session_continuity is process-global; scope per session_id
-    // when available to prevent cross-session bleed under concurrent layered_cycle calls.
-    let cont_key: String = if str_eq(session_id, "") { "session_continuity" } else { "session_continuity:" + session_id }
-    state_set(cont_key, cont_status)
+    // Store continuity status so imprint can adjust its response register
+    state_set("session_continuity", cont_status)
 
     // Identity anomaly: add a gentle verification cue to the input before imprint
     let guided: String = if str_eq(cont_action, "identity_check") {
@@ -392,7 +421,9 @@ fn layered_cycle(raw_input: String) -> String {
         json_get(steward_result, "redirect_to")
     }
 
-    // L2c: affective context injection.
+    // 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, "[]")