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

neuron-api.el

@@ -1,5 +1,4 @@
 import "memory.el"
-import "chat.el"
 
 // neuron-api.el — Native Neuron cognitive API handlers.
 //
@@ -655,13 +654,14 @@ fn handle_api_consolidate(body: String) -> String {
         engram_save(snap)
     }
     if !str_eq(summary, "") {
-        // Use session_summary_write to ensure delete-before-write semantics:
-        // prevents stale SessionSummary accumulation across sessions (issue #11).
-        // session_summary_write handles label indexing, trimming, and dedup.
-        let sum_id: String = session_summary_write(summary)
-        if str_eq(sum_id, "") {
-            println("[api] consolidate: session_summary_write failed — summary not persisted")
-        }
+        let safe_summary: String = str_replace(summary, "\"", "'")
+        let tags: String = "[\"SessionSummary\",\"consolidate\"]"
+        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
+        )
     }
     return "{\"ok\":true,\"snapshot\":\"" + snap + "\"}"
 }

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.

soul.el

@@ -163,45 +163,104 @@ fn load_identity_context() -> Void {
         }
     }
 
-    // Cross-session affective context: query engram for recent distress/crisis signals.
-    // Broadened query includes session:emotional-summary and BellEvent tags (issue #10):
-    // the old keywords-only search missed these nodes when their content lacked exact phrases.
-    // 7-day recency window applied via the "ts" field embedded in BellEvent content.
-    let affective_raw: String = engram_search_json("distress crisis upset hopeless session:emotional-summary BellEvent bell:hard bell:soft", 5)
-    let affective_ok: Bool = !str_eq(affective_raw, "") && !str_eq(affective_raw, "[]")
-    if affective_ok {
-        let ts_now: Int = time_now()
-        let ts_cutoff: Int = ts_now - 604800
-        let aff_total: Int = json_array_len(affective_raw)
-        let aff_ctx: String = ""
-        let ai: Int = 0
-        while ai < aff_total {
-            let aff_node: String = json_array_get(affective_raw, ai)
-            let aff_content: String = json_get(aff_node, "content")
-            // Try multiple timestamp fields: "ts" (embedded), "created_at", "updated_at"
-            let aff_ts_str: String = json_get(aff_node, "ts")
-            let aff_ts_str2: String = if str_eq(aff_ts_str, "") { json_get(aff_node, "created_at") } else { aff_ts_str }
-            // Also try embedded " | ts:NNN" format used in BellEvent content
-            let ts_marker: String = " | ts:"
-            let ts_pos: Int = str_index_of(aff_content, ts_marker)
-            let aff_ts_embedded: 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 eff_ts_str: String = if !str_eq(aff_ts_embedded, "") { aff_ts_embedded } else { aff_ts_str2 }
-            let aff_ts: Int = if str_eq(eff_ts_str, "") { ts_now } else { str_to_int(eff_ts_str) }
-            let is_recent: Bool = aff_ts >= ts_cutoff
-            let snip: String = if str_len(aff_content) > 200 { str_slice(aff_content, 0, 200) } else { aff_content }
-            let aff_ctx = if is_recent && !str_eq(snip, "") {
-                if str_eq(aff_ctx, "") { snip } else { aff_ctx + "\n" + snip }
-            } else { aff_ctx }
-            let ai = ai + 1
+    // 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
         }
-        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)")
+        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")
         }
     }
 }
@@ -275,59 +334,12 @@ fn emit_session_start_event() -> Void {
     }
     let ts: Int = time_now()
 
-    // Load previous session summary at boot — stash in state for session_preload.
-    // Search by label text + type, filter by exact label match to avoid false positives.
-    // engram_get_node_by_label is not a runtime builtin; engram_search_json is used instead.
-    let sum_boot_search: String = engram_search_json("session:summary SessionSummary", 5)
-    let sum_boot_ok: Bool = !str_eq(sum_boot_search, "") && !str_eq(sum_boot_search, "[]")
-    let prev_sum_content: String = if sum_boot_ok {
-        let sbs_total: Int = json_array_len(sum_boot_search)
-        let sbs_i: Int = 0
-        let sbs_found: String = ""
-        while sbs_i < sbs_total {
-            let sbs_node: String = json_array_get(sum_boot_search, sbs_i)
-            let sbs_label: String = json_get(sbs_node, "label")
-            let sbs_type: String = json_get(sbs_node, "node_type")
-            let sbs_content: String = json_get(sbs_node, "content")
-            let sbs_found = if str_eq(sbs_label, "session:summary") && str_eq(sbs_type, "SessionSummary") && !str_eq(sbs_content, "") {
-                if str_eq(sbs_found, "") { sbs_content } else { sbs_found }
-            } else { sbs_found }
-            let sbs_i = sbs_i + 1
-        }
-        if str_eq(sbs_found, "") {
-            let sum_fb: String = engram_search_json("SessionSummary previous-session", 2)
-            let sum_fb_ok: Bool = !str_eq(sum_fb, "") && !str_eq(sum_fb, "[]")
-            if sum_fb_ok {
-                let sfn: String = json_array_get(sum_fb, 0)
-                let sftype: String = json_get(sfn, "node_type")
-                let sfcontent: String = json_get(sfn, "content")
-                if str_eq(sftype, "SessionSummary") && !str_eq(sfcontent, "") { sfcontent } else { "" }
-            } else { "" }
-        } else { sbs_found }
-    } else {
-        let sum_fb2: String = engram_search_json("SessionSummary previous-session", 2)
-        let sum_fb2_ok: Bool = !str_eq(sum_fb2, "") && !str_eq(sum_fb2, "[]")
-        if sum_fb2_ok {
-            let sfn2: String = json_array_get(sum_fb2, 0)
-            let sftype2: String = json_get(sfn2, "node_type")
-            let sfcontent2: String = json_get(sfn2, "content")
-            if str_eq(sftype2, "SessionSummary") && !str_eq(sfcontent2, "") { sfcontent2 } else { "" }
-        } else { "" }
-    }
-    let has_prev_sum: String = if str_eq(prev_sum_content, "") { "false" } else { "true" }
-    if !str_eq(prev_sum_content, "") {
-        state_set("soul_prev_session_summary", prev_sum_content)
-        println("[soul] previous session summary loaded (" + int_to_str(str_len(prev_sum_content)) + " chars)")
-    }
-
-
     let payload: String = "{\"event\":\"session_start\""
         + ",\"boot\":" + boot_num
         + ",\"cgi\":\"" + eff_cgi + "\""
         + ",\"node_count\":" + int_to_str(node_ct)
         + ",\"edge_count\":" + int_to_str(edge_ct)
         + ",\"identity_loaded\":" + has_identity
-        + ",\"prev_session_summary_loaded\":" + has_prev_sum
         + ",\"ts\":" + int_to_str(ts) + "}"
 
     let tags: String = "[\"internal-state\",\"session-start\",\"InternalStateEvent\"]"
@@ -336,7 +348,7 @@ fn emit_session_start_event() -> Void {
         el_from_float(0.9), el_from_float(0.9), el_from_float(1.0),
         "Episodic", tags
     )
-    println("[soul] session-start event logged (boot=" + boot_num + " nodes=" + int_to_str(node_ct) + " edges=" + int_to_str(edge_ct) + " prev_summary=" + has_prev_sum + ")")
+    println("[soul] session-start event logged (boot=" + boot_num + " nodes=" + int_to_str(node_ct) + " edges=" + int_to_str(edge_ct) + ")")
 }
 
 // layered_cycle — routes user-facing requests through the 4-layer consciousness stack.
@@ -409,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