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,
-// ordered best-first by score. Only nodes above a minimum score (25 = salience 0.5 *
-// importance 0.5 * recency 1.0) are included; the rest are noise. Returns at most
-// max_nodes entries concatenated as JSON array text. Because el has no sort primitive,
-// we do a single selection pass picking the top N by linear scan (N=10 cap).
+// engram_compile_ranked — build a ranked list of nodes, best-first by score.
+// Fix (Issue #11): uses "|N|" index tracking instead of _sel_N JSON mutation,
+// which leaked sentinel fields into the node objects passed to the LLM.
+// Threshold lowered to 15 to include moderately-relevant older nodes.
 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.
-    // We track selected node indices and their scores to avoid duplicate picks.
-    let selected: String = ""   // comma-sep JSON snippets for chosen nodes
-    let selected_count: Int = 0
+    // selected_indices is a pipe-delimited string of chosen integer indices, e.g. "|2|7|".
+    // No sentinel fields are injected into the node JSON — the nodes stay clean.
+    let selected_indices: String = ""
+    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)
-            let above_thresh: Bool = score >= 25
-            // Check this index wasn't already selected (sentinel: look for idx marker)
-            let idx_marker: String = "\"_sel_" + int_to_str(ci) + "\""
-            let already_picked: Bool = str_contains(selected, idx_marker)
+            // Threshold lowered from 25 to 15: includes moderately-relevant older nodes.
+            // A 3-week-old node with salience 0.6 and importance 0.6 scores ~18.
+            let above_thresh: Bool = score >= 15
+            // Check this index wasn't already selected using the index string.
+            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 { "," }
-            // Append the index sentinel inline so already_picked checks work
-            let selected = selected + sep + "{\"_sel_" + int_to_str(best_idx) + "\":1," + str_slice(chosen, 1, str_len(chosen) - 1) + "}"
-            let selected_count = selected_count + 1
+            let sep: String = if str_eq(selected_nodes, "") { "" } else { "," }
+            let selected_nodes = selected_nodes + sep + chosen
+            let selected_indices = selected_indices + "|" + int_to_str(best_idx) + "|"
         }
         let pass = pass + 1
     }
 
-    if str_eq(selected, "") { return "" }
-    // Strip the _sel_N sentinel fields that were used for duplicate-detection bookkeeping.
-    // 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.
-    let clean: String = "[" + selected + "]"
-    let c0: String = str_replace(clean, "\"_sel_0\":1,", "")
-    let c1: String = str_replace(c0, "\"_sel_1\":1,", "")
-    let c2: String = str_replace(c1, "\"_sel_2\":1,", "")
-    let c3: String = str_replace(c2, "\"_sel_3\":1,", "")
-    let c4: String = str_replace(c3, "\"_sel_4\":1,", "")
-    let c5: String = str_replace(c4, "\"_sel_5\":1,", "")
-    let c6: String = str_replace(c5, "\"_sel_6\":1,", "")
-    let c7: String = str_replace(c6, "\"_sel_7\":1,", "")
-    let c8: String = str_replace(c7, "\"_sel_8\":1,", "")
-    let c9: String = str_replace(c8, "\"_sel_9\":1,", "")
-    return c9
+    if str_eq(selected_nodes, "") { return "" }
+    return "[" + selected_nodes + "]"
+}
+
+// engram_render_node — render a single engram node JSON object as a human-readable
+// bullet line for inclusion in the system prompt. Format: - [TYPE age sal] content
+// Fix (Issue #3, #4): passes context as prose bullets instead of raw JSON objects,
+// which are opaque to the LLM and waste token budget on field names.
+fn engram_render_node(node_json: String) -> String {
+    if str_eq(node_json, "") { return "" }
+    let content: String = json_get(node_json, "content")
+    if str_eq(content, "") { return "" }
+    let node_type: String = json_get(node_json, "node_type")
+    let type_label: String = if str_eq(node_type, "") { "mem" } else { node_type }
+    let now_ts: Int = time_now()
+    let created_str: String = json_get(node_json, "created_at")
+    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,20 +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 { "" }
-    let affective_part: String = if !str_eq(recent_bell, "") { recent_bell } else { "" }
-
+    // Issue 6 fix: do NOT include the bell node in this function's return value.
+    // engram_compile is called multiple times by engram_compile_multi (once per seed).
+    // If affective_part were appended here, the bell node JSON would appear once per
+    // compile call — duplicating it in the merged context. Instead, cache the bell node
+    // here and let engram_compile_multi append it exactly once after all calls complete.
     let sep1: String = if !str_eq(act_part, "") && !str_eq(srch_part, "") { "\n" } else { "" }
     let sep2: String = if (!str_eq(act_part, "") || !str_eq(srch_part, "")) && !str_eq(scan_part, "") { "\n" } else { "" }
-    let sep3: String = if (!str_eq(act_part, "") || !str_eq(srch_part, "") || !str_eq(scan_part, "")) && !str_eq(affective_part, "") { "\n" } else { "" }
-    let ctx: String = act_part + sep1 + srch_part + sep2 + scan_part + sep3 + affective_part
+    let ctx: String = act_part + sep1 + srch_part + sep2 + scan_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.
-    if str_len(ctx) > 6000 {
-        return str_slice(ctx, 0, 6000)
+    // Cap at a clean JSON object boundary — scan back from the 6000-char limit to find
+    // the last closing brace so we never return a truncated mid-object JSON string.
+    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 {
@@ -227,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")
@@ -384,40 +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",
-    // "what else?", "yes") activate on the last reply instead of the bare message.
-    // This prevents a strong off-topic memory node from hijacking the reply when the
-    // user is clearly continuing an existing thread.
-    let is_continuation: Bool = str_len(message) < 50 && hist_len > 0
-    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
-    }
+    // Issues 2-3, 8-10 fix: build_activation_seed() replaces the raw 50-char threshold
+    // with smart continuation detection, prior-user-topic anchoring, multi-turn context,
+    // and tail-biased snipping from long assistant replies.
+    let activation_seed: String = build_activation_seed(message, stored_hist, hist_len)
 
-    // Cross-session affective context: on session start (no history yet), check engram
-    // for recent distress signals within 72h and prepend a care directive if found.
+    // Issue 1 fix: call engram_compile_multi BEFORE reading the bell-node cache.
+    // engram_compile (called inside engram_compile_multi) writes "engram_compile_bell_node"
+    // at line 426. Reading the cache before the compile call means the first session turn
+    // always sees an empty cache — the very turn where safety continuity matters most.
+    // Moving compile first ensures the cache is populated before affective_prefix reads it.
+    let ctx: String = engram_compile_multi(activation_seed, message)
+
+    // Fix Issue 2: reuse cached bell result from engram_compile — no second engram query.
+    // Now runs AFTER engram_compile_multi so the cache is guaranteed to be warm.
     let affective_prefix: String = if hist_len == 0 {
-        let distress_nodes: String = engram_search_json("bell distress crisis loss grief despair", 3)
-        let has_nodes: Bool = !str_eq(distress_nodes, "") && !str_eq(distress_nodes, "[]")
-        let now_ts: Int = time_now()
-        let cutoff: Int = now_ts - 259200
-        let found_recent: Bool = if has_nodes {
-            let dn0: String = json_array_get(distress_nodes, 0)
-            let ts0_raw: String = json_get(dn0, "created_at")
-            let ts0_str: String = if str_eq(ts0_raw, "") { json_get(dn0, "updated_at") } else { ts0_raw }
-            let ts0: Int = if str_eq(ts0_str, "") { 0 } else { str_to_int(ts0_str) }
-            ts0 > cutoff
-        } else { false }
-        if found_recent {
+        let cached_bell: String = state_get("engram_compile_bell_node")
+        if !str_eq(cached_bell, "") {
             "[RECENT CONTEXT: User recently expressed significant distress. Monitor for indirect crisis signals and respond with care.]\n\n"
         } else { "" }
     } else { "" }
 
-    let ctx: String = engram_compile(activation_seed)
     let system: String = affective_prefix + build_system_prompt(ctx)
 
     // First message of the session: proactively load user profile and active work context.
@@ -526,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)
-    let act_ok: Bool = !str_eq(activation_nodes, "") && !str_eq(activation_nodes, "[]")
-    let act_out: String = if act_ok { activation_nodes } else { "[]" }
+    // Fix Issue 7: reuse activation JSON from engram_compile — no third activate query.
+    // Issue 2 fix: prefer the primary-seed activation (enriched seed, depth 5) saved
+    // 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 + "}"
@@ -974,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 }
@@ -1000,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
-    let ag_last_entry: String = if ag_is_cont { json_array_get(agentic_hist, agentic_hist_len - 1) } else { "" }
-    let ag_last_content: String = if !str_eq(ag_last_entry, "") { json_get(ag_last_entry, "content") } else { "" }
-    let ag_thread_snip: String = if str_len(ag_last_content) > 150 { str_slice(ag_last_content, 0, 150) } else { ag_last_content }
-    let ag_seed: String = if !str_eq(ag_thread_snip, "") { ag_thread_snip + " " + message } else { message }
-
-    let ctx: String = engram_compile(ag_seed)
+    // Issues 2-5, 8-10 fix: build_activation_seed for smart continuation/multi-turn.
+    // Issue 5 fix: workspace_root appended so agent activation is workspace-aware.
+    let ag_seed_base: String = build_activation_seed(message, agentic_hist, agentic_hist_len)
+    let ag_workspace_root: String = agent_workspace_root()
+    let ag_seed: String = if !str_eq(ag_workspace_root, "") {
+        ag_seed_base + " workspace:" + ag_workspace_root
+    } 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
 
@@ -1396,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 {
@@ -1448,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()

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. "