Add canonical event log and renderer skeleton (A10)

Build-order step 4, sequenced before the LLM client (step 3) because
the client interface consumes the canonical log.

- canonical.py: typed events for the full A10 table (user_message
  through compaction); canonical tool-call IDs minted locally,
  provider IDs never a join key; strict payload validation on load
- StateStore: canonical_events table via schema v2 — the first real
  migration, exercised in a test against a hand-built v1 database —
  with append_event/read_events on the same fsync-per-commit path
- render.py: request bodies rendered from the log at call time;
  first adapter targets the OpenAI-compatible shape of LiteLLM's
  normalized route; compaction events replace their id range at
  render time while staying in the durable log
- Crash integration test now also verifies transcript appends
  survive process death

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

nisse-dev/src/nisse_dev/render.py

@@ -0,0 +1,114 @@
+"""A10 renderer: provider request bodies are built from the canonical log at
+call time, never stored provider-shaped.
+
+First adapter: the OpenAI-compatible chat format LiteLLM's normalized route
+speaks — the executor role's path (A5). The Anthropic passthrough adapter
+arrives with delegations (A13). Token budgeting and prompt-cache breakpoints
+are render-time concerns and are never stored (A10); neither exists yet in
+this skeleton.
+"""
+
+import json
+from typing import Any
+
+from nisse_dev.canonical import (
+    AssistantText,
+    Compaction,
+    DelegationCompleted,
+    DelegationStarted,
+    GateOpened,
+    PlanSubmitted,
+    StoredEvent,
+    ToolCall,
+    ToolResult,
+    UserMessage,
+)
+
+
+def effective_events(stored: list[StoredEvent]) -> list[StoredEvent]:
+    """Apply compactions: events whose ids fall in a compaction's replaced
+    range are dropped; the compaction event itself stays as their summary."""
+    replaced: list[tuple[int, int]] = [
+        (e.event.replaces[0], e.event.replaces[1])
+        for e in stored
+        if isinstance(e.event, Compaction)
+    ]
+
+    def is_replaced(event_id: int) -> bool:
+        return any(first <= event_id <= last for first, last in replaced)
+
+    return [
+        e for e in stored if isinstance(e.event, Compaction) or not is_replaced(e.id)
+    ]
+
+
+class OpenAIChatRenderer:
+    """Mappings for orchestrator-side events (gates, plans, delegations,
+    compaction summaries) are provisional; they get tuned when the executor
+    loop (step 5) and delegations (step 7) consume them for real."""
+
+    def render(
+        self,
+        events: list[StoredEvent],
+        tools: list[dict[str, Any]] | None,
+        model: str,
+        system: str | None = None,
+    ) -> dict[str, Any]:
+        messages: list[dict[str, Any]] = []
+        if system is not None:
+            messages.append({"role": "system", "content": system})
+        for stored in effective_events(events):
+            messages.append(self._message_for(stored.event))
+        body: dict[str, Any] = {"model": model, "messages": messages}
+        if tools:
+            body["tools"] = tools
+        return body
+
+    def _message_for(self, event: object) -> dict[str, Any]:
+        match event:
+            case UserMessage(text=text):
+                return {"role": "user", "content": text}
+            case AssistantText(text=text):
+                return {"role": "assistant", "content": text}
+            case ToolCall(call_id=call_id, tool=tool, arguments=arguments):
+                return {
+                    "role": "assistant",
+                    "content": None,
+                    "tool_calls": [
+                        {
+                            "id": call_id,
+                            "type": "function",
+                            "function": {
+                                "name": tool,
+                                "arguments": json.dumps(arguments),
+                            },
+                        }
+                    ],
+                }
+            case ToolResult(call_id=call_id, result=result):
+                return {
+                    "role": "tool",
+                    "tool_call_id": call_id,
+                    "content": result,
+                }
+            case PlanSubmitted(plan=plan):
+                return {"role": "assistant", "content": plan}
+            case GateOpened(gate=gate, reason=reason):
+                return {"role": "user", "content": f"[gate {gate} opened: {reason}]"}
+            case DelegationStarted(brief=brief, model=model):
+                return {
+                    "role": "assistant",
+                    "content": f"[delegation started ({model}): {brief}]",
+                }
+            case DelegationCompleted(handback=handback):
+                return {
+                    "role": "assistant",
+                    "content": f"[delegation handback]\n{handback}",
+                }
+            case Compaction(summary=summary):
+                return {
+                    "role": "user",
+                    "content": f"[summary of earlier conversation]\n{summary}",
+                }
+            case _:
+                raise ValueError(f"unrenderable event: {event!r}")