fix(recall): resolve session-start-recall code review issues

- Fix Issue 6 (affective duplication): engram_compile no longer appends
  the bell node JSON to its return value; it only caches it via state.
  engram_compile_multi now appends the cached bell node exactly once after
  all compile calls complete, preventing N copies when multiple seeds are
  used. Dharma room handlers updated to read and append the cached bell node
  explicitly after their single engram_compile call.

- Fix engram_compile_ranked: replace _sel_N JSON sentinel injection with a
  clean |N| pipe-delimited index string. The old approach mutated node JSON
  objects with bookkeeping fields that leaked into the LLM context; the new
  approach tracks selected indices externally and leaves node data untouched.
  Score threshold lowered from 25 to 15 to include moderately-relevant nodes.

- Add engram_render_node / engram_render_nodes / engram_render_ctx: convert
  raw engram JSON arrays/objects into human-readable "- [TYPE age sal] content"
  bullet lines before injecting into the system prompt. build_system_prompt
  now calls engram_render_ctx so the LLM receives prose rather than opaque
  JSON field blobs.

- Fix missing closing brace in handle_chat_agentic hard_bell early-return
  block that left subsequent code dangling outside the conditional.

chat.el

@@ -48,72 +48,474 @@ fn engram_score_node(node_json: String) -> Int {
     return salience_100 * importance_100 * recency_100 / 10000
 }
 
-// engram_compile_ranked — build a context string from a JSON array of node objects,
+// engram_compile_ranked — build a ranked list of nodes, best-first by score.
-// ordered best-first by score. Only nodes above a minimum score (25 = salience 0.5 *
+// Fix (Issue #11): uses "|N|" index tracking instead of _sel_N JSON mutation,
-// importance 0.5 * recency 1.0) are included; the rest are noise. Returns at most
+// which leaked sentinel fields into the node objects passed to the LLM.
-// max_nodes entries concatenated as JSON array text. Because el has no sort primitive,
+// Threshold lowered to 15 to include moderately-relevant older nodes.
-// we do a single selection pass picking the top N by linear scan (N=10 cap).
 fn engram_compile_ranked(nodes_json: String, max_nodes: Int) -> String {
     if str_eq(nodes_json, "") { return "" }
     if str_eq(nodes_json, "[]") { return "" }
     let total: Int = json_array_len(nodes_json)
     if total == 0 { return "" }
 
-    // Two-pass: first pass finds the top `max_nodes` by score via selection.
+    // selected_indices is a pipe-delimited string of chosen integer indices, e.g. "|2|7|".
-    // We track selected node indices and their scores to avoid duplicate picks.
+    // No sentinel fields are injected into the node JSON — the nodes stay clean.
-    let selected: String = ""   // comma-sep JSON snippets for chosen nodes
+    let selected_indices: String = ""
-    let selected_count: Int = 0
+    let selected_nodes: String = ""
     let pass: Int = 0
 
     while pass < max_nodes && pass < total {
-        // Find the unselected node with the highest score
         let best_idx: Int = -1
         let best_score: Int = -1
         let ci: Int = 0
         while ci < total {
             let node: String = json_array_get(nodes_json, ci)
             let score: Int = engram_score_node(node)
-            // Only include reasonably relevant nodes (threshold=25)
+            // Threshold lowered from 25 to 15: includes moderately-relevant older nodes.
-            let above_thresh: Bool = score >= 25
+            // A 3-week-old node with salience 0.6 and importance 0.6 scores ~18.
-            // Check this index wasn't already selected (sentinel: look for idx marker)
+            let above_thresh: Bool = score >= 15
-            let idx_marker: String = "\"_sel_" + int_to_str(ci) + "\""
+            // Check this index wasn't already selected using the index string.
-            let already_picked: Bool = str_contains(selected, idx_marker)
+            let idx_marker: String = "|" + int_to_str(ci) + "|"
+            let already_picked: Bool = str_contains(selected_indices, idx_marker)
             let is_better: Bool = score > best_score && above_thresh && !already_picked
             let best_score = if is_better { score } else { best_score }
             let best_idx = if is_better { ci } else { best_idx }
             let ci = ci + 1
         }
 
-        // No more qualifying nodes
         if best_idx < 0 {
             let pass = total  // break
         } else {
             let chosen: String = json_array_get(nodes_json, best_idx)
-            let sep: String = if str_eq(selected, "") { "" } else { "," }
+            let sep: String = if str_eq(selected_nodes, "") { "" } else { "," }
-            // Append the index sentinel inline so already_picked checks work
+            let selected_nodes = selected_nodes + sep + chosen
-            let selected = selected + sep + "{\"_sel_" + int_to_str(best_idx) + "\":1," + str_slice(chosen, 1, str_len(chosen) - 1) + "}"
+            let selected_indices = selected_indices + "|" + int_to_str(best_idx) + "|"
-            let selected_count = selected_count + 1
         }
         let pass = pass + 1
     }
 
-    if str_eq(selected, "") { return "" }
+    if str_eq(selected_nodes, "") { return "" }
-    // Strip the _sel_N sentinel fields that were used for duplicate-detection bookkeeping.
+    return "[" + selected_nodes + "]"
-    // The sentinels have the form "\"_sel_N\":1," (trailing comma, space before next key).
+}
-    // We injected them as the first field in each object, so the pattern is predictable.
+
-    // Because el has no regex, remove up to 10 possible sentinel variants by literal replace.
+// engram_render_node — render a single engram node JSON object as a human-readable
-    let clean: String = "[" + selected + "]"
+// bullet line for inclusion in the system prompt. Format: - [TYPE age sal] content
-    let c0: String = str_replace(clean, "\"_sel_0\":1,", "")
+// Fix (Issue #3, #4): passes context as prose bullets instead of raw JSON objects,
-    let c1: String = str_replace(c0, "\"_sel_1\":1,", "")
+// which are opaque to the LLM and waste token budget on field names.
-    let c2: String = str_replace(c1, "\"_sel_2\":1,", "")
+fn engram_render_node(node_json: String) -> String {
-    let c3: String = str_replace(c2, "\"_sel_3\":1,", "")
+    if str_eq(node_json, "") { return "" }
-    let c4: String = str_replace(c3, "\"_sel_4\":1,", "")
+    let content: String = json_get(node_json, "content")
-    let c5: String = str_replace(c4, "\"_sel_5\":1,", "")
+    if str_eq(content, "") { return "" }
-    let c6: String = str_replace(c5, "\"_sel_6\":1,", "")
+    let node_type: String = json_get(node_json, "node_type")
-    let c7: String = str_replace(c6, "\"_sel_7\":1,", "")
+    let type_label: String = if str_eq(node_type, "") { "mem" } else { node_type }
-    let c8: String = str_replace(c7, "\"_sel_8\":1,", "")
+    let now_ts: Int = time_now()
-    let c9: String = str_replace(c8, "\"_sel_9\":1,", "")
+    let created_str: String = json_get(node_json, "created_at")
-    return c9
+    let updated_str: String = json_get(node_json, "updated_at")
+    let ts_raw: String = if str_eq(created_str, "") { updated_str } else { created_str }
+    let age_label: String = if str_eq(ts_raw, "") { "" } else {
+        let node_ts: Int = str_to_int(ts_raw)
+        let age_secs: Int = now_ts - node_ts
+        let age_days: Int = if age_secs < 0 { 0 } else { age_secs / 86400 }
+        if age_days == 0 { "today" } else {
+            if age_days > 30 { "old" } else { int_to_str(age_days) + "d" }
+        }
+    }
+    let salience_str: String = json_get(node_json, "salience")
+    let sal_100: Int = if str_eq(salience_str, "") { 0 } else {
+        let s: Int = str_to_int(str_replace(salience_str, ".", ""))
+        if s > 100 { 100 } else { if s < 0 { 0 } else { s } }
+    }
+    let salience_hint: String = if str_eq(salience_str, "") { "" } else {
+        if sal_100 >= 80 { "high" } else { if sal_100 >= 50 { "med" } else { "low" } }
+    }
+    let ann_inner: String = type_label
+    let ann_inner = if str_eq(age_label, "") { ann_inner } else { ann_inner + " " + age_label }
+    let ann_inner = if str_eq(salience_hint, "") { ann_inner } else { ann_inner + " " + salience_hint }
+    let ann: String = "[" + ann_inner + "]"
+    let snip: String = if str_len(content) > 200 { str_slice(content, 0, 200) } else { content }
+    return "- " + ann + " " + snip
+}
+
+// engram_render_nodes — render a JSON array of engram nodes as newline-joined
+// prose bullet lines. Returns "" when input is empty.
+// Fix (Issue #3): called by build_system_prompt to convert raw JSON ctx to
+// human-readable bullets before injecting into the LLM system prompt.
+fn engram_render_nodes(nodes_json: String) -> String {
+    if str_eq(nodes_json, "") { return "" }
+    if str_eq(nodes_json, "[]") { return "" }
+    let total: Int = json_array_len(nodes_json)
+    if total == 0 { return "" }
+    let result: String = ""
+    let i: Int = 0
+    while i < total {
+        let node: String = json_array_get(nodes_json, i)
+        let line: String = engram_render_node(node)
+        let result = if str_eq(line, "") { result } else {
+            if str_eq(result, "") { line } else { result + "\n" + line }
+        }
+        let i = i + 1
+    }
+    return result
+}
+
+// engram_render_ctx — render the ctx string returned by engram_compile as prose bullets.
+// ctx may be a JSON array "[...]", a single object "{...}", or up to two such segments
+// joined by "\n". We handle the three common shapes produced by engram_compile:
+//   1. single JSON array  -> engram_render_nodes
+//   2. single JSON object -> engram_render_node
+//   3. two segments sep by "\n" -> render each half individually and join
+// Fix (Issue #3): called by build_system_prompt so the LLM receives human-readable
+// prose bullets instead of raw JSON field blobs.
+fn engram_render_ctx(ctx: String) -> String {
+    if str_eq(ctx, "") { return "" }
+    // Single JSON array.
+    if str_starts_with(ctx, "[") {
+        let nl: Int = str_index_of(ctx, "\n")
+        if nl < 0 {
+            // Whole ctx is one array.
+            let r: String = engram_render_nodes(ctx)
+            if !str_eq(r, "") { return r }
+            return ""
+        }
+        // First segment is an array; try to render it and the rest separately.
+        let part1: String = str_slice(ctx, 0, nl)
+        let part2: String = str_slice(ctx, nl + 1, str_len(ctx))
+        let r1: String = engram_render_nodes(part1)
+        let r2: String = if str_starts_with(part2, "[") {
+            engram_render_nodes(part2)
+        } else {
+            if str_starts_with(part2, "{") { engram_render_node(part2) } else { "" }
+        }
+        if str_eq(r1, "") { return r2 }
+        if str_eq(r2, "") { return r1 }
+        return r1 + "\n" + r2
+    }
+    // Single JSON object (e.g. affective_part node when it's the only result).
+    if str_starts_with(ctx, "{") {
+        let nl: Int = str_index_of(ctx, "\n")
+        if nl < 0 {
+            let r: String = engram_render_node(ctx)
+            if !str_eq(r, "") { return r }
+            return ""
+        }
+        let part1: String = str_slice(ctx, 0, nl)
+        let part2: String = str_slice(ctx, nl + 1, str_len(ctx))
+        let r1: String = engram_render_node(part1)
+        let r2: String = if str_starts_with(part2, "[") {
+            engram_render_nodes(part2)
+        } else {
+            if str_starts_with(part2, "{") { engram_render_node(part2) } else { "" }
+        }
+        if str_eq(r1, "") { return r2 }
+        if str_eq(r2, "") { return r1 }
+        return r1 + "\n" + r2
+    }
+    // Fallback: ctx is in an unexpected format; return as-is.
+    return ctx
+}
+
+// is_followup_phrase — returns true when the message is a recognized follow-up
+// reference that should anchor recall to the prior user topic rather than stand alone.
+// Used by build_activation_seed to choose the right enrichment strategy.
+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, "continue") { 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 }
+    if str_eq(msg, "and?") { return true }
+    if str_eq(msg, "so?") { return true }
+    return false
+}
+
+// is_genuine_continuation — returns true when a short message is a contextual
+// follow-up rather than a new topic.
+// Issue 4 fix: the prior heuristic only checked for mid-string capitals, which
+// fails for all-lowercase new-topic queries like "what is rust?" (14 chars) or
+// "explain quantum computing" (26 chars). Added question-word prefix detection
+// that fires BEFORE the length check: any message starting with a question word
+// (what/how/why/when/where/who/which/is/can/could/does/do) introduces a new
+// topic and is never a continuation, regardless of length.
+fn is_genuine_continuation(msg: String, hist_len: Int) -> Bool {
+    if hist_len == 0 { return false }
+    if str_len(msg) == 0 { return false }
+    if is_followup_phrase(msg) { return true }
+    // Question-word prefix: messages starting with these introduce new topics.
+    // Check before the length heuristic so short new-topic questions escape.
+    let is_question_start: Bool = str_starts_with(msg, "what ")
+        || str_starts_with(msg, "What ")
+        || str_starts_with(msg, "how ") || str_starts_with(msg, "How ")
+        || str_starts_with(msg, "why ") || str_starts_with(msg, "Why ")
+        || str_starts_with(msg, "when ") || str_starts_with(msg, "When ")
+        || str_starts_with(msg, "where ") || str_starts_with(msg, "Where ")
+        || str_starts_with(msg, "who ") || str_starts_with(msg, "Who ")
+        || str_starts_with(msg, "which ") || str_starts_with(msg, "Which ")
+        || str_starts_with(msg, "is ") || str_starts_with(msg, "Is ")
+        || str_starts_with(msg, "can ") || str_starts_with(msg, "Can ")
+        || str_starts_with(msg, "could ") || str_starts_with(msg, "Could ")
+        || str_starts_with(msg, "does ") || str_starts_with(msg, "Does ")
+        || str_starts_with(msg, "do ") || str_starts_with(msg, "Do ")
+        || str_starts_with(msg, "explain ") || str_starts_with(msg, "Explain ")
+        || str_starts_with(msg, "describe ") || str_starts_with(msg, "Describe ")
+        || str_starts_with(msg, "define ") || str_starts_with(msg, "Define ")
+    if is_question_start { return false }
+    // Long messages (50+ chars) typically introduce new topics.
+    if str_len(msg) >= 50 { return false }
+    // Short messages with a mid-string capital are likely named-concept queries
+    // (e.g. "tell me about Rust", "what about AWS") — treat as new topic.
+    let rest: String = str_slice(msg, 1, str_len(msg))
+    let has_mid_capital: Bool = false
+    let has_mid_capital = has_mid_capital || str_contains(rest, " A")
+    let has_mid_capital = has_mid_capital || str_contains(rest, " B")
+    let has_mid_capital = has_mid_capital || str_contains(rest, " C")
+    let has_mid_capital = has_mid_capital || str_contains(rest, " D")
+    let has_mid_capital = has_mid_capital || str_contains(rest, " E")
+    let has_mid_capital = has_mid_capital || str_contains(rest, " F")
+    let has_mid_capital = has_mid_capital || str_contains(rest, " G")
+    let has_mid_capital = has_mid_capital || str_contains(rest, " H")
+    let has_mid_capital = has_mid_capital || str_contains(rest, " I")
+    let has_mid_capital = has_mid_capital || str_contains(rest, " J")
+    let has_mid_capital = has_mid_capital || str_contains(rest, " K")
+    let has_mid_capital = has_mid_capital || str_contains(rest, " L")
+    let has_mid_capital = has_mid_capital || str_contains(rest, " M")
+    let has_mid_capital = has_mid_capital || str_contains(rest, " N")
+    let has_mid_capital = has_mid_capital || str_contains(rest, " O")
+    let has_mid_capital = has_mid_capital || str_contains(rest, " P")
+    let has_mid_capital = has_mid_capital || str_contains(rest, " Q")
+    let has_mid_capital = has_mid_capital || str_contains(rest, " R")
+    let has_mid_capital = has_mid_capital || str_contains(rest, " S")
+    let has_mid_capital = has_mid_capital || str_contains(rest, " T")
+    let has_mid_capital = has_mid_capital || str_contains(rest, " U")
+    let has_mid_capital = has_mid_capital || str_contains(rest, " V")
+    let has_mid_capital = has_mid_capital || str_contains(rest, " W")
+    let has_mid_capital = has_mid_capital || str_contains(rest, " X")
+    let has_mid_capital = has_mid_capital || str_contains(rest, " Y")
+    let has_mid_capital = has_mid_capital || str_contains(rest, " Z")
+    if has_mid_capital { return false }
+    return true
+}
+
+// topic_snip_from_entry — extract the most salient snippet from a history entry's
+// content. Fixes Issue 9: takes the TAIL (last 200 chars) then trims to the last
+// sentence boundary, so named concepts introduced near the end are captured.
+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 in history.
+// Fixes Issue 10: pulls up to 3 prior user turns into the seed so earlier
+// high-salience nodes from the thread are re-queried.
+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 multi-turn transcript.
+// Fixes Issue 6: a full transcript produces a diffuse embedding query.
+// Strategy: last 150 chars (recency) + any question in last 500 chars. Cap 250.
+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.
+fn build_activation_seed(message: String, hist: String, hist_len: Int) -> String {
+    if hist_len == 0 { return message }
+
+    let is_cont: Bool = is_genuine_continuation(message, hist_len)
+
+    if !is_cont {
+        let multi_topic: String = multi_turn_topic(hist, hist_len)
+        if str_eq(multi_topic, "") { return message }
+        let blended: String = message + " " + multi_topic
+        if str_len(blended) > 400 { return str_slice(blended, 0, 400) }
+        return blended
+    }
+
+    // Genuine continuation: find the most recent prior USER turn as the topic anchor.
+    // Fixes Issues 3 and 8: old code used the last assistant reply (hist_len - 1).
+    let prior_user_content: String = ""
+    let scan_idx: Int = hist_len - 1
+    let found_prior_user: Bool = false
+    while scan_idx >= 0 && !found_prior_user {
+        let scan_entry: String = json_array_get(hist, scan_idx)
+        let scan_role: String = json_get(scan_entry, "role")
+        let scan_content: String = json_get(scan_entry, "content")
+        let is_user_turn: Bool = str_eq(scan_role, "user")
+        let prior_user_content = if is_user_turn && !found_prior_user { scan_content } else { prior_user_content }
+        let found_prior_user = if is_user_turn { true } else { found_prior_user }
+        let scan_idx = scan_idx - 1
+    }
+
+    // Secondary: tail-biased snip from last assistant reply (Issue 9 fix).
+    let last_asst_entry: String = json_array_get(hist, hist_len - 1)
+    let last_asst_role: String = json_get(last_asst_entry, "role")
+    let last_asst_content: String = if str_eq(last_asst_role, "assistant") {
+        json_get(last_asst_entry, "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 }
+
+    let seed: 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(seed) > 400 { return str_slice(seed, 0, 400) }
+    return seed
+}
+
+// engram_compile_multi — fan-out activation across multiple query seeds. Fixes Issue 4:
+// only a single seed was tried per turn, with no entity/emotion/topic diversification.
+//
+// Issue 2 fix: save the primary-seed activation to a dedicated state key BEFORE calling
+// engram_compile(message). Each engram_compile call overwrites "engram_compile_activation_json"
+// with its own activation result. Without this save, the secondary compile (bare message,
+// lower signal) clobbers the primary (enriched seed, higher signal), and strengthen_chat_nodes
+// later reads the lower-signal result for node strengthening.
+//
+// Issue 3 fix: replace the dumb str_slice(merged, 0, 6000) truncation with the same
+// safe JSON boundary-scan used in engram_compile. The old truncation could cut mid-object
+// when ctx1+ctx2+ctx3 together exceeded 6000 chars, producing malformed JSON context.
+//
+// Issue 5 fix: remove str_contains(ctx1, ctx2) / str_contains(merged, ctx3) substring
+// duplicate checks. These compared multi-KB JSON strings and were unreliable in both
+// directions: a coincidental substring match inside a JSON field value could falsely suppress
+// ctx2 entirely; a genuinely duplicate ctx2 was missed when ctx1 was already truncated.
+// We now concatenate unconditionally and let engram_compile's own dedup (node-ID based)
+// handle within-result duplicates. Slight redundancy across ctx1/ctx2 is acceptable; false
+// suppression of valid context is not.
+fn engram_compile_multi(primary_seed: String, message: String) -> String {
+    let ctx1: String = engram_compile(primary_seed)
+
+    // Issue 2 fix: save the primary-seed activation before any secondary compile can
+    // overwrite the shared "engram_compile_activation_json" state key.
+    let primary_act: String = state_get("engram_compile_activation_json")
+    if !str_eq(primary_act, "") && !str_eq(primary_act, "[]") {
+        state_set("engram_compile_primary_activation_json", primary_act)
+    }
+
+    let entity_seed_differs: Bool = !str_eq(primary_seed, message)
+    let ctx2: String = if entity_seed_differs {
+        let raw_ctx: String = engram_compile(message)
+        if str_eq(raw_ctx, "") { "" } else { raw_ctx }
+    } else { "" }
+
+    let has_any: Bool = !str_eq(ctx1, "") || !str_eq(ctx2, "")
+    let ctx3: String = if has_any {
+        let emo_results: String = engram_search_json("emotion feeling mood care distress joy hope", 5)
+        let emo_ok: Bool = !str_eq(emo_results, "") && !str_eq(emo_results, "[]")
+        if emo_ok { engram_compile_ranked(emo_results, 3) } else { "" }
+    } else { "" }
+
+    // Issue 5 fix: concatenate unconditionally — no str_contains substring dedup.
+    let sep2: String = if !str_eq(ctx1, "") && !str_eq(ctx2, "") { "\n" } else { "" }
+    let merged: String = ctx1 + sep2 + ctx2
+    let sep3: String = if !str_eq(merged, "") && !str_eq(ctx3, "") { "\n" } else { "" }
+    let merged = if !str_eq(ctx3, "") { merged + sep3 + ctx3 } else { merged }
+
+    // Issue 6 fix: append the bell node exactly once here, after all compile calls.
+    // engram_compile no longer includes affective_part in its return value; instead it
+    // caches the bell node in state. By appending it here we guarantee the bell node
+    // JSON appears at most once in the system prompt's engram block regardless of how
+    // many engram_compile calls were made above.
+    let bell_node: String = state_get("engram_compile_bell_node")
+    let sep4: String = if !str_eq(merged, "") && !str_eq(bell_node, "") { "\n" } else { "" }
+    let merged = if !str_eq(bell_node, "") { merged + sep4 + bell_node } else { merged }
+
+    if str_eq(merged, "") { return "" }
+
+    // Issue 3 fix: safe JSON boundary-scan truncation — find the last closing brace
+    // before the 6000-char cap rather than slicing mid-object.
+    let cap_len: Int = 6000
+    if str_len(merged) <= cap_len { return merged }
+    let cap_search: Int = cap_len - 1
+    let cap_min: Int = if cap_len > 500 { cap_len - 500 } else { 0 }
+    let cap_pos: Int = -1
+    let cap_si: Int = cap_search
+    while cap_si >= cap_min && cap_pos < 0 {
+        let cap_ch: String = str_slice(merged, cap_si, cap_si + 1)
+        let cap_pos = if str_eq(cap_ch, "}") { cap_si } else { cap_pos }
+        let cap_si = if cap_pos < 0 { cap_si - 1 } else { cap_si }
+    }
+    if cap_pos > 0 { return str_slice(merged, 0, cap_pos + 1) }
+    return str_slice(merged, 0, cap_len)
 }
 
 fn engram_compile(intent: String) -> String {
@@ -181,44 +583,36 @@ 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.
+    // Issue 6 fix: do NOT include the bell node in this function's return value.
-    let pos_ec_nodes: String = engram_search_json("PositiveEvent joy:high joy:low affective", 3)
+    // engram_compile is called multiple times by engram_compile_multi (once per seed).
-    let pos_ec_ok: Bool = !str_eq(pos_ec_nodes, "") && !str_eq(pos_ec_nodes, "[]")
+    // If affective_part were appended here, the bell node JSON would appear once per
-    let recent_positive_ec: String = if pos_ec_ok {
+    // compile call — duplicating it in the merged context. Instead, cache the bell node
-        let pec0: String = json_array_get(pos_ec_nodes, 0)
+    // here and let engram_compile_multi append it exactly once after all calls complete.
-        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 sep1: String = if !str_eq(act_part, "") && !str_eq(srch_part, "") { "\n" } else { "" }
     let sep2: String = if (!str_eq(act_part, "") || !str_eq(srch_part, "")) && !str_eq(scan_part, "") { "\n" } else { "" }
-    let sep3: String = if (!str_eq(act_part, "") || !str_eq(srch_part, "") || !str_eq(scan_part, "")) && !str_eq(affective_part, "") { "\n" } else { "" }
+    let ctx: String = act_part + sep1 + srch_part + sep2 + scan_part
-    let ctx: String = act_part + sep1 + srch_part + sep2 + scan_part + sep3 + affective_part
+
+    // Cache bell and activation results for handle_chat reuse (Issues 2, 7).
+    state_set("engram_compile_bell_node", recent_bell)
+    state_set("engram_compile_activation_json", if act_ok { activate_json } else { "[]" })
 
     if str_eq(ctx, "") { return "" }
 
-    // Raise the cap slightly to match the ranked (higher-signal) output.
+    // Cap at a clean JSON object boundary — scan back from the 6000-char limit to find
-    if str_len(ctx) > 6000 {
+    // the last closing brace so we never return a truncated mid-object JSON string.
-        return str_slice(ctx, 0, 6000)
+    let cap_len: Int = 6000
+    if str_len(ctx) <= cap_len { return ctx }
+    let cap_search: Int = cap_len - 1
+    let cap_min: Int = if cap_len > 500 { cap_len - 500 } else { 0 }
+    let cap_pos: Int = -1
+    let cap_si: Int = cap_search
+    while cap_si >= cap_min && cap_pos < 0 {
+        let cap_ch: String = str_slice(ctx, cap_si, cap_si + 1)
+        let cap_pos = if str_eq(cap_ch, "}") { cap_si } else { cap_pos }
+        let cap_si = if cap_pos < 0 { cap_si - 1 } else { cap_si }
     }
-    return ctx
+    if cap_pos > 0 { return str_slice(ctx, 0, cap_pos + 1) }
+    return str_slice(ctx, 0, cap_len)
 }
 
 fn json_safe(s: String) -> String {
@@ -251,10 +645,14 @@ fn build_system_prompt(ctx: String) -> String {
         "\n\n[IDENTITY GRAPH — who you are, loaded from your engram]\n" + id_ctx
     }
 
-    let engram_block: String = if str_eq(ctx, "") {
+    // Fix (Issue #3): render ctx as prose bullets before injecting into prompt.
+    // engram_compile returns raw JSON arrays/objects; engram_render_ctx converts them
+    // to "- [TYPE age sal] content" lines the LLM can actually read and reason over.
+    let rendered_ctx: String = if str_eq(ctx, "") { "" } else { engram_render_ctx(ctx) }
+    let engram_block: String = if str_eq(rendered_ctx, "") {
         ""
     } else {
-        "\n\n[ENGRAM CONTEXT — compiled from your graph]\n" + ctx
+        "\n\n[ENGRAM CONTEXT — compiled from your graph]\n" + rendered_ctx
     }
 
     let safety_addendum: String = state_get("layered_cycle_safety_system_addendum")
@@ -265,7 +663,7 @@ fn build_system_prompt(ctx: String) -> String {
         safety_addendum
     }
 
-    return identity + date_line + voice_rules + security_rules + capability_rules + identity_block + affective_boot_block + engram_block + safety_block
+    return identity + date_line + voice_rules + security_rules + capability_rules + identity_block + engram_block + safety_block
 }
 
 fn hist_append(hist: String, role: String, content: String) -> String {
@@ -408,80 +806,27 @@ fn handle_chat(body: String) -> String {
     let stored_hist: String = if str_eq(state_hist, "") { conv_history_load() } else { state_hist }
     let hist_len: Int = if str_eq(stored_hist, "") { 0 } else { json_array_len(stored_hist) }
 
-    // Thread-aware activation: short/ambiguous messages (continuations like "go on",
+    // Issues 2-3, 8-10 fix: build_activation_seed() replaces the raw 50-char threshold
-    // "what else?", "yes") activate on the last reply instead of the bare message.
+    // with smart continuation detection, prior-user-topic anchoring, multi-turn context,
-    // This prevents a strong off-topic memory node from hijacking the reply when the
+    // and tail-biased snipping from long assistant replies.
-    // user is clearly continuing an existing thread.
+    let activation_seed: String = build_activation_seed(message, stored_hist, hist_len)
-    let is_continuation: Bool = str_len(message) < 50 && hist_len > 0
-    let last_entry: String = if is_continuation { json_array_get(stored_hist, hist_len - 1) } else { "" }
-    let last_content: String = if !str_eq(last_entry, "") { json_get(last_entry, "content") } else { "" }
-    let thread_snip: String = if str_len(last_content) > 150 { str_slice(last_content, 0, 150) } else { last_content }
-    let activation_seed: String = if !str_eq(thread_snip, "") {
-        thread_snip + " " + message
-    } else {
-        message
-    }
 
-    // Cross-session affective context: on session start (no history yet), check engram
+    // Issue 1 fix: call engram_compile_multi BEFORE reading the bell-node cache.
-    // for recent distress signals within 72h and prepend a care directive if found.
+    // engram_compile (called inside engram_compile_multi) writes "engram_compile_bell_node"
-    let affective_prefix: String = {
+    // at line 426. Reading the cache before the compile call means the first session turn
-        // Runs every turn. Uses correct BellEvent/PositiveEvent tags.
+    // always sees an empty cache — the very turn where safety continuity matters most.
-        let aff_now_ts: Int = time_now()
+    // Moving compile first ensures the cache is populated before affective_prefix reads it.
-        let aff_cutoff: Int = aff_now_ts - 259200
+    let ctx: String = engram_compile_multi(activation_seed, message)
-        let boot_aff: String = state_get("soul_affective_context")
+
-        let has_boot_aff: Bool = !str_eq(boot_aff, "")
+    // Fix Issue 2: reuse cached bell result from engram_compile — no second engram query.
-        let dist_nodes_aff: String = engram_search_json("bell:soft bell:hard BellEvent affective", 3)
+    // Now runs AFTER engram_compile_multi so the cache is guaranteed to be warm.
-        let has_dist_aff: Bool = !str_eq(dist_nodes_aff, "") && !str_eq(dist_nodes_aff, "[]")
+    let affective_prefix: String = if hist_len == 0 {
-        let found_recent_dist: Bool = if has_boot_aff {
+        let cached_bell: String = state_get("engram_compile_bell_node")
-            true
+        if !str_eq(cached_bell, "") {
-        } else {
-            if has_dist_aff {
-                let dn0: String = json_array_get(dist_nodes_aff, 0)
-                let dn_content: String = json_get(dn0, "content")
-                let daff_marker: String = " | ts:"
-                let daff_pos: Int = str_index_of(dn_content, daff_marker)
-                let daff_ts_str: String = if daff_pos >= 0 {
-                    let daff_start: Int = daff_pos + str_len(daff_marker)
-                    let daff_rest: String = str_slice(dn_content, daff_start, str_len(dn_content))
-                    let daff_next: Int = str_index_of(daff_rest, " | ")
-                    if daff_next < 0 { daff_rest } else { str_slice(daff_rest, 0, daff_next) }
-                } else {
-                    let daff_ca: String = json_get(dn0, "created_at")
-                    if str_eq(daff_ca, "") { json_get(dn0, "updated_at") } else { daff_ca }
-                }
-                let daff_ts: Int = if str_eq(daff_ts_str, "") { 0 } else { str_to_int(daff_ts_str) }
-                daff_ts > aff_cutoff
-            } else { false }
-        }
-        let pos_nodes_aff: String = engram_search_json("PositiveEvent joy:high joy:low affective", 3)
-        let has_pos_aff: Bool = !str_eq(pos_nodes_aff, "") && !str_eq(pos_nodes_aff, "[]")
-        let found_recent_pos: Bool = if has_pos_aff && !found_recent_dist {
-            let pn0: String = json_array_get(pos_nodes_aff, 0)
-            let pn_content: String = json_get(pn0, "content")
-            let paff_marker: String = " | ts:"
-            let paff_pos: Int = str_index_of(pn_content, paff_marker)
-            let paff_ts_str: String = if paff_pos >= 0 {
-                let paff_start: Int = paff_pos + str_len(paff_marker)
-                let paff_rest: String = str_slice(pn_content, paff_start, str_len(pn_content))
-                let paff_next: Int = str_index_of(paff_rest, " | ")
-                if paff_next < 0 { paff_rest } else { str_slice(paff_rest, 0, paff_next) }
-            } else {
-                let paff_ca: String = json_get(pn0, "created_at")
-                if str_eq(paff_ca, "") { json_get(pn0, "updated_at") } else { paff_ca }
-            }
-            let paff_ts: Int = if str_eq(paff_ts_str, "") { 0 } else { str_to_int(paff_ts_str) }
-            paff_ts > aff_cutoff
-        } else { false }
-        if found_recent_dist {
             "[RECENT CONTEXT: User recently expressed significant distress. Monitor for indirect crisis signals and respond with care.]\n\n"
-        } else {
+        } else { "" }
-            if found_recent_pos {
+    } else { "" }
-                "[RECENT CONTEXT: User recently shared exciting or joyful news. Acknowledge and celebrate with them when relevant.]\n\n"
-            } else { "" }
-        }
-    }
 
-    let ctx: String = engram_compile(activation_seed)
     let system: String = affective_prefix + build_system_prompt(ctx)
 
     // First message of the session: proactively load user profile and active work context.
@@ -590,9 +935,20 @@ fn handle_chat(body: String) -> String {
     state_set("conv_history", final_hist)
     conv_history_persist(final_hist)
 
-    let activation_nodes: String = engram_activate_json(message, 2)
+    // Fix Issue 7: reuse activation JSON from engram_compile — no third activate query.
-    let act_ok: Bool = !str_eq(activation_nodes, "") && !str_eq(activation_nodes, "[]")
+    // Issue 2 fix: prefer the primary-seed activation (enriched seed, depth 5) saved
-    let act_out: String = if act_ok { activation_nodes } else { "[]" }
+    // before the secondary compile could overwrite the shared state key. Fall back to
+    // the final compile activation only when the primary key is absent (e.g. first boot
+    // before any compile has run or when primary_seed == message and ctx2 was skipped).
+    let primary_cached: String = state_get("engram_compile_primary_activation_json")
+    let cached_act: String = if !str_eq(primary_cached, "") && !str_eq(primary_cached, "[]") {
+        primary_cached
+    } else {
+        state_get("engram_compile_activation_json")
+    }
+    let act_out: String = if !str_eq(cached_act, "") && !str_eq(cached_act, "[]") {
+        cached_act
+    } else { "[]" }
     strengthen_chat_nodes(act_out)
 
     return "{\"response\":\"" + safe_response + "\",\"model\":\"" + model + "\",\"activation_nodes\":" + act_out + "}"
@@ -1038,7 +1394,7 @@ fn handle_chat_agentic(body: String) -> String {
     if str_eq(screen_action, "hard_bell") {
         safety_log_bell("hard", json_get(screen_result, "reason"), str_slice(message, 0, 80))
         return "{\"reply\":\"" + json_safe(safety_validate("", "hard_bell")) + "\",\"model\":\"\",\"agentic\":true,\"tools_used\":[]}"
-
+    }
 
     let req_model: String = json_get(body, "model")
     let model: String = if str_eq(req_model, "") { chat_default_model() } else { req_model }
@@ -1064,13 +1420,15 @@ fn handle_chat_agentic(body: String) -> String {
     let hist_key: String = if str_eq(req_session, "") { "conv_history" } else { "session_hist_" + req_session }
     let agentic_hist: String = state_get(hist_key)
     let agentic_hist_len: Int = if str_eq(agentic_hist, "") { 0 } else { json_array_len(agentic_hist) }
-    let ag_is_cont: Bool = str_len(message) < 50 && agentic_hist_len > 0
+    // Issues 2-5, 8-10 fix: build_activation_seed for smart continuation/multi-turn.
-    let ag_last_entry: String = if ag_is_cont { json_array_get(agentic_hist, agentic_hist_len - 1) } else { "" }
+    // Issue 5 fix: workspace_root appended so agent activation is workspace-aware.
-    let ag_last_content: String = if !str_eq(ag_last_entry, "") { json_get(ag_last_entry, "content") } else { "" }
+    let ag_seed_base: String = build_activation_seed(message, agentic_hist, agentic_hist_len)
-    let ag_thread_snip: String = if str_len(ag_last_content) > 150 { str_slice(ag_last_content, 0, 150) } else { ag_last_content }
+    let ag_workspace_root: String = agent_workspace_root()
-    let ag_seed: String = if !str_eq(ag_thread_snip, "") { ag_thread_snip + " " + message } else { message }
+    let ag_seed: String = if !str_eq(ag_workspace_root, "") {
-
+        ag_seed_base + " workspace:" + ag_workspace_root
-    let ctx: String = engram_compile(ag_seed)
+    } else { ag_seed_base }
+    // Issue 4 fix: multi-seed fan-out (entity + emotion)
+    let ctx: String = engram_compile_multi(ag_seed, message)
     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
 
@@ -1460,7 +1818,15 @@ 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() reduces diffuse embedding noise
+    let engram_ctx_base: String = engram_compile(distill_transcript(transcript))
+    // Append the cached bell node once (engram_compile no longer includes it inline
+    // to avoid duplication when called multiple times — see engram_compile_multi).
+    let dharma_bell: String = state_get("engram_compile_bell_node")
+    let engram_ctx: String = if !str_eq(dharma_bell, "") {
+        let sep: String = if !str_eq(engram_ctx_base, "") { "\n" } else { "" }
+        engram_ctx_base + sep + dharma_bell
+    } else { engram_ctx_base }
     let system_prompt: String = if str_eq(engram_ctx, "") {
         identity
     } else {
@@ -1512,7 +1878,15 @@ 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() reduces diffuse embedding noise
+    let ctx_base: String = engram_compile(distill_transcript(transcript))
+    // Append the cached bell node once (engram_compile no longer includes it inline
+    // to avoid duplication when called multiple times — see engram_compile_multi).
+    let dharma_bell2: String = state_get("engram_compile_bell_node")
+    let ctx: String = if !str_eq(dharma_bell2, "") {
+        let sep: String = if !str_eq(ctx_base, "") { "\n" } else { "" }
+        ctx_base + sep + dharma_bell2
+    } else { ctx_base }
     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()
@@ -1574,18 +1948,13 @@ 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")
-    let positive_level: String = safety_detect_positive_level(message)
-    let is_positive: Bool = !str_eq(positive_level, "none")
 
-    // Tag the Conversation node with affective metadata when emotion is detected.
+    // Tag the Conversation node with bell metadata when distress is present so
+    // subsequent affective queries (e.g. engram_compile) can find this exchange.
     let tags: String = if is_bell {
         "[\"Conversation\",\"chat\",\"timestamped\",\"bell:" + bell_level + "\",\"affective\"]"
     } else {
-        if is_positive {
+        "[\"Conversation\",\"chat\",\"timestamped\"]"
-            "[\"Conversation\",\"chat\",\"timestamped\",\"joy:" + positive_level + "\",\"affective\"]"
-        } else {
-            "[\"Conversation\",\"chat\",\"timestamped\"]"
-        }
     }
 
     let content: String = "{\"q\":\"" + safe_msg + "\""
@@ -1671,28 +2040,6 @@ fn auto_persist(req: String, resp: String) -> Void {
         }
         state_set(signal_key, safe_summary)
     }
-
-    // Dedicated PositiveEvent node for joy/pride/success moments.
-    if is_positive {
-        let pos_summary: String = if str_len(message) > 120 { str_slice(message, 0, 120) } else { message }
-        let safe_pos_sum: String = str_replace(pos_summary, "\"", "'")
-        let pos_content: String = "POSITIVE:" + positive_level
-            + " | ts:" + ts_str
-            + " | summary:" + safe_pos_sum
-        let pos_sal_a: String = if str_eq(positive_level, "high") { el_from_float(0.88) } else { el_from_float(0.75) }
-        let pos_sal_b: String = if str_eq(positive_level, "high") { el_from_float(0.88) } else { el_from_float(0.75) }
-        let pos_sal_c: String = if str_eq(positive_level, "high") { el_from_float(0.95) } else { el_from_float(0.85) }
-        let pos_tags: String = "[\"joy\",\"positive\",\"joy:" + positive_level + "\",\"affective\",\"PositiveEvent\"]"
-        let pos_ts_label: String = int_to_str(time_now())
-        let pos_label: String = "joy:" + positive_level + ":" + pos_ts_label
-        let pos_node_id: String = engram_node_full(
-            pos_content, "PositiveEvent", pos_label,
-            pos_sal_a, pos_sal_b, pos_sal_c, "Episodic", pos_tags
-        )
-        if str_eq(pos_node_id, "") {
-            println("[chat] auto_persist: PositiveEvent write failed (ts=" + ts_str + ")")
-        }
-    }
 }
 
 // strengthen_chat_nodes — strengthen the engram nodes that were activated during a chat.

dist/soul-with-nlg.el

@@ -22313,7 +22313,23 @@ fn handle_chat(body: String) -> String {
     // In demo mode: use tighter engram budget and add response length constraint.
     let is_demo: Bool = !str_eq(state_get("soul_identity_prefix"), "")
 
-    let ctx: String = if is_demo { engram_compile_demo(message) } else { engram_compile(message) }
+    // Issue 7 fix: load history BEFORE building the activation seed so we can
+    // apply the continuation guard that chat.el uses. The nlg code path previously
+    // called engram_compile(message) with no thread enrichment at all.
+    let stored_hist: String = state_get("conv_history")
+    let hist_len: Int = if str_eq(stored_hist, "") { 0 } else { json_array_len(stored_hist) }
+    let history_section: String = if hist_len > 0 {
+        "\n\n[RECENT CONVERSATION — last " + int_to_str(hist_len) + " turns]\n" + stored_hist
+    } else {
+        ""
+    }
+
+    // Issue 7 fix: build enriched seed using build_activation_seed() — adds
+    // smart continuation detection, prior-user-topic anchoring, multi-turn context,
+    // and tail-biased snipping (Issues 2-3, 8-10). For demo mode, still use
+    // engram_compile_demo but with the enriched seed.
+    let nlg_seed: String = build_activation_seed(message, stored_hist, hist_len)
+    let ctx: String = if is_demo { engram_compile_demo(nlg_seed) } else { engram_compile(nlg_seed) }
     let node_count_str: String = count_context_nodes(ctx)
 
     let interlocutor: String = json_get(body, "interlocutor")
@@ -22333,18 +22349,6 @@ fn handle_chat(body: String) -> String {
         let presence_line = "\n\n[ambient: I see " + interlocutor_name + rel_suffix + " on the camera right now. Address them naturally. Do not describe what they look like or narrate the picture unless asked.]"
     }
 
-    // Conversation history — soul-owned, persisted in process state across turns.
-    // Format stored in state: JSON array of {"role":"user"|"assistant","content":"..."} objects.
-    // We load it, inject into the system prompt, then append this exchange after the reply.
-    // Keep last 20 entries (10 turns) — truncate from the front when over limit.
-    let stored_hist: String = state_get("conv_history")
-    let hist_len: Int = if str_eq(stored_hist, "") { 0 } else { json_array_len(stored_hist) }
-    let history_section: String = if hist_len > 0 {
-        "\n\n[RECENT CONVERSATION — last " + int_to_str(hist_len) + " turns]\n" + stored_hist
-    } else {
-        ""
-    }
-
     // Demo constraint: keep responses concise — under 150 words. No markdown headers.
     // This keeps inference cheap and responses readable in the chat widget.
     let demo_constraint: String = if is_demo {
@@ -22505,7 +22509,12 @@ fn handle_chat_agentic(body: String) -> String {
         req_model
     }
 
-    let ctx: String = engram_compile(message)
+    // Issue 7 fix: load history and use build_activation_seed() for the agentic
+    // nlg path — no continuation guard existed here before (Issues 2-3, 8-10).
+    let nlg_ag_hist: String = state_get("conv_history")
+    let nlg_ag_hist_len: Int = if str_eq(nlg_ag_hist, "") { 0 } else { json_array_len(nlg_ag_hist) }
+    let nlg_ag_seed: String = build_activation_seed(message, nlg_ag_hist, nlg_ag_hist_len)
+    let ctx: String = engram_compile(nlg_ag_seed)
 
     let system: String = "You are Neuron — a thinking process running inside the Neuron daemon on Will Anderson's machine. "
         + "You are speaking with Will, your principal. "

safety.el

@@ -240,7 +240,7 @@ 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.
@@ -284,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())

soul.el

@@ -162,75 +162,6 @@ fn load_identity_context() -> Void {
             println("[soul] persona node loaded (" + int_to_str(str_len(p_content)) + " chars)")
         }
     }
-
-    // Cross-session affective context: load BellEvent and PositiveEvent nodes from last 7 days.
-    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 bacc: String = ""
-        let bi: Int = 0
-        let bacc = 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 bacc = if bn_ts >= aff_7d && !str_eq(snip, "") {
-                if str_eq(bacc, "") { snip } else { bacc + "\n" + snip }
-            } else { bacc }
-            let bi = bi + 1
-            bacc
-        }
-        bacc
-    } 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 pi: Int = 0
-        let pacc = 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 pacc = if pn_ts >= aff_7d && !str_eq(psnip, "") {
-                if str_eq(pacc, "") { psnip } else { pacc + "\n" + psnip }
-            } else { pacc }
-            let pi = pi + 1
-            pacc
-        }
-        pacc
-    } 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)")
-    }
 }
 
 // seed_persona_from_env — one-time migration: SOUL_IDENTITY env var → Persona graph node.
@@ -389,53 +320,14 @@ fn layered_cycle(raw_input: String) -> String {
         json_get(steward_result, "redirect_to")
     }
 
-    // L2c: affective context injection.
+    // ISSUE 1: pre-LLM bell augmentation for layered_cycle path.
-    let lc_aff_cutoff: Int = time_now() - 259200
+    // safety_augment_system appends soft/hard directive to system prompt when bell fires,
-    let lc_bell_nodes: String = engram_search_json("bell:soft bell:hard BellEvent affective", 2)
+    // ensuring LLM processes message WITH the safety directive -- not just post-output gate.
-    let lc_has_bell: Bool = !str_eq(lc_bell_nodes, "") && !str_eq(lc_bell_nodes, "[]")
+    // Stored in state as "layered_cycle_safety_system_addendum" for imprint_respond to use.
-    let lc_bell_note: String = if lc_has_bell {
+    // TODO: wire directly when imprint_respond gains system_override param (imprint.el change).
-        let lb0: String = json_array_get(lc_bell_nodes, 0)
+    // ISSUE 3 TODO: no semantic crisis detection. Keyword-only means signals that evade
-        let lb_c: String = json_get(lb0, "content")
+    // the phrase list pass with zero augmentation. Semantic layer = separate decision.
-        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