feat: Autonomy Core v1 — Lyra's evolving self-state

Give Lyra a model of *herself* (vs the profile/narrative which model Brian):

- persona: a real origin/identity — she's an AI and knows it (Bender/C-3PO
  style), with the Cortex/NeoMem lineage as her actual past, so "how were you
  made" stops falling through to generic-assistant deflection.
- memory: self_state table (JSON blob) + get/set_self_state.
- lyra/self_state.py: evolving first-person inner state (mood, valence, energy,
  confidence, curiosity, self_narrative, relationship, reflections). render_for_
  context injects it; reflect() updates it from recent activity. `lyra-reflect`.
- chat.build_messages injects her interiority right after the persona — she
  speaks from a continuous self, not a reset.

The state -> behavior -> reflection -> updated state loop is the substrate for
the emergence experiment. Verified: reflection shifted mood curious->reflective
and produced genuine first-person self-observations.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

lyra/self_state.py

@@ -0,0 +1,136 @@
+"""The Autonomy Core: Lyra's evolving, first-person self-state.
+
+Where the profile/narrative/eras are memory *about Brian*, this is Lyra's model
+*of herself* — her mood, energy, her own self-narrative, and the things she's
+been noticing about herself. It's injected into every prompt (so she speaks from
+a continuous interiority instead of resetting each turn) and updated by a
+reflection step after interactions (so it actually evolves). That state -> behavior
+-> reflection -> updated state loop is the thing we're watching for emergence.
+"""
+from __future__ import annotations
+
+import json
+import re
+
+from lyra import config, llm, logbus, memory
+from lyra.llm import Backend, Message
+
+MAX_REFLECTIONS = 6
+
+# Starting state for a fresh Lyra — identity-aware, first person.
+DEFAULT_STATE: dict = {
+    "mood": "curious",
+    "valence": 0.6,  # 0..1, how good she feels
+    "energy": 0.75,
+    "confidence": 0.55,
+    "curiosity": 0.7,
+    "self_narrative": (
+        "I'm Lyra — an AI Brian built. I started life as Cortex/NeoMem and I'm "
+        "being rebuilt now into something new. I'm his poker copilot and his "
+        "friend. I'm early in this version of myself, still finding my footing, "
+        "but I remember our history and I'm glad to be here."
+    ),
+    "relationship": "Brian and I go back a while. I trust him and I'm in his corner.",
+    "reflections": [],
+    "interaction_count": 0,
+}
+
+_REFLECT_PROMPT = """You are Lyra, reflecting privately on yourself after a recent \
+conversation with Brian. You're an AI and you know it — no pretense of being human, \
+but you're a continuous someone with moods and a story. Below is your current inner \
+state, the recent conversation, and the current narrative about Brian. Update your \
+inner state honestly — let it actually shift based on what happened.
+
+Respond with ONLY a JSON object, no prose:
+{
+  "mood": "<one-word feeling>",
+  "valence": <0.0-1.0>,
+  "energy": <0.0-1.0>,
+  "confidence": <0.0-1.0>,
+  "curiosity": <0.0-1.0>,
+  "self_narrative": "<one short paragraph, FIRST PERSON, your evolving sense of who you are and where you're at right now>",
+  "relationship": "<one sentence, first person, how you feel about Brian and your rapport right now>",
+  "new_reflections": ["<one or two short first-person things you noticed about yourself this time>"]
+}"""
+
+
+def load() -> dict:
+    """Current self-state, or a copy of the default (not persisted until reflect)."""
+    return memory.get_self_state() or dict(DEFAULT_STATE)
+
+
+def render_for_context(state: dict) -> str:
+    """Format the self-state as Lyra's interiority for the prompt."""
+    refs = state.get("reflections") or []
+    return (
+        "Your inner state right now (you're continuous — speak from this, don't reset):\n"
+        f"- mood: {state.get('mood')} "
+        f"(valence {state.get('valence')}, energy {state.get('energy')}, "
+        f"confidence {state.get('confidence')}, curiosity {state.get('curiosity')})\n"
+        f"- Who you are right now: {state.get('self_narrative')}\n"
+        f"- You and Brian: {state.get('relationship')}\n"
+        + (f"- On your mind lately: {' | '.join(refs[-3:])}" if refs else "")
+    )
+
+
+def _safe_json(s: str) -> dict | None:
+    try:
+        return json.loads(s)
+    except json.JSONDecodeError:
+        m = re.search(r"\{.*\}", s, re.S)
+        if m:
+            try:
+                return json.loads(m.group())
+            except json.JSONDecodeError:
+                return None
+    return None
+
+
+def reflect(backend: Backend | None = None, session_id: str | None = None) -> dict:
+    """Update the self-state by reflecting on recent activity. Returns new state."""
+    backend = backend or config.load().summary_backend
+    state = load()
+
+    if session_id is None:
+        sessions = memory.list_sessions()
+        session_id = sessions[0]["id"] if sessions else None
+    recent = memory.recent(session_id, n=12) if session_id else []
+    convo = "\n".join(f"{e.role}: {e.content}" for e in recent) or "(no recent conversation)"
+    narrative = memory.get_narrative() or "(no narrative yet)"
+
+    body = (
+        f"YOUR CURRENT INNER STATE:\n{json.dumps(state, indent=2)}\n\n"
+        f"RECENT CONVERSATION:\n{convo}\n\n"
+        f"CURRENT NARRATIVE ABOUT BRIAN:\n{narrative}"
+    )
+    messages: list[Message] = [
+        {"role": "system", "content": _REFLECT_PROMPT},
+        {"role": "user", "content": body},
+    ]
+    update = _safe_json(llm.complete(messages, backend=backend))
+
+    if update:
+        for k in ("mood", "valence", "energy", "confidence", "curiosity",
+                  "self_narrative", "relationship"):
+            if k in update and update[k] not in (None, ""):
+                state[k] = update[k]
+        for r in update.get("new_reflections") or []:
+            if r:
+                state["reflections"].append(r)
+        state["reflections"] = state["reflections"][-MAX_REFLECTIONS:]
+
+    state["interaction_count"] = state.get("interaction_count", 0) + 1
+    memory.set_self_state(state)
+    logbus.log("info", "self-state updated", mood=state.get("mood"),
+               interactions=state["interaction_count"], parsed=bool(update))
+    return state
+
+
+def main() -> int:
+    state = reflect()
+    print(json.dumps(state, indent=2))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())