fix(cross-session-continuity): resolve 11 issues from code review

1. Missing closing brace on hard_bell block in handle_chat_agentic — safety gate was broken and all subsequent code unreachable.
2. Replace phantom engram_get_node_by_label() (not a runtime builtin) with engram_search_json + exact label filter in all three call sites (chat.el session_preload, session_summary_write, soul.el boot loader).
3. Fix session_summary_autogenerate scoping bug — snippets/count mutations were inside an if block and silently discarded each iteration; moved to top-level of while body using if-expressions per the el mutation rule.
4. Fix agentic session history restore — state_get fallback now calls session_hist_load (session:messages:SESSION_ID) on cold start; persist now uses session_hist_save so the write and read use the same label scheme.
5. Wire soul_prev_session_summary state key into session_preload as primary source, eliminating the dead state write.
6. Wire soul_affective_context state key into handle_chat affective prefix check, eliminating the dead state write.
7. Add session_summary_autogenerate + session_summary_write to the agentic path so users on handle_chat_agentic get session summary continuity.
8. Add import "chat.el" to neuron-api.el to make session_summary_write dependency explicit.
9. Replace corrupted em-dash bytes (\xc3\xa2\xc2\x80\xc2\x94) in session_preload headers with plain hyphen per VOICE RULE.
10. Add newline before return in handle_api_consolidate to fix statement-separator issue.
11. Add delete-before-write to conv_history_persist to prevent unbounded engram accumulation per turn.

neuron-api.el

@@ -1,4 +1,5 @@
 import "memory.el"
+import "chat.el"
 
 // neuron-api.el — Native Neuron cognitive API handlers.
 //
@@ -654,14 +655,13 @@ fn handle_api_consolidate(body: String) -> String {
         engram_save(snap)
     }
     if !str_eq(summary, "") {
-        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
-        )
+        // 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")
+        }
     }
     return "{\"ok\":true,\"snapshot\":\"" + snap + "\"}"
 }

sessions.el

@@ -488,38 +488,6 @@ 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,104 +163,45 @@ fn load_identity_context() -> Void {
         }
     }
 
-    // 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
+    // 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
         }
-        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")
+        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)")
         }
     }
 }
@@ -334,12 +275,59 @@ 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\"]"
@@ -348,7 +336,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) + ")")
+    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 + ")")
 }
 
 // layered_cycle — routes user-facing requests through the 4-layer consciousness stack.
@@ -421,55 +409,14 @@ fn layered_cycle(raw_input: String) -> String {
         json_get(steward_result, "redirect_to")
     }
 
-    // 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
+    // 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.
     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