soul loop-1: identity loading, boot counter, internal state events, richer awareness

- memory.el: mem_boot_count_get/inc (persisted counter), mem_emit_state_event (InternalStateEvent schema)
- soul.el: load_identity_context() loads intel-dna/values/mem-philosophy nodes into state at boot; boot counter incremented on every startup
- awareness.el: attend() gains search/activate/strengthen/forget action types; one_cycle() emits InternalStateEvent for non-trivial decisions
- chat.el: build_system_prompt includes [IDENTITY GRAPH] block from graph-loaded context; handle_chat strengthens activated nodes after each turn

memory.el

@@ -52,3 +52,55 @@ fn mem_save(path: String) -> Void {
 fn mem_load(path: String) -> Void {
     engram_load(path)
 }
+
+// mem_boot_count_get — retrieve current boot count from engram.
+// Searches for the "soul:boot_count" node and returns its numeric value.
+// Returns 0 if not found.
+fn mem_boot_count_get() -> Int {
+    let results: String = engram_search_json("soul:boot_count", 3)
+    if str_eq(results, "") { return 0 }
+    if str_eq(results, "[]") { return 0 }
+    let node: String = json_array_get(results, 0)
+    let content: String = json_get(node, "content")
+    let prefix: String = "soul:boot_count:"
+    if !str_starts_with(content, prefix) { return 0 }
+    let num_str: String = str_slice(content, str_len(prefix), str_len(content))
+    return str_to_int(num_str)
+}
+
+// mem_boot_count_inc — increment boot counter, store new node, return new count.
+// Each boot creates a new "soul:boot_count:N" node. Old ones accumulate as
+// history — the search above always returns the highest value seen.
+fn mem_boot_count_inc() -> Int {
+    let current: Int = mem_boot_count_get()
+    let next: Int = current + 1
+    let content: String = "soul:boot_count:" + int_to_str(next)
+    let tags: String = "[\"soul-meta\",\"boot-counter\"]"
+    let discard: String = engram_node_full(
+        content, "Memory", "soul:boot_count",
+        el_from_float(0.9), el_from_float(0.9), el_from_float(1.0),
+        "Canonical", tags
+    )
+    return next
+}
+
+// mem_emit_state_event — log an internal state event as structured memory.
+// Schema: {trigger, kind, content, boot, ts}
+// This creates an auditable evidence trail of cognitive decisions.
+fn mem_emit_state_event(trigger: String, kind: String, content: String) -> String {
+    let boot: Int = mem_boot_count_get()
+    let ts: Int = time_now()
+    let safe_trigger: String = str_replace(trigger, "\"", "'")
+    let safe_content: String = str_replace(content, "\"", "'")
+    let payload: String = "{\"trigger\":\"" + safe_trigger + "\""
+        + ",\"kind\":\"" + kind + "\""
+        + ",\"content\":\"" + safe_content + "\""
+        + ",\"boot\":" + int_to_str(boot)
+        + ",\"ts\":" + int_to_str(ts) + "}"
+    let tags: String = "[\"internal-state\",\"pre-reasoning\",\"InternalStateEvent\"]"
+    return engram_node_full(
+        payload, "InternalStateEvent", "state-event:" + kind,
+        el_from_float(0.85), el_from_float(0.8), el_from_float(0.9),
+        "Episodic", tags
+    )
+}