docs(sse): document state_change + in_progress_snapshot events

Updates the docs that describe the per-workstream SSE event stream and
the SessionUI lifecycle to match the refresh-resume changes:

- api-reference.md: documented the `state_change` event (previously
  undocumented despite already being a live event) and the new
  `in_progress_snapshot` event; rewrote the multi-consumer fan-out
  paragraph to mention the kind-specific replay tail (state_change +
  optional in_progress_snapshot) so the "no catch-up needed" claim
  is no longer misleading.
- architecture.md: bumped the SessionUI Protocol stub to 16 methods
  (added `on_turn_start` / `on_turn_committed`) and pointed at the
  in_progress_snapshot section in the API reference.
- sdk.md: added rows for `state_change`, `in_progress_snapshot`, and
  `approval_resolved` (preexisting gap) to the per-workstream event
  table.
- coordinator-api-tour.md: added an `in_progress_snapshot` row to the
  event table and rewrote the reconnection-contract paragraph to
  cover mid-stream content/reasoning restoration.
- diagrams/04-conversation-turn.puml: added `on_turn_start()` before
  the thinking-start emit and `on_turn_committed()` immediately after
  `messages.append(assistant_msg)`, with notes explaining the inflight-
  buffer reset semantics. PNG regenerated.

docs/api-reference.md

@@ -325,6 +325,44 @@ finalize any in-progress assistant message.
 {"type": "stream_end"}
 ```
 
+**`state_change`** -- the worker thread transitioned to a new state. Drives
+the client's busy-mode (composer in send vs. stop, spinner indicators,
+auto-focus on idle). Sent live during normal operation AND on every fresh
+SSE subscribe (so a mid-stream page refresh restores the correct composer
+state without waiting for the next live transition).
+
+```json
+{"type": "state_change", "state": "running"}
+```
+
+| Field    | Type   | Description                                                          |
+|----------|--------|----------------------------------------------------------------------|
+| `state`  | string | One of `"running"`, `"thinking"`, `"attention"`, `"idle"`, `"error"` |
+
+**`in_progress_snapshot`** -- one-shot replay of the in-progress turn's
+content + reasoning text-so-far when this client connects mid-stream.
+Lets a refreshing browser tab restore partial assistant text immediately
+instead of waiting for the response to complete. Yielded once after the
+kind-specific replay phase (history + pending), only when at least one
+of `content` / `reasoning` is non-empty. Both halves render into the same
+assistant bubble the live `content` / `reasoning` events would target;
+clients should treat the snapshot as idempotent (skip overwrite if the
+current local buffer is already a superset prefix — covers EventSource
+auto-reconnect re-replays).
+
+```json
+{
+  "type": "in_progress_snapshot",
+  "content": "Here is the answer so far: it depends on ",
+  "reasoning": "The user is asking about a comparison; let me think about..."
+}
+```
+
+| Field        | Type   | Description                                                |
+|--------------|--------|------------------------------------------------------------|
+| `content`    | string | Joined assistant content text accumulated this turn        |
+| `reasoning`  | string | Joined reasoning / chain-of-thought text accumulated       |
+
 **`tool_info`** -- one or more tool calls that were auto-approved (no user
 action required).
 
@@ -522,7 +560,13 @@ Each SSE connection to a workstream receives its own delivery queue.  Events
 produced by the worker thread are fanned out to all registered listener queues,
 so multiple consumers (browser, console proxy, SDK) can connect
 simultaneously and each receives every event.  On reconnect the client receives
-a full history replay, so no catch-up mechanism is needed.
+the kind-specific replay (`connected` + `status` + `history` + pending
+approval / plan for interactive; `connected` + `status` + pending for coord)
+followed by a `state_change` carrying the current worker state and an
+optional `in_progress_snapshot` carrying any partial content / reasoning
+buffered for the in-progress turn — so a mid-stream refresh restores both
+the busy-mode UI and the partial assistant text without waiting for the
+response to complete.
 
 ---