feat: full-fidelity conversation export (chat + tool calls)

Chat only ever lived in SQLite's `exchanges` table (what was *said*); tool
calls were transient — logged to the in-memory ring buffer and gone at
end-of-turn. This adds a persistent record of what Lyra *did* and exports the
two merged into one transcript.

- memory: new `tool_events` table + `add_tool_event`/`tool_events` accessors;
  `delete_session` cascades to it.
- chat: persist each tool call (name/args/result) right where it fires, in both
  the non-stream and stream paths. Move the user `remember` to just after
  assembly so its timestamp precedes mid-turn tool events — keeps the export in
  true chronological order (and records when the message actually arrived).
- transcript: new module renders a session as Markdown (Brian/Lyra speech with
  ⚙ tool-call lines interleaved) or JSON (machine-readable event stream).
- server: GET /sessions/{id}/export?format=md|json (attachment download).
- ui: ⬇ Export button by the session selector (Markdown or JSON).

Doubles as the receipt for "did the tool actually fire?" — the thing that was
invisible when she'd reply about a hand without logging it.

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

lyra/chat.py

@@ -69,6 +69,7 @@ def _mind_loop(messages, backend: Backend, model: str | None, tool_specs,
         messages.append(assistant_msg)
         for tc in tool_calls:
             result = toolkit.dispatch(tc["name"], tc["arguments"], ctx)
+            memory.add_tool_event(session_id, tc["name"], tc["arguments"], result)
             logbus.log("info", "tool call", session=session_id, tool=tc["name"], result=result[:80])
             messages.append({"role": "tool", "tool_call_id": tc["id"], "content": result})
             _maybe_switch_mode(session_id, tc["name"])
@@ -99,6 +100,9 @@ def respond(session_id: str, user_msg: str, backend: Backend = "cloud",
     tool_specs = toolkit.specs(turn.mode.tools) if backend in TOOL_BACKENDS else None
     ctx = {"session_id": session_id, "backend": backend}
 
+    # Persist the user turn before the tool loop so its timestamp precedes any
+    # tool events fired mid-turn (keeps the transcript export in true order).
+    memory.remember(session_id, "user", user_msg)
     reply, _ = _mind_loop(messages, backend, model, tool_specs, ctx, session_id)
     mouth = _mouth_target(cfg, backend, model)
     if mouth and reply:
@@ -107,7 +111,6 @@ def respond(session_id: str, user_msg: str, backend: Backend = "cloud",
         reply = _TANGLED
     logbus.log("info", "reply", session=session_id, chars=len(reply), voiced=bool(mouth))
 
-    memory.remember(session_id, "user", user_msg)
     memory.remember(session_id, "assistant", reply)
     summary.maybe_summarize_async(session_id)  # compact once enough new turns pile up
     return reply
@@ -128,6 +131,10 @@ def respond_stream(session_id: str, user_msg: str, backend: Backend = "cloud",
     ctx = {"session_id": session_id, "backend": backend}
     mouth = _mouth_target(cfg, backend, model)
 
+    # Persist the user turn up front (see respond): keeps tool events, which fire
+    # mid-turn, chronologically after the user message in the exported transcript.
+    memory.remember(session_id, "user", user_msg)
+
     if mouth is None:
         # No separate voice: stream the mind directly (the original path, unchanged).
         parts: list[str] = []
@@ -149,6 +156,7 @@ def respond_stream(session_id: str, user_msg: str, backend: Backend = "cloud",
             messages.append(assistant_msg)
             for tc in tool_calls:
                 result = toolkit.dispatch(tc["name"], tc["arguments"], ctx)
+                memory.add_tool_event(session_id, tc["name"], tc["arguments"], result)
                 logbus.log("info", "tool call", session=session_id, tool=tc["name"], result=result[:80])
                 messages.append({"role": "tool", "tool_call_id": tc["id"], "content": result})
                 _maybe_switch_mode(session_id, tc["name"])
@@ -177,7 +185,6 @@ def respond_stream(session_id: str, user_msg: str, backend: Backend = "cloud",
             yield ("delta", reply)
 
     logbus.log("info", "reply", session=session_id, chars=len(reply), voiced=bool(mouth))
-    memory.remember(session_id, "user", user_msg)
     memory.remember(session_id, "assistant", reply)
     summary.maybe_summarize_async(session_id)
     yield ("done", reply)