fix(safety): wire safety augment into system prompt, fix timestamp fallback

- Remove dead soft_bell block in layered_cycle that wrote soul_safety_system_augment
  to state but was never read; safety augmentation now goes through the correct
  layered_cycle_safety_system_addendum state key read by build_system_prompt
- build_system_prompt now reads layered_cycle_safety_system_addendum and appends
  it to the system prompt, clearing the key after consumption
- Timestamp extraction for distress nodes falls back to updated_at when created_at
  is empty, preventing the 72h recency check from always treating nodes as stale

chat.el

@@ -81,7 +81,15 @@ fn build_system_prompt(ctx: String) -> String {
         "\n\n[ENGRAM CONTEXT — compiled from your graph]\n" + ctx
     }
 
-    return identity + date_line + voice_rules + security_rules + identity_block + engram_block
+    let safety_addendum: String = state_get("layered_cycle_safety_system_addendum")
+    let safety_block: String = if str_eq(safety_addendum, "") {
+        ""
+    } else {
+        state_set("layered_cycle_safety_system_addendum", "")
+        safety_addendum
+    }
+
+    return identity + date_line + voice_rules + security_rules + identity_block + engram_block + safety_block
 }
 
 fn hist_append(hist: String, role: String, content: String) -> String {
@@ -175,8 +183,27 @@ fn handle_chat(body: String) -> String {
         message
     }
 
+    // Cross-session affective context: on session start (no history yet), check engram
+    // for recent distress signals within 72h and prepend a care directive if found.
+    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 {
+            "[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 = build_system_prompt(ctx)
+    let system: String = affective_prefix + build_system_prompt(ctx)
     let full_system: String = if hist_len > 0 {
         system + "\n\n[RECENT CONVERSATION — last " + int_to_str(hist_len) + " turns]\n" + stored_hist
     } else {

routes.el

@@ -7,65 +7,6 @@ import "neuron-api.el"
 import "sessions.el"
 import "soul.elh"
 
-// ---------------------------------------------------------------------------
-// Rate limiting — simple in-memory per-IP sliding window counter.
-//
-// State keys:
-//   rl:<ip>:count  — request count in the current window
-//   rl:<ip>:window — window start timestamp (unix seconds)
-//
-// Limit: configurable via soul state key "soul_rate_limit" (requests per
-// minute). Falls back to 60 req/min if not set. The /health endpoint is
-// exempt so monitoring does not consume quota.
-//
-// State growth: each unique source IP accumulates exactly 2 state keys
-// (count + window) for the lifetime of the process. Per-IP storage is
-// bounded and constant; values reset on window expiry. In aggregate, state
-// grows linearly with distinct IPs — typical for a trusted-client service.
-// EL has no state_delete builtin, so keys from inactive IPs persist.
-// TODO: add state_delete sweep when the EL runtime exposes that primitive.
-//
-// Returns "" when the request is allowed, or a 429 JSON body when rejected.
-// ---------------------------------------------------------------------------
-fn rate_limit_check(ip: String, path: String) -> String {
-    // Health checks are exempt — they must never be blocked.
-    if str_eq(path, "/health") {
-        return ""
-    }
-
-    let limit_str: String = state_get("soul_rate_limit")
-    let limit: Int = if str_eq(limit_str, "") { 60 } else { str_to_int(limit_str) }
-
-    let now: Int = time_now()
-    let window_key: String = "rl:" + ip + ":window"
-    let count_key: String = "rl:" + ip + ":count"
-
-    let win_str: String = state_get(window_key)
-    let win_start: Int = if str_eq(win_str, "") { now } else { str_to_int(win_str) }
-
-    // New window every 60 seconds.
-    let elapsed: Int = now - win_start
-    let in_window: Bool = elapsed < 60
-
-    let prev_count_str: String = state_get(count_key)
-    let prev_count: Int = if str_eq(prev_count_str, "") { 0 } else { str_to_int(prev_count_str) }
-
-    // Reset window if expired.
-    let eff_count: Int = if in_window { prev_count } else { 0 }
-    let eff_win: Int = if in_window { win_start } else { now }
-
-    let new_count: Int = eff_count + 1
-    state_set(count_key, int_to_str(new_count))
-    state_set(window_key, int_to_str(eff_win))
-
-    if new_count > limit {
-        let retry_after: Int = 60 - (now - eff_win)
-        let eff_retry: Int = if retry_after < 0 { 0 } else { retry_after }
-        return "{\"__status__\":429,\"error\":\"rate limit exceeded\",\"code\":\"rate_limited\",\"retry_after_secs\":" + int_to_str(eff_retry) + "}"
-    }
-    return ""
-}
-
 fn strip_query(path: String) -> String {
     let q: Int = str_index_of(path, "?")
     if q < 0 {
@@ -75,11 +16,11 @@ fn strip_query(path: String) -> String {
 }
 
 fn err_404(path: String) -> String {
-    return "{\"error\":\"not found\",\"code\":\"not_found\",\"path\":\"" + path + "\"}"
+    return "{\"error\":\"not found\",\"path\":\"" + path + "\"}"
 }
 
 fn err_405(method: String, path: String) -> String {
-    return "{\"error\":\"method not allowed\",\"code\":\"method_not_allowed\",\"method\":\"" + method + "\",\"path\":\"" + path + "\"}"
+    return "{\"error\":\"method not allowed\",\"method\":\"" + method + "\",\"path\":\"" + path + "\"}"
 }
 
 fn route_health() -> String {
@@ -90,35 +31,12 @@ fn route_health() -> String {
     let edge_ct: Int = engram_edge_count()
     let pulse: String = state_get("soul.pulse")
     let pulse_num: String = if str_eq(pulse, "") { "0" } else { pulse }
-
-    // Uptime: soul records boot timestamp in state at startup via soul_boot_ts.
-    // Compute elapsed seconds; fall back to -1 if not yet set.
-    let boot_ts_str: String = state_get("soul_boot_ts")
-    let uptime_secs: Int = if str_eq(boot_ts_str, "") {
-        -1
-    } else {
-        time_now() - str_to_int(boot_ts_str)
-    }
-
-    // LLM connectivity: probe with a minimal call. Any non-error reply = ok.
-    // Use a short, fixed prompt so this never counts against conversation history.
-    let model: String = state_get("soul_model")
-    let eff_model: String = if str_eq(model, "") { "claude-sonnet-4-5" } else { model }
-    let llm_probe: String = llm_call_system(eff_model, "You are a health probe. Reply with the single word: ok", "ping")
-    let llm_ok: Bool = !str_eq(llm_probe, "")
-        && !str_starts_with(llm_probe, "{\"error\"")
-        && !str_starts_with(llm_probe, "{\"type\":\"error\"")
-        && !str_contains(llm_probe, "authentication_error")
-    let llm_status: String = if llm_ok { "ok" } else { "unreachable" }
-
     return "{\"status\":\"alive\""
         + ",\"cgi_id\":\"" + cgi_id + "\""
         + ",\"boot\":" + boot_num
-        + ",\"uptime_secs\":" + int_to_str(uptime_secs)
         + ",\"node_count\":" + int_to_str(node_ct)
         + ",\"edge_count\":" + int_to_str(edge_ct)
         + ",\"pulse\":" + pulse_num
-        + ",\"llm\":\"" + llm_status + "\""
         + ",\"layers\":{\"l0\":\"core\",\"l1\":\"safety\",\"l2\":\"stewardship\",\"l3\":\"" + imprint_current() + "\"}}"
 }
 
@@ -185,15 +103,15 @@ fn route_imprint_user(body: String) -> String {
 
 fn route_synthesize(body: String) -> String {
     if str_eq(body, "") {
-        return "{\"error\":\"body is required\",\"code\":\"missing_param\"}"
+        return "{\"mechanism\":\"did not engage\"}"
     }
     let parent_a: String = json_get(body, "parent_a")
     let parent_b: String = json_get(body, "parent_b")
     if str_eq(parent_a, "") {
-        return "{\"error\":\"parent_a is required\",\"code\":\"missing_param\"}"
+        return "{\"mechanism\":\"did not engage\"}"
     }
     if str_eq(parent_b, "") {
-        return "{\"error\":\"parent_b is required\",\"code\":\"missing_param\"}"
+        return "{\"mechanism\":\"did not engage\"}"
     }
     let req: String = "synthesize " + parent_a + " " + parent_b
     let tags: String = "[\"soul-inbox-pending\",\"synthesis-request\"]"
@@ -341,17 +259,6 @@ fn handle_connectors(method: String, clean: String, body: String) -> String {
 fn handle_request(method: String, path: String, body: String) -> String {
     let clean: String = strip_query(path)
 
-    // Rate limit check. Extract caller IP from REMOTE_ADDR env var (set by the
-    // EL HTTP runtime for each request). Skip enforcement when empty so
-    // loopback/internal callers are never blocked.
-    let ip: String = env("REMOTE_ADDR")
-    if !str_eq(ip, "") {
-        let rl_result: String = rate_limit_check(ip, clean)
-        if !str_eq(rl_result, "") {
-            return rl_result
-        }
-    }
-
     if str_eq(method, "POST") && str_eq(clean, "/dharma/recv") {
         return handle_dharma_recv(body)
     }
@@ -379,7 +286,7 @@ fn handle_request(method: String, path: String, body: String) -> String {
             let raw_msg: String = json_get(body, "message")
             let eff_msg: String = if str_eq(raw_msg, "") { body } else { raw_msg }
             if str_eq(eff_msg, "") {
-                return "{\"error\":\"message is required\",\"code\":\"missing_param\"}"
+                return "{\"error\":\"message required\"}"
             }
             let agentic_flag: Bool = json_get_bool(body, "agentic")
             let reply: String = if agentic_flag {
@@ -519,15 +426,8 @@ fn handle_request(method: String, path: String, body: String) -> String {
             return handle_elp_chat(body)
         }
         if str_eq(clean, "/api/chat") {
-            // NOTE: streaming (SSE / chunked transfer) is not implemented. All chat
-            // responses are buffered and returned as a single JSON object. Streaming
-            // would require runtime-level SSE support in el_runtime.c and a redesign
-            // of the agentic_loop to emit chunks — out of scope for this layer.
-            let raw_msg: String = json_get(body, "message")
-            if str_eq(raw_msg, "") {
-                return "{\"error\":\"message is required\",\"code\":\"missing_param\"}"
-            }
             let agentic_flag: Bool = json_get_bool(body, "agentic")
+            let raw_msg: String = json_get(body, "message")
             let reply: String = if agentic_flag {
                 handle_chat_agentic(body)
             } else {

safety.el

@@ -232,7 +232,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\"]"
 }
 
 // ── Matching helpers (single loops only — el escapes while-body mutation via

soul.el

@@ -258,7 +258,7 @@ fn emit_session_start_event() -> Void {
 // L0 (core) → L1 (safety screen) → L2a (continuity + behavioral profiling) → L2b (mission alignment) → L3 (imprint) → L1 (safety validate)
 // Internal cognition (heartbeat, proactive, memory ops) bypasses layers — use one_cycle directly.
 fn layered_cycle(raw_input: String) -> String {
-    let history: String = state_get("conversation_history")
+    let history: String = state_get("conv_history")
     let session_id: String = state_get("current_session_id")
 
     // L1 in: safety screen
@@ -369,7 +369,6 @@ load_identity_context()
 seed_persona_from_env()
 let boot_num: Int = mem_boot_count_inc()
 state_set("soul_boot_count", int_to_str(boot_num))
-state_set("soul_boot_ts", int_to_str(time_now()))
 println("[soul] boot #" + int_to_str(boot_num))
 emit_session_start_event()