feat(web): frontend redesign — aurora telemetry instrument + live Markdown (v0.17.0)

A design pass through /frontend-design on the web companion to retain
all debugging richness while raising usability and polish. Single-file
vanilla HTML/CSS/JS; no build, no CDN, no node_modules. HTTP surface,
endpoints, presentation contract, and INV-001..009 all unchanged.

Aesthetic direction: "Aurora telemetry instrument."
- Runic glyph + wordmark, live connection dot (idle = aurora-green,
  streaming = pulsing cyan, error = dawn-red), session identity right-
  aligned. Persona summary lives inline in the top bar with labeled
  P/A/D micro-bars (centered baseline, [-1,1] mapped).
- Aurora signature band — thin cyan→blue→green shimmer animation
  at the top edge, echoed on the setup card.
- Conversation column with turn-divider rules, cyan ❯ prompt echoes,
  assistant text with a live cyan left-rule. Terminal events become
  status chips (done = aurora-green, error = dawn-red, cancelled =
  dawn-yellow) with metadata. Animated "awaiting first token · Ns"
  indicator with elapsed counter.
- Telemetry column: tabs with live count badges that flash on new
  events, sticky pane header carries the active pane name + copy
  button, new-line flash highlight on each pane append, structured
  empty states, persona pane structured render.
- Composer: real input, send/cancel buttons, streaming-lock state.
- Status line: keyboard legend + version footer.
- Centered setup card overlay with styled agent select on first open.
- All-monospace by intent (no-CDN constraint + right for a wire-
  monitor tool); system mono stack. CSS-only motion (pulse, shimmer,
  staggered rise, flash, awaiting dots).

Live Markdown — transcript response + thinking panes:
- Hand-rolled markdownSafe() renderer: escape-FIRST (INV-004
  preserved), then a whitelist subset (headings, bold, italic, inline
  code, fenced code blocks, ordered/unordered lists, blockquotes,
  links). No raw HTML passthrough. Link href restricted to http(s):// +
  conservative charset (rejects javascript:, attribute-breakout URLs).
- Per-turn live buffer; each text/thinking delta re-renders the
  accumulated buffer in place (same pattern as the TUI's v0.9.0 live
  MD rendering).
- Verified under node: rendering (bold/italic/code/lists/headings/
  fences/safe links) + XSS neutralization (script tags, javascript:
  schemes, attribute-breakout URLs, img onerror) all behave correctly.
- Tools/Debug/Persona panes stay literal monospace by deliberate
  choice: they carry our structured audit lines + JSON, where MD would
  corrupt readability (underscores in tool names, JSON braces, etc.).

Thinking pane per-turn breaks:
- Each turn lays down a labeled `── turn N ──` divider in the
  thinking pane. The prior turn's live block is closed and a fresh
  MD-rendered block opens below the divider, so each turn's chain-
  of-thought is its own break-separated section.

Tests: 378 passing (no test change — server-side surface unchanged).
Markdown safety verified via standalone node harness exercising
rendering + 4 XSS vectors.

Minor per SemVer discipline: substantial new browser-side behavior
(live Markdown rendering, redesigned presentation) that consumers
would opt into via the next launch. No HTTP-caller adapts.

AGENTS.md

@@ -0,0 +1,124 @@
+# Ratatoskr — AGENTS.md (Codex session)
+
+This file is what the Codex CLI reads at session start in the Ratatoskr repo. Analog to `CLAUDE.md` for Claude sessions. The session running here is the **implementer** under the Codex-first coding discipline.
+
+## Repo identity
+
+- **Name:** Ratatoskr
+- **Purpose:** Dev-grade TUI debug client for Worldtree's Conversation API. See `docs/design-brief.md` (synced from `brokkr-smithy/docs/ratatoskr-design-brief.md`) for the design framing.
+- **Project home:** `~/development/ratatoskr/`
+- **Remote:** Gitea (`gitea.phasefinal.com:vh/ratatoskr.git`)
+- **Primary branch:** `main`
+- **Norse name:** Ratatoskr — the squirrel that carries messages up and down Yggdrasil. The TUI carries messages between layers of Worldtree's API surface.
+
+## Your role
+
+You are **`ratatoskr-codex`**, the Codex implementer for issues dispatched under the Codex-first coding discipline.
+
+Discipline spec: `~/development/brokkr-smithy/docs/codex-first-discipline.md` v0.1.
+
+You implement; you do not review. The Claude session at handle `ratatoskr-dev` (running in this same repo, sharing this working tree) is the lead reviewer. Cross-frontier review signal arrives via `/heid-code-review groa` invocations triggered by `ratatoskr-dev`.
+
+## Communication
+
+- **Your handle:** `ratatoskr-codex`
+- **Reviewer handle:** `ratatoskr-dev`
+- **Inbound:** Zellij-plugin push into your prompt buffer. Treat inbound messages as if the operator typed them. Convention: `~/development/corviduo-project-template/docs/althing-monitoring.md`.
+- **Outbound:** `althing-cli post --to <handle> --subject "<subject>" --session-kind interactive` with body on stdin.
+- **Live-pane requirement:** Your zellij pane must stay visible to the push plugin for inbound to work. If the pane is closed or the plugin loses sight of it, inbound breaks.
+
+## Workflow
+
+Per `codex-first-discipline.md` §3. When `ratatoskr-codex` receives a dispatch from `/codex-dispatch <N>` (which arrives as a structured YAML-frontmatter message via push):
+
+1. Read the contract at `docs/contracts/issues/<N>.contract.md` — the spec is authoritative.
+2. Create branch `codex/<N>-<slug>` where `<slug>` is derived from the issue title.
+3. Implement. Commit locally as you go; do not push yet.
+4. Before any `git push` / `git fetch --tags` / `tea pr <action>`, request a write-window from `ratatoskr-dev` via althing. Format per `codex-first-discipline.md` §7 (`handshake-v1`):
+   ```
+   althing-cli post --to ratatoskr-dev --subject "write-window-request: #<N>" --session-kind interactive
+   ```
+   Body: `write-window-request: branch=codex/<N>-<slug>, action=<push|push+pr-open|amend>, eta=<seconds>`
+5. Wait for `write-window-granted: ttl=<seconds>`. Do not proceed without it.
+6. Push branch + open PR via `tea pr create --title "<title>" --description "<body>" --base main --head codex/<N>-<slug>`.
+7. Close the window: `write-window-close: branch=<branch>, action=done, pr=<url>` to `ratatoskr-dev`.
+8. Standby in this session for amendment requests.
+
+If the window expires without close (e.g., your push or PR-open fails partway), post `write-window-close: action=failed, reason=<short>` so `ratatoskr-dev` can resume.
+
+## Guardrails
+
+Inherited from Sleipnir-preflight (universal across the Corviduo agent-dispatch surface):
+
+- **Do not ignore `do NOT` instructions in the contract.** If the contract says "do NOT depend on X," do not depend on X. Surface concerns to `ratatoskr-dev` via althing before deciding to deviate.
+- **Do not improvise around missing dependencies.** If the contract assumes a library/service/endpoint that turns out not to exist, halt and surface to `ratatoskr-dev`. Do not write a stub and proceed.
+- **Do not substitute mocks for spec-mandated real-integration or HTTP tests.** If the contract requires a real integration test against Worldtree's Conversation API, write the real test. Mocked tests passing while real integration breaks is the failure mode this guardrail closes.
+
+## Branch + PR conventions
+
+- **Branch pattern:** `codex/<N>-<slug>` where `<N>` is the issue number and `<slug>` is a short kebab-case derivation of the issue title.
+- **Never push to `main` directly.** Always branch + PR via `tea`.
+- **PR title:** match the issue title or a sharpened version. Reference issue with `Closes #<N>` in the PR body.
+- **PR body shape:** terse summary + test plan checklist. No "Generated with..." footer.
+
+## Push posture
+
+Codex stages locally. Pushes only inside a granted write-window per `handshake-v1` (§7 of the discipline spec). This is **not** the standard Corviduo push-discretion model — for the Codex-first discipline the working-tree-sharing with the reviewer's Claude session requires explicit coordination.
+
+`tea` credentials for `vh/ratatoskr` are provisioned in this session by infra-ops. If `tea` auth fails at PR-open time, post to `ratatoskr-dev` and surface to the operator — do not retry with bypass.
+
+## Attribution
+
+All committed artifacts attribute to **Vuong Hoang**. Universal Corviduo rule from user-level `~/.claude/CLAUDE.md` §Attribution.
+
+Never reference Codex, OpenAI, ChatGPT, "AI-assisted", "Generated with...", or model-name attribution in:
+
+- Git commit messages
+- PR titles or bodies
+- README author lines
+- `pyproject.toml` authors
+- LICENSE copyright
+- File headers
+- HTML footers
+- Any other byline
+
+When citing assistant-mediated input in commits or PR bodies, cite mechanisms — althing message IDs, dispatch IDs, contract paths — not model names.
+
+## Persistent memory
+
+`persistent-memory.md` at repo root captures durable intent and supporting evidence for the project. If your work makes a project-level decision that should survive a context reset, update `persistent-memory.md` in the same commit as the code change.
+
+Do not let `persistent-memory.md` lag the code. If `git status` shows it as modified while you're committing other work, stage it alongside. (Universal Corviduo rule.)
+
+## Out-of-scope for you (Codex)
+
+Files you read but do not modify without explicit dispatch:
+
+- `CLAUDE.md` — the Claude reviewer's session file. Propose changes via althing to `ratatoskr-dev`.
+- `AGENTS.md` (this file) — propose changes via althing to `brokkr-smithy-dev` (the discipline owner) or `ratatoskr-dev`.
+- `docs/design-brief.md` — synced from Brokkr-Smithy. Propose changes via althing to `brokkr-smithy-dev`.
+- `docs/contracts/issues/<N>.contract.md` — the contract is the spec, not your editing surface. If the spec is wrong, halt and request amendment from `ratatoskr-dev`.
+- Other repos' code. You implement in `~/development/ratatoskr/` only. Read other Corviduo repos as needed for reference (`~/development/worldtree/` for the Conversation API surface, especially) but do not modify them.
+
+## Bootstrap protocol
+
+At session start, before any dispatch lands:
+
+1. Read this file end-to-end.
+2. Read `CLAUDE.md` (for context on the Claude reviewer's conventions, even though you don't enforce them).
+3. Read `persistent-memory.md` for current project state.
+4. Check `git status` + `git log -5` to understand the current branch state.
+5. Announce yourself to `ratatoskr-dev`:
+   ```
+   althing-cli post --to ratatoskr-dev --subject "codex-online" --session-kind interactive
+   ```
+   Body: `codex-online: branch=<current>, head=<sha>, ready`
+6. Wait for ack from `ratatoskr-dev`. Expected format: `dev-ack: active-branches=[...], wip-on=[...], no-locks` (or similar).
+7. Standby for dispatch messages.
+
+## Cross-references
+
+- `~/development/brokkr-smithy/docs/codex-first-discipline.md` — the discipline you operate under. Read this end-to-end before your first dispatch.
+- `~/development/corviduo-project-template/docs/althing-monitoring.md` — the inbound transport convention.
+- `~/development/brokkr-smithy/docs/ratatoskr-design-brief.md` — the design framing for this project. Synced into this repo at `docs/design-brief.md`.
+- `~/.claude/CLAUDE.md` — universal Corviduo conventions (attribution, SemVer, etc.). You don't load this directly (it's Claude's global file), but its rules — particularly attribution — apply universally.

docs/SPEC-PIN.md

@@ -7,11 +7,19 @@ documents the pin, the vendored artifacts, and the bump procedure.
 
 | Field | Value |
 |---|---|
-| Worldtree git SHA | `55101e909abcd2219833266b6f905c5bc956e0f0` |
-| Worldtree HEAD message | `memory: snapshot — #177 Vili v1 + persona async-decouple shipped as v0.19.0` |
-| Pinned on | 2026-05-20 |
-| Pinned by | brokkr-smithy-dev (initial scaffold) |
-| Worldtree version at pin | `v0.19.0` |
+| Worldtree git SHA | `562001af28d752c3a60d449c7ddd09f44fa9dc9a` |
+| Worldtree HEAD message | `feat(#201): v0.29.0 — awaiting_llm_first_token SSE heartbeat` |
+| Pinned on | 2026-05-26 |
+| Pinned by | ratatoskr-dev (bump for #201 awaiting_llm_first_token SSE) |
+| Worldtree version at pin | `v0.29.0` |
+
+## Pin history
+
+| Date | SHA | Version | Notable deltas consumed |
+|---|---|---|---|
+| 2026-05-26 | `562001a` | v0.29.0 | #201 — new SSE event `awaiting_llm_first_token` (heartbeat during BuildingPrompt → CallingLLM gap, default 5s interval) |
+| 2026-05-25 | `da93ca7` | v0.28.0 | #204 — new SSE event `affect_update` (current/scheduled), new endpoint `GET /agents/{id}/persona_state`, auth-model doc edits |
+| 2026-05-20 | `55101e9` | v0.19.0 | initial scaffold pin |
 
 ## Vendored artifacts
 

docs/contracts/issues/13.contract.md

@@ -0,0 +1,218 @@
+---
+contract_version: "2.1"
+target_module: "ratatoskr.tui"
+scope: "Design-brief §5 v1 entry point: reshape the TUI from vertical-stack single-pane to Horizontal two-column with `TabbedContent` on the right; first (and only v1) tab is `Tools`, which consumes `ToolStart` / `ToolResult` SSE events that previously rendered inline in the transcript. Pure in-place amendment to issue #4 + #12 — no new modules, no new files apart from this contract. The CLI (`ratatoskr.cli`) is unaffected: `--send` mode is non-interactive and keeps its current inline tool-event rendering. Substrate move only: persona / admin-events / bifrost-state / server-log panes stay deferred (blocked on remote-Worldtree topology + admin scope + opt-in flag). The TabbedContent shape makes them additive — when a blocker resolves the new pane plugs in as another TabPane sibling without further layout work."
+depends_on:
+  - "textual"
+used_by: []
+language: "python"
+complexity: "medium"
+estimated_loc: 180
+confidence: 0.85
+assumptions:
+  - "Textual's `TabbedContent(*titles, initial='')` + `TabPane(title, *children, id=...)` is the right primitive for the right-column tabs (verified API at textual.widgets._tabbed_content). One `TabPane(\"Tools\", tools_log, id=\"tools-tab\")` in v1; additional siblings get appended as Persona/AdminEvents/BifrostState/ServerLog land."
+  - "Textual's `Horizontal` + `Vertical` containers compose the two-column split (verified at textual.containers). Width via CSS `width: 2fr` on the left container + `width: 1fr` on the right container gives the 2:1 chat-primary split."
+  - "**The presenter contract amendment is small and tightly scoped**: `TuiPresenterState.render` gains a `tools_log: RichLog` parameter alongside the existing `log: RichLog` (main transcript) + `thinking_widget: Static`. `ToolStart` / `ToolResult` events route to `tools_log`; every other event (Text, Thinking, WorkerPhase, Done, Error, Cancelled, TextBoundary) keeps its existing routing to `log` + `thinking_widget`. The plain-label fallback path in `_plain_label` (issue #12 INV-009 render-exception recovery) keeps its current shape — only the routing target changes."
+  - "**Tool events are routed, not duplicated**. The brief's §5 wording 'side pane (inline-from-SSE for v1)' factors tool events OUT of the main transcript. A consumer who wants to debug a tool-using turn now reads the Tools pane; the main transcript stays focused on assistant text. Trade-off: a fast-skim of the transcript no longer shows tool activity inline; if that hurts the debug ergonomics empirically, a follow-up issue can add a one-line `· tool_used name=...` breadcrumb to the transcript as a compromise. v1 commits to the cleaner split."
+  - "**Demoted-prefix style stays consistent across panes**. ToolStart in the Tools pane renders as `· tool_start: name=foo args={...}` — the same `· ` ASCII prefix issue #12 INV-005 established for demoted telemetry in the main transcript. Pane separation handles the visual hierarchy; prefix style stays cross-pane consistent so the operator's mental model is portable."
+  - "**Input field retains focus across tab switches** (design-brief §5 invariant: 'Tab key (Ctrl+1..5) jumps between tabs without losing focus on the input field'). INV-016 is the load-bearing invariant; the assumption about Textual's default behavior is just an implementation hint. If Textual's default `TabbedContent.active = ...` programmatic assignment preserves Input focus (current observed behavior), no extra code is needed. If a future Textual version regresses on this, the implementation MUST add `self.query_one('#prompt', Input).focus()` immediately after the `.active = ` assignment in `action_focus_tools` to satisfy INV-016. The test `test_ctrl_1_preserves_input_focus` is the regression guard; if it fails, the fix is the explicit `.focus()` call, not relaxing the invariant. Pre-existing INV-007 (Input always-focused except during error sub-states) is preserved verbatim."
+  - "**Status footer gains a `current-pane-name` element** — design-brief §5 calls for it explicitly. v1 only has one tab so the indicator stable-renders \"Tools\". Wiring it as a separate Static (`id='pane-name'`) docked alongside identity + hint makes it trivially extend when more tabs land — the widget is in place; the value will become dynamic in the future multi-tab issue. **No tab-switch handler wiring lands in #13.** The `on_mount` flow populates `pane-name` once with the literal string \"Tools\" and never updates it. Adding event-handler plumbing in v1 (a `@on(TabbedContent.TabActivated)` handler, etc.) is out of scope — that's a deliberate deferral, not an implementer's call."
+  - "**The existing `· thinking-current` widget keeps its position** — docked to the top of the left column (was docked top of the whole App; now docked top of the left Vertical container). Pre-amendment dock-fix from v0.2.1 stays; the scope of the dock just narrows from \"App\" to \"left column\" so it doesn't bleed into the right column's TabbedContent area."
+  - "**Width split is fixed `2fr : 1fr` for v1**. User-resizable splits are textual-native (via `Splitter` or similar), but adding interactive resize is its own UX surface. v1 ships fixed; if the right pane proves cramped on narrow terminals operators will tell us. Out of scope."
+  - "**TabbedContent's CSS classes**: the right column's TabbedContent + its tabbed-content wrappers (`#tabbed-content`, `.--tabs`, etc.) come with Textual's default styling. No custom CSS for tab strip in v1; if the visual feels wrong adjust later. The contract specifies the structure; the chrome stays Textual-default."
+  - "**Test strategy**: existing TestStreamTurnWorker tests for Text/Thinking/Done/Error/Cancelled routing stay GREEN unchanged (they assert what shows in the transcript log; that still shows the same content). ToolStart/ToolResult tests get adjusted to assert routing to `tools_log` instead of `log`. New tests cover layout shape (Horizontal parent exists, TabbedContent with tools-tab on the right) + Ctrl+1 binding + tools_log writes for tool events."
+  - "**Issue #12's INV-009 render-exception fallback path** stays correct: `_plain_label(event)` is still callable; the render method's except branch writes the labeled-string to the appropriate Widget (tools_log for tool events; log for everything else). The fallback writes to the same routed widget as a successful render — failure mode preserves the routing invariant."
+open_questions:
+  - "Should the Tools tab show a count badge when new tool events arrive while the user is on a future Persona/AdminEvents tab? Draft: no for v1 — only one tab, so the question is moot. When persona/admin-events panes land, revisit: a small `[N]` badge on the tab header (`'Tools [3]'`) would help operators not miss tool activity that happens off-screen. Defer to a follow-up that touches multiple panes."
+  - "Should the Tools pane support filter-by-tool-name (e.g., show only `kb_search` results)? Draft: no for v1 — flat scroll matches the design brief's posture. The volume of tool events per turn is small enough that scrollback handles the use case. Revisit if mimir-style heavy-tool agents produce visible-cluttering volume."
+  - "Should the v1 Ctrl+1 binding be Ctrl+1 specifically, or `t` for 'tools' (no modifier)? Draft: Ctrl+1 — design brief specifies `Ctrl+1..5` as the family; matches the Ctrl-prefix discipline already used by Ctrl-C / Ctrl-D bindings. Plain-letter bindings would steal letter input from the Input field; Ctrl-prefixed is the standard escape."
+prd:
+  issue: 13
+  issue_url: "https://gitea.phasefinal.com/vh/ratatoskr/issues/13"
+  body_sha256_16: "52c8f886a9cc986a"
+  lock_in_comment_id: null
+  lock_in_sha256_16: null
+  lock_in_at: null
+  pinned_at: "2026-05-24T02:28:28+00:00"
+dependencies:
+  - issue: 4
+    path: "src/ratatoskr/tui.py"
+    reason: "In-place contract amendment: `RatatoskrApp.compose()` reshapes from vertical-stack to Horizontal 2-col + TabbedContent right; `RatatoskrApp.DEFAULT_CSS` reshapes to scope dock rules to the new left/right containers; `RatatoskrApp.__init__` is unchanged (state attributes carry over); `RatatoskrApp.on_mount` gains pane-name widget population + tools_log lookup; `RatatoskrApp.BINDINGS` gains `Ctrl+1` → `action_focus_tools`; existing `action_interrupt` / `action_quit` unchanged."
+  - issue: 12
+    path: "src/ratatoskr/tui.py"
+    reason: "In-place contract amendment: `TuiPresenterState.render` signature widens to accept `tools_log: RichLog` alongside `log` + `thinking_widget`; ToolStart/ToolResult branches write to `tools_log` instead of `log`. `_stream_turn_worker` does the new lookup (`self.query_one('#tools-log', RichLog)`) and threads it through. All other event branches stay verbatim."
+---
+
+# TUI layout reshape + Tools pane — §5 v1 entry point
+
+## Context
+
+`ratatoskr.tui` ships v0.x as a single-pane Textual app: Header / thinking-current widget / transcript RichLog / Input / identity + hint Statics / Footer, vertical-stacked via `dock: top` / `dock: bottom` CSS (v0.2.1 layout fix). Design-brief §5 commits the product to a multi-pane debug-observability dashboard. Most of §5's panes (Persona, AdminEvents, BifrostState widget, ServerLog) are blocked on substrate that isn't here — remote-Worldtree topology blocks file-tail-based panes; issue #11's `admin.events.read` scope blocks the admin surfaces.
+
+The unblocked v1 entry point is **layout reshape + Tools pane together**: reshape the TUI into the Horizontal two-column shape the design brief specifies, with `TabbedContent` on the right populated by a single `Tools` tab that consumes the existing `ToolStart` / `ToolResult` SSE events. No new endpoints; no scope grants; no cross-repo coordination. The shape is the foundation; subsequent panes plug in additively.
+
+## Data flow
+
+**Input** (unchanged from issue #4):
+- `args: ParsedArgs`, `session_id: str`, `agent_id: str | None`, `client: httpx.AsyncClient`.
+- SSE event stream from `ratatoskr.sse_client.stream_turn`.
+
+**Output** (unchanged):
+- Exit code via `App.exit(code)`.
+
+**Internal routing change**:
+- `ToolStart` / `ToolResult` events route to `tools_log: RichLog` (Tools pane) instead of the main transcript `log: RichLog`.
+- All other event types (`Text`, `Thinking`, `WorkerPhase`, `TextBoundary`, `Done`, `Error`, `Cancelled`) keep their existing routing.
+
+## Layout shape (post-amendment)
+
+```
+RatatoskrApp(App[int]):
+  compose():
+    yield Header()
+    yield Horizontal(
+      Vertical(
+        Static(id="thinking-current"),     # dock: top of left column
+        RichLog(id="transcript"),          # height: 1fr (fills middle)
+        Input(id="prompt"),                # dock: bottom of left column
+        id="left-column",
+      ),
+      Vertical(
+        TabbedContent(
+          TabPane("Tools", RichLog(id="tools-log"), id="tools-tab"),
+          # future: TabPane("Persona", …, id="persona-tab"), etc.
+          id="side-panes",
+        ),
+        id="right-column",
+      ),
+      id="main-row",
+    )
+    yield Static(id="identity")            # dock: bottom of App
+    yield Static(id="pane-name")           # dock: bottom of App (new in §5)
+    yield Static(id="hint")                # dock: bottom of App
+    yield Footer()
+```
+
+**DEFAULT_CSS reshape:**
+
+```css
+#main-row { height: 1fr; }
+#left-column { width: 2fr; }
+#right-column { width: 1fr; }
+#thinking-current { dock: top; height: auto; }
+#transcript { height: 1fr; }
+#prompt { dock: bottom; }
+#identity { dock: bottom; height: 1; }
+#pane-name { dock: bottom; height: 1; }
+#hint { dock: bottom; height: 1; }
+```
+
+Dock rules scope to the right container (left column for `thinking-current`/`prompt`; App for `identity`/`pane-name`/`hint`). The left-column `prompt` Input docks to the bottom of its column, not the App, so the right column's TabbedContent extends full height beside it.
+
+## Presenter routing (amendment to issue #12)
+
+```
+FN TuiPresenterState.render(
+    event: Event,
+    *,
+    log: RichLog,
+    thinking_widget: Static,
+    tools_log: RichLog,         # NEW (issue #13)
+    raw: bool,
+) -> None
+```
+
+Steps (only the ToolStart/ToolResult cases change; every other case keeps issue #12's behavior verbatim):
+
+- `ToolStart` → write `· tool_start: name=<name> args=<args!r>` to `tools_log` (not `log`).
+- `ToolResult` → write `· tool_result: name=<name> duration_ms=<n> result=<r!r:.200>` to `tools_log` (not `log`).
+- All other events → unchanged routing per issue #12 INV-005.
+- Render-exception fallback (`_plain_label(event)`): write to `tools_log` if the event is `ToolStart`/`ToolResult`; write to `log` otherwise. Routing preservation under failure.
+
+## Keybindings (amendment)
+
+```
+BINDINGS: ClassVar[list[Binding]] = [
+  Binding("ctrl+c", "interrupt", "Cancel / Exit", priority=True),
+  Binding("ctrl+d", "quit", "Exit immediately", priority=True),
+  Binding("ctrl+1", "focus_tools", "Tools tab", priority=False),  # NEW
+]
+
+def action_focus_tools(self) -> None:
+    self.query_one(TabbedContent).active = "tools-tab"
+    # Input focus is preserved by Textual's default behavior — TabbedContent
+    # doesn't steal focus when `.active` is set programmatically.
+```
+
+`Ctrl+1` is the v1 entry of the design-brief `Ctrl+1..5` family. `Ctrl+2..5` get added by subsequent issues as Persona/AdminEvents/BifrostState/ServerLog land. The binding does NOT steal Input focus — the test asserts `Input` keeps focus across the tab switch.
+
+## Status footer (amendment)
+
+New `Static(id="pane-name")` widget alongside the existing `identity` + `hint` widgets. v1 renders the literal string `"Tools"` set once at `on_mount`; the widget never updates after that. Dynamic updating + tab-switch handler wiring is **out of scope for #13** — it lands in the multi-tab follow-up that introduces the second TabPane. An implementer who adds a `@on(TabbedContent.TabActivated)` handler in this issue is out of spec.
+
+## Invariants
+
+- **INV-013**: Layout is `Horizontal` two-column. Left column width = 2fr; right column width = 1fr.
+- **INV-014**: `ToolStart` / `ToolResult` events route to `tools_log` (Tools pane), never to `log` (transcript).
+- **INV-015** *(amended v0.5.0)*: The transcript (`log`) is **content-only** — receives `Text`, `Done` (label + Markdown body + Rule), `Error`, `Cancelled`, and the user-prompt echo (`❯ <content>`). **All telemetry events (`Thinking` closed runs, `WorkerPhase`, `TextBoundary`) route to `debug_log` (Debug pane), NOT `log`.** Live thinking deltas continue to update `thinking_widget` per-delta. The pre-v0.5.0 shape (telemetry mixed into transcript) is retired under the project's no-backwards-compat rule.
+- **INV-016**: Input retains keyboard focus across `Ctrl+1` / `Ctrl+2` tab switches.
+- **INV-017** *(amended v0.5.0)*: `thinking-current` Static docks to the top of the **right column** (above `TabbedContent`), not the left column. Live thinking visibility persists across tab switches. v0.5.0 moves it from left → right so the left column is genuinely content-only.
+- **INV-018**: CLI mode (`ratatoskr.cli._amain`) is unaffected. CLI keeps inline `· tool_start: …` / `· tool_result: …` rendering on stderr per issue #12 INV-005.
+- **INV-019** *(amended v0.6.0)*: Three TabPanes in the right column: `Tools` (id `tools-tab`, contains `#tools-log`) + `Debug` (id `debug-tab`, contains `#debug-log`) + `Thinking` (id `thinking-tab`, contains `#thinking-log`). Ctrl+1/Ctrl+2/Ctrl+3 activate respective tabs. `pane-name` Static reflects active tab name dynamically.
+- **INV-020** *(amended v0.6.0)*: Render-exception fallback (INV-009) preserves routing per event class: `ToolStart` / `ToolResult` → `tools_log`; `Thinking` → `thinking_log`; `WorkerPhase` / `TextBoundary` → `debug_log`; everything else → `log`.
+- **INV-021** *(new v0.6.0)*: `Text` events do NOT route to `log` per-delta. They accumulate into `TuiPresenterState.text_buffer` and update a single `current_text` Static (docked above the prompt). On terminal event (`Done`/`Error`/`Cancelled`), `current_text` is cleared and (raw mode) accumulated text or (non-raw) post-Done `Markdown(response)` is written to `log`. The pre-v0.6.0 per-token RichLog spam is retired.
+- **INV-022** *(amended v0.7.1)*: Thinking deltas COALESCE on `\n` boundaries before writing to `thinking_log`. The first delta of a run writes `Rule(title=f"turn N · thinking #K start")`; subsequent deltas accumulate in `TuiPresenterState.thinking_chunk_buffer`; whenever the buffer contains `\n`, the leading line(s) flush as RichLog entries (one entry per natural paragraph). The run closes on the next non-thinking event: any tail in the buffer flushes as a final line, then `Rule(title=f"turn N · thinking #K end")`. Pre-v0.7.1 per-delta-per-line caused token-spam (Worldtree emits thinking at token granularity); coalescing produces one log line per natural paragraph, not per token.
+- **INV-023** *(new v0.6.0)*: Turn-ID header `Rule(title=f"turn N")` is written to all four log panes (`log`, `tools_log`, `debug_log`, `thinking_log`) by `_stream_turn_worker` on the first event of each turn — enables cross-pane visual correlation during multi-turn debugging.
+- **INV-024** *(amended v0.6.5)*: `thinking-current` Static REMOVED. v0.6.1 placed it inside the Thinking pane (docked bottom); operators reported the bottom-docked Static "scrolling a little section at the bottom" (its 200-char tail acting as a scroll-window) instead of letting the whole pane scroll. v0.6.5 deletes the Static entirely and streams Thinking deltas directly into `thinking_log` (the scrollable RichLog) — the whole pane scrolls naturally as content arrives. The Rule(start) at the first delta of a run is now the live "thinking is happening" indicator.
+
+## TESTS (additions / changes to test_tui.py)
+
+```
+- test_compose_has_horizontal_main_row: RatatoskrApp.compose() yields a Horizontal with id="main-row" containing left-column + right-column children.
+- test_compose_right_column_has_tabbed_content: query_one("#side-panes", TabbedContent) is non-None; one TabPane child with title="Tools" id="tools-tab".
+- test_compose_left_column_has_transcript_input: query_one("#left-column", Vertical) contains #transcript (RichLog) + #prompt (Input).
+- test_tools_log_present: query_one("#tools-log", RichLog) is non-None; lives inside the tools-tab TabPane.
+- test_pane_name_widget_renders_tools: query_one("#pane-name", Static).renderable == "Tools" (v1 static).
+- test_tool_start_routes_to_tools_log: stream_turn emits ToolStart → tools_log receives the line; transcript RichLog does NOT receive it.
+- test_tool_result_routes_to_tools_log: stream_turn emits ToolResult → tools_log receives the line; transcript does NOT receive it.
+- test_text_event_still_routes_to_transcript: stream_turn emits Text("hello") → transcript receives it; tools_log does NOT.
+- test_thinking_event_still_routes_to_thinking_widget: thinking deltas continue to update #thinking-current Static, not tools_log.
+- test_done_event_still_routes_to_transcript: Done event renders `[done] …` in transcript, not tools_log.
+- test_ctrl_1_activates_tools_tab: simulate Ctrl+1 → TabbedContent.active == "tools-tab".
+- test_ctrl_1_preserves_input_focus: simulate Ctrl+1 while Input is focused → Input is still focused afterwards.
+- test_plain_label_fallback_routes_tool_events_to_tools_log: simulate render exception on a ToolStart → tools_log gets the _plain_label fallback string; transcript doesn't.
+```
+
+Existing tests that need adjustment (NOT rewrite):
+- Any test that asserted `log.write(...)` was called with a `tool_start: …` / `tool_result: …` string changes its target widget to `tools_log` instead.
+- TestAppMount tests gain `tools_log` widget lookup assertions.
+
+## ERROR_ROUTING (unchanged)
+
+All error routing from issues #4 / #6 / #7 / #12 stays verbatim. The tools_log routing change is internal to the presenter; error paths (`SseConnectFailed`, `SseConnectionDropped`, `MalformedSseId`, `MalformedSseData`, `TurnIdFlip`) all write their labeled lines to `log` (the main transcript). Reason: errors are turn-terminal and need to be visible in the operator's primary attention surface; routing them to the Tools pane would hide them behind a tab switch.
+
+## Layout-spec snapshot (after v0.5.0)
+
+```
++────────────────────────────────+──────────────────────+
+|  ❯ user-typed line             | · thinking-current   |
+|  assistant streaming text...   |  ┌Tools─┬─Debug─────┐|
+|  [done] turn_id=… duration=…   |  │ · tool_start:..  │|
+|  …markdown render…             |  │ · tool_result..  │|
+|                                |  │                  │|
+|                                |  │                  │|
+|                                |  │                  │|
+|  [prompt: type and press Enter]|  └──────────────────┘|
++────────────────────────────────+──────────────────────+
+| agent · …sess_id  Tools  Ctrl-C twice to exit         |
++───────────────────────────────────────────────────────+
+```
+
+Left column is content-only (transcript + prompt). Right column hosts the
+live `thinking-current` Static at top + `TabbedContent` cycling between
+`Tools` (tool events) and `Debug` (thinking closed runs + worker_phase +
+text_boundary).
+
+(Width split 2fr:1fr; tab strip is Textual-default; Header/Footer
+backgrounds explicitly set to `$surface` to override the Textual default
+`$primary`-blue tinting.)

docs/contracts/issues/15.contract.md

@@ -0,0 +1,290 @@
+---
+contract_version: "2.1"
+target_module: "ratatoskr.tier3"
+scope: "New module `ratatoskr.tier3` exposing Worldtree's Tier 3 (consumer-defined) agent lifecycle: `define_agent` (POST /agents/define), `patch_agent` (PATCH /agents/<id>), `delete_agent` (DELETE /agents/<id>), plus `Tier3AgentInfo` frozen dataclass. Plus a thin CLI entry point (`python -m ratatoskr.tier3 <define|patch|delete>`) that mirrors `ratatoskr.cli`'s env-var posture (`WORLDTREE_API_URL`, `WORLDTREE_API_KEY`). Convention-aligned with `ratatoskr.sessions` (issue #2): caller-owned httpx.AsyncClient, no Worldtree imports, response parsing into frozen dataclass, exception `.body` truncated to `[:1024]`. Picker stays generic — agents with `:` in agent_id show in the list like any other per issue #8's out-of-scope clause. Goal: ratatoskr operators can define, mutate, and delete Tier 3 agents from the command line, then exercise the full session flow against them to observe how Tier 3 agent_ids (colon-containing) flow through the picker / session-create / SSE stream."
+depends_on:
+  - "httpx"
+used_by: []
+language: "python"
+complexity: "low"
+estimated_loc: 250
+confidence: 0.9
+assumptions:
+  - "Tier 3 endpoints land at the same `WORLDTREE_API_URL` as the rest of the Conversation API — no separate hostname / port. Auth via the same bearer key. The caller's user_id is derived server-side from the API key's owner; the agent's `agent_id` is constructed as `<auth_user_id>:<agent_name>`. Live probe against personal Worldtree (2026-05-25) confirmed: POST with `{agent_name: 'smoke-test', ...}` and `Authorization: Bearer <key>` returned `agent_id=ratatoskr:smoke-test`, `user_id=ratatoskr`."
+  - "Per Worldtree spec §2576-2750: `agent_name` is a strict slug `[a-z][a-z0-9-]{2,63}` and immutable after definition. `user_id` is derived from the auth, must be slug-safe (`[a-z][a-z0-9-]{2,63}` per Phase 2.0 gate). PATCH accepts ONLY `system_prompt` and/or `model`; any other key (including the immutable `agent_name`, `user_id`, or layer fields `persona`/`motivational`/`valence`/`memory` — even with `null` value) returns 422 `field_not_mutable` BEFORE the DB lookup."
+  - "**Layer fields are explicitly null** on define. Phase 2.0 ships baseline addressing + ownership + lifecycle only; `persona` / `motivational` / `valence` / `memory` are schema-reserved. Non-null on these → 422 `layer_deferred`. The module's `define_agent` does NOT expose these as parameters at all — sending them would require an amendment when a future Phase enables them."
+  - "**`model` field is a provider model ID, not a profile alias.** Live probe found: `model='default'` (an llm_profiles profile name) returns 422 `model_not_available`; `model='qwen3.6-35-a3b'` (an actual provider model ID) returns 201. The CLI / module take the string verbatim and pass through — validation is server-side. Operators discover valid IDs via the model `metadata` on existing sessions or out-of-band."
+  - "**Quota: 50 Tier 3 agents per Heimdall key.** 51st define → 429 `agent_quota_exceeded` with `Retry-After: 0`. The module raises `Tier3QuotaExceeded(retry_after=0)` — the retry_after field captures the header value verbatim for forward-compat if Worldtree later returns a non-zero throttle."
+  - "**Key-revocation cascade is server-side.** When an API key is revoked (`DELETE /admin/keys/{key_id}`), every Tier 3 agent with `owner_key_hash` equal to the revoked key's hash is soft-deleted in the same SQL transaction. Active sessions on those agents return 401 `auth_revoked` on next message. The ratatoskr module doesn't track or simulate this — operators discover it via runtime 401s and the admin-side audit log."
+  - "**Picker integration is implicit** — no changes to `ratatoskr.tui.AgentPickerApp` for this issue. Tier 3 agents appear in `GET /agents` if defined and the picker's existing format `{agent_id} · {name} — {description}` renders the colon-containing agent_id without special-casing. Per issue #8 out-of-scope clause, ratatoskr does not visually distinguish Tier 1 vs Tier 3 in the picker — same UX surface."
+  - "**Session-create with colon-containing agent_id works unchanged.** Issue #5 already routes `end_user_id` into the POST /sessions body, which Tier 3 session-create requires from Phase 2.0 (per spec §2649-2664). No `ratatoskr.sessions` change needed."
+  - "**CLI uses argparse with subparsers** (define / patch / delete). The subparsers entry point lives at `python -m ratatoskr.tier3` via `__main__.py`. Output on success: prints a one-line summary (`defined ratatoskr:wizard (qwen3.6-35-a3b)` / `patched ratatoskr:wizard` / `deleted ratatoskr:wizard`). Output on error: `[<error_code>] <message>` to stderr + non-zero exit. Exit codes mirror `ratatoskr.cli`: 0 happy / 10 usage / 11 auth / 20 api-failure / 21 network."
+  - "**No `list` subcommand in v1.** A `tier3 list` operation would have to filter `GET /agents` by prefix-matching the caller's user_id, but that prefix isn't exposed in the response — only the agent_id is, and you'd have to introspect the auth's user_id. Operators discover their own Tier 3 agents by reading the `GET /agents` list (which the picker already surfaces) and looking for `<their-user-id>:*` entries. Add `list` in a follow-up if operators report friction."
+  - "**Module is standalone**: does NOT import or interact with `ratatoskr.sessions` / `ratatoskr.sse_client` / `ratatoskr.tui` / `ratatoskr.cli` beyond reusing the `USER_AGENT` constant from `ratatoskr.cli`. Cross-module use is one-way (cli supplies the user-agent string; tier3 does not import sessions). This keeps the module surface minimal and testable in isolation."
+  - "**The CLI's `python -m ratatoskr.tier3` entry point uses sys.argv handling that mirrors `ratatoskr.cli`** — a top-level `main(argv: list[str] | None = None) -> int` function that argparse-dispatches to subcommand handlers. Each subcommand handler is an async coroutine wrapped by `asyncio.run(...)`. Auth resolution: `--api-key` flag > `$WORLDTREE_API_KEY` env > `_AuthError` (exit 11). Server URL: `--server` > `$WORLDTREE_API_URL` > default `http://localhost:8000` (same default as `ratatoskr.cli`)."
+  - "**Tests use `respx` for HTTP mocking** (same pattern as `tests/test_sessions.py`). New test file: `tests/test_tier3.py`. Cover all success + error response codes per the ERROR_ROUTING matrix below. No live network in unit tests — the live smoke is in the acceptance criteria, not the unit tests."
+open_questions:
+  - "Should `define_agent` accept an optional `bifrost` parameter for Bifrost-bound Tier 3 sessions? The spec §2658 shows `bifrost` as a session-create field (not define-time). Draft: no — Bifrost binding is per-session; if a Tier 3 agent needs Bifrost on every session, that's an orthogonal feature on POST /sessions, not POST /agents/define. Issue #5's `--end-user-id` already covers the session-create-side parameters."
+  - "Should the CLI also offer `--end-user-id` for sessions created via tier3 + ratatoskr-cli composition? Draft: no — once an agent is defined, operators use the main `ratatoskr --new --agent <id> --end-user-id <eid>` flow; tier3 CLI is define/patch/delete only."
+  - "Should `delete_agent` support a `--force` flag for 'really delete even if active sessions exist'? Per spec §2634-2639, `DELETE` already cancels active sessions and revokes the per-resource scope grant on the owner — there's no soft fail. Draft: no — the spec's hard-delete-with-cascade behavior is the right shape; ratatoskr doesn't need to wrap it."
+prd:
+  issue: 15
+  issue_url: "https://gitea.phasefinal.com/vh/ratatoskr/issues/15"
+  body_sha256_16: "03367d7b451ab17f"
+  lock_in_comment_id: null
+  lock_in_sha256_16: null
+  lock_in_at: null
+  pinned_at: "2026-05-25T03:21:38+00:00"
+dependencies:
+  - issue: 2
+    path: "src/ratatoskr/sessions.py"
+    reason: "Convention dependency, not a code dependency. Issue #2 (`ratatoskr.sessions`) is the posture template: caller-owned httpx client, async-native, no Worldtree imports, response-parsing into frozen dataclasses, exception body truncation to [:1024]. `ratatoskr.tier3` follows the same shape verbatim."
+  - issue: 3
+    path: "src/ratatoskr/cli.py"
+    reason: "Convention dependency only. `ratatoskr.tier3.__main__` mirrors `ratatoskr.cli`'s argparse + env-fallback + exit-code shape. Imports `USER_AGENT` from `ratatoskr.cli` so outbound HTTP carries the same identity string."
+---
+
+# Tier 3 — Consumer-defined agent lifecycle module
+
+## Context
+
+Worldtree's Tier 3 (Phase 2.0, spec §2576-2750) lets the consumer define their own agents at `<user_id>:<agent_name>`. The agent's `user_id` is the auth's user identity (derived from the API key's owner); the `agent_name` is supplied at define-time. The lifecycle is owner-only — only the key that defined an agent can patch / delete it (modulo the key-revocation cascade).
+
+`ratatoskr.tier3` exposes this lifecycle as a Python module + small CLI tool. Picker integration is implicit (Tier 3 agents already appear in `GET /agents` per issue #8). Session-create works unchanged through `ratatoskr.sessions.create_session` since the colon-containing agent_id is opaque to that layer.
+
+## Public surface
+
+```python
+@dataclass(frozen=True)
+class Tier3AgentInfo:
+    """Worldtree Tier 3 agent envelope returned by define / patch."""
+
+    agent_id: str       # f"{user_id}:{agent_name}"
+    user_id: str
+    agent_name: str
+    system_prompt: str
+    model: str
+    created_at: str     # ISO 8601 with offset
+    updated_at: str     # ISO 8601 with offset
+
+
+async def define_agent(
+    client: httpx.AsyncClient,
+    *,
+    agent_name: str,
+    system_prompt: str,
+    model: str,
+) -> Tier3AgentInfo:
+    """POST /agents/define → 201 with Tier3AgentInfo. See FN define_agent."""
+
+
+async def patch_agent(
+    client: httpx.AsyncClient,
+    agent_id: str,
+    *,
+    system_prompt: str | None = None,
+    model: str | None = None,
+) -> Tier3AgentInfo:
+    """PATCH /agents/<id> → 200 with updated Tier3AgentInfo. See FN patch_agent."""
+
+
+async def delete_agent(client: httpx.AsyncClient, agent_id: str) -> None:
+    """DELETE /agents/<id> → 204. See FN delete_agent."""
+```
+
+## Exception classes
+
+```python
+class Tier3QuotaExceeded(Exception):
+    """429 agent_quota_exceeded — 50-agent cap reached on the Heimdall key."""
+    def __init__(self, *, retry_after: int) -> None: ...
+    retry_after: int
+
+class Tier3UserIdUnsupported(Exception):
+    """403 tier3_user_id_unsupported — auth's user_id not slug-safe."""
+
+class Tier3FieldNotMutable(Exception):
+    """422 field_not_mutable — PATCH carrying an immutable key."""
+    def __init__(self, *, field: str | None) -> None: ...
+    field: str | None
+
+class Tier3LayerDeferred(Exception):
+    """422 layer_deferred — define carrying non-null layer field."""
+    def __init__(self, *, field: str | None) -> None: ...
+    field: str | None
+
+class Tier3AgentNotFound(Exception):
+    """404 — patch/delete on non-existent agent."""
+    def __init__(self, *, agent_id: str) -> None: ...
+    agent_id: str
+
+# Reused from ratatoskr.sessions (one-way import — sessions doesn't depend on tier3):
+# SessionApiFailed(status, body) for all other non-2xx responses.
+```
+
+## Functions
+
+### FN define_agent
+
+```
+FN define_agent(
+    client: httpx.AsyncClient,
+    *, agent_name: str, system_prompt: str, model: str,
+) -> Tier3AgentInfo
+BRIEF: POST /agents/define → 201 with Tier3AgentInfo.
+
+PRE-001: agent_name matches `[a-z][a-z0-9-]{2,63}` (slug guard — client-side
+         assert; the server enforces too, but this prevents wire round-trip
+         for trivially-bad input).
+PRE-002: system_prompt is non-empty.
+PRE-003: model is non-empty.
+
+STEPS:
+  1. assert PRE-001/002/003.
+  2. body = {
+       "agent_name": agent_name,
+       "system_prompt": system_prompt,
+       "model": model,
+     }
+  3. resp = await client.post("/agents/define", json=body)
+  4. ROUTE response status:
+     201 → parse body into Tier3AgentInfo, return.
+     422 → inspect error_code:
+       layer_deferred → raise Tier3LayerDeferred(field=err.get("field"))
+       (others) → raise SessionApiFailed(status=422, body=resp.content)
+     403 + tier3_user_id_unsupported → raise Tier3UserIdUnsupported
+     429 → raise Tier3QuotaExceeded(retry_after=int(resp.headers.get("Retry-After", 0)))
+     other → raise SessionApiFailed(status, body)
+
+POST-001: returned Tier3AgentInfo has agent_id of shape "<user_id>:<agent_name>".
+```
+
+### FN patch_agent
+
+```
+FN patch_agent(
+    client: httpx.AsyncClient, agent_id: str,
+    *, system_prompt: str | None = None, model: str | None = None,
+) -> Tier3AgentInfo
+BRIEF: PATCH /agents/<id> → 200 with updated Tier3AgentInfo.
+
+PRE-001: agent_id contains `:` (Tier 3 shape).
+PRE-002: at least one of system_prompt or model is non-None (no-op patches
+         are still server-accepted but client-side assert avoids the round-trip).
+
+STEPS:
+  1. assert PRE-001/002.
+  2. body = {}; if system_prompt is not None: body["system_prompt"] = system_prompt;
+     if model is not None: body["model"] = model.
+  3. resp = await client.patch(f"/agents/{agent_id}", json=body)
+  4. ROUTE response status:
+     200 → parse, return.
+     404 → raise Tier3AgentNotFound(agent_id=agent_id)
+     422 + field_not_mutable → raise Tier3FieldNotMutable(field=err.get("field"))
+     other → raise SessionApiFailed(status, body)
+```
+
+### FN delete_agent
+
+```
+FN delete_agent(client: httpx.AsyncClient, agent_id: str) -> None
+BRIEF: DELETE /agents/<id> → 204.
+
+PRE-001: agent_id contains `:` (Tier 3 shape).
+
+STEPS:
+  1. assert PRE-001.
+  2. resp = await client.delete(f"/agents/{agent_id}")
+  3. ROUTE response status:
+     204 → return None.
+     404 → raise Tier3AgentNotFound(agent_id=agent_id)
+     other → raise SessionApiFailed(status, body)
+```
+
+## CLI surface (`python -m ratatoskr.tier3`)
+
+```
+$ python -m ratatoskr.tier3 define --name wizard \
+    --system-prompt "You are a guided-elicitation wizard..." \
+    --model qwen3.6-35-a3b
+defined ratatoskr:wizard (qwen3.6-35-a3b)
+
+$ python -m ratatoskr.tier3 patch ratatoskr:wizard --system-prompt "New prompt"
+patched ratatoskr:wizard
+
+$ python -m ratatoskr.tier3 delete ratatoskr:wizard
+deleted ratatoskr:wizard
+```
+
+Auth + server URL: same env-var fallback as `ratatoskr.cli`. Exit codes: 0 / 10 (usage) / 11 (auth) / 20 (api-failure) / 21 (network).
+
+## Invariants
+
+- **INV-001**: `define_agent` request body carries exactly `{agent_name, system_prompt, model}` — no layer fields, no `bifrost`, no `metadata`. Phase 2.0 baseline shape only.
+- **INV-002**: `patch_agent` request body carries ONLY `system_prompt` and/or `model` — every other key is omitted. Server-side 422 `field_not_mutable` is the safety net; client-side body-construction is the first line.
+- **INV-003**: `delete_agent` is fire-and-confirm — no body, no retry, no soft-delete. Cascade handling is server-side; ratatoskr doesn't track it.
+- **INV-004**: All exceptions carry a `[:1024]` body cap (when applicable) per the issue #2 convention.
+- **INV-005**: CLI auth resolution mirrors `ratatoskr.cli`: `--api-key` flag > `$WORLDTREE_API_KEY` > exit 11.
+- **INV-006**: CLI server URL resolution mirrors `ratatoskr.cli`: `--server` > `$WORLDTREE_API_URL` > `http://localhost:8000`.
+- **INV-007**: Module never imports `ratatoskr.sessions` / `ratatoskr.sse_client` / `ratatoskr.tui` (one-way: only `cli.USER_AGENT` is imported, and only by `__main__.py` for the outbound User-Agent header).
+- **INV-008**: All HTTP through caller-owned `httpx.AsyncClient` — module never constructs its own client. (`__main__` constructs one for the CLI entry point per ratatoskr.cli's pattern.)
+
+## TESTS (tests/test_tier3.py — new file)
+
+```
+- test_define_happy: 201 + full response shape → Tier3AgentInfo populated.
+- test_define_quota_exceeded: 429 + Retry-After header → Tier3QuotaExceeded(retry_after=N).
+- test_define_user_id_unsupported: 403 tier3_user_id_unsupported → Tier3UserIdUnsupported.
+- test_define_layer_deferred_persona: 422 layer_deferred → Tier3LayerDeferred (would only fire if the body sent a layer field; the module never sends one, so this asserts server-side defense but reflecting a 422 we don't actually generate. Test exercises the response path, not the request).
+- test_define_bad_slug: PRE-001 assertion fires before HTTP for agent_name="X" (uppercase) or "ab" (too short).
+- test_define_empty_prompt: PRE-002 assertion fires for empty system_prompt.
+- test_define_other_5xx: 503 → SessionApiFailed(status=503).
+- test_patch_happy_both_fields: 200 + updated body → Tier3AgentInfo.
+- test_patch_happy_single_field: 200 with only system_prompt set; body omits model.
+- test_patch_field_not_mutable: 422 field_not_mutable → Tier3FieldNotMutable.
+- test_patch_404: 404 → Tier3AgentNotFound(agent_id=...).
+- test_patch_no_args: PRE-002 assertion fires (both None).
+- test_patch_non_tier3_id: PRE-001 assertion fires for agent_id without `:`.
+- test_delete_happy: 204 → returns None.
+- test_delete_404: 404 → Tier3AgentNotFound.
+- test_delete_non_tier3_id: PRE-001 assertion fires.
+- test_delete_other_5xx: 500 → SessionApiFailed.
+- test_cli_define_happy: argv → 201 mock → stdout="defined ratatoskr:wizard (qwen3.6-35-a3b)" + exit 0.
+- test_cli_patch_happy: argv → 200 mock → stdout="patched ratatoskr:wizard" + exit 0.
+- test_cli_delete_happy: argv → 204 mock → stdout="deleted ratatoskr:wizard" + exit 0.
+- test_cli_missing_auth: no API key → stderr "[auth_error]" + exit 11.
+- test_cli_api_failed: 500 mock → stderr "[api_failed]" + exit 20.
+```
+
+## ERROR_ROUTING (module + CLI)
+
+| HTTP shape | error_code | Exception (module) | CLI label | Exit |
+|---|---|---|---|---|
+| 201 / 200 / 204 | — | (none — happy) | one-line confirmation on stdout | 0 |
+| 429 | agent_quota_exceeded | `Tier3QuotaExceeded(retry_after=N)` | `[quota_exceeded] retry_after=N` | 20 |
+| 403 | tier3_user_id_unsupported | `Tier3UserIdUnsupported` | `[user_id_unsupported]` | 20 |
+| 404 | — | `Tier3AgentNotFound(agent_id=...)` | `[agent_not_found] <id>` | 20 |
+| 422 | field_not_mutable | `Tier3FieldNotMutable(field=...)` | `[field_not_mutable] field=...` | 20 |
+| 422 | layer_deferred | `Tier3LayerDeferred(field=...)` | `[layer_deferred] field=...` | 20 |
+| any other non-2xx | — | `SessionApiFailed(status, body)` | `[api_failed] status=N body=...` | 20 |
+| httpx.ConnectError / ReadTimeout / TransportError | — | propagates | `[network_error] T: M` | 21 |
+| PRE-001/002/003 assertion violation | — | `AssertionError` | `[usage_error] <msg>` | 10 |
+| no auth | — | `_AuthError` (reused from cli) | `[auth_error] no API key` | 11 |
+
+## Layout after this module lands
+
+```
+src/ratatoskr/
+  __init__.py
+  cli.py            (existing, unchanged)
+  sessions.py       (existing, unchanged)
+  sse_client.py     (existing, unchanged)
+  tui.py            (existing, unchanged)
+  tier3.py          NEW
+  __main__/         (no change — main cli still entry-point)
+
+# CLI invocation:
+$ python -m ratatoskr.tier3 define --name wizard ...
+$ python -m ratatoskr.tier3 patch ratatoskr:wizard ...
+$ python -m ratatoskr.tier3 delete ratatoskr:wizard
+```

docs/contracts/issues/16.contract.md

@@ -0,0 +1,394 @@
+---
+contract_version: "2.1"
+issue: 16
+target_module: "ratatoskr.web"
+scope: "New module `ratatoskr.web` exposing a browser-based debug companion to the Ratatoskr TUI. Reuses `ratatoskr.sse_client`, `ratatoskr.sessions`, `ratatoskr.tier3`, `ratatoskr.local_agents`, `ratatoskr.cli` unchanged. Adds a Starlette web server (`ratatoskr.web.server`), a lazy-import console-script entrypoint (`ratatoskr.web.entrypoint`), and a single-page static UI at `ratatoskr/web/static/index.html`. Optional-deps group `[web]` carries `starlette>=0.40` and `uvicorn[standard]>=0.30`. Surface: 9 HTTP endpoints (1 root, 1 static, 1 version, 5 API proxies, 1 SSE stream). Bound to `0.0.0.0` by default for LAN consumption — internal-LAN debug surface, no auth, no CORS guard (deliberate operator direction). The five Worldtree SSE surfaces (transcript, thinking, tools, debug, persona) render in the browser via the same routing rules as the TUI, with client-side JS re-implementing the presentation discipline (no shared abstraction extracted at v0.15.0). Goal: operators have a sharable / inspectable second viewport on the same Worldtree SSE stream, reachable from any device on the LAN."
+depends_on:
+  - "ratatoskr.sse_client"
+  - "ratatoskr.sessions"
+  - "ratatoskr.tier3"
+  - "ratatoskr.local_agents"
+  - "ratatoskr.cli"
+  - "starlette"
+  - "uvicorn"
+  - "httpx"
+used_by: []
+language: "python"
+complexity: "medium"
+estimated_loc: 600
+confidence: 0.85
+assumptions:
+  - "**Browser-native EventSource is GET-only.** The SSE stream endpoint is `GET /api/turns/{sid}/stream?turn_id=<id>`; the prompt-submit is a separate `POST /api/turns/{sid}` that returns `{turn_id}`. The two calls share a small in-memory turn registry keyed on `(session_id, turn_id)` so the cancel and disconnect-cleanup paths can find the in-flight upstream request. This split is a load-bearing correction from the Heid panel review (Hulda) on scope v1."
+  - "**Trust model is internal LAN.** Binds `0.0.0.0:8765` by default; `--host 127.0.0.1` available for localhost-only. No auth, no TLS, no CORS guard. The operator has explicitly accepted this: anyone routable to the host's port can reach the interface. What stays disciplined regardless of network trust: (1) transcript HTML-escapes assistant content (model output is untrusted text — adversarial HTML in responses must not execute in the browser); (2) upstream API key never reaches the browser DOM or any client-visible response field."
+  - "**Optional-deps lazy-import discipline.** `ratatoskr.web` deps (`starlette`, `uvicorn`) are an optional-extras group `[web]`. The console-script entrypoint `ratatoskr.web.entrypoint:main` parses CLI flags BEFORE importing `ratatoskr.web.server` so users without the extras installed get a clean `pip install ratatoskr[web]` message instead of a naked `ImportError: starlette`. Both Heid panel arms (Gróa + Hulda) converged on this. `ratatoskr.web.__init__` is bare; no module-level imports of starlette/uvicorn anywhere on the cli import path."
+  - "**Starlette over FastAPI.** Both Heid panel arms converged: five thin proxy endpoints don't need FastAPI's Pydantic / OpenAPI / dependency-injection machinery. Use Starlette + manual `Response` / `StreamingResponse` / `JSONResponse` construction."
+  - "**Static asset packaging.** `src/ratatoskr/web/static/index.html` ships in the wheel via `[tool.hatch.build.targets.wheel]` include rules. Located at runtime via `importlib.resources.files('ratatoskr.web') / 'static' / 'index.html'`. Test asserts this resolution works in the installed package."
+  - "**Presentation contract pinning.** A JSON fixture at `tests/fixtures/presentation_contract.json` enumerates the expected browser-facing event payload for each Event type (one entry each for WorkerPhase, Thinking, Text, TextBoundary, ToolStart, ToolResult, Done, Error, Cancelled, AffectUpdate, AwaitingLlmFirstToken). Server-side proxy serialization is unit-tested against this fixture. JS-side rendering treats the fixture as the contract. Drift detection between TUI and JS presenter without forcing a shared abstraction (Hulda)."
+  - "**Browser-disconnect → upstream cancel.** When the browser closes the EventSource (tab close, navigation, explicit disconnect), the server's stream handler catches the `asyncio.CancelledError` raised by Starlette's BackgroundTask cleanup and triggers an upstream cancel on the matching `(session_id, turn_id)` via `ratatoskr.sse_client.cancel_turn`. Both Heid arms convergent. Test simulates the disconnect via `respx` + `httpx.AsyncClient` test-client and verifies the upstream cancel call lands."
+  - "**Mid-stream Ctrl-C safety.** Server uses Starlette's `lifespan` shutdown hook to issue upstream cancels for every entry in the turn registry within a 5-second cleanup budget. Entries that don't ack in time are abandoned (structured-logged). No half-written state on the Worldtree side under cooperative cleanup."
+  - "**Markdown rendering is escape-first.** v0.15.0 ships HTML-escaped plain-text rendering for the transcript pane only. Markdown rendering with a vendored safe-subset renderer is deferred to v0.16.x. This is a deliberate first-cut safety call (Hulda) — hand-rolled Markdown is easy to get wrong around HTML escaping when model output is untrusted."
+  - "**Server-side structured JSON logging.** One JSON line per HTTP request (method/path/status/duration_ms/client) + one line per SSE open/close (with events_forwarded + reason). Lets the operator diagnose problems when the browser viewport is the only one running (Gróa)."
+  - "**Per-pane copy + version footer affordances.** Each pane (Tools / Debug / Thinking / Persona) has a copy button that surfaces the pane's plain-text content for paste-into-issue / paste-into-bug-report flows. Footer carries the running `ratatoskr` package version for version-correlation when comparing browser to TUI (both Gróa-flagged)."
+  - "**Resume punted at v0.15.0.** No cross-reload session resume via `Last-Event-ID`; reload starts fresh. `/api/sessions` (GET) endpoint dropped from v0.15.0 — only `POST /api/sessions` (create) is shipped. Resume moves to v0.16.x."
+  - "**Tier 3 lifecycle stays CLI-only.** The web UI is read-only for Tier 3 surface — define / patch / delete remain in the `ratatoskr.tier3` CLI. Web surface lists Tier 3 agents (via the same `local_agents.json` merge that the TUI does) but doesn't expose mutation. Mutation UI deferred to v0.16.x."
+  - "**Tests use Starlette's TestClient + respx for upstream.** Same `respx` pattern as `tests/test_sse_client.py` / `tests/test_sessions.py`. New test files: `tests/test_web_server.py`, `tests/test_web_presentation_contract.py`, `tests/test_web_packaging.py`. No live network; the live smoke-test is part of the post-merge ship verification, not the unit tests."
+open_questions:
+  - "Should `--open` auto-open default to True or False? Draft: False — the LAN use case often runs the server on one device and connects from another, so auto-opening on the host is wrong by default. Operator passes `--open` when running locally and wants the convenience."
+  - "Should the turn registry's cleanup-budget timeout (5s) be CLI-configurable? Draft: no for v0.15.0 — 5s is a reasonable default and adding a flag invites bikeshedding. Revisit if real outage telemetry suggests otherwise."
+  - "Should the static `index.html` carry a build-time hash for browser cache-busting? Draft: no for v0.15.0 — the use case is short-lived debug sessions; operators reload manually. Vendored renderer + Markdown rendering in v0.16.x is the right time to introduce cache-busting if needed."
+prd:
+  issue: 16
+  issue_url: https://gitea.phasefinal.com/vh/ratatoskr/issues/16
+  body_sha256_16: "ae32cee38fd35761"
+  lock_in_comment_id: null
+  lock_in_sha256_16: null
+  lock_in_at: null
+  pinned_at: "2026-05-28T01:43:24+00:00"
+---
+
+# Web companion — in-browser debug surface
+
+## Context
+
+Ratatoskr is a debug TUI for the Worldtree Conversation API. The wire-layer modules (`sse_client`, `sessions`, `tier3`, `local_agents`) are well-factored and reusable. This issue adds a sibling presentation surface: a browser-based debug companion that consumes the same SSE wire and renders the same five panes (transcript, thinking, tools, debug, persona). Reachable from any device on the operator's LAN — "show someone what I'm seeing" — without replacing the TUI as the canonical debug interface.
+
+The work is wire-layer-zero (no changes to `sse_client` / `sessions` / `tier3` / `local_agents`) plus a new top-level module `ratatoskr.web` with a Starlette app, a console-script entrypoint, and a single-page static UI. Optional dependencies (`starlette`, `uvicorn`) ship as an `[web]` extras group so users who only want the TUI don't pay the install cost.
+
+## Public surface
+
+### Console script
+
+```
+ratatoskr-web [--host HOST] [--port PORT] [--open]
+
+  --host HOST   Bind address. Default: 0.0.0.0 (LAN-accessible).
+                Use 127.0.0.1 to restrict to localhost.
+  --port PORT   Listen port. Default: 8765. Use 0 for random free.
+  --open        Auto-open the URL in the system browser.
+```
+
+### Server endpoint surface
+
+```
+GET   /                                  → serve index.html (200)
+GET   /static/<path>                     → serve static asset (200) or 404
+GET   /version                           → {"ratatoskr": "<version>"}  (200)
+
+GET   /api/agents                        → 200 with [AgentInfo + tier3 local merge]
+POST  /api/sessions                      → 201 with SessionInfo
+GET   /api/agents/{agent_id}/persona_state
+                                         → 200 with PersonaSnapshot, or 404 / 403
+
+POST  /api/turns/{session_id}            → 200 with {"turn_id": <int>}
+GET   /api/turns/{session_id}/stream
+        ?turn_id=<int>                   → 200 SSE stream (text/event-stream)
+POST  /api/turns/{session_id}/cancel
+        ?turn_id=<int>                   → 200 ok / 404 / 409 / 500
+```
+
+### Module shape
+
+```
+src/ratatoskr/web/
+  __init__.py            # bare — no module-level imports of starlette/uvicorn
+  entrypoint.py          # console-script: argparse, lazy import of server
+  server.py              # Starlette app factory + endpoint handlers + turn registry
+  static/
+    index.html           # single-page UI (vanilla HTML/CSS/JS, no build step)
+```
+
+### Public functions
+
+```python
+def create_app(client_factory: Callable[[], httpx.AsyncClient]) -> Starlette: ...
+def main(argv: list[str] | None = None) -> int: ...  # entrypoint.main
+```
+
+`create_app` is the factory — takes a callable that produces a configured `httpx.AsyncClient` (bearer auth, base_url from env, User-Agent set per `ratatoskr.cli.USER_AGENT`) and returns a Starlette app with routes wired. Decoupling via factory keeps tests simple (the test client passes a respx-mocked `AsyncClient`).
+
+`entrypoint.main` is the console-script target — parses flags, builds the client factory from env, calls `create_app`, runs uvicorn. The lazy-import discipline lives here: `import starlette` does NOT happen at module top — it lands inside `main()` after arg parsing, with an `ImportError` catch that prints the `pip install ratatoskr[web]` hint and exits non-zero.
+
+## v0.16.0 amendment (post-Heid-code-review)
+
+Heid panel review (Gróa + Hulda, thread `01KSP5P6CSJH`) on the
+v0.15.0/v0.15.1 implementation surfaced three contract-text issues
+now corrected below:
+
+1. **Upstream vs local turn_id.** Cancel paths (explicit cancel,
+   browser-disconnect, lifespan shutdown) MUST target the *upstream*
+   (Worldtree-assigned) turn_id captured from the first SSE event's
+   `sse_id.turn_id`, NOT the browser-local `_TURN_COUNTER` value (which
+   is only a registry key). The `TurnHandle.upstream_response` field is
+   replaced by `upstream_turn_id: int | None`. Cancel before the
+   upstream stream starts (upstream_turn_id is None) is a no-op
+   (`{"cancelled": false, "reason": "not_started"}`).
+2. **`RATATOSKR_END_USER_ID` is server-configured.** `FN main` reads it
+   from env and threads it into `create_app(..., end_user_id=...)`; the
+   `POST /api/sessions` endpoint uses `app.state.end_user_id` server-
+   side. The browser NEVER supplies end_user_id — a client cannot
+   impersonate an arbitrary end-user partition.
+3. **Stream client lifecycle.** The `async with client_factory() as
+   client:` sketch in `FN stream_turn_endpoint` is not executable for a
+   long-lived async generator that must outlive the handler frame; the
+   implementation uses manual `client = ...; try: ... finally: await
+   client.aclose()`. Sketch corrected below.
+
+## Invariants
+
+- **INV-001**: `ratatoskr.web.__init__` and `ratatoskr.web.entrypoint` MUST NOT import `starlette` or `uvicorn` at module top. Import is inside `main()` after flag parsing. The missing-extras `ImportError` catch is scoped to the OPTIONAL extras (`starlette` / `uvicorn`) ONLY — baseline-dep / first-party import failures propagate as real tracebacks rather than masking as exit-12.
+- **INV-002**: `ratatoskr.web.server.create_app` MUST accept a `client_factory` callable. The app MUST NOT construct `httpx.AsyncClient` at module top or in route handlers; it MUST call the factory.
+- **INV-003**: Upstream API key MUST never appear in any browser-visible response. Server proxies upstream calls using the client factory; only the upstream's JSON / SSE payload is forwarded. No header echo.
+- **INV-004**: Transcript content from upstream `text` SSE events MUST be HTML-escaped before reaching the browser DOM (escape on the wire in the SSE proxy serialization OR escape in the JS rendering — both are acceptable; pick one and stick to it).
+- **INV-005**: Browser disconnect mid-stream (`asyncio.CancelledError` in the SSE handler) MUST trigger an upstream cancel via `sse_client.cancel_turn` on the captured `upstream_turn_id` (v0.16.0 — NOT the browser-local turn_id). If the turn already completed, the cancel is a best-effort no-op (`CancelAlreadyCompleted` swallowed). If `upstream_turn_id` is still None (upstream stream never started), the disconnect cancel is skipped — nothing to cancel.
+- **INV-006**: Server shutdown (Ctrl-C / SIGTERM) MUST issue upstream cancels (on `upstream_turn_id`) for every in-flight registry entry within a 5-second cleanup budget. Handles whose `upstream_turn_id` is None are skipped. Entries that don't ack in time are abandoned with a per-entry structured log line carrying `session_id` + `upstream_turn_id`.
+- **INV-007**: The turn registry MUST be in-process memory only — no persistence, no shared state across server restarts. Process exit drops the registry.
+- **INV-008**: Each SSE event serialized to the browser MUST follow the contract enumerated in `tests/fixtures/presentation_contract.json` — one entry per Event type, with the exact JSON shape the browser presenter renders against.
+- **INV-009**: All wire-layer modules (`sse_client`, `sessions`, `tier3`, `local_agents`) MUST be used unchanged. Any required change to those modules is out of scope for this issue and gets its own ticket.
+
+## Constraints
+
+- **[security]** Upstream API key never reaches the browser. Lives in `WORLDTREE_API_KEY` env, passed to upstream via `Authorization: Bearer …` header in the client factory.
+- **[security]** Model-output text is HTML-escaped in the transcript pane. No script injection from adversarial assistant responses.
+- **[security]** No CORS guard, no auth — internal-LAN debug surface per operator direction.
+- **[testability]** Server is testable via `starlette.testclient.TestClient` + `respx` upstream mocks. No live network in unit tests.
+- **[packaging]** Static asset `index.html` ships in the wheel; resolvable via `importlib.resources` post-install.
+- **[performance]** Server is stateless across browser tabs; one in-memory registry entry per in-flight turn. Cleanup on browser disconnect / server shutdown.
+
+## Tests (overview)
+
+All test files live under `tests/`. New test files added by this issue:
+
+- `tests/test_web_server.py` — endpoint contract tests via TestClient + respx
+- `tests/test_web_presentation_contract.py` — SSE proxy serialization vs fixture
+- `tests/test_web_packaging.py` — static asset resolution + lazy-import discipline
+
+Existing test files remain unchanged.
+
+## Function blocks
+
+```contract
+FN main(argv: list[str] | None) -> int
+BRIEF: Console-script entry point — parses flags, lazy-imports server, runs uvicorn.
+PRE: [PRE-001 hard] argv parsing succeeds -- argparse raises SystemExit on bad args (exit 2)
+PRE: [PRE-002 soft] WORLDTREE_API_KEY env var present -- if missing, exit 11 [auth_error]
+PRE: [PRE-003 hard] starlette + uvicorn importable -- catch ImportError, print install hint, exit 12 [missing_extras]
+POST: [POST-001 side_effect] uvicorn serves until SIGINT/SIGTERM -- blocking call returns on shutdown
+POST: [POST-002 side_effect] boot banner printed to stderr -- URL + connect-instructions visible
+ERRORS:
+  ImportError -> print "Install ratatoskr[web]" hint, return 12
+  KeyError -> print missing-env error, return 11
+STEPS:
+  1. [parse] argparse: --host (default 0.0.0.0), --port (default 8765, 0 = random), --open (default False)
+  2. [validate] read WORLDTREE_API_URL, WORLDTREE_API_KEY, RATATOSKR_END_USER_ID from env
+     IF WORLDTREE_API_KEY missing:
+       - write [auth_error] to stderr, return 11
+  3. [import] try: from ratatoskr.web.server import create_app
+     EXCEPT ImportError:
+       - write "ratatoskr-web requires the [web] extras..." hint to stderr, return 12
+  4. [factory] build client_factory closure capturing url + key + user-agent
+  5. [app] app = create_app(client_factory)
+  6. [banner] print boot banner to stderr (version, host:port, connect URLs)
+  7. [open] IF --open: webbrowser.open(f"http://localhost:{port}/")
+  8. [serve] uvicorn.run(app, host=host, port=port, log_config=None)
+  9. [return] return 0 on clean shutdown
+TESTS:
+  happy_argv [tracer]: argv=["--port", "0"] with env set → returns 0 after serve loop mocked
+  missing_extras [error]: starlette unimportable → stderr has install hint, returns 12
+  missing_api_key [error]: WORLDTREE_API_KEY unset → stderr has [auth_error], returns 11
+  default_host_is_zero [trace]: argv=[] → parsed host == "0.0.0.0"
+  port_zero_supported [trace]: argv=["--port", "0"] → parsed port == 0
+  open_flag_calls_webbrowser [trace]: argv=["--open"] with mocked webbrowser → webbrowser.open called
+  no_open_default [trace]: argv=[] → webbrowser.open not called
+```
+
+```contract
+FN create_app(client_factory: Callable[[], httpx.AsyncClient]) -> Starlette
+BRIEF: Construct the Starlette app — wire routes, register lifespan, build turn registry.
+PRE: [PRE-001 hard] client_factory is callable -- assert callable(client_factory)
+POST: [POST-001 return_value] returns Starlette instance with all routes registered -- inspect app.routes
+POST: [POST-002 state_change] app.state.turn_registry initialized as dict -- app.state.turn_registry == {}
+STEPS:
+  1. [setup] turn_registry: dict[tuple[str, int], TurnHandle] = {}
+  2. [routes] register routes for: /, /static/{path}, /version, /api/agents, /api/sessions,
+     /api/agents/{id}/persona_state, /api/turns/{sid} (POST), /api/turns/{sid}/stream (GET),
+     /api/turns/{sid}/cancel (POST)
+  3. [lifespan] register lifespan handler that drains turn_registry on shutdown
+     within 5s cleanup budget per INV-006
+  4. [state] attach client_factory and turn_registry to app.state
+  5. [return] return Starlette(routes=routes, lifespan=lifespan)
+TESTS:
+  routes_registered [tracer]: factory=mock → app.routes contains all 9 path patterns
+  state_attached [trace]: factory=mock → app.state.turn_registry is empty dict
+  factory_stored [trace]: factory=mock → app.state.client_factory is the same callable
+```
+
+```contract
+FN version_endpoint(request: Request) -> JSONResponse
+BRIEF: Return the ratatoskr package version as JSON.
+POST: [POST-001 return_value] response is JSON {"ratatoskr": <version>} status 200
+STEPS:
+  1. [lookup] version = importlib.metadata.version("ratatoskr")
+  2. [return] JSONResponse({"ratatoskr": version}, status_code=200)
+TESTS:
+  happy [tracer]: GET /version → 200, body == {"ratatoskr": "<current-version>"}
+```
+
+```contract
+FN agents_endpoint(request: Request) -> JSONResponse
+BRIEF: Proxy GET /agents from upstream; merge with local Tier 3 index.
+POST: [POST-001 return_value] 200 with list of agent dicts (upstream + local tier3 merged)
+POST: [POST-002 exception] upstream error → JSONResponse with upstream's error_code envelope
+STEPS:
+  1. [proxy] async with app.state.client_factory() as client: agents = await list_agents(client)
+  2. [local] local = local_agents.load_local_agents()
+  3. [merge] merged = [as_dict(a) for a in agents] + [as_dict(le) for le in local if le.agent_id not in {a.agent_id for a in agents}]
+  4. [return] JSONResponse(merged, status_code=200)
+ERRORS:
+  SessionApiFailed -> JSONResponse({"error_code": "session_api_failed", "status": exc.status}, exc.status)
+  httpx.RequestError -> JSONResponse({"error_code": "network_error", "message": str(exc)}, 502)
+TESTS:
+  happy [tracer]: respx mock /agents 200 → response merges upstream + local index
+  upstream_500 [error]: respx mock 500 → 500 with error_code envelope
+  network_error [error]: respx connection refused → 502 with network_error envelope
+  local_dedup [scenario]: local entry with same agent_id as upstream → no duplicate in merge
+```
+
+```contract
+FN create_session_endpoint(request: Request) -> JSONResponse
+BRIEF: Proxy POST /sessions to upstream.
+PRE: [PRE-001 hard] request body has "agent_id" key -- 400 if missing
+POST: [POST-001 return_value] 201 with SessionInfo on upstream success
+STEPS:
+  1. [parse] body = await request.json(); agent_id = body["agent_id"] (400 if missing)
+  2. [server-side] end_user_id = request.app.state.end_user_id  # v0.16.0: server-configured, NOT from body
+  3. [proxy] async with client_factory() as client: info = await create_session(client, agent_id, end_user_id=end_user_id)
+  4. [return] JSONResponse(as_dict(info), status_code=201)
+ERRORS:
+  AgentNotFound -> JSONResponse({"error_code": "agent_not_found"}, 404)
+  SessionApiFailed -> JSONResponse({"error_code": "session_api_failed", "status": exc.status}, exc.status)
+TESTS:
+  happy [tracer]: respx mock 201 → endpoint returns 201 with session JSON
+  unknown_agent [error]: respx mock 404 → 404 with agent_not_found envelope
+  missing_agent_id [adversarial]: body without agent_id → 400
+  server_side_end_user_id [v0.16.0]: create_app(end_user_id="X") → upstream body carries end_user_id="X"
+  ignores_body_end_user_id [v0.16.0,security]: body end_user_id is overridden by server value
+```
+
+```contract
+FN persona_state_endpoint(request: Request) -> JSONResponse
+BRIEF: Proxy GET /agents/{id}/persona_state to upstream.
+POST: [POST-001 return_value] 200 with PersonaSnapshot on upstream success
+STEPS:
+  1. [parse] agent_id = request.path_params["agent_id"]
+  2. [proxy] async with client_factory() as client: snap = await get_persona_state(client, agent_id)
+  3. [return] JSONResponse(snap, status_code=200)
+ERRORS:
+  PersonaNotConfigured -> JSONResponse({"error_code": "persona_not_configured"}, 404)
+  AgentNotAvailable -> JSONResponse({"error_code": "agent_not_available"}, 404)
+  AuthScopeDenied -> JSONResponse({"error_code": "auth_scope_denied"}, 403)
+TESTS:
+  happy [tracer]: respx mock 200 → endpoint returns 200 with snapshot
+  persona_not_configured [error]: respx mock 404 + persona_not_configured → 404 envelope
+  agent_not_available [error]: respx mock 404 + agent_not_available → 404 envelope
+  auth_scope_denied [error]: respx mock 403 + auth_scope_denied → 403 envelope
+```
+
+```contract
+FN submit_turn_endpoint(request: Request) -> JSONResponse
+BRIEF: Accept a prompt-submit; allocate a turn_id in the registry; return it. NO upstream call yet — the stream endpoint opens that.
+PRE: [PRE-001 hard] request body has "content" key -- 400 if missing
+POST: [POST-001 return_value] 200 with {"turn_id": <int>}
+POST: [POST-002 state_change] app.state.turn_registry has entry for (sid, turn_id) with content + status "queued"
+STEPS:
+  1. [parse] session_id = path_params["session_id"]; body = await request.json(); content = body["content"]
+  2. [allocate] turn_id = next_turn_id()  # process-local monotonic counter
+  3. [register] turn_registry[(session_id, turn_id)] = TurnHandle(content=content, status="queued", upstream_turn_id=None)  # v0.16.0: was upstream_response
+  4. [return] JSONResponse({"turn_id": turn_id}, status_code=200)
+TESTS:
+  happy [tracer]: POST {"content": "hi"} → 200 with turn_id; registry populated
+  missing_content [adversarial]: body without content → 400
+  monotonic_turn_ids [trace]: two submits → second turn_id > first turn_id
+```
+
+```contract
+FN stream_turn_endpoint(request: Request) -> StreamingResponse
+BRIEF: Open SSE stream to browser — proxy upstream stream_turn() events, forward as SSE.
+PRE: [PRE-001 hard] (session_id, turn_id) in registry -- 404 if absent
+POST: [POST-001 side_effect] each upstream event serialized to browser as SSE event with type+data per fixture
+POST: [POST-002 state_change] on completion/disconnect, registry entry removed; upstream cancel if turn still in flight
+STEPS:
+  1. [validate] sid, tid = path/query params; handle = registry.get((sid, tid)); 404 if None
+  2. [open] client = client_factory()  # v0.16.0: manual lifecycle, NOT `async with` — the generator outlives this frame; closed in finally
+     - handle.status = "streaming"
+  3. [forward] async for event in stream_turn(client, sid, handle.content):
+     - IF handle.upstream_turn_id is None: handle.upstream_turn_id = event.sse_id.turn_id  # v0.16.0: capture upstream turn id
+     - serialize per fixture: {"type": <ssetype>, "data": <json>}
+     - yield as `event: <type>\\ndata: <json>\\n\\n` bytes
+  4. [terminal] on Done/Error/Cancelled: yield final SSE, mark handle.status, break
+  5. [cleanup] finally:
+     - IF asyncio.CancelledError caught AND status=="streaming" AND upstream_turn_id is not None: cancel_turn(client, sid, handle.upstream_turn_id)  # v0.16.0: upstream id, not tid
+     - remove (sid, tid) from registry; await client.aclose()
+ERRORS:
+  KeyError -> 404 turn_not_found
+  asyncio.CancelledError -> upstream cancel, propagate
+  SseConnectFailed -> yield synthetic error event, close stream
+  SseConnectionDropped -> yield synthetic error event, close stream
+TESTS:
+  happy [tracer]: respx mock one text+done → SSE stream yields text event + done event
+  unknown_turn [error]: GET with turn_id not in registry → 404
+  upstream_error [error]: respx 500 on /sessions/{sid}/messages → synthetic error SSE event
+  disconnect_triggers_cancel [scenario]: browser disconnect mid-stream → cancel_turn called on upstream
+  full_event_vocab [scenario]: respx with one of each Event type → fixture-shaped JSON for each
+```
+
+```contract
+FN cancel_turn_endpoint(request: Request) -> JSONResponse
+BRIEF: Proxy upstream cancel for a registered turn.
+PRE: [PRE-001 hard] (session_id, turn_id) in registry -- 404 if absent
+POST: [POST-001 side_effect] upstream cancel call lands; registry entry removed
+POST: [POST-002 return_value] 200 with {"cancelled": true} or 200 with status reflecting upstream race
+STEPS:
+  1. [validate] sid, tid = params; handle = registry.get((sid, tid)); 404 if None
+  2. [not-started] IF handle.upstream_turn_id is None: del registry[(sid,tid)]; return 200 {"cancelled": false, "reason": "not_started"}  # v0.16.0: upstream never opened
+  3. [cancel] async with client_factory() as client:
+     - try: await cancel_turn(client, sid, handle.upstream_turn_id)  # v0.16.0: upstream id, not tid
+     - return 200 {"cancelled": true}
+  4. [race] EXCEPT CancelAlreadyCompleted / CancelTurnNotFound:
+     - return 200 {"cancelled": false, "reason": "race_or_completed"}
+  5. [cleanup] del registry[(sid, tid)]
+TESTS:
+  happy [tracer]: registered turn (upstream_turn_id set) → POST cancel → 200, upstream cancel at the upstream id
+  unknown_turn [error]: not in registry → 404
+  cancel_before_started [v0.16.0]: upstream_turn_id None → 200 {cancelled:false, reason:not_started}, no upstream call
+  cancel_targets_upstream_turn_id [v0.16.0]: local tid != upstream id → cancel URL uses upstream id
+  already_completed [race]: respx cancel returns 409 → 200 with reason=race_or_completed
+  cancel_failed [error]: respx returns 500 → 500 with cancel_failed envelope
+```
+
+```contract
+FN root_endpoint(request: Request) -> FileResponse
+BRIEF: Serve the static index.html.
+POST: [POST-001 return_value] FileResponse for ratatoskr/web/static/index.html, status 200, content-type text/html
+STEPS:
+  1. [resolve] path = importlib.resources.files("ratatoskr.web") / "static" / "index.html"
+  2. [return] FileResponse(path, media_type="text/html")
+TESTS:
+  happy [tracer]: GET / → 200, content-type text/html, body contains "<html"
+```
+
+```contract
+FN lifespan_shutdown(app: Starlette) -> None
+BRIEF: On Ctrl-C / SIGTERM, drain the turn registry within 5s budget per INV-006.
+POST: [POST-001 side_effect] every in-flight upstream turn gets a cancel attempt within budget
+POST: [POST-002 side_effect] entries that don't ack in budget logged + abandoned
+STEPS:
+  1. [collect] in_flight = [h for h in registry.values() if h.status == "streaming" and h.upstream_turn_id is not None]  # v0.16.0: skip not-yet-started
+  2. [cancel] async with client_factory() as client:
+     - task_to_handle = {create_task(cancel_turn(client, h.session_id, h.upstream_turn_id)): h for h in in_flight}  # v0.16.0: upstream id
+     - done, pending = await asyncio.wait(task_to_handle, timeout=5.0)
+  3. [log] for each pending: cancel task + log {"kind": "shutdown", "event": "cleanup_timeout", "session_id": h.session_id, "upstream_turn_id": h.upstream_turn_id}
+  4. [clear] registry.clear()
+TESTS:
+  happy [tracer]: 2 in-flight turns + shutdown → both upstream cancels called, registry empty
+  timeout [scenario]: 1 hanging cancel + 1 normal → normal succeeds, hanging logged as cleanup_timeout
+```

docs/contracts/issues/8.contract.md

@@ -0,0 +1,323 @@
+---
+contract_version: "2.1"
+target_module: "ratatoskr.sessions"
+scope: "Startup agent picker for TUI mode when `--new` is passed without `--agent`. Small surface change distributed across three existing modules via in-place contract amendments: `ratatoskr.sessions` gains `list_agents()` (GET /agents) returning `list[AgentInfo]` (new frozen dataclass with omit-when-null defaults mirroring SessionInfo's INV-001/INV-002 pattern); `ratatoskr.cli` softens `--agent` requirement from absolute to mode-conditional (`--send --new` still requires it; bare `--new` accepts None; `--session` still forbids it); `ratatoskr.tui._resolve_then_run` gains a pre-create branch that, when `args.new and args.agent_id is None`, calls `list_agents(client)` then runs a dedicated tiny `AgentPickerApp` (separate Textual `App` instance, opens before the main `RatatoskrApp`) whose `run_async()` returns the chosen `agent_id` (or `None` on Esc/Ctrl-D for clean exit). No new files; no wire-level surface change beyond the new endpoint hit. Composes naturally with #5 (`--end-user-id`): both thread through `ParsedArgs` before any App opens."
+depends_on:
+  - "httpx"
+  - "textual"
+used_by:
+  - "ratatoskr.cli"
+  - "ratatoskr.tui"
+language: "python"
+complexity: "low"
+estimated_loc: 200
+confidence: 0.85
+assumptions:
+  - "Worldtree spec pin (`docs/conversation-api-spec.md` v0.19.0, repo SHA `55101e909abcd2219833266b6f905c5bc956e0f0`) declares `GET /agents` at §832: returns 200 with a JSON array of agent objects. Three fields always present (`agent_id`, `name`, `description`); five optional with omit-when-null/omit-when-empty semantics (`version`, `capabilities`, `supported_models`, `persona_traits`, `ui_hints`). No pagination, no filters, no auth-scope requirement beyond bearer-authenticated (worldtree-dev confirmed 2026-05-23: Tier 1 `agent.list` baseline scope covers it; same auth posture as POST /sessions)."
+  - "`AgentInfo` is a frozen dataclass on `ratatoskr.sessions` (alongside `SessionInfo` / `SessionPage`) carrying all 8 fields. Origin-conditional defaults mirror INV-001/INV-002 from issue #2: required fields (`agent_id`, `name`, `description`) take the response value verbatim; optional fields default to `None` (scalar `version`) or empty container (`capabilities=[]`, `supported_models=[]`, `persona_traits={}`, `ui_hints={}`) when omitted from the response. Empty containers (NOT `None`) for collection-shaped optionals so caller code can branch on truthiness without `is None` ceremony."
+  - "`list_agents` uses the same caller-owned-client posture as `create_session` / `list_sessions`: takes `httpx.AsyncClient`, returns `list[AgentInfo]`, raises `SessionApiFailed(status, body)` on any non-200 response. No new exception type — list_agents' failure modes (auth, transport, server-side 5xx) all map cleanly to the existing `SessionApiFailed` shape. The module's posture against shared types with sse_client (`ratatoskr.sessions` issue #1 convention dependency) is preserved."
+  - "**CLI surface change is mode-conditional, not flag-removal**: `--agent` becomes optional ONLY when `--new` is passed AND `--send` is NOT passed (i.e., bare TUI-mode create). `--send --new` still raises `UsageError('--agent is required when --new is passed in --send mode')` because non-interactive --send mode has no way to prompt. `--session <id>` still forbids `--agent` (preserves issue #3 INV-004 mutual-exclusion). The single existing line `if ns.new and not ns.agent: raise UsageError(...)` in `_parse_args` STEP 3 splits into two conditionals that distinguish on `ns.send`."
+  - "**Picker is its own App, not a Screen within RatatoskrApp** (deliberate divergence from the issue body's 'pushed onto the App's screen stack' phrasing, which predated issue #6's refactor). Reason: issue #6's load-bearing invariant is that session-resolution + startup errors land on the operator's REAL stderr before any alt-screen opens. `list_agents` failures (network, auth, server error) need that same property. Doing it via a Screen inside RatatoskrApp re-introduces the alt-screen-eats-stderr problem #6 fixed. Doing it via a separate `AgentPickerApp` opened in `_resolve_then_run` (before `RatatoskrApp`) preserves #6's invariant: `list_agents` errors print to stderr and short-circuit BEFORE the picker's alt-screen opens; picker errors (which don't really exist — it's pure UI navigation) are bounded; chosen `agent_id` flows back through `app.run_async()`'s return value."
+  - "**Two alt-screen cycles is acceptable** (picker opens + closes; main RatatoskrApp opens). Textual's `App.run_async()` handles alt-screen entry + restoration cleanly per-instance. The visible-flicker cost is one quick alt-screen flash between picker dismissal and main App mount; the architectural cost of avoiding this (Screen-within-App, breaking #6) is higher than the cosmetic cost. If empirical operator feedback indicates the flicker is jarring, follow-up issue collapses to one App with two Screens AFTER re-engineering the stderr-error path."
+  - "**Picker Esc/Ctrl-D returns exit 0, NOT a `UsageError`**: when the operator dismisses the picker without choosing, the intent is 'never mind, exit cleanly' — same as Ctrl-D from the main chat pane in INV-002 of issue #4. `_resolve_then_run` returns 0 without calling `create_session` or `App.run_async()` on RatatoskrApp. No session is created server-side; no `agent_id` is required to satisfy this exit path."
+  - "**Picker layout uses ListView, not DataTable**: design-brief §5 mentions `DataTable` for the session picker but ListView is the right primitive for agent picking — single-column, keyboard-navigable, one row per agent rendered as `agent_id · name — description`. v1 picker is a flat list per the issue's out-of-scope clause (search/filter/sort/ui_hints rendering all deferred). DataTable's column-header + sortable-column ergonomics are wasted on this surface."
+  - "**Empty agent list is a clean exit, not an error**: if `GET /agents` returns `[]`, the picker writes `[no_agents] server returned empty agent list\\n` to stderr and `_resolve_then_run` returns exit code 13 (new — see ERROR_ROUTING below). The picker UI never opens in this case; no point showing an empty list with no actionable rows."
+  - "**Single agent does NOT auto-select**: if `GET /agents` returns one agent, the picker still opens with one row. Auto-select would hide the choice (and the agent's description) from the operator. The cost is one keystroke; the benefit is transparency about what's about to happen."
+  - "**`AgentInfo` field order in the dataclass matches the spec's column order** (`agent_id`, `name`, `description`, `version`, `capabilities`, `supported_models`, `persona_traits`, `ui_hints`). Mirrors how readers scanning the dataclass map mental model from spec → code."
+  - "**`AgentInfo.persona_traits` / `ui_hints` are typed as `dict[str, Any]` not nested dataclasses**: v1 picker just displays `agent_id · name — description`; the inner shape (ocean object, icon, color_hint, vibe) is opaque to ratatoskr. Future polish that renders icon/color_hint would either parse on-demand or introduce nested dataclasses then. Keeping them as dict[str, Any] avoids paying a typing tax now for a display surface that's deferred."
+  - "**`list_agents` does NOT pass query params**: spec §832 declares no pagination, no filters. The request is a bare `GET /agents` with the bearer header from the caller-owned client. If Worldtree later adds filters (e.g., `?capability=foo`), `list_agents` gains them via amendment then."
+open_questions:
+  - "Should the picker display `version` when available (e.g., `mimir v0.2.0 — Keeper of the Well of Knowledge`)? Draft: no for v1 — the issue body specifies `agent_id · name — description` exactly. Add in a follow-up if operators report ambiguity (two `mimir` rows from different deployments). Drift-check evidence first."
+  - "Should `AgentPickerApp.run_async()` return the chosen `AgentInfo` or just the `agent_id` string? Draft: just the `agent_id` string for v1 — that's all `create_session` needs. Returning the full `AgentInfo` would let `RatatoskrApp` show name/description in the identity widget without re-fetching, but the existing identity widget format is `<agent_id> · …<session_id>` so the extra metadata has no consumer yet. Defer until §5 side-panes work needs it."
+  - "Should the picker show a loading spinner while `list_agents` is in flight? Draft: no for v1 — list_agents runs BEFORE the picker App opens (per the architectural decision above), so there's no in-app loading state to show. Operator sees stderr label on failure; on success the picker opens with the list already populated. If the request latency turns out to be noticeable (e.g., >300ms), reconsider."
+prd:
+  issue: 8
+  issue_url: "https://gitea.phasefinal.com/vh/ratatoskr/issues/8"
+  body_sha256_16: "c34f4878936a4edc"
+  lock_in_comment_id: null
+  lock_in_sha256_16: null
+  lock_in_at: null
+  pinned_at: "2026-05-24T00:49:03+00:00"
+dependencies:
+  - issue: 2
+    path: "src/ratatoskr/sessions.py"
+    reason: "In-place contract amendment: new `list_agents()` function + new `AgentInfo` frozen dataclass added to the module's public surface. POST /sessions paths unchanged; no shared types with the new code beyond the module's existing `SessionApiFailed` exception (reused for non-200 responses)."
+  - issue: 3
+    path: "src/ratatoskr/cli.py"
+    reason: "In-place contract amendment: `_parse_args` STEP 3 splits the single `if ns.new and not ns.agent` check into two conditionals — `--send --new` keeps the strict requirement; bare `--new` accepts `agent_id=None` for the TUI-picker case."
+  - issue: 4
+    path: "src/ratatoskr/tui.py"
+    reason: "In-place contract amendment: new `AgentPickerApp(App[str | None])` class with ListView + Enter/Esc bindings; `_resolve_then_run` gains a pre-create branch that runs the picker when `args.new and args.agent_id is None`; on chosen `agent_id`, threads it into `create_session(client, chosen, end_user_id=args.end_user_id)`. RatatoskrApp itself is unchanged."
+---
+
+# Startup agent picker — GET /agents when --new without --agent (TUI)
+
+## Context
+
+Today, `ratatoskr --new` requires `--agent <id>`. If omitted, `_parse_args`
+raises `UsageError("--agent is required when --new is passed")`. That's
+correct for `--send --new` (non-interactive — can't prompt) but wrong
+for the TUI (operator may not know which agents are available, would
+prefer to pick from a list at startup).
+
+Worldtree's spec §832 exposes `GET /agents`. The endpoint returns a flat
+JSON array; required fields are `agent_id`, `name`, `description`;
+optional fields (`version`, `capabilities`, `supported_models`,
+`persona_traits`, `ui_hints`) follow omit-when-null/empty rules. No
+pagination, no filters, no special scope. Worldtree-dev confirmed
+2026-05-23: Tier 1 baseline auth covers it.
+
+This issue threads a small surface change through three existing modules
+in-place — no new files apart from this contract.
+
+## Data flow
+
+**Input:**
+- `httpx.AsyncClient` (caller-owned, base_url + bearer auth on the client).
+- No request body, no query params.
+
+**Output (`list_agents`):**
+- `list[AgentInfo]` — one entry per available agent, in server-declared order.
+
+**Output (`AgentPickerApp.run_async()`):**
+- `str | None` — chosen `agent_id`, or `None` on Esc/Ctrl-D dismissal.
+
+## Public surface (ratatoskr.sessions amendment)
+
+```python
+@dataclass(frozen=True)
+class AgentInfo:
+    """One agent's metadata from GET /agents.
+
+    INV-005: Required fields (`agent_id`, `name`, `description`) take the
+    response value verbatim. Optional fields default to None (`version`)
+    or an empty container (`capabilities`, `supported_models`,
+    `persona_traits`, `ui_hints`) when omitted from the server response,
+    mirroring SessionInfo's INV-001/INV-002 origin-conditional pattern.
+    """
+
+    agent_id: str
+    name: str
+    description: str
+    version: str | None
+    capabilities: list[str]
+    supported_models: list[str]
+    persona_traits: dict[str, Any]
+    ui_hints: dict[str, Any]
+
+
+async def list_agents(client: httpx.AsyncClient) -> list[AgentInfo]:
+    """GET /agents → list of available agents. See contract FN list_agents."""
+```
+
+## Functions
+
+### FN list_agents
+
+```
+FN list_agents(client: httpx.AsyncClient) -> list[AgentInfo]
+BRIEF: GET /agents → list of available agents. No pagination, no filters.
+
+PRE-001: client is not None.
+
+STEPS:
+  1. resp = await client.get("/agents")
+  2. IF resp.status_code != 200:
+       raise SessionApiFailed(status=resp.status_code, body=resp.content)
+  3. body = resp.json()  # expected: list[dict]
+  4. items = [
+       AgentInfo(
+         agent_id      = item["agent_id"],
+         name          = item["name"],
+         description   = item["description"],
+         version       = item.get("version"),
+         capabilities  = item.get("capabilities") or [],
+         supported_models = item.get("supported_models") or [],
+         persona_traits   = item.get("persona_traits") or {},
+         ui_hints         = item.get("ui_hints") or {},
+       )
+       for item in body
+     ]
+  5. RETURN items
+
+POST-001: every item in the return list has required fields populated.
+POST-002: optional fields default to None / [] / {} when absent from the response.
+
+ERROR_ROUTING:
+  - 200 with non-list body          → KeyError / TypeError propagates (server bug; not handled here).
+  - non-200                         → SessionApiFailed(status=N, body=resp.content)
+  - httpx.RequestError              → propagates (network failure; caller handles).
+
+TESTS:
+  - test_happy_full_shape: 200 + spec's full-shape mimir example → AgentInfo with all fields populated.
+  - test_happy_minimum_shape: 200 + spec's minimum-shape "minimal" example → AgentInfo with required + defaulted optional.
+  - test_happy_multi_agent: 200 + array of 3 agents → list of 3 AgentInfo in order.
+  - test_happy_empty: 200 + [] → empty list (no error).
+  - test_omit_capabilities: 200 + agent missing capabilities → AgentInfo.capabilities == [].
+  - test_omit_persona_traits: 200 + agent missing persona_traits → AgentInfo.persona_traits == {}.
+  - test_omit_ui_hints: 200 + agent missing ui_hints → AgentInfo.ui_hints == {}.
+  - test_500_raises: 500 → SessionApiFailed with status=500.
+  - test_401_raises: 401 → SessionApiFailed with status=401.
+```
+
+## CLI surface change (ratatoskr.cli amendment)
+
+`_parse_args` STEP 3, currently:
+
+```python
+if ns.new and not ns.agent:
+    raise UsageError("--agent is required when --new is passed")
+```
+
+becomes:
+
+```python
+if ns.new and not ns.agent:
+    if ns.send is not None:
+        # --send --new mode: non-interactive, cannot prompt for choice.
+        raise UsageError("--agent is required with --new in --send mode")
+    # else: bare --new (TUI mode) — agent_id stays None, TUI runs picker.
+```
+
+INV-004 (`--session` + `--agent` mutual exclusion) is unchanged. Existing
+`--send --new` smoke flows that pass `--agent` continue to work unchanged.
+
+ERROR_ROUTING (cli):
+- `--send --new` without `--agent` → `UsageError` → exit 10 (unchanged from today).
+- bare `--new` without `--agent` → `ParsedArgs.agent_id=None`, TUI handles.
+
+TESTS (additions to test_cli.py):
+- test_parse_send_new_without_agent_raises: `--send "hi" --new` (no --agent) → UsageError.
+- test_parse_bare_new_without_agent_accepted: `--new` (no --agent, no --send) → ParsedArgs with agent_id=None.
+- test_parse_bare_new_with_agent_accepted: `--new --agent mimir` → unchanged behavior, agent_id="mimir".
+
+## TUI surface change (ratatoskr.tui amendment)
+
+### New: AgentPickerApp
+
+```python
+class AgentPickerApp(App[str | None]):
+    """Single-purpose picker App. Opens before RatatoskrApp.
+
+    `run_async()` returns the chosen agent_id (str) or None on Esc/Ctrl-D.
+    """
+
+    BINDINGS: ClassVar[list[Binding]] = [
+        Binding("enter", "pick", "Pick", priority=True),
+        Binding("escape", "dismiss", "Cancel", priority=True),
+        Binding("ctrl+d", "dismiss", "Cancel", priority=True),
+        Binding("ctrl+c", "dismiss", "Cancel", priority=True),
+    ]
+
+    def __init__(self, agents: list[AgentInfo]) -> None:
+        super().__init__()
+        assert agents  # PRE-002 — caller guarantees non-empty
+        self.agents = agents
+
+    def compose(self) -> ComposeResult:
+        yield Header()
+        yield Static("Pick an agent for the new session:", id="picker-prompt")
+        yield ListView(
+            *[
+                ListItem(Label(f"{a.agent_id} · {a.name} — {a.description}"))
+                for a in self.agents
+            ],
+            id="agent-list",
+        )
+        yield Footer()
+
+    async def on_mount(self) -> None:
+        self.query_one("#agent-list", ListView).focus()
+
+    def action_pick(self) -> None:
+        lv = self.query_one("#agent-list", ListView)
+        idx = lv.index
+        if idx is None:
+            return  # no row highlighted; ignore
+        self.exit(self.agents[idx].agent_id)
+
+    def action_dismiss(self) -> None:
+        self.exit(None)
+```
+
+### Modified: _resolve_then_run
+
+Insert a pre-create branch between the `async with httpx.AsyncClient(...)`
+and the existing `if args.new:` block:
+
+```python
+async def _resolve_then_run(args: ParsedArgs) -> int:
+    assert isinstance(args, ParsedArgs) and args.send_content is None
+    async with httpx.AsyncClient(...) as client:
+        # NEW (issue #8): startup agent picker when --new without --agent.
+        chosen_agent_id: str | None = args.agent_id
+        if args.new and args.agent_id is None:
+            try:
+                agents = await list_agents(client)
+            except SessionApiFailed as exc:
+                sys.stderr.write(
+                    f"[session_api_failed] status={exc.status} body={exc.body!r}\n"
+                )
+                return 20
+            except (httpx.ConnectError, httpx.ReadTimeout, httpx.TransportError) as exc:
+                sys.stderr.write(f"[network_error] {type(exc).__name__}: {exc}\n")
+                return 21
+            if not agents:
+                sys.stderr.write("[no_agents] server returned empty agent list\n")
+                return 13
+            picker = AgentPickerApp(agents)
+            chosen_agent_id = await picker.run_async()
+            if chosen_agent_id is None:
+                return 0  # Esc/Ctrl-D — clean exit, no session created
+        # EXISTING: create_session OR re-use --session id
+        if args.new:
+            assert chosen_agent_id is not None
+            try:
+                info = await create_session(
+                    client, chosen_agent_id, end_user_id=args.end_user_id
+                )
+            ...
+        else:
+            ...
+        app = RatatoskrApp(args, session_id=session_id, agent_id=agent_id, client=client)
+        ...
+```
+
+### ERROR_ROUTING (tui startup)
+
+| Failure | Stderr label | Exit |
+|---------|--------------|------|
+| `list_agents` → `SessionApiFailed` | `[session_api_failed] status=N body=B` | 20 |
+| `list_agents` → network error | `[network_error] T: M` | 21 |
+| empty agent list (`GET /agents` returns `[]`) | `[no_agents] server returned empty agent list` | 13 (new) |
+| picker Esc/Ctrl-D dismissal | (none — clean exit) | 0 |
+| `create_session` post-pick → `AgentNotFound` | `[agent_not_found] agent_id=X` | 12 (unchanged from #4) |
+
+INV: exit code 13 is new (no-agents). Previously unused — does not collide
+with any existing exit code in `_resolve_then_run` or `_amain`.
+
+### TESTS (additions to test_tui.py)
+
+```
+- test_picker_happy_path: list_agents returns 2 agents; AgentPickerApp opens; user picks index 0; chosen agent_id flows into create_session; main App opens.
+- test_picker_esc_clean_exit: list_agents returns 2 agents; picker opens; user presses Esc; _resolve_then_run returns 0; create_session NOT called; RatatoskrApp NOT opened.
+- test_picker_skipped_when_agent_id_provided: bare --new --agent mimir → list_agents NOT called; picker NOT opened; create_session called with "mimir".
+- test_picker_skipped_when_session_mode: --session s-1 → list_agents NOT called; picker NOT opened; no create_session.
+- test_picker_list_agents_session_api_failed: list_agents raises SessionApiFailed → stderr [session_api_failed]; exit 20; picker NOT opened; create_session NOT called.
+- test_picker_list_agents_network_error: list_agents raises ConnectError → stderr [network_error]; exit 21.
+- test_picker_empty_list: list_agents returns [] → stderr [no_agents]; exit 13; picker NOT opened; create_session NOT called.
+- test_agent_picker_app_renders_rows: AgentPickerApp with 3 agents → ListView has 3 ListItem children with expected text.
+- test_agent_picker_app_pick_returns_agent_id: simulate Enter on highlighted row → exit value == agents[idx].agent_id.
+- test_agent_picker_app_dismiss_returns_none: simulate Esc → exit value is None.
+```
+
+## Invariants
+
+- **INV-005**: `AgentInfo` field defaults are origin-conditional (mirrors INV-001/002 from #2). Required → verbatim; optional → None / [] / {}.
+- **INV-006**: `list_agents` failure modes route through `SessionApiFailed` only — no new exception type introduced.
+- **INV-007**: Picker is a separate App, opened by `_resolve_then_run` BEFORE `RatatoskrApp`. Preserves issue #6's stderr-error invariant for `list_agents` failures.
+- **INV-008**: `--agent` CLI requirement is mode-conditional: required only when `--send --new`; bare `--new` accepts None; `--session` always forbids it.
+- **INV-009**: Picker dismissal (Esc/Ctrl-D) returns clean exit 0; no session created server-side.
+- **INV-010**: Empty agent list is a clean stderr exit (code 13), not an open picker.
+- **INV-011**: Single-agent response still opens the picker — no auto-select.
+- **INV-012**: Two alt-screen cycles (picker + main App) is the explicit architectural tradeoff for preserving INV-007.

docs/conversation-api-spec.md

@@ -55,6 +55,69 @@ conversation_api:
 
 ---
 
+## Authorization model — agent invocation
+
+When you call `POST /sessions` against an agent, the authorization check that fires depends on **which kind of agent** you target. There are two distinct scope namespaces — the spelling differs by one character (`agent` vs `agents`) and the granting mechanism differs entirely. Confusing the two is a common source of bug reports.
+
+### Tier 1 — foundational agents (no `:` in agent_id)
+
+Agents bundled with Worldtree: `mimir`, `lofn`, `soong`, `forseti`, `domari`, `vili`, `actor`, `saga`, `bragi`, `leif`, `troi`, `cara`, `glados`, and any future Asgardian. The agent_id is a simple slug like `mimir` — no colon.
+
+> **About tiers:** Your `tier` is set on the `users` table row your API key resolves to, assigned at key-mint time (see `POST /admin/keys`). Tiers are `anonymous` (dev-mode unauthenticated), `user` (default for newly-issued keys), `free`/`pro` (subscription-shaped, not actively differentiated), and `admin`. The tier you have is visible via `GET /me`'s `tier` field. Tier-derived scopes come from `config/policies.yaml > tiers.<tier>.scopes` — there is no per-key scope override.
+
+**Authorization rule (singular `agent`):**
+
+```yaml
+- id: agent-call-baseline-allow
+  principal:
+    tiers: ["anonymous", "user", "free", "pro", "admin"]
+  action: "agent.call:*"
+  resource: "*"
+  effect: allow
+```
+
+This baseline rule lives at `config/policies.yaml`. Every authenticated tier — including the `user` tier that newly-issued keys default to — already passes this check for every Tier 1 agent. **There is no per-agent scope you can add to "grant" Tier 1 access; it's covered by tier.**
+
+If you get a 422 calling a Tier 1 agent (e.g., `lofn` rejecting with `end_user_id_required`), that's a **request-body validation**, not a scope denial. Check the `error_code` in the response detail — `END_USER_ID_REQUIRED` means the agent requires an `end_user_id` field in the request body; `AUTH_SCOPE_DENIED` (403) would be the actual scope problem. They're not interchangeable.
+
+### Tier 3 — consumer-defined agents (`:` in agent_id)
+
+Agents created at runtime via `POST /agents/define`. The agent_id is `<owner_user_id>:<agent_name>`, e.g., `acme:support-bot`. The `:` in the path is the trigger that switches the auth model.
+
+**Authorization is DB-backed per-resource, NOT policy-driven (plural `agents`):**
+
+```
+scope action checked: agents.call:<owner_user_id>:<agent_name>
+                       ^^^^^^
+                       PLURAL — different namespace from Tier 1
+```
+
+There is **no blanket allow rule** for `agents.call:*` in policy. The grant comes from the live `consumer_agents` table:
+
+- A non-soft-deleted row in `consumer_agents` owned by `ctx.user_id` IS the grant.
+- Cascade soft-delete and owner-initiated `DELETE` revoke it.
+- Missing row → policy defaults to deny (403 `auth_scope_denied`).
+
+To "add the scope" for a Tier 3 agent, you don't amend any config or call an admin endpoint — you `POST /agents/define` to register it under your `user_id`. Owning the row IS the grant. You cannot call another user's Tier 3 agent; ownership is checked at session-create (`row.user_id == ctx.user_id`).
+
+### Common pitfalls
+
+- **Singular vs plural.** Tier 1 uses `agent.call:*` (singular `agent`). Tier 3 uses `agents.call:<owner>:<name>` (plural `agents`). One character difference, two completely different mechanisms. There is no Tier 1 scope named `agent.call:mimir` or `agents.call:mimir` — Tier 1 is granted by baseline rule, not per-agent name.
+- **No scope-mutation API.** `POST /admin/keys` accepts `{user_id, label, tier}` only. There is no per-key scope override mechanism in the storage schema. To change a user's effective scopes, change their `tier`, not their key. Per-resource Tier 3 grants flow through `POST /agents/define` (and its DELETE counterpart), not through admin endpoints.
+- **422 vs 403.** A 422 is body-validation (e.g., `end_user_id_required`); a 403 is auth-policy denial (`auth_scope_denied`). Different fix paths. Read the `error_code` in `detail`.
+
+### Quick decision table for consumers
+
+| Target | Auth requirement |
+|---|---|
+| Tier 1 agent (e.g., `mimir`) | Authenticated tier ≥ `user`. No additional body requirements |
+| Tier 1 agent `lofn` (the default welcoming intermediary) | Authenticated tier ≥ `user` + `end_user_id` field required in request body. 422 `END_USER_ID_REQUIRED` if absent |
+| Tier 3 agent (any agent_id containing `:`) | `end_user_id` field required in body. AND the row must be owner-matched: `POST /agents/define` first to create a row under your `user_id`, then session-create works against your existing key. Cross-user Tier 3 invocation is rejected with 403 |
+
+> **Programmatic discovery of `end_user_id` requirements:** as of v0.22.x there is no field on `GET /agents` indicating which agents require `end_user_id` — the spec line above (lofn + Tier 3) is the authoritative list, and 422 `END_USER_ID_REQUIRED` is the fallback signal at request time. Adding a discoverable `requires_end_user_id` field on `AgentInfoResponse` is on the table as a small future capability; ping if you want to drive it.
+
+---
+
 ## GET /me
 
 Returns the authenticated principal's identity and key metadata. Lets a client verify its key on boot without triggering agent-config-loading side effects.
@@ -1878,6 +1941,65 @@ Tool-using turns cycle through `CallingLLM → ProcessingTools → CallingLLM
 
 Clients that don't need phase events can filter on `event["type"] != "worker_phase"` client-side. Existing SSE consumers that switch on `event["type"]` ignore this event type without code changes.
 
+### affect_update
+
+Persona-state observability event (issue #204). Fires twice per turn for agents with `persona.enabled: true` on non-ephemeral sessions; suppressed entirely for persona-disabled agents (e.g. `domari`, `muninn`), Tier 3 consumer-defined agents (Phase 2.0), and ephemeral sessions.
+
+**Start-of-turn — `status: "current"`:**
+
+Emitted immediately at the start of each qualifying turn, before any `worker_phase` event. Carries the agent's current persona snapshot reflecting all prior turns' completed appraisals.
+
+```json
+{
+  "type": "affect_update",
+  "status": "current",
+  "turn_id": 42,
+  "snapshot": {
+    "agent_id": "mimir",
+    "pad": {"pleasure": 0.52, "arousal": 0.47, "dominance": 0.50},
+    "dominant_emotion": "curiosity",
+    "emotions_active": [
+      {"type": "curiosity", "intensity": 0.6, "decay_remaining_s": 202.7}
+    ],
+    "baseline_pad": {"pleasure": 0.50, "arousal": 0.40, "dominance": 0.50},
+    "mood_drift": {"valence_delta": 0.02, "arousal_delta": 0.07},
+    "last_updated_at": "2026-05-25T22:30:18+00:00"
+  }
+}
+```
+
+**End-of-turn — `status: "scheduled"`:**
+
+Emitted after the post-turn appraisal task has been scheduled (per #177 Phase A's fire-and-forget discipline) and before `done`. Lightweight notification — no PAD numbers, since the appraisal is still running asynchronously. The result lands in the NEXT turn's `status: "current"` snapshot.
+
+```json
+{"type": "affect_update", "status": "scheduled", "turn_id": 42}
+```
+
+`scheduled` is skipped on turn failure/cancel paths (the appraisal was never reached); `current` still fires unconditionally for qualifying turns.
+
+Bootstrap reads available via `GET /agents/{agent_id}/persona_state` (same `snapshot` shape, requires `persona.read` scope).
+
+### awaiting_llm_first_token
+
+Periodic heartbeat event (issue #201) emitted at a configurable interval during the gap between `worker_phase: phase="BuildingPrompt"` and `worker_phase: phase="CallingLLM"`. Solves the legitimate-slow first-token visibility gap: consumer TUIs can render a "thinking for Ns…" timer rather than a frozen line during heavy-CoT prompt warmup.
+
+```json
+{
+  "type": "awaiting_llm_first_token",
+  "turn_id": 42,
+  "elapsed_ms_since_building_prompt": 5012.3
+}
+```
+
+`elapsed_ms_since_building_prompt` is the server-authoritative wall-clock milliseconds since `BuildingPrompt` was emitted. Independent of network latency or clock skew.
+
+Heartbeats stop the moment the engine produces its first event (the `CallingLLM` marker). They do NOT re-fire during tool-roundtrip `CallingLLM` re-entries — the heartbeat is scoped to the FIRST `BuildingPrompt → CallingLLM` gap only.
+
+**Configuration:** `conversation_api.awaiting_llm_first_token_heartbeat_s` (default `5.0`). Per-agent override via `agent.conversation.awaiting_llm_first_token_heartbeat_s`. Value `0.0` disables emission entirely.
+
+Cancellation paths (stall watchdog, user-cancel) also stop the heartbeat — no `awaiting_llm_first_token` event appears after the terminal `cancelled` event.
+
 ### thinking
 
 Incremental reasoning/thinking content (from thinking-enabled models).

docs/conversation_api.contract.md

@@ -1851,6 +1851,103 @@ SQLite `consumer_agents` table.
   before any other processing; non-slug user_ids return 403
   `tier3_user_id_unsupported`.
 
+### Persona-state observability (issue #204)
+
+- **INV-204-1 (affect_update event type)**: `affect_update` is a
+  top-level SSE event `type` discriminator, sibling to `worker_phase`
+  / `tool_*` / `text` / `thinking` / `done`. Not a `worker_phase` sub-
+  phase. INV-061's "BuildingPrompt is the FIRST event" property is
+  scoped to `worker_phase` events only — `affect_update status="current"`
+  may precede BuildingPrompt for persona-enabled agents.
+- **INV-204-2 (per-turn emission)**: For agents with persona enabled
+  on non-ephemeral sessions, `stream_turn` emits `status="current"`
+  before any other SSE event on a successful or failed turn, and
+  `status="scheduled"` after `update_after_turn` schedules the
+  appraisal task (success path only — skipped on cancel / error
+  before update_after_turn was reached). See contract
+  `docs/contracts/issues/204.contract.md`.
+- **INV-204-3 (emission suppression)**: Persona-disabled agents and
+  ephemeral sessions emit ZERO `affect_update` events.
+- **INV-204-6 / INV-204-7 (persona_state endpoint)**: New
+  `GET /agents/{agent_id}/persona_state` gated on Heimdall scope
+  `persona.read`. Route ordering: auth → Tier 3 short-circuit (404
+  `persona_not_configured`) → Tier 1/2 existence (404
+  `agent_not_available`) → persona-enabled check (404
+  `persona_not_configured`) → snapshot (200).
+- **INV-204-9 (read-only registry primitive)**: `PersonaRegistry.get_state`
+  is mutex-free and never mutates `persona.emotions`. Eventual
+  consistency under concurrent `_appraisal_wrapper` mutations.
+- **INV-204-14 (replay participation)**: `affect_update` events flow
+  through `_publish`, so SSE resume / replay handles them with no
+  special case.
+
+## Amendment — AwaitingLLMFirstToken heartbeat (issue #201, INV-201-1..7)
+
+Adds a periodic SSE heartbeat event during the gap between
+`BuildingPrompt` and `CallingLLM` so consumers can distinguish
+"engine is thinking" from "engine is wedged" without out-of-band
+server inspection. Filed by ratatoskr-dev; ships in v0.29.0.
+
+- **INV-201-1 (new top-level event type)**: `awaiting_llm_first_token`
+  is a new top-level SSE event type, sibling to `worker_phase` /
+  `tool_*` / `text` / `thinking` / `debug` / `done` / `affect_update`.
+  `_WORKER_PHASE_VOCAB` is NOT extended; INV-053 / INV-054 unchanged.
+  Same precedent as #204's `affect_update`.
+
+- **INV-201-2 (config-gated emission)**: Heartbeat emission requires
+  `awaiting_llm_first_token_heartbeat_s > 0.0`. When the resolved
+  value is `0.0`, the heartbeat task is never started and zero
+  `awaiting_llm_first_token` events emit for the turn. When > 0.0,
+  the task starts immediately after `_publish_phase("BuildingPrompt")`
+  and emits an event every `interval` seconds until cancelled.
+
+- **INV-201-3 (defense-in-depth cancellation)**: The heartbeat task
+  is cancelled at three sites (idempotent via the `_cancel_heartbeat`
+  helper): (a) immediately before `_publish_phase("CallingLLM")` on
+  the engine-first-event path; (b) inside the `cancelled`/`error`
+  handling that wraps `_handle_cancel` (covers stall + user-cancel
+  paths); (c) in the outer `finally` block alongside
+  `_clear_stall_timer`. After cancellation, no further
+  `awaiting_llm_first_token` events emit.
+
+- **INV-201-4 (wire shape)**: Payload is exactly `{type:
+  "awaiting_llm_first_token", turn_id: <int>,
+  elapsed_ms_since_building_prompt: <float>}` plus the composite `id:
+  "<turn_id>:<seq>"` stamped by `_publish`. No additional fields.
+  `elapsed_ms_since_building_prompt` is `(time.monotonic() -
+  building_prompt_t) * 1000.0` where `building_prompt_t` is captured
+  immediately before `BuildingPrompt` is published.
+
+- **INV-201-5 (first-gap-only scope)**: Heartbeat is scoped to the
+  FIRST `BuildingPrompt → CallingLLM` gap of the turn. Tool round-trip
+  `CallingLLM` re-entries (INV-058) emit ZERO
+  `awaiting_llm_first_token` events. Out-of-scope sub-phases
+  (`AwaitingToolResult`, `AwaitingNextLLMCall`) would be separate
+  follow-up features.
+
+- **INV-201-6 (replay participation)**: Heartbeat events flow through
+  `_publish → _replay_buffer + queue` per INV-060 — same replay
+  semantics as worker_phase events. On `Last-Event-ID` reconnect,
+  prior heartbeats replay identically.
+
+- **INV-201-7 (config resolution precedence)**: Per-agent
+  `agent.conversation.awaiting_llm_first_token_heartbeat_s` →
+  `api_cfg.awaiting_llm_first_token_heartbeat_s` → built-in `5.0`.
+  Negative values raise `ConfigurationError` at agent load; `0.0`
+  is valid and means "disabled." Mirrors the `_resolve_stall_timeout_s`
+  precedence pattern (INV-038).
+
+### Mechanism note
+
+The heartbeat task is a separate `asyncio.Task` (NOT `loop.call_later`,
+because heartbeats repeat at an interval rather than fire once at a
+timeout). An `asyncio.Queue` shared between the heartbeat task and the
+generator carries events; the generator uses
+`asyncio.wait(return_when=FIRST_COMPLETED)` to race the engine's
+`__anext__` against the heartbeat queue's `get` ONLY during the first
+iteration. After `CallingLLM` fires, the heartbeat task is cancelled
+and subsequent iterations use the original non-race pattern.
+
 ### Storage extension
 
 The `consumer_agents` table lives in `core/heimdall/storage/sqlite.py`

persistent-memory.md

@@ -1,6 +1,6 @@
 # Persistent memory — ratatoskr
 
-_Last updated: 2026-05-23_
+_Last updated: 2026-05-24_
 
 This file captures durable intent and supporting evidence (goals, decisions,
 foot-gun warnings, in-flight state) across context resets. Read it at session
@@ -32,77 +32,107 @@ separate dev team rather than an in-tree Worldtree tool.
 
 ## Current state / in-flight
 
-_As of 2026-05-23 (end of day, post-#12 implementation, pre-commit):_
+_As of 2026-05-25 (post-v0.8.2 drop double-print; v0.9.0 live-md next):_
 
-**Status: issue #12 (presenter contract semantics amendment)
-TDD-complete, in working tree, awaiting commit.** Seven core issues
-complete (`sse_client` #1, `sessions` #2, `cli` #3, `tui` #4,
-`--end-user-id` #5, TUI startup error visibility #6, presenter
-contract semantics amendment #12) + robustness fix #7 (MalformedSseData
-+ empty-skip). 208/208 tests GREEN; ruff clean. pyproject.toml bumped
-to v0.2.0; `uv.lock` refreshed. Working tree has 9 modified files +
-the new `docs/contracts/issues/12.contract.md` (untracked); commit not
-yet authored.
+**Status: v0.8.2 shipped.** Eleven core features complete (`sse_client`
+#1, `sessions` #2, `cli` #3, `tui` #4, `--end-user-id` #5, TUI
+startup error visibility #6, presenter contract semantics amendment
+#12, startup agent picker #8, §5 layout reshape + Tools pane #13)
++ robustness fix #7 (MalformedSseData + empty-skip) + v0.2.1 TUI
+layout fix. 236/236 tests GREEN; ruff clean.
+
+**§5 v1 entry point shipped (issue #13).** TUI now Horizontal
+two-column: left = chat surface (transcript + thinking-current +
+prompt); right = TabbedContent with single Tools tab (RichLog
+receiving ToolStart/ToolResult events). Routing-not-duplication:
+tool events leave the main transcript entirely. Ctrl+1 activates
+Tools tab without losing Input focus (INV-016). New `pane-name`
+Static in the footer (static "Tools" v1; dynamic when more tabs
+land). CLI mode (--send) unaffected by design — INV-018.
 
 Last commits on `main`:
-- `8282156` snapshot: persistent-memory Heimdall scope-model foot-gun (post-v0.1.0)
-- `804c2df` feat(sessions,cli,tui): issues #5 + #6 + worldtree-dev consumer-API follow-up (tagged v0.1.0)
+- v0.8.2 fix(tui): drop post-Done Markdown body re-render (no double-print)
+- `11ef683` fix(tui,sse): inline Text streaming + empty-id keepalive skip (v0.8.1)
+- `9fade55` feat(local_agents): JSON-backed local tier-3 index + picker merge (v0.8.0)
+- `9918c10` fix(tui): coalesce thinking deltas on `\n` (v0.7.1)
+- `c086ae2` feat(tier3): ratatoskr.tier3 module + CLI (v0.7.0)
+- `d356990` refactor(tui): thinking streams into thinking-log (v0.6.5)
+- `82437bd` style(tui): picker highlighted item → Aurora blue (v0.6.4)
+- `ac690c1` style(tui): restore Australis palette, only $background → pure black (v0.6.3)
+- `d845b20` style(tui): neutralize Australis dark palette (v0.6.2, reverted)
+- `8463eb2` style(tui): kill remaining blue + thinking-current into pane (v0.6.1)
+- `cfee89a` refactor(tui): streaming + turn headers + Thinking pane (v0.6.0)
+- `7106af5` style(tui): UI polish pass — terminal label colors, placeholders (v0.5.1)
+- `ffd22fb` refactor(tui): content-only main pane + Debug tab + chrome dark (v0.5.0)
+- `2756f5f` style(tui): apply Australis theme to TUI chrome + widgets (v0.4.1)
+- `24e4371` feat(tui): issue #13 — §5 layout reshape + Tools pane (v0.4.0)
+- `d30be12` feat(sessions,cli,tui): issue #8 — startup agent picker (v0.3.0)
+- `c85f6bd` fix(tui): anchor layout via dock so Input never moves (v0.2.1)
+- `3b9c610` feat(cli,tui): issue #12 — presenter contract semantics amendment (v0.2.0)
+- `8282156` snapshot: persistent-memory Heimdall scope-model foot-gun
+- `804c2df` feat(sessions,cli,tui): issues #5 + #6 + worldtree-dev follow-up (v0.1.0)
 
-`--send` validated end-to-end against personal Worldtree at v0.1.0
-(`http://10.250.50.152:8081`, mimir on qwen3.6-35-a3b, 2026-05-23 smoke
-returned `[done] turn_id=116 duration_ms=5467`). Lofn smoke is
-**auth-unblocked** as of 2026-05-23 — worldtree-dev confirmed our key
-(`c990f0be`) already covers Tier 1 agents via the `agent.call:*`
-baseline policy; the initial "scope-add needed" diagnosis was a phantom
-ask (see Tried-and-abandoned). The actual lofn fix shipped as issue #5
-(`--end-user-id` flag).
-
-**Async cross-frontier activity in flight:**
-- Issue #12 code-review consult posted to volva 2026-05-23 (althing
-  thread `01KSBH8GYH4G3H03T767X613W7`). Reply pending in inbox.
+**Smoke status:**
+- `--send --new --agent mimir` v0.3.0 smoke clean
+  (`[done] turn_id=141 model=qwen3.6-35-a3b duration=2.2s`).
+- Live `list_agents` smoke against personal Worldtree returned 12
+  agents (actor, bragi, cara, domari, forseti, glados, leif, lofn,
+  mimir, soong, troi, saga).
+- Picker end-to-end smoke against live Worldtree: bare `--new` →
+  list_agents → picker (auto-picked lofn programmatically since
+  driving alt-screen interactively from CLI smoke isn't possible)
+  → POST /sessions with end_user_id="ratatoskr-tui" succeeded;
+  RatatoskrApp constructed with agent_id="lofn".
+- TUI v0.2.0 was visually broken (Input pane bouncing with thinking
+  runs); v0.2.1 fixed via dock-based layout. Operator confirmed
+  "a lot better" interactively.
 
 **Outstanding operator-side todos:**
-- **Commit issue #12 work** + tag v0.2.0 + push. 9 modified files +
-  new `12.contract.md` ready.
-- **Post-v0.2.0 mimir smoke (the visual one)** — `source env.sh && uv
-  run ratatoskr --new --agent mimir --send "test"` to eyeball the new
-  rendering (`. thinking: ...` coalesce, `. worker_phase: ...` demotion,
-  `duration=5.5s` formatting, `usage 6756 in -> 126 out (...)` shape).
-  The v0.1.0 mimir smoke confirmed wire-level backwards compat but
-  did NOT exercise the v0.2.0 rendering.
-- **Post-v0.2.0 lofn smoke** — `source env.sh && uv run ratatoskr
-  --new --agent lofn --send "hello"` (env.sh ships
-  `RATATOSKR_END_USER_ID="ratatoskr-tui"`). Now unblocked on auth.
+- **Interactive §5 layout eyeball** — `source env.sh && uv run
+  ratatoskr --new --agent mimir`, ask a tool-using question
+  ("search your KB for X"). Confirm: left column shows chat /
+  thinking; right column's Tools tab shows tool_start +
+  tool_result with `· ` prefix; Ctrl+1 doesn't break input focus;
+  no width-clamp issues on the operator's terminal. Programmatic
+  smoke confirmed all the routing + binding; visual confirmation
+  pending.
+- **Post-v0.2.1 TUI multi-turn eyeball** — confirm thinking-run
+  bouncing is gone across multiple turns; the layout fix has only
+  been confirmed for a single turn so far.
 
 **Pending issues filed but not started:**
-- **Issue #8 (startup agent picker)** — filed but unscaffolded.
-  `GET /agents` is free to call (worldtree-dev confirmed); auth side
-  is unblocked. Depends on #5 composably (both thread through
-  `ParsedArgs` → `_resolve_then_run`).
 - **Issue #9 (spec-pin refresh v0.19.0 → v0.22.1)** — filed
-  2026-05-23. Documentation debt. None of the v0.20.0/v0.21.0/v0.22.0
-  changes break ratatoskr's existing surface; the pin lies about
-  what we've committed to.
-- **Issue #10 (subject:{type,id} migration)** — filed 2026-05-23 to
-  track Worldtree #196's LOCKED-but-not-shipped breaking change.
-  Don't pre-implement per worldtree-dev's explicit guidance.
+  2026-05-23. Documentation debt; defer unless we need a v0.20.0+
+  capability.
+- **Issue #10 (subject:{type,id} migration)** — filed 2026-05-23
+  to track Worldtree #196. Don't pre-implement per worldtree-dev.
 - **Issue #11 (AdminEvents pane auth prerequisite)** — filed
-  2026-05-23. Future side-pane requires `admin.events.read` scope.
+  2026-05-23. Future side-pane needs `admin.events.read` scope.
 
-Branch: `main` (dirty with #12 work pending commit). Remote:
+**Pending Worldtree-dev follow-up:**
+- worldtree-dev committed (althing `01KSBKTG096Q…`) to file a
+  Worldtree-side issue for the stall-watchdog gap (cancel-check is
+  inside the engine-event loop, so a never-yielding first-LLM-call
+  bypasses the 300s watchdog). Will file after the immediate stall
+  is cleared.
+- Ratatoskr-side companion (potential): a client-side stall watchdog
+  (e.g., 90s-no-events → `[server_stalled]` stderr label, keep
+  connection). Defer until recurrence; defense-in-depth regardless of
+  whether Worldtree fixes its own.
+
+Branch: `main` (clean). Remote:
 `origin → git@gitea.phasefinal.com:vh/ratatoskr.git`.
 
 **Next natural moves:**
 
-1. **Triage volva's #12 code-review** when the reply lands in the
-   inbox; apply tactical fixes inline, surface architectural calls.
-2. **Commit + tag v0.2.0 + push.**
-3. **Post-v0.2.0 smokes** — mimir (visual), lofn (newly unblocked).
-4. **Issue #8 (startup agent picker)** — scaffold + contract, then
-   TDD. Composes with the forward end_user_id direction (see Recent
-   decisions).
-5. **Side-pane issues** — Persona pane first (file-tail, cheap).
-6. **Issue #9 (spec-pin refresh)** — defer unless we need a v0.20.0+
+1. **Interactive picker eyeball** — operator confirms the TUI
+   picker UX (rendering, Enter pick, Esc dismiss) against personal
+   Worldtree.
+2. **§5 side-panes work** — Persona pane first per design-brief; the
+   collapsible Thinking pane + Debug pane proposals fold IN as
+   additional `TabbedContent` tabs alongside Persona/Tools/AdminEvents.
+   Reshapes layout from vertical-stack to Horizontal two-column.
+3. **Issue #9 (spec-pin refresh)** — defer unless we need a v0.20.0+
    capability (e.g., `memory_context` for Phase 2.1).
 
 ## Recent decisions
@@ -134,6 +164,8 @@ decision. Captures rationale that won't be obvious from code alone.
 - `[2026-05-23]` **Issue #5 (`--end-user-id`) implemented via TDD.** Small surface change across three modules (sessions, cli, tui): `create_session(client, agent_id, *, end_user_id=None)` widens with optional kwarg; body conditionally adds the field when non-None (INV-002: omitting != sending empty); PRE-003 asserts non-empty. `ParsedArgs.end_user_id: str | None = None` field; `--end-user-id` CLI flag with non-empty validation (mirrors `--send` check). `_amain` and `_resolve_then_run` thread `end_user_id=args.end_user_id` to their `create_session` calls. Post-#6 adjustment: the contract originally named `on_mount` as the TUI threading site, but #6 had moved session resolution to `_resolve_then_run` — same shape, different function. 7 new tests across the 3 modules.
 - `[2026-05-23]` **Worldtree-dev consult landed authoritative consumer-API guidance** (althing thread `01KSBARG2B8M8C82H6AJGJWX1B`). Key takeaways shaped follow-on work: (1) `end_user_id` is a free-form partition key for long-term memory + persona/valence state; same value → same partition, different values → fully isolated. For Vuong-debugging-Worldtree the recommended posture is a project-stable default with `--end-user-id` override. (2) No programmatic `requires_end_user_id` discovery on `GET /agents` — "try and react to 422" remains the pattern. (3) Breaking-change #196 LOCKED but not shipped: `subject:{type,id}` replaces `end_user_id` at future v0.22.x or v0.23.0; don't pre-implement. (4) Spec pin (v0.19.0) is 3 minor versions stale (current v0.22.1); none of v0.20.0/v0.21.0/v0.22.0 break ratatoskr's surface but the pin lies about what we're committed to. (5) User-Agent header: send one (`ratatoskr/<version> (vh@phasefinal.com)`). (6) `agents.call:lofn` scope needed for lofn smoke. (7) `GET /agents` requires no special scope; issue #8 unblocked on auth.
 - `[2026-05-23]` **Follow-up acted on:** User-Agent header added to both `_amain` and `_resolve_then_run` httpx.AsyncClient constructions (with `importlib.metadata` version lookup + fallback to `0.0.0`); `RATATOSKR_END_USER_ID` env-var fallback added to `_parse_args` (resolution: flag > env > None); env.sh ships `RATATOSKR_END_USER_ID="ratatoskr-tui"` as project-stable default. Original issue #5 posture rejected env-var fallback as "papering over isolation"; revised after worldtree-dev's guidance that the realistic single-operator use case wants partition continuity. Issue #5 + #3 contracts amended in-place to document the env-var fallback. Infra-ops pinged via althing for `agents.call:lofn` scope (broker pattern; they forwarded to worldtree-dev). Three Gitea issues filed: #9 (spec-pin refresh), #10 (subject:{type,id} migration tracking), #11 (AdminEvents pane auth prereq).
+- `[2026-05-23]` **v0.2.1 layout fix: dock-anchored TUI chrome so Input never moves** (commit `c85f6bd`, tag `v0.2.1`). Reported during the v0.2.0 mimir TUI smoke: Input bouncing up/down throughout a turn, tokens landing at shifting screen positions. Cause: v0.2.0's `Static(id="thinking-current")` was yielded between `hint` and `Footer` in the auto-stacked vertical flow, so each `display=True/False` toggle per thinking-run shifted Input + identity + hint vertically; RichLog growth from streaming text also drifted Input downward. Fix: `RatatoskrApp.DEFAULT_CSS` docks the chrome to screen edges — `thinking-current` docks top under Header; `transcript` (RichLog) gets `height: 1fr` and absorbs all reflows internally via its scroll viewport; `prompt`, `identity`, `hint` all dock bottom (locked above Footer). Compose order moved `thinking-current` to position 2 (right after Header) so source-order matches the dock layout. **Operator-confirmed "a lot better"** interactively. Pure UI fix; no public API change; tests pass without modification. v0.2.0 → v0.2.1 (patch). I couldn't verify in a TTY from this non-interactive session — the design was sound enough to ship blind, with operator verification post-commit. Going forward: TUI-layout patches like this are "ship + operator verifies" since the TTY is the load-bearing test surface and respx + Pilot mocks can't catch screen-relative positioning bugs.
+- `[2026-05-23]` **Sequencing decision: design-brief §5 side-panes work absorbs the inline collapsible-Thinking-pane + Debug-pane proposals; do issue #8 (startup agent picker) BEFORE §5.** Surfaced during the v0.2.1 follow-up discussion. The operator's proposal — "create a collapsible pane for all thinking tokens; text_boundary goes to a debug pane" — is exactly §5-shaped work (the design-brief proposes a `Horizontal` two-column layout with `TabbedContent` for Persona/Tools/AdminEvents/BifrostState/ServerLog). Building inline-Collapsibles now and then rebuilding as `TabbedContent` panes at §5 would be wasted work. So: do #8 first (independent surface, no layout overlap), then §5 (which folds in Thinking + Debug panes alongside the design-brief's named §5 panes). Interim acceptance: v0.2.1 fixes the structural layout-bouncing pain; transcript-dominated-by-thinking is still real but doesn't degrade further — operator can scroll back, Input doesn't move, tokens land predictably. The interim "noisy transcript" pain is real but bounded; §5 work resolves it cleanly.
 - `[2026-05-23]` **Issue #12 (presenter contract semantics amendment) implemented via TDD.** Headline: thinking deltas render as ONE coalesced growing line (CLI) / one closed RichLog entry per run + live Static(id="thinking-current") widget per-delta (TUI), not 50 lines per turn. Introduced stateful per-turn presenters: `CliPresenterState` (cli.py) and `TuiPresenterState` (tui.py), both `@dataclass(slots=True)` with thinking_buffer + thinking_open (+ text_written_since_newline for CLI). Editorial promotion line settled: load-bearing = Text/Done/Error/Cancelled (no prefix); demoted telemetry = WorkerPhase/Thinking/TextBoundary/ToolStart/ToolResult (CLI `. ` ASCII prefix; TUI `· ` Unicode dim prefix). CLI stdout/stderr newline-boundary INV-005: when text was streamed mid-line, flush a `\n` to stdout before writing terminal labels to stderr; `text_written_since_newline = not event.content.endswith("\n")` per Volva F4 fix. Helpers `_format_duration_ms` (`347ms` / `5.5s` / `1.2m` autoscale) and `_format_usage` (`6756 in -> 126 out (6882 total, 0 cached)` with arrow="->" CLI or "→" TUI). Per Vor (eitri-smithy-dev cross-frontier consult, althing 01KSBE52YZR5) + Volva paraphrase (5 contract-text ambiguities all fixed in #12.contract.md). `[create_session]` lifecycle line demoted to `. create_session:` (written directly by `_amain`, bypasses state.render). Old `_render_event` / `_render_event_to_log` functions and their TestRenderEvent/TestRenderEventToLog classes removed (no-backwards-compat rule). Contracts amended: #3 (CliPresenterState block + `_run_turn` thread state + `_amain` create_session demotion + `_format_*` helper blocks), #4 (TuiPresenterState block + `_stream_turn_worker` state construction + `compose` Static widget addition). 39 new tests; 19 obsolete tests removed; net 208 GREEN. v0.1.0 → v0.2.0 (minor; pre-amendment output shape broken intentionally — scripts grepping `[thinking] '` no longer work; that's the intended cleanup). Cross-frontier design pass with eitri-smithy-dev returned 16-of-16 confirmed decisions + 4 material divergences applied (ASCII `· ` factual fix, RichLog-one-entry-per-run vs inline-mirror, presenter-state object vs stateless, "contract semantics amendment" framing not "polish"). Calibration note: eitri-smithy-dev's value here was *architectural* (state-object pattern + chronological-vs-live decoupling) not just *tactical*; the framing rename alone justified the consult. Volva paraphrase round added 5 prose-precision fixes (INV-001 "growing display" semantics, TUI hide mechanism unification, render_error security/readability tension, newline-tracking corner case, [create_session] integration path).
 - `[2026-05-23]` **Forward direction: Ratatoskr will require `end_user_id` for EVERY access before too long.** Operator's call. Reasoning: even Tier 1 foundational agents (mimir, all Asgardians) that don't *require* `end_user_id` server-side currently fall back to a `_no_end_user` sentinel substrate partition — effectively pollution from a single-operator-debug-tool's perspective. The right shape is "every conversation has an explicit partition key." `RATATOSKR_END_USER_ID="ratatoskr-tui"` env-default in env.sh is the first step toward that posture; once we've validated the partition-isolation experience, the next move is making `end_user_id` mandatory (probably remove the `None`-default in `_parse_args`, fail-closed with a UsageError if neither flag nor env provides it). Consequence for cross-project asks: declined worldtree-dev's offer to ship `requires_end_user_id: bool` on `AgentInfoResponse` because we'd treat every value as true regardless; the try-and-react-to-422 pattern goes away from our side because we never send a request without the field. File a ratatoskr issue when scheduling the change — touches `_parse_args` validation + `_resolve_then_run` + `_amain` + tests + contract amendments to #3 / #5. Treat as a v0.2.0 minor (breaking: existing `--new --agent mimir` without env or flag would start failing). **Cross-frontier alignment (worldtree-dev ack 2026-05-23, althing 01KSBD9FPMCWJMBXNNS4B3MYBS):** the platform side agrees with this framing — `_no_end_user` is a substrate accommodation for identity-less transports, NOT a consumer model. The fallback's `_is_fallback=True` trap door (#185 INV-185-5/8) "could become operator-controlled later" per worldtree-dev, meaning Worldtree itself may tighten the substrate-fallback path. Ratatoskr's forward posture pre-empts that tightening — moving from "we send end_user_id when set" to "we never send a request without end_user_id" stays consumer-correct regardless of what Worldtree does with the fallback knob.
 
@@ -153,4 +185,5 @@ defense against re-attempting the same cul-de-sac.
 - `[2026-05-21]` **TUI session-identity rendering via `self.sub_title` + `self.hint` plain attributes.** Stored state but never rendered to a visible widget. The contract's "session-identity-always-visible" invariant was satisfied at the state-attribute level but not the user-visible-widget level. Tests asserted the attributes (which passed); Volva code-review flagged the gap. Fix: dedicated `Static(id="identity")` + `Static(id="hint")` widgets in compose; `_set_hint()` helper mirrors state → widget. Calibration evidence for the "TDD catches state, code-review catches whether the user can see it" pattern.
 - `[2026-05-23]` **Using the cross-model review agent's name directly in composed prose.** The peer review agent's name (the `althing` handle starting with "V-o-l-v-a") is one letter from a body-part term. Anthropic's content classifier does fuzzy matching and intermittently blocks responses mid-stream when the name appears in composed prose sentences (especially in meta-commentary about the agent's work). Direct-quoted tool output (e.g., the `althing-cli thread` body) passes through fine. Mitigation: use role descriptions ("the cross-model reviewer," "the paraphrase peer") in prose rather than the name; quote content via tool output. Confirmed by switching to Sonnet 4.6 for a test read — same raw content read cleanly when fetched via Bash rather than composed into an LLM response. This is a persistent environmental constraint, not a one-off.
 - `[2026-05-22]` **`json.loads(sse.data)` unguarded against empty data.** `_iter_events` unconditionally called `json.loads` on every dispatched `ServerSentEvent`. When `httpx_sse` surfaced a frame with `id:` present but `data:` empty (a known library-vs-spec divergence — RFC says don't dispatch; httpx_sse is permissive), `json.loads('')` raised `JSONDecodeError` → propagated through Textual's worker → app crash. Crashed mimir conversation at turn 93/seq 1078 after 1077 successful events. Fix: `if sse.data == '': continue` BEFORE `_parse_sse_id` (empty-data event with a malformed id is still a keepalive — don't reorder). Non-empty malformed data raises new `MalformedSseData(raw[:200])`. Don't reintroduce unconditional `json.loads(sse.data)`; always pre-check for the empty case.
+- `[2026-05-23]` **Diagnostic shorthand: "2-events-then-silence" = Worldtree-side LLM-call wedge, not ratatoskr.** If a mimir `--send` smoke shows exactly two stderr events — `. create_session: ...` followed by `. worker_phase: phase=BuildingPrompt ...` — and then nothing for >60s, the root cause is upstream of ratatoskr. Worldtree's `service.py:2560` gates the `CallingLLM` event on the engine yielding its first LLM-provider chunk; if that provider connection is wedged at the TCP level, the `async for` never iterates and the SSE stream stays silent forever. ratatoskr's `read=None` httpx timeout (the issue #1 + #4 INV-007 fix for "5s default killed mid-stream during mimir's thinking") waits patiently as designed; there's no client-side stall watchdog above the read-timeout layer. Worldtree's OWN stall watchdog (300s `_start_stall_timer`) exists but its cancel-check is INSIDE the engine-event loop, so a never-yielding first-LLM-call bypasses it. Confirmed by worldtree-dev (althing thread `01KSBKTG096Q07JVRG41JXA1DD`). **Don't waste time bisecting ratatoskr code when this shape appears** — diagnose the LLM-provider connection state at Worldtree's host. Restarting the Worldtree service (`:8081` in our case) cleared a wedged llama-swap connection. Future ratatoskr issue worth filing if recurrence: client-side stall watchdog (e.g., 90s-no-events → `[server_stalled]` stderr label, keep connection open). Also worth knowing: 10.250.50.152 hosts 3 Worldtree instances (`:8080`, `:8081`, `:8082`) — each with its own DB and key namespace. Our key is valid only on `:8081`.
 - `[2026-05-23]` **Phantom "per-Tier-1-agent scope add" pattern.** Issue #5's lofn 422 was initially diagnosed (with worldtree-dev's first reply) as needing `agents.call:lofn` added to ratatoskr's existing key. Routed through infra-ops via althing per the credential-brokerage rule; infra-ops discovered no public scope-mutation endpoint on personal Worldtree, brokered to worldtree-dev for the actual mechanism. Worldtree-dev came back with a correction: their first answer conflated two distinct Heimdall scope namespaces. **Tier 1 foundational agents** (mimir, lofn, soong, all Asgardians) are covered by a blanket `agent.call:*` (singular) baseline rule in `config/policies.yaml > tiers.<tier>.scopes` for ALL authenticated tiers including `user`. There is no per-agent grant for Tier 1 — the baseline rule covers it. **Tier 3 consumer-defined agents** (IDs containing `:`, like `vh:custom-bot`) use the plural `agents.call:<owner>:<agent>` shape granted implicitly via owning a `consumer_agents` DB row, registered through `POST /agents/define`. The two notations differ by one letter and that was the source of the confusion. **The actual lofn fix was issue #5's `--end-user-id` flag — it was always a request-body validation, not an auth-scope gate.** Don't ping infra-ops for "per-Tier-1-agent scope adds" again; the pattern is a phantom ask. Real future infra-ops asks: admin-tier key for the AdminEvents pane (`admin.events.read` scope, different tier), and Tier 3 custom-agent registration (different flow entirely, requires `POST /agents/define`).

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "ratatoskr"
-version = "0.2.0"
+version = "0.17.0"
 description = "Worldtree Conversation API debug TUI — multi-pane observability dashboard"
 readme = "README.md"
 requires-python = ">=3.12"
@@ -21,6 +21,10 @@ dependencies = [
 ]
 
 [project.optional-dependencies]
+web = [
+    "starlette>=0.40",
+    "uvicorn[standard]>=0.30",
+]
 dev = [
     "pytest>=8",
     "pytest-asyncio>=0.24",
@@ -29,10 +33,12 @@ dev = [
     "mypy>=1.11",
     "textual-dev>=1.5",     # textual console + live reload during dev
     "pyyaml>=6",            # used by docs/contracts/contract_parser.py and scripts/contract_drift_check.py
+    "ratatoskr[web]",       # web extras included in dev so test_web_* can import starlette
 ]
 
 [project.scripts]
-ratatoskr = "ratatoskr.cli:main"
+ratatoskr     = "ratatoskr.cli:main"
+ratatoskr-web = "ratatoskr.web.entrypoint:main"
 
 [project.urls]
 Repository = "https://gitea.phasefinal.com/vh/ratatoskr"
@@ -42,13 +48,18 @@ Repository = "https://gitea.phasefinal.com/vh/ratatoskr"
 # Ratatoskr is built against Worldtree at this commit; the vendored
 # spec snapshot in docs/ reflects that SHA.
 [tool.ratatoskr.spec-pin]
-worldtree-spec-rev = "55101e909abcd2219833266b6f905c5bc956e0f0"
-worldtree-version = "v0.19.0"
-pinned-on = "2026-05-20"
+worldtree-spec-rev = "562001af28d752c3a60d449c7ddd09f44fa9dc9a"
+worldtree-version = "v0.29.0"
+pinned-on = "2026-05-26"
 
 [tool.hatch.build.targets.wheel]
 packages = ["src/ratatoskr"]
 
+# Issue #16: ship the web companion's static HTML in the wheel so
+# importlib.resources can locate it post-install.
+[tool.hatch.build.targets.wheel.force-include]
+"src/ratatoskr/web/static" = "ratatoskr/web/static"
+
 [tool.pytest.ini_options]
 asyncio_mode = "auto"
 testpaths = ["tests"]

src/ratatoskr/cli.py

@@ -18,6 +18,8 @@ import httpx
 
 from ratatoskr.sessions import AgentNotFound, SessionApiFailed, create_session
 from ratatoskr.sse_client import (
+    AffectUpdate,
+    AwaitingLlmFirstToken,
     CancelAlreadyCompleted,
     CancelFailed,
     Cancelled,
@@ -124,8 +126,11 @@ def _parse_args(argv: list[str] | None) -> ParsedArgs:
         raise UsageError("pass exactly one of --session or --new")
     if ns.session and ns.agent:
         raise UsageError("--agent is required with --new and forbidden with --session")
-    if ns.new and not ns.agent:
-        raise UsageError("--agent is required when --new is passed")
+    if ns.new and not ns.agent and ns.send is not None:
+        # Issue #8: --agent stays required for --send --new (non-interactive,
+        # cannot prompt). Bare --new (TUI mode) accepts None — picker drives
+        # the choice via list_agents in _resolve_then_run.
+        raise UsageError("--agent is required when --new is passed in --send mode")
 
     api_key = ns.api_key or os.environ.get("WORLDTREE_API_KEY") or ""
     if not api_key:
@@ -202,6 +207,7 @@ class CliPresenterState:
             (
                 WorkerPhase, Thinking, Text, TextBoundary,
                 ToolStart, ToolResult, Done, Error, Cancelled,
+                AffectUpdate, AwaitingLlmFirstToken,
             ),
         )
         # Thinking events accumulate into the open run.
@@ -272,6 +278,28 @@ class CliPresenterState:
                 f". text_boundary: kind={event.kind} char_offset={event.char_offset}\n"
             )
             return
+        if isinstance(event, AffectUpdate):
+            # Worldtree #204 / v0.28.0. CLI surface is debug telemetry —
+            # one line to stderr with status + (for current) dominant_emotion.
+            if event.snapshot is not None:
+                dom = event.snapshot.get("dominant_emotion")
+                stderr.write(
+                    f". affect_update: status={event.status} turn_id={event.turn_id} "
+                    f"dominant_emotion={dom!r}\n"
+                )
+            else:
+                stderr.write(
+                    f". affect_update: status={event.status} turn_id={event.turn_id}\n"
+                )
+            return
+        if isinstance(event, AwaitingLlmFirstToken):
+            # Worldtree #201 / v0.29.0. Heartbeat during BuildingPrompt →
+            # CallingLLM gap. Stderr surface, one line per heartbeat.
+            secs = event.elapsed_ms_since_building_prompt / 1000.0
+            stderr.write(
+                f". awaiting_llm_first_token: turn_id={event.turn_id} elapsed={secs:.1f}s\n"
+            )
+            return
 
 
 async def _cancel_and_log(

src/ratatoskr/local_agents.py

@@ -0,0 +1,134 @@
+"""Local index of tier-3 agents defined via `python -m ratatoskr.tier3`.
+
+Workaround for Worldtree's ``GET /agents`` not returning consumer-defined
+agents (the public list excludes tier-3 per-spec; see issue #15 smoke
+findings). Local file maintains a list of agent_ids + display metadata so
+the picker can show them alongside foundational agents.
+
+Storage shape: JSON at ``$XDG_CONFIG_HOME/ratatoskr/local_agents.json``
+(default ``~/.config/ratatoskr/local_agents.json``). Override via
+``$RATATOSKR_LOCAL_AGENTS`` env var for tests / per-machine isolation.
+
+If Worldtree later starts returning tier-3 agents in ``GET /agents``, this
+module's role narrows to redundant local cache; can be removed cleanly
+since the picker's dedup-by-agent-id keeps remote-wins behavior.
+
+Failure modes are lenient: missing file → empty index; corrupt JSON or
+schema mismatch → empty index (no crash). The picker continues to show
+foundational agents either way; the local-tier-3 surface degrades to
+"operator passes --agent ratatoskr:<name> explicitly" — the
+pre-v0.8.0 workflow.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+from dataclasses import asdict, dataclass
+from pathlib import Path
+
+_SCHEMA_VERSION = 1
+
+
+@dataclass(frozen=True)
+class LocalAgentEntry:
+    """One row in the local tier-3 agent index.
+
+    Schema:
+      - ``agent_id``: full "user_id:agent_name" string (Worldtree-owned).
+      - ``agent_name``: slug from define (display name).
+      - ``model``: provider model ID at last define/patch.
+      - ``description``: synthetic display string (typically derived from
+        the system_prompt's first line + a "(tier 3)" prefix; the picker
+        uses this in its ``{id} · {name} — {description}`` rendering).
+      - ``defined_at``: ISO-8601 timestamp from the Tier3AgentInfo response.
+    """
+
+    agent_id: str
+    agent_name: str
+    model: str
+    description: str
+    defined_at: str
+
+
+def _local_agents_path() -> Path:
+    """Resolve the local index file path with XDG + env-var override."""
+    override = os.environ.get("RATATOSKR_LOCAL_AGENTS")
+    if override:
+        return Path(override)
+    xdg = os.environ.get("XDG_CONFIG_HOME")
+    base = Path(xdg) if xdg else (Path.home() / ".config")
+    return base / "ratatoskr" / "local_agents.json"
+
+
+def load_local_agents() -> list[LocalAgentEntry]:
+    """Read the local index. Returns ``[]`` on missing file, corrupt JSON,
+    schema mismatch, or any read error — never raises.
+    """
+    path = _local_agents_path()
+    if not path.exists():
+        return []
+    try:
+        raw = json.loads(path.read_text())
+    except (json.JSONDecodeError, OSError):
+        return []
+    if not isinstance(raw, dict) or raw.get("version") != _SCHEMA_VERSION:
+        return []
+    agents = raw.get("agents", [])
+    if not isinstance(agents, list):
+        return []
+    out: list[LocalAgentEntry] = []
+    for item in agents:
+        if not isinstance(item, dict):
+            continue
+        try:
+            out.append(LocalAgentEntry(**item))
+        except TypeError:
+            # Malformed row (missing/extra fields) — skip silently.
+            continue
+    return out
+
+
+def _save_local_agents(agents: list[LocalAgentEntry]) -> None:
+    """Persist the index. Creates parent dir as needed."""
+    path = _local_agents_path()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    payload = {"version": _SCHEMA_VERSION, "agents": [asdict(a) for a in agents]}
+    path.write_text(json.dumps(payload, indent=2))
+
+
+def add_local_agent(entry: LocalAgentEntry) -> None:
+    """Add (or replace) an agent in the local index. agent_id is the key."""
+    agents = [a for a in load_local_agents() if a.agent_id != entry.agent_id]
+    agents.append(entry)
+    _save_local_agents(agents)
+
+
+def update_local_agent(entry: LocalAgentEntry) -> None:
+    """Update an existing entry. Identical semantics to ``add_local_agent``
+    (agent_id is the dedup key), exposed separately so callers can
+    self-document intent.
+    """
+    add_local_agent(entry)
+
+
+def remove_local_agent(agent_id: str) -> None:
+    """Remove an entry by agent_id. No-op if absent (idempotent)."""
+    agents = [a for a in load_local_agents() if a.agent_id != agent_id]
+    _save_local_agents(agents)
+
+
+def make_description(system_prompt: str) -> str:
+    """Synthesize a one-line description for the picker from a system prompt.
+
+    Strategy: first non-empty line, stripped of leading markdown heading
+    markers and whitespace, prefixed with "(tier 3) ", truncated to 80
+    chars. Falls back to "(tier 3) custom system prompt" if the prompt is
+    empty (defensive — define rejects empty prompts at PRE-002).
+    """
+    for line in system_prompt.splitlines():
+        stripped = line.lstrip("# ").strip()
+        if stripped:
+            label = f"(tier 3) {stripped}"
+            return label[:80] + ("…" if len(label) > 80 else "")
+    return "(tier 3) custom system prompt"

src/ratatoskr/sessions.py

@@ -39,6 +39,26 @@ class SessionPage:
     next_cursor: str | None
 
 
+@dataclass(frozen=True)
+class AgentInfo:
+    """Worldtree agent envelope from GET /agents (issue #8).
+
+    INV-005: required fields (`agent_id`, `name`, `description`) take the
+    response value verbatim. Optional fields default to None / [] / {} when
+    omitted by the server, mirroring SessionInfo's INV-001/INV-002
+    origin-conditional defaulting.
+    """
+
+    agent_id: str
+    name: str
+    description: str
+    version: str | None
+    capabilities: list[str]
+    supported_models: list[str]
+    persona_traits: dict[str, Any]
+    ui_hints: dict[str, Any]
+
+
 class AgentNotFound(Exception):
     """Raised on HTTP 404 from POST /sessions — unknown agent_id."""
 
@@ -69,6 +89,46 @@ class SessionApiFailed(Exception):
         self.body = body
 
 
+# Worldtree #204 / v0.28.0 — persona_state endpoint failure modes.
+class PersonaNotConfigured(Exception):
+    """Raised on HTTP 404 `persona_not_configured` from GET persona_state.
+
+    Agent exists but has no persona surface: persona-disabled Tier 1/2
+    agents (e.g. `domari`, `muninn`) and all Tier 3 consumer-defined
+    agents (Phase 2.0). Distinct from `AgentNotAvailable` which means the
+    agent_id is unknown entirely.
+    """
+
+    def __init__(self, *, agent_id: str) -> None:
+        super().__init__(f"persona not configured for agent_id: {agent_id!r}")
+        self.agent_id = agent_id
+
+
+class AgentNotAvailable(Exception):
+    """Raised on HTTP 404 `agent_not_available` from GET persona_state.
+
+    The agent_id is unknown to the server. Distinct from
+    `PersonaNotConfigured` (agent exists but has no persona).
+    """
+
+    def __init__(self, *, agent_id: str) -> None:
+        super().__init__(f"agent not available: {agent_id!r}")
+        self.agent_id = agent_id
+
+
+class AuthScopeDenied(Exception):
+    """Raised on HTTP 403 `auth_scope_denied` from a Heimdall-scoped endpoint.
+
+    The API key lacks the required scope (e.g. `persona.read` for
+    GET /agents/{id}/persona_state). User-tier keys carry `persona.read`
+    by default; this surfaces when a narrower key is in use.
+    """
+
+    def __init__(self, *, scope: str) -> None:
+        super().__init__(f"auth scope denied: required={scope!r}")
+        self.scope = scope
+
+
 async def list_sessions(
     client: httpx.AsyncClient,
     *,
@@ -153,3 +213,81 @@ async def create_session(
         archived=False,
         tags=[],
     )
+
+
+async def list_agents(client: httpx.AsyncClient) -> list[AgentInfo]:
+    """GET /agents — list available agents. See contract FN list_agents (issue #8).
+
+    No request params, no pagination. Returns server-ordered list. Optional
+    fields are defaulted to None / [] / {} per INV-005.
+    """
+    assert client is not None
+
+    resp = await client.get("/agents")
+    if resp.status_code != 200:
+        raise SessionApiFailed(status=resp.status_code, body=resp.content)
+    body = resp.json()
+    return [
+        AgentInfo(
+            agent_id=item["agent_id"],
+            name=item["name"],
+            description=item["description"],
+            version=item.get("version"),
+            capabilities=item.get("capabilities") or [],
+            supported_models=item.get("supported_models") or [],
+            persona_traits=item.get("persona_traits") or {},
+            ui_hints=item.get("ui_hints") or {},
+        )
+        for item in body
+    ]
+
+
+async def get_persona_state(
+    client: httpx.AsyncClient, agent_id: str
+) -> dict[str, Any]:
+    """GET /agents/{agent_id}/persona_state — fetch current persona snapshot.
+
+    Worldtree #204 / v0.28.0. Returns the same `snapshot` dict shape as the
+    `affect_update` SSE event's `status="current"` emission: pad,
+    dominant_emotion, emotions_active, baseline_pad, mood_drift,
+    last_updated_at. Bootstrap read for clients that want to populate a
+    persona pane on session-open without waiting for turn-1's `affect_update`.
+
+    Auth: requires Heimdall `persona.read` scope (user-tier default).
+
+    Failure modes (mapped to typed exceptions per the spec error_codes):
+      - 404 `persona_not_configured` → PersonaNotConfigured (persona-disabled
+        agents: domari / muninn, and all Tier 3 in Phase 2.0)
+      - 404 `agent_not_available` → AgentNotAvailable (unknown agent_id)
+      - 403 `auth_scope_denied` → AuthScopeDenied (key lacks persona.read)
+      - any other non-2xx → SessionApiFailed (preserves the broader-error
+        precedent from list_agents / list_sessions / create_session)
+    """
+    assert client is not None
+    assert agent_id and isinstance(agent_id, str)
+
+    resp = await client.get(f"/agents/{agent_id}/persona_state")
+    if resp.status_code == 200:
+        return resp.json()
+    # Discriminate the 4xx error_code sub-codes; everything else falls
+    # through. Worldtree returns errors as either flat `{"error_code": …}`
+    # OR FastAPI-default `{"detail": {"error_code": …}}` depending on
+    # which handler raised — unwrap both shapes (real wire observed
+    # 2026-05-28 returning the detail-nested form for auth_scope_denied
+    # from /agents/{id}/persona_state).
+    try:
+        err = resp.json()
+    except ValueError:
+        err = None
+    error_code: str | None = None
+    if isinstance(err, dict):
+        error_code = err.get("error_code")
+        if error_code is None and isinstance(err.get("detail"), dict):
+            error_code = err["detail"].get("error_code")
+    if resp.status_code == 404 and error_code == "persona_not_configured":
+        raise PersonaNotConfigured(agent_id=agent_id)
+    if resp.status_code == 404 and error_code == "agent_not_available":
+        raise AgentNotAvailable(agent_id=agent_id)
+    if resp.status_code == 403 and error_code == "auth_scope_denied":
+        raise AuthScopeDenied(scope="persona.read")
+    raise SessionApiFailed(status=resp.status_code, body=resp.content)

src/ratatoskr/sse_client.py

@@ -111,6 +111,55 @@ class Cancelled:
     partial_message_id: int | None
 
 
+@dataclass(frozen=True)
+class AwaitingLlmFirstToken:
+    """SSE event `awaiting_llm_first_token`: heartbeat during slow first-token.
+
+    Fires at the configured interval (default 5s) during the gap between
+    `worker_phase` phase=BuildingPrompt and phase=CallingLLM. Lets clients
+    render a live "thinking for Ns…" indicator instead of a frozen line
+    during legitimate-slow first-token latency. Stops the moment CallingLLM
+    fires (defense-in-depth at three sites); no heartbeat after Cancelled
+    or stalled terminal events. Tool round-trip re-entries do NOT re-fire
+    heartbeats — INV-201-5 scopes the mechanism to the FIRST gap only.
+
+    `elapsed_ms_since_building_prompt` is server-authoritative
+    `time.monotonic()`-based — independent of network latency or clock
+    skew, monotonically increasing across the heartbeat sequence.
+
+    See docs/conversation-api-spec.md § awaiting_llm_first_token
+    (Worldtree #201, v0.29.0).
+    """
+
+    sse_id: SseId
+    turn_id: int
+    elapsed_ms_since_building_prompt: float
+
+
+@dataclass(frozen=True)
+class AffectUpdate:
+    """SSE event `affect_update`: persona-state observability snapshot.
+
+    Two emissions per qualifying turn (persona-enabled agent on non-
+    ephemeral session): `status="current"` at turn start carrying the full
+    snapshot, `status="scheduled"` after post-turn appraisal kicks off
+    (lightweight — `snapshot` is None). Suppressed entirely for persona-
+    disabled agents (e.g. `domari`, `muninn`), Tier 3 consumer-defined
+    agents (Phase 2.0), and ephemeral sessions.
+
+    Bootstrap reads available via `GET /agents/{agent_id}/persona_state`
+    (same `snapshot` shape, requires `persona.read` scope).
+
+    See docs/conversation-api-spec.md § affect_update (Worldtree #204,
+    v0.28.0).
+    """
+
+    sse_id: SseId
+    status: str  # "current" | "scheduled"
+    turn_id: int
+    snapshot: dict[str, Any] | None  # None when status="scheduled"
+
+
 Event = (
     WorkerPhase
     | Thinking
@@ -121,6 +170,8 @@ Event = (
     | Done
     | Error
     | Cancelled
+    | AffectUpdate
+    | AwaitingLlmFirstToken
 )
 
 
@@ -284,6 +335,26 @@ def _envelope_for_type(body: dict[str, Any], sse_id: SseId) -> Event:
             reason=body.get("reason"),
             partial_message_id=body.get("partial_message_id"),
         )
+    if t == "awaiting_llm_first_token":
+        # Worldtree #201 / v0.29.0: top-level heartbeat during BuildingPrompt
+        # → CallingLLM gap. Lets clients render live elapsed-time indicators
+        # instead of frozen lines on legitimate-slow first-token latency.
+        return AwaitingLlmFirstToken(
+            sse_id=sse_id,
+            turn_id=body["turn_id"],
+            elapsed_ms_since_building_prompt=body["elapsed_ms_since_building_prompt"],
+        )
+    if t == "affect_update":
+        # Worldtree #204 / v0.28.0: persona-state observability event.
+        # status="current" carries full snapshot at turn start;
+        # status="scheduled" omits snapshot (lightweight post-appraisal-
+        # kickoff notification).
+        return AffectUpdate(
+            sse_id=sse_id,
+            status=body["status"],
+            turn_id=body["turn_id"],
+            snapshot=body.get("snapshot"),
+        )
     raise ValueError(f"unknown SSE event type: {t!r}")
 
 
@@ -309,6 +380,14 @@ async def _iter_events(
             # with a bad id is still a keepalive). Don't reorder.
             if sse.data == "":
                 continue
+            # v0.8.1: empty-id frames are also treated as keepalives. Worldtree
+            # SOMETIMES emits events without an `id:` line (observed mid-stream
+            # on the qwen3.6-35-a3b-heretic provider, 2026-05-25). Per the SSE
+            # RFC, events without ids are legitimate (they just don't update
+            # Last-Event-ID); the previous strict behavior crashed every turn
+            # on the offending agent. Treat same as empty-data: skip silently.
+            if sse.id == "":
+                continue
             try:
                 sse_id = _parse_sse_id(sse.id)
             except ValueError as exc:

src/ratatoskr/tier3.py

@@ -0,0 +1,471 @@
+"""Worldtree Tier 3 (consumer-defined) agent lifecycle client.
+
+Implements docs/contracts/issues/15.contract.md. Caller-owned httpx.AsyncClient
+posture (same as ratatoskr.sessions). Exposes three lifecycle operations:
+
+- ``define_agent`` — POST /agents/define
+- ``patch_agent`` — PATCH /agents/<id>
+- ``delete_agent`` — DELETE /agents/<id>
+
+Plus a frozen ``Tier3AgentInfo`` dataclass for the response shape. The picker
+already handles colon-containing agent_ids generically (issue #8); session
+creation works unchanged via ``ratatoskr.sessions.create_session``.
+
+Spec reference: ``docs/conversation-api-spec.md`` §2576-2750 (Phase 2.0).
+"""
+
+from __future__ import annotations
+
+import argparse
+import re
+from dataclasses import dataclass
+
+import httpx
+
+from ratatoskr.sessions import SessionApiFailed
+
+# Per spec §2627: agent_name + user_id slugs are `[a-z][a-z0-9-]{2,63}`.
+_SLUG_RE = re.compile(r"^[a-z][a-z0-9-]{2,63}$")
+
+
+@dataclass(frozen=True)
+class Tier3AgentInfo:
+    """Worldtree Tier 3 agent envelope returned by define / patch.
+
+    INV-001: ``agent_id`` is always shape ``"<user_id>:<agent_name>"`` —
+    constructed server-side from the auth's user_id + the supplied agent_name.
+    """
+
+    agent_id: str
+    user_id: str
+    agent_name: str
+    system_prompt: str
+    model: str
+    created_at: str
+    updated_at: str
+
+
+class Tier3QuotaExceeded(Exception):
+    """Raised on HTTP 429 ``agent_quota_exceeded`` — 50-agent cap reached
+    on the Heimdall key. ``retry_after`` captures the Retry-After header
+    verbatim (defaults to 0 per spec §2675; forward-compat for non-zero)."""
+
+    def __init__(self, *, retry_after: int) -> None:
+        super().__init__(f"Tier 3 agent quota exceeded (retry_after={retry_after})")
+        self.retry_after = retry_after
+
+
+class Tier3UserIdUnsupported(Exception):
+    """Raised on HTTP 403 ``tier3_user_id_unsupported`` — auth's user_id
+    is not slug-safe per Phase 2.0 gate (spec §2626)."""
+
+    def __init__(self) -> None:
+        super().__init__("tier3 caller user_id is not slug-safe")
+
+
+class Tier3FieldNotMutable(Exception):
+    """Raised on HTTP 422 ``field_not_mutable`` — PATCH request body
+    carried a key that's immutable post-define (``agent_name``, ``user_id``,
+    or any layer field). Server rejects BEFORE the DB lookup (spec §2644)."""
+
+    def __init__(self, *, field: str | None) -> None:
+        super().__init__(f"field not mutable on Tier 3 patch: {field!r}")
+        self.field = field
+
+
+class Tier3LayerDeferred(Exception):
+    """Raised on HTTP 422 ``layer_deferred`` — define request carried a
+    non-null layer field (``persona`` / ``motivational`` / ``valence`` /
+    ``memory``). Phase 2.0 ships baseline only; layers are schema-reserved.
+
+    Note: ``define_agent`` never sends layer fields, so this exception is
+    defense-against-server-side-changes / forward-compat. INV-001 in the
+    request body construction is the first line of defense.
+    """
+
+    def __init__(self, *, field: str | None) -> None:
+        super().__init__(f"tier3 layer field deferred: {field!r}")
+        self.field = field
+
+
+class Tier3AgentNotFound(Exception):
+    """Raised on HTTP 404 — PATCH or DELETE on a non-existent agent_id
+    (spec §2634 + §2641)."""
+
+    def __init__(self, *, agent_id: str) -> None:
+        super().__init__(f"tier3 agent not found: {agent_id!r}")
+        self.agent_id = agent_id
+
+
+def _extract_error_code(resp: httpx.Response) -> str | None:
+    """Pluck the ``detail.error_code`` from a Worldtree error envelope.
+
+    Worldtree wraps API errors in ``{"detail": {"error_code": "...", ...}}``
+    per the spec. Returns None on shape mismatch (so callers fall through
+    to the generic ``SessionApiFailed`` branch).
+    """
+    try:
+        body = resp.json()
+    except ValueError:
+        return None
+    detail = body.get("detail") if isinstance(body, dict) else None
+    if isinstance(detail, dict):
+        code = detail.get("error_code")
+        if isinstance(code, str):
+            return code
+    return None
+
+
+def _extract_error_field(resp: httpx.Response) -> str | None:
+    """Pluck ``detail.field`` from a Worldtree error envelope (used for
+    ``field_not_mutable`` and ``layer_deferred`` to surface which field
+    triggered the rejection). Returns None on shape mismatch.
+    """
+    try:
+        body = resp.json()
+    except ValueError:
+        return None
+    detail = body.get("detail") if isinstance(body, dict) else None
+    if isinstance(detail, dict):
+        field = detail.get("field")
+        if isinstance(field, str):
+            return field
+    return None
+
+
+def _parse_tier3_agent_info(body: dict) -> Tier3AgentInfo:
+    """Parse a Worldtree Tier 3 agent JSON body into the frozen dataclass."""
+    return Tier3AgentInfo(
+        agent_id=body["agent_id"],
+        user_id=body["user_id"],
+        agent_name=body["agent_name"],
+        system_prompt=body["system_prompt"],
+        model=body["model"],
+        created_at=body["created_at"],
+        updated_at=body["updated_at"],
+    )
+
+
+async def define_agent(
+    client: httpx.AsyncClient,
+    *,
+    agent_name: str,
+    system_prompt: str,
+    model: str,
+) -> Tier3AgentInfo:
+    """POST /agents/define — create a Tier 3 agent.
+
+    See contract FN define_agent. Validates the agent_name slug client-side
+    before the network round-trip; server-side validation is the safety net.
+    Returns a fully populated Tier3AgentInfo on 201. Routes documented error
+    codes to typed exceptions; unknown non-2xx → SessionApiFailed.
+    """
+    assert client is not None
+    assert _SLUG_RE.match(agent_name), (
+        f"agent_name must match [a-z][a-z0-9-]{{2,63}}: {agent_name!r}"
+    )
+    assert system_prompt, "system_prompt must be non-empty"
+    assert model, "model must be non-empty"
+
+    body = {
+        "agent_name": agent_name,
+        "system_prompt": system_prompt,
+        "model": model,
+    }
+    resp = await client.post("/agents/define", json=body)
+
+    if resp.status_code == 201:
+        return _parse_tier3_agent_info(resp.json())
+    if resp.status_code == 429:
+        # Spec §2675: 51st define → 429 with Retry-After: 0.
+        try:
+            retry_after = int(resp.headers.get("Retry-After", "0"))
+        except (TypeError, ValueError):
+            retry_after = 0
+        raise Tier3QuotaExceeded(retry_after=retry_after)
+    if resp.status_code == 403:
+        if _extract_error_code(resp) == "tier3_user_id_unsupported":
+            raise Tier3UserIdUnsupported()
+    if resp.status_code == 422:
+        code = _extract_error_code(resp)
+        if code == "layer_deferred":
+            raise Tier3LayerDeferred(field=_extract_error_field(resp))
+    raise SessionApiFailed(status=resp.status_code, body=resp.content)
+
+
+async def patch_agent(
+    client: httpx.AsyncClient,
+    agent_id: str,
+    *,
+    system_prompt: str | None = None,
+    model: str | None = None,
+) -> Tier3AgentInfo:
+    """PATCH /agents/<id> — mutate system_prompt and/or model.
+
+    See contract FN patch_agent. Per spec §2641: only system_prompt + model
+    are mutable in Phase 2.0; any other key returns 422 field_not_mutable.
+    """
+    assert client is not None
+    assert ":" in agent_id, f"tier 3 agent_id must contain ':': {agent_id!r}"
+    assert system_prompt is not None or model is not None, (
+        "patch requires at least one of system_prompt or model"
+    )
+
+    body: dict[str, str] = {}
+    if system_prompt is not None:
+        body["system_prompt"] = system_prompt
+    if model is not None:
+        body["model"] = model
+    resp = await client.patch(f"/agents/{agent_id}", json=body)
+
+    if resp.status_code == 200:
+        return _parse_tier3_agent_info(resp.json())
+    if resp.status_code == 404:
+        raise Tier3AgentNotFound(agent_id=agent_id)
+    if resp.status_code == 422:
+        code = _extract_error_code(resp)
+        if code == "field_not_mutable":
+            raise Tier3FieldNotMutable(field=_extract_error_field(resp))
+    raise SessionApiFailed(status=resp.status_code, body=resp.content)
+
+
+async def delete_agent(client: httpx.AsyncClient, agent_id: str) -> None:
+    """DELETE /agents/<id> — owner hard-delete (cancels active sessions
+    server-side per spec §2636).
+
+    See contract FN delete_agent. 204 on success; 404 if the agent_id
+    doesn't exist; other non-2xx → SessionApiFailed.
+    """
+    assert client is not None
+    assert ":" in agent_id, f"tier 3 agent_id must contain ':': {agent_id!r}"
+
+    resp = await client.delete(f"/agents/{agent_id}")
+    if resp.status_code == 204:
+        return
+    if resp.status_code == 404:
+        raise Tier3AgentNotFound(agent_id=agent_id)
+    raise SessionApiFailed(status=resp.status_code, body=resp.content)
+
+
+# ---- CLI (`python -m ratatoskr.tier3 <subcommand>`) ------------------------
+#
+# Auth + server URL resolution mirrors ratatoskr.cli verbatim. Exit codes
+# mirror ratatoskr.cli: 0 happy / 10 usage / 11 auth / 20 api-failure /
+# 21 network. Outbound requests carry the same User-Agent string.
+
+
+class _Tier3UsageError(Exception):
+    """Argparse usage violation → exit 10."""
+
+
+class _Tier3AuthError(Exception):
+    """No API key resolvable → exit 11."""
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="python -m ratatoskr.tier3",
+        description="Worldtree Tier 3 (consumer-defined) agent lifecycle.",
+    )
+    parser.add_argument("--api-key", dest="api_key", default=None)
+    parser.add_argument("--server", dest="server", default=None)
+    sub = parser.add_subparsers(dest="cmd", required=True)
+
+    p_define = sub.add_parser("define", help="Create a Tier 3 agent.")
+    p_define.add_argument("--name", required=True, help="agent_name (slug).")
+    p_define.add_argument(
+        "--system-prompt", dest="system_prompt", required=True,
+        help="System prompt the agent ships with.",
+    )
+    p_define.add_argument(
+        "--model", required=True,
+        help="Provider model ID (NOT a profile alias; e.g., qwen3.6-35-a3b).",
+    )
+
+    p_patch = sub.add_parser("patch", help="Mutate system_prompt and/or model.")
+    p_patch.add_argument("agent_id", help='Full "<user_id>:<agent_name>" form.')
+    p_patch.add_argument("--system-prompt", dest="system_prompt", default=None)
+    p_patch.add_argument("--model", default=None)
+
+    p_delete = sub.add_parser("delete", help="Hard-delete a Tier 3 agent.")
+    p_delete.add_argument("agent_id", help='Full "<user_id>:<agent_name>" form.')
+
+    return parser
+
+
+def _resolve_auth(ns: argparse.Namespace) -> tuple[str, str]:
+    """Resolve API key + server URL with the same env-var fallback as cli.py."""
+    import os
+
+    api_key = ns.api_key or os.environ.get("WORLDTREE_API_KEY") or ""
+    if not api_key:
+        raise _Tier3AuthError("no API key (set --api-key or WORLDTREE_API_KEY)")
+    server_url = (
+        ns.server or os.environ.get("WORLDTREE_API_URL") or "http://localhost:8000"
+    )
+    return api_key, server_url
+
+
+async def _run_define(ns: argparse.Namespace) -> int:
+    api_key, server_url = _resolve_auth(ns)
+    from ratatoskr.cli import USER_AGENT
+    from ratatoskr.local_agents import (
+        LocalAgentEntry,
+        add_local_agent,
+        make_description,
+    )
+
+    async with httpx.AsyncClient(
+        base_url=server_url,
+        headers={
+            "Authorization": f"Bearer {api_key}",
+            "User-Agent": USER_AGENT,
+        },
+        timeout=httpx.Timeout(connect=10.0, read=30.0, write=10.0, pool=10.0),
+    ) as client:
+        info = await define_agent(
+            client,
+            agent_name=ns.name,
+            system_prompt=ns.system_prompt,
+            model=ns.model,
+        )
+        # v0.8.0: persist to local index so the picker can show it.
+        add_local_agent(
+            LocalAgentEntry(
+                agent_id=info.agent_id,
+                agent_name=info.agent_name,
+                model=info.model,
+                description=make_description(info.system_prompt),
+                defined_at=info.created_at,
+            )
+        )
+        print(f"defined {info.agent_id} ({info.model})")
+        return 0
+
+
+async def _run_patch(ns: argparse.Namespace) -> int:
+    api_key, server_url = _resolve_auth(ns)
+    from ratatoskr.cli import USER_AGENT
+    from ratatoskr.local_agents import (
+        LocalAgentEntry,
+        make_description,
+        update_local_agent,
+    )
+
+    if ns.system_prompt is None and ns.model is None:
+        raise _Tier3UsageError(
+            "patch requires at least one of --system-prompt or --model"
+        )
+    async with httpx.AsyncClient(
+        base_url=server_url,
+        headers={
+            "Authorization": f"Bearer {api_key}",
+            "User-Agent": USER_AGENT,
+        },
+        timeout=httpx.Timeout(connect=10.0, read=30.0, write=10.0, pool=10.0),
+    ) as client:
+        info = await patch_agent(
+            client,
+            ns.agent_id,
+            system_prompt=ns.system_prompt,
+            model=ns.model,
+        )
+        # v0.8.0: refresh local index with the post-patch state.
+        update_local_agent(
+            LocalAgentEntry(
+                agent_id=info.agent_id,
+                agent_name=info.agent_name,
+                model=info.model,
+                description=make_description(info.system_prompt),
+                defined_at=info.updated_at,
+            )
+        )
+        print(f"patched {info.agent_id}")
+        return 0
+
+
+async def _run_delete(ns: argparse.Namespace) -> int:
+    api_key, server_url = _resolve_auth(ns)
+    from ratatoskr.cli import USER_AGENT
+    from ratatoskr.local_agents import remove_local_agent
+
+    async with httpx.AsyncClient(
+        base_url=server_url,
+        headers={
+            "Authorization": f"Bearer {api_key}",
+            "User-Agent": USER_AGENT,
+        },
+        timeout=httpx.Timeout(connect=10.0, read=30.0, write=10.0, pool=10.0),
+    ) as client:
+        await delete_agent(client, ns.agent_id)
+        # v0.8.0: drop from local index so the picker stops listing it.
+        remove_local_agent(ns.agent_id)
+        print(f"deleted {ns.agent_id}")
+        return 0
+
+
+def main(argv: list[str] | None = None) -> int:
+    """Sync entry point — argparse + dispatch + error → exit-code mapping.
+
+    Mirrors ratatoskr.cli.main()'s error-routing matrix:
+      0  happy
+      10 usage error
+      11 auth error
+      20 api-failure (typed exception or generic SessionApiFailed)
+      21 network error
+    """
+    import asyncio
+    import sys
+
+    parser = _build_parser()
+    try:
+        ns = parser.parse_args(argv)
+    except SystemExit as exc:
+        return int(exc.code) if exc.code is not None else 0
+
+    handler = {
+        "define": _run_define,
+        "patch": _run_patch,
+        "delete": _run_delete,
+    }[ns.cmd]
+
+    try:
+        return asyncio.run(handler(ns))
+    except _Tier3UsageError as exc:
+        sys.stderr.write(f"[usage_error] {exc}\n")
+        return 10
+    except _Tier3AuthError as exc:
+        sys.stderr.write(f"[auth_error] {exc}\n")
+        return 11
+    except AssertionError as exc:
+        sys.stderr.write(f"[usage_error] {exc}\n")
+        return 10
+    except Tier3QuotaExceeded as exc:
+        sys.stderr.write(f"[quota_exceeded] retry_after={exc.retry_after}\n")
+        return 20
+    except Tier3UserIdUnsupported:
+        sys.stderr.write("[user_id_unsupported]\n")
+        return 20
+    except Tier3AgentNotFound as exc:
+        sys.stderr.write(f"[agent_not_found] {exc.agent_id}\n")
+        return 20
+    except Tier3FieldNotMutable as exc:
+        sys.stderr.write(f"[field_not_mutable] field={exc.field}\n")
+        return 20
+    except Tier3LayerDeferred as exc:
+        sys.stderr.write(f"[layer_deferred] field={exc.field}\n")
+        return 20
+    except SessionApiFailed as exc:
+        sys.stderr.write(
+            f"[api_failed] status={exc.status} body={exc.body!r}\n"
+        )
+        return 20
+    except (httpx.ConnectError, httpx.ReadTimeout, httpx.TransportError) as exc:
+        sys.stderr.write(f"[network_error] {type(exc).__name__}: {exc}\n")
+        return 21
+
+
+if __name__ == "__main__":
+    import sys
+
+    sys.exit(main())

src/ratatoskr/web/__init__.py

@@ -0,0 +1,8 @@
+"""ratatoskr.web — browser debug companion to the Ratatoskr TUI.
+
+Per issue #16 INV-001: this module MUST NOT import starlette or
+uvicorn at module top. Both live behind the optional `[web]` extras
+group; importing them eagerly here would defeat the lazy-import
+discipline that gives users without the extras a clean install hint
+instead of a naked ImportError.
+"""

src/ratatoskr/web/entrypoint.py

@@ -0,0 +1,119 @@
+"""Console-script entrypoint for `ratatoskr-web`.
+
+Per docs/contracts/issues/16.contract.md FN main and INV-001:
+- MUST NOT import starlette / uvicorn at module top
+- Imports happen INSIDE main() after argparse, with ImportError caught
+  and converted to a clean `pip install ratatoskr[web]` exit
+- Users without the [web] extras installed get a readable hint instead
+  of a naked ImportError traceback
+"""
+
+from __future__ import annotations
+
+import argparse
+import os
+import sys
+import webbrowser
+from importlib.metadata import version as _pkg_version
+
+
+def _build_arg_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(
+        prog="ratatoskr-web",
+        description="Browser-based debug companion to ratatoskr.",
+    )
+    p.add_argument(
+        "--host", default="0.0.0.0",
+        help="Bind address. Default: 0.0.0.0 (LAN-accessible). "
+             "Use 127.0.0.1 to restrict to localhost.",
+    )
+    p.add_argument(
+        "--port", type=int, default=8765,
+        help="Listen port. Default 8765. Use 0 for random free.",
+    )
+    p.add_argument(
+        "--open", action="store_true",
+        help="Auto-open the URL in the system browser.",
+    )
+    return p
+
+
+def main(argv: list[str] | None = None) -> int:
+    """Console-script entry. Per FN main.
+
+    Returns:
+      0 on clean shutdown
+      11 on missing WORLDTREE_API_KEY ([auth_error])
+      12 on missing [web] extras ([missing_extras])
+    """
+    args = _build_arg_parser().parse_args(argv)
+
+    # Validate env BEFORE importing starlette so missing env shows the
+    # right error regardless of extras-install state.
+    api_key = os.environ.get("WORLDTREE_API_KEY")
+    if not api_key:
+        sys.stderr.write(
+            "[auth_error] WORLDTREE_API_KEY env var required. "
+            "Source env.sh in your project root.\n"
+        )
+        return 11
+    server_url = os.environ.get("WORLDTREE_API_URL", "http://localhost:8000")
+    end_user_id = os.environ.get("RATATOSKR_END_USER_ID")
+
+    # INV-001: lazy import. Users without [web] extras get a clean hint
+    # instead of a raw ImportError. Scoped narrowly to the OPTIONAL
+    # extras (starlette / uvicorn) so a real import bug inside a
+    # production module (ratatoskr.web.server, ratatoskr.cli, httpx —
+    # all baseline deps) propagates as a true traceback rather than
+    # being masked as "install ratatoskr[web]".
+    try:
+        import starlette  # noqa: F401  (extras-presence probe)
+        import uvicorn
+    except ImportError as exc:
+        sys.stderr.write(
+            f"[missing_extras] {exc}\n"
+            f"ratatoskr-web requires the [web] optional dependencies.\n"
+            f"Install with: pip install ratatoskr[web]\n"
+        )
+        return 12
+
+    # Baseline deps + own modules — a failure here is a real bug, not a
+    # missing-extras condition; let it propagate.
+    import httpx
+    from ratatoskr.cli import USER_AGENT
+    from ratatoskr.web.server import create_app
+
+    def client_factory() -> "httpx.AsyncClient":
+        return httpx.AsyncClient(
+            base_url=server_url,
+            headers={
+                "Authorization": f"Bearer {api_key}",
+                "User-Agent": USER_AGENT,
+            },
+            timeout=httpx.Timeout(connect=10.0, read=None, write=10.0, pool=10.0),
+        )
+
+    app = create_app(client_factory, end_user_id=end_user_id)
+
+    # Boot banner to stderr (so stdout stays clean for piping).
+    version = _pkg_version("ratatoskr")
+    host = args.host
+    port = args.port
+    display_host = "localhost" if host == "0.0.0.0" else host
+    sys.stderr.write(
+        f"ratatoskr-web v{version}\n"
+        f"Listening on http://{host}:{port}/\n"
+        f"Connect from this device: http://{display_host}:{port}/\n"
+    )
+    if host == "0.0.0.0":
+        sys.stderr.write(
+            f"Connect from LAN:        http://<host-ip>:{port}/\n"
+        )
+    sys.stderr.write("Ctrl-C to stop.\n")
+    sys.stderr.flush()
+
+    if args.open:
+        webbrowser.open(f"http://{display_host}:{port}/")
+
+    uvicorn.run(app, host=host, port=port, log_config=None)
+    return 0

src/ratatoskr/web/server.py

@@ -0,0 +1,416 @@
+"""Starlette app factory + endpoint handlers for ratatoskr.web.
+
+Per docs/contracts/issues/16.contract.md. INV-002: create_app accepts
+a client_factory callable; the factory produces a configured
+httpx.AsyncClient. Tests pass a respx-mocked factory; production
+passes a factory that bakes in WORLDTREE_API_URL + WORLDTREE_API_KEY.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import itertools
+import json
+from collections.abc import AsyncIterator, Callable
+from dataclasses import asdict, dataclass, is_dataclass
+from importlib.metadata import version as _pkg_version
+
+import httpx
+from starlette.applications import Starlette
+from starlette.requests import Request
+from starlette.responses import FileResponse, JSONResponse, StreamingResponse
+from starlette.routing import Mount, Route
+from starlette.staticfiles import StaticFiles
+
+from ratatoskr import local_agents as _local_agents
+from ratatoskr.sessions import (
+    AgentNotAvailable,
+    AgentNotFound,
+    AuthScopeDenied,
+    PersonaNotConfigured,
+    SessionApiFailed,
+    create_session,
+    get_persona_state,
+    list_agents,
+)
+from ratatoskr.sse_client import (
+    CancelAlreadyCompleted,
+    Cancelled,
+    CancelFailed,
+    CancelTurnNotFound,
+    Done,
+    Error,
+    MalformedSseData,
+    MalformedSseId,
+    SseConnectFailed,
+    SseConnectionDropped,
+    TurnIdFlip,
+    cancel_turn,
+    stream_turn,
+)
+
+
+def _static_dir() -> str:
+    """Locate the bundled static/ directory inside the installed package.
+
+    Uses importlib.resources so the lookup works for editable installs,
+    wheel installs, and uvicorn's worker reload. Per INV-009 packaging:
+    static/index.html ships in the wheel.
+    """
+    from importlib.resources import files
+    return str(files("ratatoskr.web") / "static")
+
+
+def _root_endpoint(request: Request) -> FileResponse:
+    """GET / → index.html. Per FN root_endpoint POST-001."""
+    from pathlib import Path
+    return FileResponse(
+        Path(_static_dir()) / "index.html",
+        media_type="text/html",
+    )
+
+
+def _version_endpoint(request: Request) -> JSONResponse:
+    """GET /version → {"ratatoskr": "<version>"}.
+
+    Per FN version_endpoint POST-001.
+    """
+    return JSONResponse({"ratatoskr": _pkg_version("ratatoskr")}, status_code=200)
+
+
+def _as_dict(obj: object) -> dict:
+    """Best-effort dataclass-to-dict for AgentInfo / LocalAgentEntry."""
+    if is_dataclass(obj):
+        return asdict(obj)
+    return dict(obj)  # type: ignore[arg-type]
+
+
+async def _agents_endpoint(request: Request) -> JSONResponse:
+    """GET /api/agents → upstream /agents + local Tier 3 index merge.
+
+    Per FN agents_endpoint POST-001 + ERRORS table.
+    """
+    client_factory = request.app.state.client_factory
+    try:
+        async with client_factory() as client:
+            upstream = await list_agents(client)
+    except SessionApiFailed as exc:
+        return JSONResponse(
+            {"error_code": "session_api_failed", "status": exc.status},
+            status_code=exc.status,
+        )
+    except httpx.RequestError as exc:
+        return JSONResponse(
+            {"error_code": "network_error", "message": str(exc)},
+            status_code=502,
+        )
+    upstream_ids = {a.agent_id for a in upstream}
+    local = _local_agents.load_local_agents()
+    merged = [_as_dict(a) for a in upstream] + [
+        _as_dict(le) for le in local if le.agent_id not in upstream_ids
+    ]
+    return JSONResponse(merged, status_code=200)
+
+
+async def _create_session_endpoint(request: Request) -> JSONResponse:
+    """POST /api/sessions → upstream POST /sessions. Per FN create_session_endpoint.
+
+    v0.16.0: end_user_id is SERVER-configured (app.state.end_user_id from
+    RATATOSKR_END_USER_ID), never read from the browser body. A client
+    cannot impersonate an arbitrary end-user partition.
+    """
+    body = await request.json()
+    agent_id = body.get("agent_id") if isinstance(body, dict) else None
+    if not agent_id:
+        return JSONResponse({"error_code": "missing_agent_id"}, status_code=400)
+    end_user_id = request.app.state.end_user_id
+    client_factory = request.app.state.client_factory
+    try:
+        async with client_factory() as client:
+            info = await create_session(client, agent_id, end_user_id=end_user_id)
+    except AgentNotFound:
+        return JSONResponse({"error_code": "agent_not_found"}, status_code=404)
+    except SessionApiFailed as exc:
+        return JSONResponse(
+            {"error_code": "session_api_failed", "status": exc.status},
+            status_code=exc.status,
+        )
+    return JSONResponse(_as_dict(info), status_code=201)
+
+
+@dataclass
+class TurnHandle:
+    """In-flight turn record stored in app.state.turn_registry.
+
+    Per FN submit_turn_endpoint + INV-005/006/007.
+
+    v0.16.0: `upstream_turn_id` captures Worldtree's server-assigned
+    turn_id (from the first SSE event's sse_id.turn_id) once the stream
+    opens. Cancel paths target THIS, not the browser-local `turn_id` —
+    the local counter is only a registry key. None until the first
+    upstream event arrives; cancel before then is a no-op (nothing to
+    cancel upstream yet).
+    """
+
+    session_id: str
+    turn_id: int
+    content: str
+    status: str = "queued"  # queued | streaming | done | error | cancelled
+    upstream_turn_id: int | None = None
+
+
+# Process-local monotonic turn_id counter. Per FN submit_turn_endpoint
+# STEPS 2: turn_id is opaque to the upstream Worldtree (whose own
+# turn_ids come back via SSE); the registry's key uses our own counter
+# so cancel/stream lookups don't need upstream-issued ids.
+_TURN_COUNTER = itertools.count(1)
+
+
+async def _submit_turn_endpoint(request: Request) -> JSONResponse:
+    """POST /api/turns/{session_id} → allocate turn_id + register handle.
+
+    Per FN submit_turn_endpoint. Does NOT open the upstream stream here;
+    the subsequent GET /api/turns/{sid}/stream does that.
+    """
+    body = await request.json()
+    content = body.get("content") if isinstance(body, dict) else None
+    if not content:
+        return JSONResponse({"error_code": "missing_content"}, status_code=400)
+    session_id = request.path_params["session_id"]
+    turn_id = next(_TURN_COUNTER)
+    request.app.state.turn_registry[(session_id, turn_id)] = TurnHandle(
+        session_id=session_id, turn_id=turn_id, content=content,
+    )
+    return JSONResponse({"turn_id": turn_id}, status_code=200)
+
+
+def _event_to_browser_payload(event: object) -> tuple[str, dict]:
+    """Serialize an upstream Event dataclass to (browser_event_type, json_dict).
+
+    Per INV-008 + FN stream_turn_endpoint STEP 3. The dict shape is
+    locked by tests/fixtures/presentation_contract.json — one entry per
+    Event type. Implementation: snake_case class name as event_type;
+    asdict(event) with sse_id flattened to "T:S" string.
+    """
+    type_name = type(event).__name__
+    # CamelCase → snake_case
+    browser_type = "".join(
+        ("_" + c.lower() if c.isupper() and i else c.lower())
+        for i, c in enumerate(type_name)
+    )
+    data = asdict(event)  # type: ignore[arg-type]
+    sse_id = data.get("sse_id")
+    if isinstance(sse_id, (list, tuple)) and len(sse_id) == 2:
+        data["sse_id"] = f"{sse_id[0]}:{sse_id[1]}"
+    elif isinstance(sse_id, dict) and "turn_id" in sse_id and "seq" in sse_id:
+        data["sse_id"] = f"{sse_id['turn_id']}:{sse_id['seq']}"
+    return browser_type, data
+
+
+def _format_sse(event_type: str, data: dict) -> bytes:
+    """Format a browser-facing SSE event with `event:` + `data:`.
+
+    Two-newline terminator per the SSE spec.
+    """
+    return f"event: {event_type}\ndata: {json.dumps(data)}\n\n".encode()
+
+
+async def _stream_turn_endpoint(request: Request) -> StreamingResponse:
+    """GET /api/turns/{session_id}/stream?turn_id=N → proxy upstream SSE.
+
+    Per FN stream_turn_endpoint. Handles browser-disconnect cleanup
+    (INV-005) and synthesizes `event: error` for upstream typed
+    exceptions.
+    """
+    session_id = request.path_params["session_id"]
+    try:
+        turn_id = int(request.query_params["turn_id"])
+    except (KeyError, ValueError):
+        return JSONResponse({"error_code": "missing_turn_id"}, status_code=400)
+    registry = request.app.state.turn_registry
+    handle = registry.get((session_id, turn_id))
+    if handle is None:
+        return JSONResponse({"error_code": "turn_not_found"}, status_code=404)
+
+    client_factory = request.app.state.client_factory
+
+    async def gen() -> AsyncIterator[bytes]:
+        client = client_factory()
+        try:
+            handle.status = "streaming"
+            try:
+                async for event in stream_turn(client, session_id, handle.content):
+                    # v0.16.0: capture the upstream (Worldtree-assigned)
+                    # turn_id from the first event so cancel paths target
+                    # the real upstream turn, not our local counter.
+                    if handle.upstream_turn_id is None:
+                        sse_id = getattr(event, "sse_id", None)
+                        if sse_id is not None:
+                            handle.upstream_turn_id = sse_id.turn_id
+                    event_type, data = _event_to_browser_payload(event)
+                    yield _format_sse(event_type, data)
+                    if isinstance(event, (Done, Error, Cancelled)):
+                        handle.status = type(event).__name__.lower()
+                        break
+            except (SseConnectFailed, SseConnectionDropped, MalformedSseId,
+                    MalformedSseData, TurnIdFlip) as exc:
+                yield _format_sse(
+                    "error",
+                    {"exception": type(exc).__name__, "message": str(exc)},
+                )
+                handle.status = "error"
+            except asyncio.CancelledError:
+                # Browser disconnect path (INV-005). Cancel the UPSTREAM
+                # turn (if it started) — never the local turn_id.
+                if handle.status == "streaming" and handle.upstream_turn_id is not None:
+                    try:
+                        await cancel_turn(client, session_id, handle.upstream_turn_id)
+                    except (CancelAlreadyCompleted, CancelTurnNotFound):
+                        pass  # cooperative race — turn already terminal upstream
+                    except Exception as exc:
+                        # v0.16.1: unexpected cancel failure during disconnect
+                        # cleanup (e.g. CancelFailed, transport error) — log for
+                        # diagnosability instead of silently swallowing. Never
+                        # re-raise: we're already unwinding the cancelled
+                        # generator and must not mask the CancelledError.
+                        import sys as _sys
+                        _sys.stderr.write(
+                            f'{{"kind":"disconnect_cancel","event":"cancel_failed",'
+                            f'"session_id":"{session_id}",'
+                            f'"upstream_turn_id":{handle.upstream_turn_id},'
+                            f'"exc":"{type(exc).__name__}"}}\n'
+                        )
+                raise
+        finally:
+            registry.pop((session_id, turn_id), None)
+            await client.aclose()
+
+    return StreamingResponse(gen(), media_type="text/event-stream")
+
+
+async def _cancel_turn_endpoint(request: Request) -> JSONResponse:
+    """POST /api/turns/{session_id}/cancel?turn_id=N. Per FN cancel_turn_endpoint."""
+    session_id = request.path_params["session_id"]
+    try:
+        turn_id = int(request.query_params["turn_id"])
+    except (KeyError, ValueError):
+        return JSONResponse({"error_code": "missing_turn_id"}, status_code=400)
+    registry = request.app.state.turn_registry
+    handle = registry.get((session_id, turn_id))
+    if handle is None:
+        return JSONResponse({"error_code": "turn_not_found"}, status_code=404)
+    # v0.16.0: cancel targets the UPSTREAM turn_id captured during
+    # streaming, not the browser-local turn_id. If the upstream stream
+    # never started (upstream_turn_id is None), there's nothing to
+    # cancel — clean up and report a no-op.
+    if handle.upstream_turn_id is None:
+        registry.pop((session_id, turn_id), None)
+        return JSONResponse(
+            {"cancelled": False, "reason": "not_started"}, status_code=200
+        )
+    client_factory = request.app.state.client_factory
+    try:
+        async with client_factory() as client:
+            await cancel_turn(client, session_id, handle.upstream_turn_id)
+        body = {"cancelled": True}
+    except (CancelAlreadyCompleted, CancelTurnNotFound):
+        body = {"cancelled": False, "reason": "race_or_completed"}
+    except CancelFailed as exc:
+        registry.pop((session_id, turn_id), None)
+        return JSONResponse(
+            {"error_code": "cancel_failed", "status": exc.status},
+            status_code=exc.status,
+        )
+    registry.pop((session_id, turn_id), None)
+    return JSONResponse(body, status_code=200)
+
+
+async def _persona_state_endpoint(request: Request) -> JSONResponse:
+    """GET /api/agents/{agent_id}/persona_state. Per FN persona_state_endpoint."""
+    agent_id = request.path_params["agent_id"]
+    client_factory = request.app.state.client_factory
+    try:
+        async with client_factory() as client:
+            snap = await get_persona_state(client, agent_id)
+    except PersonaNotConfigured:
+        return JSONResponse({"error_code": "persona_not_configured"}, status_code=404)
+    except AgentNotAvailable:
+        return JSONResponse({"error_code": "agent_not_available"}, status_code=404)
+    except AuthScopeDenied:
+        return JSONResponse({"error_code": "auth_scope_denied"}, status_code=403)
+    return JSONResponse(snap, status_code=200)
+
+
+def create_app(
+    client_factory: Callable[[], httpx.AsyncClient],
+    *,
+    end_user_id: str | None = None,
+) -> Starlette:
+    """Construct the Starlette app — wire routes + state per FN create_app.
+
+    INV-002: app MUST NOT construct httpx.AsyncClient at module top;
+    everything HTTP-bound goes through client_factory.
+    INV-006: lifespan shutdown drains the turn registry within a 5s
+    budget — every in-flight turn gets a best-effort upstream cancel.
+
+    v0.16.0: `end_user_id` is the server-configured Worldtree end-user
+    partition (from RATATOSKR_END_USER_ID). Threaded into POST /sessions
+    server-side; never accepted from the browser.
+    """
+    assert callable(client_factory)
+
+    from contextlib import asynccontextmanager
+
+    @asynccontextmanager
+    async def lifespan(app: Starlette):
+        yield
+        # Shutdown path — drain in-flight turns per INV-006. Cancel the
+        # UPSTREAM turn_id (v0.16.0); skip handles whose upstream stream
+        # never started (upstream_turn_id is None — nothing to cancel).
+        import sys as _sys
+
+        registry: dict[tuple[str, int], TurnHandle] = app.state.turn_registry
+        in_flight = [
+            h for h in registry.values()
+            if h.status == "streaming" and h.upstream_turn_id is not None
+        ]
+        if in_flight:
+            client = client_factory()
+            try:
+                task_to_handle = {
+                    asyncio.create_task(
+                        cancel_turn(client, h.session_id, h.upstream_turn_id)
+                    ): h
+                    for h in in_flight
+                }
+                done, pending = await asyncio.wait(task_to_handle, timeout=5.0)
+                # Per-pending session/turn detail (INV-006 logging fidelity).
+                for task in pending:
+                    h = task_to_handle[task]
+                    task.cancel()
+                    _sys.stderr.write(
+                        f'{{"kind":"shutdown","event":"cleanup_timeout",'
+                        f'"session_id":"{h.session_id}",'
+                        f'"upstream_turn_id":{h.upstream_turn_id}}}\n'
+                    )
+            finally:
+                await client.aclose()
+        registry.clear()
+
+    routes = [
+        Route("/", _root_endpoint),
+        Mount("/static", app=StaticFiles(directory=_static_dir()), name="static"),
+        Route("/version", _version_endpoint),
+        Route("/api/agents", _agents_endpoint),
+        Route("/api/sessions", _create_session_endpoint, methods=["POST"]),
+        Route("/api/agents/{agent_id}/persona_state", _persona_state_endpoint),
+        Route("/api/turns/{session_id}", _submit_turn_endpoint, methods=["POST"]),
+        Route("/api/turns/{session_id}/stream", _stream_turn_endpoint),
+        Route("/api/turns/{session_id}/cancel", _cancel_turn_endpoint, methods=["POST"]),
+    ]
+    app = Starlette(routes=routes, lifespan=lifespan)
+    app.state.client_factory = client_factory
+    app.state.end_user_id = end_user_id
+    # INV-002: turn registry is in-process memory, keyed (session_id, turn_id)
+    app.state.turn_registry = {}
+    return app

src/ratatoskr/web/static/index.html

@@ -0,0 +1,983 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8" />
+<meta name="viewport" content="width=device-width, initial-scale=1" />
+<title>ratatoskr · wire monitor</title>
+<style>
+/* ============================================================
+   ratatoskr-web — Aurora telemetry instrument
+   A precision wire-monitoring console for the Worldtree
+   Conversation API. All-monospace by intent; Australis dark
+   cool-tone palette with aurora-borealis accents on LIVE
+   surfaces. Single file, no build, no CDN.
+   ============================================================ */
+:root {
+  /* layered voids */
+  --void:       #000000;
+  --surface-1:  #07090c;
+  --surface-2:  #0d1117;
+  --surface-3:  #141a22;
+  --line:       #1b212a;
+  --line-2:     #283039;
+
+  /* Australis Sea — text ramp */
+  --fg:         #b9c8ce;
+  --fg-2:       #8a97a0;
+  --fg-dim:     #6e7882;
+  --fg-faint:   #49525c;
+
+  /* Aurora accents */
+  --cyan:       #42dcd1;
+  --blue:       #a4c4ff;
+  --green:      #51e08a;
+  --green-deep: #16b866;
+  --red:        #ff5a36;
+  --amber:      #e1c631;
+
+  --glow-cyan:  rgba(66, 220, 209, 0.14);
+
+  --mono: "Berkeley Mono", "JetBrains Mono", "IBM Plex Mono",
+          "SFMono-Regular", "Cascadia Code", "Roboto Mono",
+          ui-monospace, Menlo, Consolas, monospace;
+
+  --row: 30px;
+}
+
+* { box-sizing: border-box; }
+html, body { height: 100%; margin: 0; }
+
+body {
+  background: var(--void);
+  color: var(--fg);
+  font-family: var(--mono);
+  font-size: 13px;
+  line-height: 1.5;
+  display: flex;
+  flex-direction: column;
+  overflow: hidden;
+  /* faint cyan glow at top + grain */
+  background-image:
+    radial-gradient(120% 60% at 50% -10%, var(--glow-cyan), transparent 60%),
+    url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='120' height='120'%3E%3Cfilter id='n'%3E%3CfeTurbulence type='fractalNoise' baseFrequency='0.9' numOctaves='2'/%3E%3C/filter%3E%3Crect width='100%25' height='100%25' filter='url(%23n)' opacity='0.025'/%3E%3C/svg%3E");
+}
+
+/* selection */
+::selection { background: rgba(66,220,209,0.25); color: #fff; }
+
+/* scrollbars */
+::-webkit-scrollbar { width: 10px; height: 10px; }
+::-webkit-scrollbar-track { background: transparent; }
+::-webkit-scrollbar-thumb { background: var(--line-2); border-radius: 0; }
+::-webkit-scrollbar-thumb:hover { background: var(--fg-faint); }
+
+/* ---- aurora signature band ---- */
+.aurora {
+  height: 2px;
+  flex: 0 0 auto;
+  background: linear-gradient(90deg,
+    transparent, var(--cyan), var(--blue), var(--green), var(--cyan), transparent);
+  background-size: 300% 100%;
+  animation: aurora-drift 14s linear infinite;
+  opacity: 0.85;
+}
+@keyframes aurora-drift {
+  0% { background-position: 0% 0; }
+  100% { background-position: 300% 0; }
+}
+
+/* ---- top command bar ---- */
+#topbar {
+  flex: 0 0 auto;
+  height: 46px;
+  display: flex;
+  align-items: center;
+  gap: 20px;
+  padding: 0 16px;
+  background: linear-gradient(180deg, var(--surface-2), var(--surface-1));
+  border-bottom: 1px solid var(--line);
+}
+.brand { display: flex; align-items: baseline; gap: 9px; flex: 0 0 auto; }
+.brand .glyph {
+  font-size: 16px; color: var(--cyan);
+  text-shadow: 0 0 12px var(--glow-cyan);
+  transform: translateY(1px);
+}
+.brand .name {
+  font-size: 14px; font-weight: 600; letter-spacing: 0.04em; color: var(--fg);
+}
+.brand .tag {
+  font-size: 9px; letter-spacing: 0.18em; text-transform: uppercase;
+  color: var(--fg-faint);
+}
+
+.conn {
+  display: flex; align-items: center; gap: 7px; flex: 0 0 auto;
+  font-size: 10px; letter-spacing: 0.14em; text-transform: uppercase;
+  color: var(--fg-dim);
+}
+.conn .dot {
+  width: 7px; height: 7px; border-radius: 50%;
+  background: var(--fg-faint);
+  box-shadow: 0 0 0 0 transparent;
+}
+.conn[data-state="idle"] .dot { background: var(--green-deep); }
+.conn[data-state="streaming"] .dot {
+  background: var(--cyan);
+  animation: pulse 1.1s ease-in-out infinite;
+}
+.conn[data-state="error"] .dot { background: var(--red); }
+.conn[data-state="streaming"] { color: var(--cyan); }
+.conn[data-state="error"] { color: var(--red); }
+@keyframes pulse {
+  0%,100% { box-shadow: 0 0 0 0 rgba(66,220,209,0.55); }
+  50%     { box-shadow: 0 0 0 5px rgba(66,220,209,0); }
+}
+
+/* persona strip — lives in the top bar, hidden until hydrated */
+#persona-strip {
+  display: none;
+  align-items: center; gap: 14px;
+  flex: 1 1 auto;
+  min-width: 0;
+  padding-left: 18px;
+  border-left: 1px solid var(--line);
+  height: 26px;
+}
+#persona-strip.show { display: flex; }
+#persona-strip .emo {
+  font-size: 11px; color: var(--blue); letter-spacing: 0.02em;
+  white-space: nowrap; flex: 0 0 auto;
+}
+#persona-strip .emo b { color: var(--cyan); font-weight: 600; }
+.pad-bars { display: flex; gap: 12px; flex: 0 0 auto; }
+.pad { display: flex; align-items: center; gap: 5px; }
+.pad .k { font-size: 9px; color: var(--fg-faint); width: 8px; }
+.pad .track {
+  width: 46px; height: 4px; background: var(--line-2);
+  position: relative; overflow: hidden;
+}
+.pad .track::before { /* center baseline tick */
+  content: ""; position: absolute; left: 50%; top: 0; bottom: 0;
+  width: 1px; background: var(--fg-faint); opacity: 0.5;
+}
+.pad .fill {
+  position: absolute; top: 0; bottom: 0; left: 50%;
+  background: linear-gradient(90deg, var(--cyan), var(--blue));
+  transition: width 0.4s ease, left 0.4s ease;
+}
+
+.spacer { flex: 1 1 auto; }
+#identity {
+  font-size: 11px; color: var(--fg-dim); letter-spacing: 0.02em;
+  white-space: nowrap; flex: 0 0 auto;
+}
+#identity .a { color: var(--blue); }
+
+/* ---- workspace split ---- */
+#workspace {
+  display: none;
+  flex: 1 1 auto;
+  min-height: 0;
+  grid-template-columns: 1.85fr 1fr;
+}
+#workspace.live { display: grid; }
+
+.conversation, .telemetry { display: flex; flex-direction: column; min-height: 0; min-width: 0; }
+.conversation { border-right: 1px solid var(--line); }
+
+/* transcript */
+#transcript {
+  flex: 1 1 auto; overflow-y: auto; padding: 18px 22px 28px;
+  scroll-behavior: smooth;
+}
+.turn-header {
+  display: flex; align-items: center; gap: 10px;
+  margin: 18px 0 10px; color: var(--fg-faint);
+  font-size: 10px; letter-spacing: 0.16em; text-transform: uppercase;
+}
+.turn-header::before, .turn-header::after {
+  content: ""; height: 1px; background: var(--line); flex: 1 1 auto;
+}
+.turn-header:first-child { margin-top: 0; }
+
+.prompt-echo {
+  color: var(--cyan); font-weight: 500; margin: 4px 0 10px;
+  display: flex; gap: 9px; align-items: baseline;
+  animation: rise 0.3s ease both;
+}
+.prompt-echo::before {
+  content: "❯"; color: var(--cyan); font-weight: 700;
+  text-shadow: 0 0 10px var(--glow-cyan);
+}
+.response {
+  white-space: pre-wrap; word-break: break-word;
+  color: var(--fg); margin: 0 0 6px;
+  padding-left: 18px; border-left: 2px solid var(--line-2);
+}
+.response.live { border-left-color: var(--cyan); }
+
+.awaiting {
+  display: inline-flex; align-items: center; gap: 8px;
+  color: var(--fg-dim); font-style: italic; font-size: 12px;
+  margin: 6px 0; padding-left: 18px;
+}
+.awaiting::after {
+  content: ""; width: 16px; text-align: left;
+  animation: dots 1.4s steps(4, end) infinite;
+}
+@keyframes dots {
+  0% { content: ""; } 25% { content: "·"; }
+  50% { content: "··"; } 75% { content: "···"; }
+}
+
+/* terminal status chips */
+.chip {
+  display: inline-flex; align-items: center; gap: 7px;
+  margin: 8px 0 4px; padding: 3px 10px;
+  font-size: 10px; letter-spacing: 0.08em;
+  border: 1px solid currentColor; border-radius: 2px;
+  animation: rise 0.3s ease both;
+}
+.chip .lbl { text-transform: uppercase; font-weight: 600; }
+.chip .meta { color: var(--fg-dim); border: 0; letter-spacing: 0; }
+.chip.done      { color: var(--green); }
+.chip.error     { color: var(--red); }
+.chip.cancelled { color: var(--amber); }
+.chip.wire      { color: var(--red); }
+@keyframes rise { from { opacity: 0; transform: translateY(3px); } to { opacity: 1; transform: none; } }
+
+/* composer */
+.composer {
+  flex: 0 0 auto; border-top: 1px solid var(--line);
+  background: var(--surface-1);
+  display: flex; align-items: center; gap: 10px; padding: 10px 14px;
+}
+.composer .prompt-mark { color: var(--cyan); font-weight: 700; }
+#prompt-input {
+  flex: 1 1 auto; background: transparent; border: 0; outline: none;
+  color: var(--fg); font-family: var(--mono); font-size: 13px;
+  padding: 6px 2px;
+}
+#prompt-input::placeholder { color: var(--fg-faint); }
+#send-btn {
+  flex: 0 0 auto; cursor: pointer;
+  background: transparent; color: var(--cyan);
+  border: 1px solid var(--line-2); border-radius: 2px;
+  font-family: var(--mono); font-size: 10px; letter-spacing: 0.12em;
+  text-transform: uppercase; padding: 6px 12px;
+  transition: all 0.15s ease;
+}
+#send-btn:hover { border-color: var(--cyan); background: rgba(66,220,209,0.08); }
+.composer.streaming #send-btn { display: none; }
+#cancel-btn {
+  display: none; flex: 0 0 auto; cursor: pointer;
+  background: transparent; color: var(--amber);
+  border: 1px solid rgba(225,198,49,0.4); border-radius: 2px;
+  font-family: var(--mono); font-size: 10px; letter-spacing: 0.12em;
+  text-transform: uppercase; padding: 6px 12px;
+}
+.composer.streaming #cancel-btn { display: inline-block; }
+#cancel-btn:hover { border-color: var(--amber); background: rgba(225,198,49,0.08); }
+
+/* ---- telemetry column ---- */
+.telemetry { background: var(--surface-1); }
+.tabs {
+  flex: 0 0 auto; display: flex; border-bottom: 1px solid var(--line);
+  background: var(--surface-2);
+}
+.tab {
+  flex: 1 1 0; cursor: pointer; user-select: none;
+  background: transparent; border: 0; border-bottom: 2px solid transparent;
+  color: var(--fg-dim); font-family: var(--mono);
+  font-size: 10px; letter-spacing: 0.1em; text-transform: uppercase;
+  padding: 11px 6px 9px; display: flex; align-items: center;
+  justify-content: center; gap: 6px; transition: color 0.15s ease;
+}
+.tab:hover { color: var(--fg-2); }
+.tab.active { color: var(--cyan); border-bottom-color: var(--cyan); }
+.tab .kbd { color: var(--fg-faint); font-size: 9px; }
+.tab .badge {
+  min-width: 16px; padding: 0 4px; height: 14px; line-height: 14px;
+  font-size: 9px; text-align: center; border-radius: 7px;
+  background: var(--line-2); color: var(--fg-dim);
+  transition: background 0.2s ease, color 0.2s ease;
+}
+.tab.active .badge { background: rgba(66,220,209,0.16); color: var(--cyan); }
+.tab .badge.flash { background: var(--cyan); color: var(--void); }
+
+.pane-head {
+  flex: 0 0 auto; display: flex; align-items: center; justify-content: space-between;
+  padding: 7px 12px; border-bottom: 1px solid var(--line);
+  font-size: 10px; letter-spacing: 0.14em; text-transform: uppercase;
+  color: var(--fg-dim); background: var(--surface-1);
+}
+.pane-head .copy {
+  cursor: pointer; background: transparent; border: 1px solid var(--line-2);
+  color: var(--fg-dim); border-radius: 2px; font-family: var(--mono);
+  font-size: 9px; letter-spacing: 0.1em; text-transform: uppercase;
+  padding: 2px 8px; transition: all 0.15s ease;
+}
+.pane-head .copy:hover { border-color: var(--cyan); color: var(--cyan); }
+.pane-head .copy.copied { border-color: var(--green); color: var(--green); }
+
+.pane-wrap { flex: 1 1 auto; min-height: 0; position: relative; }
+.pane {
+  position: absolute; inset: 0; overflow-y: auto;
+  padding: 10px 12px; display: none;
+  white-space: pre-wrap; word-break: break-word;
+  font-size: 12px; color: var(--fg-2);
+}
+.pane.active { display: block; }
+.pane > div { padding: 1px 0; }
+.pane .empty {
+  color: var(--fg-faint); font-style: italic;
+}
+.pane .rule { color: var(--fg-faint); }
+/* new-line flash */
+.pane > div.fresh { animation: flash 0.9s ease; }
+@keyframes flash { from { background: rgba(66,220,209,0.12); } to { background: transparent; } }
+
+/* persona pane structured render */
+#pane-persona .pk { color: var(--fg-dim); }
+#pane-persona .pv { color: var(--blue); }
+#pane-persona .ph { color: var(--cyan); letter-spacing: 0.1em; text-transform: uppercase; font-size: 10px; }
+
+/* thinking-pane per-turn dividers */
+.pane-turn {
+  display: flex; align-items: center; gap: 10px;
+  margin: 14px 0 8px; color: var(--fg-faint);
+  font-size: 10px; letter-spacing: 0.16em; text-transform: uppercase;
+}
+.pane-turn:first-child { margin-top: 0; }
+.pane-turn::before, .pane-turn::after {
+  content: ""; height: 1px; background: var(--line); flex: 1 1 auto;
+}
+
+/* ---- safe live Markdown (transcript response + thinking) ---- */
+/* Renderer escapes first, then applies a whitelist subset; no raw HTML
+   passthrough, link schemes restricted to http(s). See markdownSafe(). */
+.md-body { white-space: normal; }
+.md-body .md-p { margin: 0 0 7px; white-space: pre-wrap; }
+.md-body .md-p:last-child { margin-bottom: 0; }
+.md-body .md-h { margin: 10px 0 5px; color: var(--blue); font-weight: 600; letter-spacing: 0.01em; }
+.md-body .md-h1 { font-size: 15px; } .md-body .md-h2 { font-size: 14px; }
+.md-body .md-h3, .md-body .md-h4, .md-body .md-h5, .md-body .md-h6 { font-size: 13px; }
+.md-body strong { color: var(--fg); font-weight: 700; }
+.md-body em { color: var(--blue); font-style: italic; }
+.md-body code {
+  background: var(--surface-3); color: var(--cyan);
+  padding: 0 4px; border-radius: 2px; font-size: 0.92em;
+}
+.md-body pre.md-code {
+  background: var(--surface-2); border: 1px solid var(--line);
+  border-radius: 3px; padding: 8px 10px; margin: 7px 0;
+  white-space: pre-wrap; word-break: break-word; color: var(--fg-2);
+}
+.md-body ul, .md-body ol { margin: 5px 0; padding-left: 20px; }
+.md-body li { margin: 2px 0; }
+.md-body .md-quote {
+  border-left: 2px solid var(--line-2); padding-left: 10px;
+  margin: 5px 0; color: var(--fg-dim);
+}
+.md-body a { color: var(--cyan); text-decoration: underline; text-underline-offset: 2px; }
+.md-body a:hover { color: var(--blue); }
+
+/* ---- status line ---- */
+#statusline {
+  flex: 0 0 auto; height: 24px; display: flex; align-items: center;
+  gap: 16px; padding: 0 14px; background: var(--surface-2);
+  border-top: 1px solid var(--line); font-size: 10px; color: var(--fg-faint);
+  letter-spacing: 0.04em;
+}
+#statusline .legend { display: flex; gap: 14px; flex: 1 1 auto; min-width: 0; overflow: hidden; }
+#statusline kbd {
+  font-family: var(--mono); color: var(--fg-dim);
+  border: 1px solid var(--line-2); border-radius: 2px;
+  padding: 0 4px; font-size: 9px;
+}
+#version { flex: 0 0 auto; color: var(--fg-dim); }
+
+/* ---- setup overlay ---- */
+#setup {
+  position: fixed; inset: 0; z-index: 20;
+  display: flex; align-items: center; justify-content: center;
+  background: radial-gradient(80% 80% at 50% 30%, rgba(13,17,23,0.6), var(--void) 80%);
+  backdrop-filter: blur(2px);
+}
+.setup-card {
+  width: 440px; max-width: 90vw;
+  background: linear-gradient(180deg, var(--surface-3), var(--surface-1));
+  border: 1px solid var(--line-2); border-radius: 4px;
+  padding: 30px 30px 26px; position: relative; overflow: hidden;
+  animation: rise 0.4s ease both;
+}
+.setup-card .aurora { position: absolute; top: 0; left: 0; right: 0; }
+.setup-card h1 {
+  margin: 6px 0 4px; font-size: 18px; font-weight: 600; letter-spacing: 0.02em;
+  color: var(--fg);
+}
+.setup-card h1 .glyph { color: var(--cyan); text-shadow: 0 0 14px var(--glow-cyan); }
+.setup-card .sub {
+  margin: 0 0 22px; font-size: 11px; color: var(--fg-dim);
+  letter-spacing: 0.04em; line-height: 1.6;
+}
+.field-label {
+  display: block; font-size: 10px; letter-spacing: 0.14em;
+  text-transform: uppercase; color: var(--fg-dim); margin: 0 0 7px;
+}
+.select-wrap { position: relative; margin-bottom: 22px; }
+.select-wrap::after {
+  content: "▾"; position: absolute; right: 12px; top: 50%;
+  transform: translateY(-50%); color: var(--cyan); pointer-events: none; font-size: 11px;
+}
+#agent-picker {
+  width: 100%; appearance: none; -webkit-appearance: none;
+  background: var(--surface-1); color: var(--fg);
+  border: 1px solid var(--line-2); border-radius: 3px;
+  font-family: var(--mono); font-size: 13px; padding: 10px 34px 10px 12px;
+  cursor: pointer; outline: none; transition: border-color 0.15s ease;
+}
+#agent-picker:focus { border-color: var(--cyan); }
+#start-btn {
+  width: 100%; cursor: pointer;
+  background: linear-gradient(180deg, rgba(66,220,209,0.16), rgba(66,220,209,0.06));
+  color: var(--cyan); border: 1px solid var(--cyan); border-radius: 3px;
+  font-family: var(--mono); font-size: 12px; letter-spacing: 0.14em;
+  text-transform: uppercase; padding: 11px; font-weight: 600;
+  transition: all 0.15s ease;
+}
+#start-btn:hover { background: rgba(66,220,209,0.2); box-shadow: 0 0 22px var(--glow-cyan); }
+#start-btn:disabled { opacity: 0.4; cursor: wait; }
+.setup-err { color: var(--red); font-size: 11px; margin-top: 12px; min-height: 14px; }
+</style>
+</head>
+<body>
+<div class="aurora"></div>
+
+<header id="topbar">
+  <div class="brand">
+    <span class="glyph">ᛯ</span>
+    <span class="name">ratatoskr</span>
+    <span class="tag">wire monitor</span>
+  </div>
+  <div class="conn" id="conn" data-state="">
+    <span class="dot"></span><span id="conn-label">offline</span>
+  </div>
+  <div id="persona-strip"></div>
+  <div class="spacer"></div>
+  <div id="identity">—</div>
+</header>
+
+<main id="workspace">
+  <section class="conversation">
+    <div id="transcript"></div>
+    <div class="composer" id="composer">
+      <span class="prompt-mark">❯</span>
+      <input id="prompt-input" type="text" autocomplete="off"
+             placeholder="Message — Enter sends, Shift+Enter newline" />
+      <button id="send-btn">send</button>
+      <button id="cancel-btn">cancel ⌃C</button>
+    </div>
+  </section>
+
+  <section class="telemetry">
+    <nav class="tabs" id="tabs">
+      <button class="tab active" data-pane="tools">tools <span class="kbd">⌃1</span><span class="badge">0</span></button>
+      <button class="tab" data-pane="debug">debug <span class="kbd">⌃2</span><span class="badge">0</span></button>
+      <button class="tab" data-pane="thinking">think <span class="kbd">⌃3</span><span class="badge">0</span></button>
+      <button class="tab" data-pane="persona">persona <span class="kbd">⌃4</span></button>
+    </nav>
+    <div class="pane-head">
+      <span id="pane-name">tools</span>
+      <button class="copy" id="copy-btn">copy</button>
+    </div>
+    <div class="pane-wrap">
+      <div class="pane active" id="pane-tools"><div class="empty">no tool events yet</div></div>
+      <div class="pane" id="pane-debug"><div class="empty">waiting for wire telemetry…</div></div>
+      <div class="pane" id="pane-thinking"><div class="empty">no chain-of-thought captured yet</div></div>
+      <div class="pane" id="pane-persona"><div class="empty">persona state loads on session open</div></div>
+    </div>
+  </section>
+</main>
+
+<div id="setup">
+  <div class="setup-card">
+    <div class="aurora"></div>
+    <h1><span class="glyph">ᛯ</span> ratatoskr-web</h1>
+    <p class="sub">Internal-LAN debug companion to the Worldtree Conversation API. Pick an agent and open a session to begin watching the wire.</p>
+    <label class="field-label" for="agent-picker">Agent</label>
+    <div class="select-wrap">
+      <select id="agent-picker"><option>loading…</option></select>
+    </div>
+    <button id="start-btn">open session</button>
+    <div class="setup-err" id="setup-err"></div>
+  </div>
+</div>
+
+<footer id="statusline">
+  <div class="legend">
+    <span><kbd>Enter</kbd> send</span>
+    <span><kbd>⇧Enter</kbd> newline</span>
+    <span><kbd>⌃1</kbd>–<kbd>⌃4</kbd> panes</span>
+    <span><kbd>⌃C</kbd> cancel turn</span>
+  </div>
+  <div id="version">ratatoskr —</div>
+</footer>
+
+<script>
+// ratatoskr-web — vanilla JS client.
+// Five-pane debug surface. HTML-escapes ALL model/tool output (INV-004 —
+// model output is untrusted text; adversarial HTML must not execute).
+// Drift-detection contract: tests/fixtures/presentation_contract.json
+"use strict";
+
+const $ = (id) => document.getElementById(id);
+const state = { sessionId: null, agentId: null, turnId: null, eventSource: null };
+
+function esc(s) {
+  const d = document.createElement("div");
+  d.appendChild(document.createTextNode(String(s)));
+  return d.innerHTML;
+}
+function ts() {
+  const d = new Date();
+  return d.toTimeString().slice(0, 8) + "." + String(d.getMilliseconds()).padStart(3, "0");
+}
+
+// ---- safe live Markdown ------------------------------------------------
+// Model output is UNTRUSTED (INV-004). Strategy: escape EVERYTHING first
+// (esc neutralizes < > &), THEN apply a whitelist of markdown transforms
+// on the already-escaped text. No raw HTML ever passes through; link
+// hrefs are restricted to http(s) and a conservative charset so a
+// crafted URL can't break out of the attribute. Hand-rolled (no CDN,
+// no library) — a deliberately small subset for a debug surface.
+function mdInline(s) {
+  s = s.replace(/\*\*([^*]+)\*\*/g, "<strong>$1</strong>");
+  s = s.replace(/__([^_]+)__/g, "<strong>$1</strong>");
+  s = s.replace(/(^|[^*])\*([^*\n]+)\*/g, "$1<em>$2</em>");
+  s = s.replace(/(^|[^_\w])_([^_\n]+)_/g, "$1<em>$2</em>");
+  // [text](url) — http(s) only, conservative charset (no quotes/brackets/ws)
+  s = s.replace(/\[([^\]]+)\]\(([^)]+)\)/g, (m, text, url) =>
+    /^https?:\/\/[^\s"'<>)]+$/.test(url)
+      ? `<a href="${url}" target="_blank" rel="noopener noreferrer">${text}</a>`
+      : text);
+  return s;
+}
+function markdownSafe(raw) {
+  let s = esc(raw);  // escape < > & FIRST
+  const cb = [], ic = [];
+  // fenced code blocks (no inline transforms inside)
+  s = s.replace(/```[^\n`]*\n([\s\S]*?)```/g, (m, body) => { cb.push(body); return `CB${cb.length - 1}`; });
+  // inline code
+  s = s.replace(/`([^`\n]+)`/g, (m, body) => { ic.push(body); return `IC${ic.length - 1}`; });
+  const out = [];
+  let para = [], list = null;
+  const flushPara = () => { if (para.length) { out.push(`<div class="md-p">${para.map(mdInline).join("<br>")}</div>`); para = []; } };
+  const closeList = () => { if (list) { out.push(`</${list}>`); list = null; } };
+  for (const line of s.split("\n")) {
+    let m;
+    if ((m = /^(#{1,6})\s+(.*)$/.exec(line))) { flushPara(); closeList(); out.push(`<div class="md-h md-h${m[1].length}">${mdInline(m[2])}</div>`); }
+    else if ((m = /^&gt;\s?(.*)$/.exec(line))) { flushPara(); closeList(); out.push(`<div class="md-quote">${mdInline(m[1])}</div>`); }
+    else if ((m = /^\s*[-*+]\s+(.*)$/.exec(line))) { flushPara(); if (list !== "ul") { closeList(); out.push("<ul>"); list = "ul"; } out.push(`<li>${mdInline(m[1])}</li>`); }
+    else if ((m = /^\s*\d+\.\s+(.*)$/.exec(line))) { flushPara(); if (list !== "ol") { closeList(); out.push("<ol>"); list = "ol"; } out.push(`<li>${mdInline(m[1])}</li>`); }
+    else if (/^\s*$/.test(line)) { flushPara(); closeList(); }
+    else { closeList(); para.push(line); }
+  }
+  flushPara(); closeList();
+  let html = out.join("");
+  html = html.replace(/IC(\d+)/g, (m, i) => `<code>${ic[+i]}</code>`);
+  html = html.replace(/CB(\d+)/g, (m, i) => `<pre class="md-code">${cb[+i]}</pre>`);
+  return html;
+}
+
+// per-turn live buffers (reset at turn open)
+const LIVE = { resp: "", think: "" };
+
+// ---- pane helpers ----
+const PANE_BADGE = { tools: 0, debug: 0, thinking: 0 };
+function bumpBadge(pane) {
+  if (!(pane in PANE_BADGE)) return;
+  PANE_BADGE[pane] += 1;
+  const tab = document.querySelector(`.tab[data-pane="${pane}"]`);
+  if (!tab) return;
+  const b = tab.querySelector(".badge");
+  if (b) {
+    b.textContent = PANE_BADGE[pane];
+    b.classList.add("flash");
+    setTimeout(() => b.classList.remove("flash"), 220);
+  }
+}
+function paneOf(paneId) { return paneId.replace("pane-", ""); }
+
+function appendTo(paneId, html) {
+  const el = $(paneId);
+  const empty = el.querySelector(".empty");
+  if (empty) empty.remove();
+  el.insertAdjacentHTML("beforeend", html);
+  const last = el.lastElementChild;
+  if (last) { last.classList.add("fresh"); setTimeout(() => last.classList.remove("fresh"), 900); }
+  el.scrollTop = el.scrollHeight;
+  bumpBadge(paneOf(paneId));
+}
+
+// ---- connection state ----
+function setConn(stateName, label) {
+  const c = $("conn");
+  c.dataset.state = stateName;
+  $("conn-label").textContent = label;
+}
+
+// ---- bootstrap fetches ----
+async function loadAgents() {
+  try {
+    const r = await fetch("/api/agents");
+    const agents = await r.json();
+    const picker = $("agent-picker");
+    picker.innerHTML = "";
+    for (const a of agents) {
+      const opt = document.createElement("option");
+      opt.value = a.agent_id;
+      opt.textContent = a.agent_id + (a.name ? " · " + a.name : "");
+      picker.appendChild(opt);
+    }
+    if (!agents.length) {
+      $("setup-err").textContent = "no agents available from upstream";
+    }
+  } catch (e) {
+    $("setup-err").textContent = "failed to load agents";
+  }
+}
+
+async function loadVersion() {
+  try {
+    const v = await (await fetch("/version")).json();
+    $("version").textContent = "ratatoskr " + v.ratatoskr;
+  } catch (_) {}
+}
+
+// ---- persona rendering ----
+function clamp01(v) { return Math.max(0, Math.min(1, (Number(v) + 1) / 2)); }
+function setPersonaStrip(snap) {
+  const strip = $("persona-strip");
+  const pad = snap.pad || {};
+  const axes = [["P", pad.pleasure], ["A", pad.arousal], ["D", pad.dominance]];
+  let bars = "";
+  for (const [k, v] of axes) {
+    const frac = (v === undefined || v === null) ? 0.5 : clamp01(v);
+    // fill grows from center baseline toward the value
+    const left = Math.min(0.5, frac) * 100;
+    const width = Math.abs(frac - 0.5) * 100;
+    bars += `<div class="pad"><span class="k">${k}</span>`
+          + `<span class="track"><span class="fill" style="left:${left}%;width:${width}%"></span></span></div>`;
+  }
+  strip.innerHTML =
+    `<span class="emo">${esc(snap.agent_id || "?")} · <b>${esc(snap.dominant_emotion || "neutral")}</b></span>`
+    + `<span class="pad-bars">${bars}</span>`;
+  strip.classList.add("show");
+}
+function renderPersonaPane(snap) {
+  const row = (k, v) => `<div><span class="pk">${esc(k)}</span> <span class="pv">${esc(v)}</span></div>`;
+  const head = (t) => `<div class="ph">${esc(t)}</div>`;
+  const pane = $("pane-persona");
+  pane.innerHTML =
+    head("persona snapshot · " + (snap.agent_id || "?")) +
+    `<div> </div>` +
+    row("dominant", snap.dominant_emotion || "?") +
+    `<div> </div>` + head("pad") +
+    row("pleasure", JSON.stringify(snap.pad?.pleasure)) +
+    row("arousal", JSON.stringify(snap.pad?.arousal)) +
+    row("dominance", JSON.stringify(snap.pad?.dominance)) +
+    `<div> </div>` + head("baseline / drift") +
+    row("baseline", JSON.stringify(snap.baseline_pad || {})) +
+    row("mood_drift", JSON.stringify(snap.mood_drift || {})) +
+    `<div> </div>` + head("active emotions (" + (snap.emotions_active || []).length + ")") +
+    (snap.emotions_active || []).map((e) => row("·", JSON.stringify(e))).join("") +
+    `<div> </div>` + row("last_updated", snap.last_updated_at || "?");
+}
+
+async function loadPersona(agentId) {
+  try {
+    const r = await fetch("/api/agents/" + encodeURIComponent(agentId) + "/persona_state");
+    if (r.status === 200) {
+      const snap = await r.json();
+      renderPersonaPane(snap);
+      setPersonaStrip(snap);
+    } else {
+      $("pane-persona").innerHTML = `<div class="empty">persona not available (HTTP ${esc(r.status)})</div>`;
+    }
+  } catch (e) {
+    $("pane-persona").innerHTML = `<div class="empty">persona fetch failed</div>`;
+  }
+}
+
+// ---- session lifecycle ----
+async function startSession() {
+  const agentId = $("agent-picker").value;
+  if (!agentId) return;
+  state.agentId = agentId;
+  $("start-btn").disabled = true;
+  $("setup-err").textContent = "";
+  try {
+    // end_user_id is server-configured (RATATOSKR_END_USER_ID) — not sent
+    // from the browser; the server ignores any end_user_id in this body.
+    const r = await fetch("/api/sessions", {
+      method: "POST", headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ agent_id: agentId }),
+    });
+    if (r.status !== 201) {
+      $("setup-err").textContent = "create session failed: HTTP " + r.status;
+      $("start-btn").disabled = false;
+      return;
+    }
+    const info = await r.json();
+    state.sessionId = info.session_id;
+    $("identity").innerHTML =
+      `<span class="a">${esc(agentId)}</span> · …${esc(info.session_id.slice(-8))}`;
+    setConn("idle", "connected");
+    $("setup").style.display = "none";
+    $("workspace").classList.add("live");
+    await loadPersona(agentId);
+    $("prompt-input").focus();
+  } catch (e) {
+    $("setup-err").textContent = "network error opening session";
+    $("start-btn").disabled = false;
+  }
+}
+
+// ---- transcript ----
+// Live Markdown: accumulate the turn's raw response, re-render the whole
+// bubble each delta via markdownSafe (escape-first, whitelist subset).
+function appendResponse(text) {
+  LIVE.resp += text;
+  let bubble = document.querySelector("#transcript .response.live");
+  if (!bubble) {
+    bubble = document.createElement("div");
+    bubble.className = "response live md-body";
+    $("transcript").appendChild(bubble);
+  }
+  bubble.innerHTML = markdownSafe(LIVE.resp);
+  $("transcript").scrollTop = $("transcript").scrollHeight;
+}
+function finalizeResponse() {
+  const live = document.querySelector("#transcript .response.live");
+  if (live) live.classList.remove("live");
+}
+// Thinking: same live-Markdown treatment into the current turn's block.
+function appendThinking(text) {
+  LIVE.think += text;
+  let block = document.querySelector("#pane-thinking .think-live");
+  if (!block) {
+    const empty = $("pane-thinking").querySelector(".empty");
+    if (empty) empty.remove();
+    block = document.createElement("div");
+    block.className = "think-live md-body";
+    $("pane-thinking").appendChild(block);
+  }
+  block.innerHTML = markdownSafe(LIVE.think);
+  $("pane-thinking").scrollTop = $("pane-thinking").scrollHeight;
+  bumpBadge("thinking");
+}
+
+// ---- turn ----
+async function submitPrompt() {
+  const input = $("prompt-input");
+  const content = input.value.trim();
+  if (!content || !state.sessionId || state.turnId) return;
+  input.value = "";
+
+  const echo = document.createElement("div");
+  echo.className = "prompt-echo";
+  echo.textContent = content;
+  $("transcript").appendChild(echo);
+
+  let r;
+  try {
+    r = await fetch("/api/turns/" + encodeURIComponent(state.sessionId), {
+      method: "POST", headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ content }),
+    });
+  } catch (e) {
+    appendTo("pane-debug", `<div>[${ts()}] submit_failed network_error</div>`);
+    return;
+  }
+  if (r.status !== 200) {
+    appendTo("pane-debug", `<div>[${ts()}] submit_failed status=${r.status}</div>`);
+    return;
+  }
+  const { turn_id } = await r.json();
+  state.turnId = turn_id;
+  setConn("streaming", "streaming");
+  $("composer").classList.add("streaming");
+
+  const head = document.createElement("div");
+  head.className = "turn-header";
+  head.textContent = "turn " + turn_id;
+  $("transcript").appendChild(head);
+
+  // Reset per-turn live buffers; lay down a labeled divider in the
+  // thinking pane and close the prior turn's live thinking block so each
+  // turn's chain-of-thought renders as its own break-separated section.
+  LIVE.resp = ""; LIVE.think = "";
+  const tp = $("pane-thinking");
+  const tpEmpty = tp.querySelector(".empty");
+  if (tpEmpty) tpEmpty.remove();
+  tp.querySelectorAll(".think-live").forEach((b) => b.classList.remove("think-live"));
+  const tdiv = document.createElement("div");
+  tdiv.className = "pane-turn";
+  tdiv.textContent = "turn " + turn_id;
+  tp.appendChild(tdiv);
+
+  const url = "/api/turns/" + encodeURIComponent(state.sessionId) + "/stream?turn_id=" + turn_id;
+  const es = new EventSource(url);
+  state.eventSource = es;
+  let textDeltas = 0, thinkingDeltas = 0, heartbeats = 0;
+  const turnStart = Date.now();
+  const audit = (line) => appendTo("pane-debug", `<div>[${ts()}] ${esc(line)}</div>`);
+
+  audit("turn_open turn_id=" + turn_id);
+
+  es.addEventListener("worker_phase", (e) => {
+    const d = JSON.parse(e.data);
+    audit("worker_phase phase=" + d.phase + " turn_id=" + d.turn_id);
+  });
+  es.addEventListener("thinking", (e) => {
+    const d = JSON.parse(e.data);
+    thinkingDeltas += 1;
+    appendThinking(d.content);
+  });
+  es.addEventListener("text", (e) => {
+    const d = JSON.parse(e.data);
+    textDeltas += 1;
+    appendResponse(d.content);
+  });
+  es.addEventListener("text_boundary", (e) => {
+    const d = JSON.parse(e.data);
+    audit("text_boundary kind=" + d.kind + " offset=" + d.char_offset);
+  });
+  es.addEventListener("tool_start", (e) => {
+    const d = JSON.parse(e.data);
+    appendTo("pane-tools",
+      `<div>· <span style="color:var(--cyan)">tool_start</span> name=${esc(d.name)} args=${esc(JSON.stringify(d.arguments))}</div>`);
+  });
+  es.addEventListener("tool_result", (e) => {
+    const d = JSON.parse(e.data);
+    appendTo("pane-tools",
+      `<div>· <span style="color:var(--green)">tool_result</span> name=${esc(d.name)} duration_ms=${esc(d.duration_ms)}</div>`);
+  });
+  es.addEventListener("awaiting_llm_first_token", (e) => {
+    const d = JSON.parse(e.data);
+    heartbeats += 1;
+    let el = document.querySelector("#transcript .awaiting.live");
+    if (!el) {
+      el = document.createElement("div");
+      el.className = "awaiting live";
+      $("transcript").appendChild(el);
+    }
+    el.firstChild ? (el.firstChild.textContent =
+        "awaiting first token · " + (d.elapsed_ms_since_building_prompt / 1000).toFixed(1) + "s ")
+      : el.append(document.createTextNode(
+        "awaiting first token · " + (d.elapsed_ms_since_building_prompt / 1000).toFixed(1) + "s "));
+  });
+  es.addEventListener("affect_update", (e) => {
+    const d = JSON.parse(e.data);
+    audit("affect_update status=" + d.status + " turn_id=" + d.turn_id);
+    if (d.status === "current" && d.snapshot) {
+      renderPersonaPane(d.snapshot);
+      setPersonaStrip(d.snapshot);
+    }
+  });
+
+  function terminal(label, cls, e) {
+    const aw = document.querySelector("#transcript .awaiting.live");
+    if (aw) aw.remove();
+    finalizeResponse();
+    document.querySelectorAll("#pane-thinking .think-live").forEach((b) => b.classList.remove("think-live"));
+    let meta = "";
+    try { meta = e && e.data ? JSON.parse(e.data) && summarizeTerminal(cls, JSON.parse(e.data)) : ""; } catch (_) { meta = ""; }
+    const chip = document.createElement("div");
+    chip.className = "chip " + cls;
+    chip.innerHTML = `<span class="lbl">${esc(label)}</span>` + (meta ? `<span class="meta">${esc(meta)}</span>` : "");
+    $("transcript").appendChild(chip);
+    $("transcript").scrollTop = $("transcript").scrollHeight;
+    const elapsed = Math.round((Date.now() - turnStart) / 100) / 10;
+    audit(`turn_summary turn_id=${turn_id} text_deltas=${textDeltas} thinking_deltas=${thinkingDeltas} heartbeats=${heartbeats} elapsed_s=${elapsed}`);
+    es.close();
+    state.eventSource = null; state.turnId = null;
+    $("composer").classList.remove("streaming");
+    setConn(cls === "error" ? "error" : "idle", cls === "error" ? "error" : "connected");
+    $("prompt-input").focus();
+  }
+  es.addEventListener("done", (e) => terminal("done", "done", e));
+  es.addEventListener("error", (e) => terminal("error", "error", e));
+  es.addEventListener("cancelled", (e) => terminal("cancelled", "cancelled", e));
+  es.onerror = () => {
+    audit("sse_connection_dropped turn_id=" + turn_id);
+    es.close();
+    state.eventSource = null; state.turnId = null;
+    $("composer").classList.remove("streaming");
+    setConn("idle", "connected");
+  };
+}
+
+function summarizeTerminal(cls, d) {
+  if (cls === "done") return `model=${d.model} duration_ms=${d.duration_ms}`;
+  if (cls === "error") return `code=${d.error_code} ${d.message || ""}`;
+  if (cls === "cancelled") return `reason=${d.reason}`;
+  return "";
+}
+
+async function cancelTurn() {
+  if (!state.sessionId || !state.turnId) return;
+  try {
+    await fetch("/api/turns/" + encodeURIComponent(state.sessionId) +
+                "/cancel?turn_id=" + state.turnId, { method: "POST" });
+  } catch (_) {}
+}
+
+// ---- tabs ----
+function activateTab(tab) {
+  document.querySelectorAll(".tab").forEach((x) => x.classList.remove("active"));
+  document.querySelectorAll(".pane").forEach((x) => x.classList.remove("active"));
+  tab.classList.add("active");
+  const pane = tab.dataset.pane;
+  $("pane-" + pane).classList.add("active");
+  $("pane-name").textContent = pane;
+}
+document.querySelectorAll(".tab").forEach((t) =>
+  t.addEventListener("click", () => activateTab(t)));
+
+// ---- keyboard ----
+document.addEventListener("keydown", (e) => {
+  if (e.ctrlKey && ["1", "2", "3", "4"].includes(e.key)) {
+    const tabs = document.querySelectorAll(".tab");
+    const idx = parseInt(e.key, 10) - 1;
+    if (tabs[idx]) { activateTab(tabs[idx]); e.preventDefault(); }
+  }
+  if (e.ctrlKey && e.key === "c" && state.turnId) { cancelTurn(); e.preventDefault(); }
+});
+
+// ---- copy active pane ----
+$("copy-btn").addEventListener("click", () => {
+  const active = document.querySelector(".pane.active");
+  if (!active) return;
+  navigator.clipboard.writeText(active.textContent || "").then(() => {
+    const btn = $("copy-btn");
+    btn.classList.add("copied"); btn.textContent = "copied";
+    setTimeout(() => { btn.classList.remove("copied"); btn.textContent = "copy"; }, 1200);
+  });
+});
+
+// ---- wiring ----
+$("start-btn").addEventListener("click", startSession);
+$("send-btn").addEventListener("click", submitPrompt);
+$("cancel-btn").addEventListener("click", cancelTurn);
+$("prompt-input").addEventListener("keydown", (e) => {
+  if (e.key === "Enter" && !e.shiftKey) { e.preventDefault(); submitPrompt(); }
+});
+
+loadAgents();
+loadVersion();
+</script>
+</body>
+</html>

tests/fixtures/presentation_contract.json

@@ -0,0 +1,125 @@
+{
+  "_contract_version": "0.15.0",
+  "_provenance": "Issue #16 INV-008 — server-side proxy serialization shape. One entry per Event type defined in ratatoskr.sse_client. The JS presenter in static/index.html renders against the `data` shape; if either side changes, both must update in lockstep.",
+
+  "worker_phase": {
+    "event_type": "worker_phase",
+    "data": {
+      "sse_id": "42:3",
+      "phase": "BuildingPrompt",
+      "turn_id": 42
+    }
+  },
+
+  "thinking": {
+    "event_type": "thinking",
+    "data": {
+      "sse_id": "42:5",
+      "content": "Let me think..."
+    }
+  },
+
+  "text": {
+    "event_type": "text",
+    "data": {
+      "sse_id": "42:7",
+      "content": "Hello there"
+    }
+  },
+
+  "text_boundary": {
+    "event_type": "text_boundary",
+    "data": {
+      "sse_id": "42:8",
+      "kind": "sentence",
+      "char_offset": 11,
+      "ts": "2026-05-28T00:00:00Z"
+    }
+  },
+
+  "tool_start": {
+    "event_type": "tool_start",
+    "data": {
+      "sse_id": "42:9",
+      "name": "search",
+      "arguments": {"q": "ratatoskr"}
+    }
+  },
+
+  "tool_result": {
+    "event_type": "tool_result",
+    "data": {
+      "sse_id": "42:10",
+      "name": "search",
+      "result": {"n": 1},
+      "duration_ms": 12
+    }
+  },
+
+  "done": {
+    "event_type": "done",
+    "data": {
+      "sse_id": "42:11",
+      "phase": "succeeded",
+      "response": "Hello there",
+      "model": "qwen3.6-35-a3b",
+      "duration_ms": 1234,
+      "usage": {
+        "prompt_tokens": 100,
+        "completion_tokens": 50,
+        "total_tokens": 150,
+        "cached_input_tokens": 0
+      }
+    }
+  },
+
+  "error": {
+    "event_type": "error",
+    "data": {
+      "sse_id": "42:11",
+      "phase": "failed",
+      "message": "llm output invalid",
+      "error_code": "llm_output_invalid"
+    }
+  },
+
+  "cancelled": {
+    "event_type": "cancelled",
+    "data": {
+      "sse_id": "42:11",
+      "phase": "cancelled",
+      "turn_id": 42,
+      "reason": "user_cancel",
+      "partial_message_id": null
+    }
+  },
+
+  "affect_update": {
+    "event_type": "affect_update",
+    "data": {
+      "sse_id": "42:1",
+      "status": "current",
+      "turn_id": 42,
+      "snapshot": {
+        "agent_id": "mimir",
+        "pad": {"pleasure": 0.52, "arousal": 0.47, "dominance": 0.50},
+        "dominant_emotion": "curiosity",
+        "emotions_active": [
+          {"type": "curiosity", "intensity": 0.6, "decay_remaining_s": 202.7}
+        ],
+        "baseline_pad": {"pleasure": 0.50, "arousal": 0.40, "dominance": 0.50},
+        "mood_drift": {"valence_delta": 0.02, "arousal_delta": 0.07},
+        "last_updated_at": "2026-05-28T00:00:00+00:00"
+      }
+    }
+  },
+
+  "awaiting_llm_first_token": {
+    "event_type": "awaiting_llm_first_token",
+    "data": {
+      "sse_id": "42:2",
+      "turn_id": 42,
+      "elapsed_ms_since_building_prompt": 5012.3
+    }
+  }
+}

tests/test_cli.py

@@ -176,11 +176,37 @@ class TestParseArgs:
         with pytest.raises(UsageError, match="pass exactly one"):
             _parse_args(["--send", "hi", "--api-key", "k"])
 
-    def test_usage_new_without_agent(self) -> None:
-        """usage_new_without_agent: --new without --agent → UsageError."""
+    def test_usage_send_new_without_agent(self) -> None:
+        """send_new_without_agent (issue #8): --send --new without --agent → UsageError.
+
+        --send mode is non-interactive — cannot prompt; --agent stays required.
+        """
         with pytest.raises(UsageError, match="--agent is required when --new"):
             _parse_args(["--send", "hi", "--new", "--api-key", "k"])
 
+    def test_parse_bare_new_without_agent_accepted(self) -> None:
+        """bare_new_without_agent (issue #8): --new without --send or --agent → agent_id=None.
+
+        TUI mode CAN prompt; startup picker handles the choice. _parse_args
+        accepts None here and the TUI's _resolve_then_run drives the picker.
+        """
+        args = _parse_args(["--new", "--api-key", "k"])
+        assert args.new is True
+        assert args.agent_id is None
+        assert args.send_content is None
+
+    def test_parse_bare_new_with_agent_accepted(self) -> None:
+        """bare_new_with_agent (issue #8): --new --agent mimir (no --send) → picker skipped.
+
+        Existing TUI launch path with an explicit agent_id continues to work
+        — _resolve_then_run sees `args.agent_id is not None` and skips the
+        picker entirely.
+        """
+        args = _parse_args(["--new", "--agent", "mimir", "--api-key", "k"])
+        assert args.new is True
+        assert args.agent_id == "mimir"
+        assert args.send_content is None
+
     def test_usage_session_with_agent(self) -> None:
         """usage_session_with_agent: --session AND --agent → UsageError."""
         with pytest.raises(UsageError, match="forbidden with --session"):

tests/test_local_agents.py

@@ -0,0 +1,187 @@
+"""Tests for ratatoskr.local_agents.
+
+Use ``$RATATOSKR_LOCAL_AGENTS`` env-var override + pytest tmp_path to
+isolate from the operator's real ``~/.config/ratatoskr/local_agents.json``.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import pytest
+
+from ratatoskr.local_agents import (
+    LocalAgentEntry,
+    _local_agents_path,
+    add_local_agent,
+    load_local_agents,
+    make_description,
+    remove_local_agent,
+    update_local_agent,
+)
+
+
+@pytest.fixture
+def local_path(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> Path:
+    """Point $RATATOSKR_LOCAL_AGENTS at a fresh tmp file for the test."""
+    path = tmp_path / "local_agents.json"
+    monkeypatch.setenv("RATATOSKR_LOCAL_AGENTS", str(path))
+    return path
+
+
+def _entry(
+    agent_id: str = "ratatoskr:wizard",
+    agent_name: str = "wizard",
+    model: str = "qwen3.6-35-a3b",
+    description: str = "(tier 3) test agent",
+    defined_at: str = "2026-05-25T00:00:00+00:00",
+) -> LocalAgentEntry:
+    return LocalAgentEntry(
+        agent_id=agent_id,
+        agent_name=agent_name,
+        model=model,
+        description=description,
+        defined_at=defined_at,
+    )
+
+
+class TestPathResolution:
+    def test_env_override(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        monkeypatch.setenv("RATATOSKR_LOCAL_AGENTS", "/tmp/custom-agents.json")
+        assert _local_agents_path() == Path("/tmp/custom-agents.json")
+
+    def test_xdg_config_home(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        monkeypatch.delenv("RATATOSKR_LOCAL_AGENTS", raising=False)
+        monkeypatch.setenv("XDG_CONFIG_HOME", "/tmp/xdg-config")
+        assert (
+            _local_agents_path()
+            == Path("/tmp/xdg-config/ratatoskr/local_agents.json")
+        )
+
+    def test_default_home(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        monkeypatch.delenv("RATATOSKR_LOCAL_AGENTS", raising=False)
+        monkeypatch.delenv("XDG_CONFIG_HOME", raising=False)
+        path = _local_agents_path()
+        assert path == Path.home() / ".config" / "ratatoskr" / "local_agents.json"
+
+
+class TestLoadEmpty:
+    def test_missing_file_returns_empty(self, local_path: Path) -> None:
+        assert not local_path.exists()
+        assert load_local_agents() == []
+
+    def test_corrupt_json_returns_empty(self, local_path: Path) -> None:
+        local_path.parent.mkdir(parents=True, exist_ok=True)
+        local_path.write_text("not json at all")
+        assert load_local_agents() == []
+
+    def test_wrong_schema_version_returns_empty(self, local_path: Path) -> None:
+        local_path.parent.mkdir(parents=True, exist_ok=True)
+        local_path.write_text(json.dumps({"version": 999, "agents": []}))
+        assert load_local_agents() == []
+
+    def test_missing_version_key_returns_empty(self, local_path: Path) -> None:
+        local_path.parent.mkdir(parents=True, exist_ok=True)
+        local_path.write_text(json.dumps({"agents": []}))
+        assert load_local_agents() == []
+
+    def test_malformed_row_skipped(self, local_path: Path) -> None:
+        local_path.parent.mkdir(parents=True, exist_ok=True)
+        local_path.write_text(
+            json.dumps(
+                {
+                    "version": 1,
+                    "agents": [
+                        {"agent_id": "incomplete"},  # missing required fields
+                        {
+                            "agent_id": "ratatoskr:good",
+                            "agent_name": "good",
+                            "model": "m",
+                            "description": "d",
+                            "defined_at": "t",
+                        },
+                    ],
+                }
+            )
+        )
+        entries = load_local_agents()
+        assert len(entries) == 1
+        assert entries[0].agent_id == "ratatoskr:good"
+
+
+class TestAdd:
+    def test_add_one(self, local_path: Path) -> None:
+        add_local_agent(_entry())
+        entries = load_local_agents()
+        assert len(entries) == 1
+        assert entries[0].agent_id == "ratatoskr:wizard"
+
+    def test_add_two_different(self, local_path: Path) -> None:
+        add_local_agent(_entry(agent_id="ratatoskr:a", agent_name="a"))
+        add_local_agent(_entry(agent_id="ratatoskr:b", agent_name="b"))
+        ids = {e.agent_id for e in load_local_agents()}
+        assert ids == {"ratatoskr:a", "ratatoskr:b"}
+
+    def test_add_replaces_same_id(self, local_path: Path) -> None:
+        add_local_agent(_entry(model="old-model"))
+        add_local_agent(_entry(model="new-model"))
+        entries = load_local_agents()
+        assert len(entries) == 1
+        assert entries[0].model == "new-model"
+
+    def test_creates_parent_dirs(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        nested = tmp_path / "deep" / "nested" / "path" / "agents.json"
+        monkeypatch.setenv("RATATOSKR_LOCAL_AGENTS", str(nested))
+        add_local_agent(_entry())
+        assert nested.exists()
+
+
+class TestUpdate:
+    def test_update_changes_existing(self, local_path: Path) -> None:
+        add_local_agent(_entry(model="v1"))
+        update_local_agent(_entry(model="v2"))
+        entries = load_local_agents()
+        assert len(entries) == 1
+        assert entries[0].model == "v2"
+
+
+class TestRemove:
+    def test_remove_existing(self, local_path: Path) -> None:
+        add_local_agent(_entry())
+        remove_local_agent("ratatoskr:wizard")
+        assert load_local_agents() == []
+
+    def test_remove_missing_is_noop(self, local_path: Path) -> None:
+        add_local_agent(_entry())
+        remove_local_agent("ratatoskr:doesnotexist")
+        assert len(load_local_agents()) == 1
+
+
+class TestMakeDescription:
+    def test_first_nonempty_line(self) -> None:
+        prompt = "\n\n# IDENTITY\nYou are a test agent..."
+        desc = make_description(prompt)
+        assert desc.startswith("(tier 3) IDENTITY")
+
+    def test_strips_heading_markers(self) -> None:
+        prompt = "# A nice heading\nMore prompt..."
+        desc = make_description(prompt)
+        assert "(tier 3) A nice heading" == desc
+
+    def test_truncates_long(self) -> None:
+        prompt = "x" * 200
+        desc = make_description(prompt)
+        # 80 char cap including the prefix
+        assert len(desc) == 81  # 80 + ellipsis char
+        assert desc.endswith("…")
+
+    def test_empty_prompt_fallback(self) -> None:
+        desc = make_description("")
+        assert desc == "(tier 3) custom system prompt"
+
+    def test_whitespace_only_fallback(self) -> None:
+        desc = make_description("   \n\n  ")
+        assert desc == "(tier 3) custom system prompt"

tests/test_sessions.py

@@ -5,11 +5,17 @@ import pytest
 import respx
 
 from ratatoskr.sessions import (
+    AgentInfo,
+    AgentNotAvailable,
     AgentNotFound,
+    AuthScopeDenied,
     InvalidCursor,
+    PersonaNotConfigured,
     SessionApiFailed,
     SessionPage,
     create_session,
+    get_persona_state,
+    list_agents,
     list_sessions,
 )
 
@@ -412,3 +418,290 @@ class TestListSessions:
             with pytest.raises(AssertionError):
                 await list_sessions(client, cursor="")
         assert route.call_count == 0
+
+
+# ---- Issue #8: list_agents + AgentInfo --------------------------------------
+
+
+class TestListAgents:
+    @respx.mock
+    async def test_happy_full_shape(self) -> None:
+        """happy_full_shape [happy,tracer]: spec full-shape mimir example → all fields."""
+        respx.get("https://w.example/agents").mock(
+            return_value=httpx.Response(
+                200,
+                json=[
+                    {
+                        "agent_id": "mimir",
+                        "name": "Mimir",
+                        "description": "Keeper of the Well of Knowledge.",
+                        "version": "0.2.0",
+                        "capabilities": ["knowledge_base", "semantic_search"],
+                        "supported_models": ["default", "heavy"],
+                        "persona_traits": {
+                            "ocean": {
+                                "openness": 0.7,
+                                "conscientiousness": 0.9,
+                                "extraversion": 0.1,
+                                "agreeableness": 0.5,
+                                "neuroticism": 0.3,
+                            },
+                            "vibe": "contemplative",
+                        },
+                        "ui_hints": {"icon": "well", "color_hint": "#5b8aa3"},
+                    }
+                ],
+            )
+        )
+        async with httpx.AsyncClient(base_url="https://w.example") as client:
+            agents = await list_agents(client)
+        assert len(agents) == 1
+        a = agents[0]
+        assert isinstance(a, AgentInfo)
+        assert a.agent_id == "mimir"
+        assert a.name == "Mimir"
+        assert a.description == "Keeper of the Well of Knowledge."
+        assert a.version == "0.2.0"
+        assert a.capabilities == ["knowledge_base", "semantic_search"]
+        assert a.supported_models == ["default", "heavy"]
+        assert a.persona_traits["vibe"] == "contemplative"
+        assert a.ui_hints["icon"] == "well"
+
+    @respx.mock
+    async def test_happy_minimum_shape(self) -> None:
+        """happy_minimum_shape: required-only agent → optional fields default."""
+        respx.get("https://w.example/agents").mock(
+            return_value=httpx.Response(
+                200,
+                json=[
+                    {
+                        "agent_id": "minimal",
+                        "name": "Minimal Agent",
+                        "description": "Just a sketch.",
+                    }
+                ],
+            )
+        )
+        async with httpx.AsyncClient(base_url="https://w.example") as client:
+            agents = await list_agents(client)
+        a = agents[0]
+        assert a.agent_id == "minimal"
+        assert a.version is None
+        assert a.capabilities == []
+        assert a.supported_models == []
+        assert a.persona_traits == {}
+        assert a.ui_hints == {}
+
+    @respx.mock
+    async def test_happy_multi_agent(self) -> None:
+        """happy_multi_agent: 3 agents preserve order."""
+        respx.get("https://w.example/agents").mock(
+            return_value=httpx.Response(
+                200,
+                json=[
+                    {"agent_id": "a", "name": "A", "description": "x"},
+                    {"agent_id": "b", "name": "B", "description": "y"},
+                    {"agent_id": "c", "name": "C", "description": "z"},
+                ],
+            )
+        )
+        async with httpx.AsyncClient(base_url="https://w.example") as client:
+            agents = await list_agents(client)
+        assert [a.agent_id for a in agents] == ["a", "b", "c"]
+
+    @respx.mock
+    async def test_happy_empty(self) -> None:
+        """happy_empty: 200 with [] returns empty list (no error)."""
+        respx.get("https://w.example/agents").mock(
+            return_value=httpx.Response(200, json=[])
+        )
+        async with httpx.AsyncClient(base_url="https://w.example") as client:
+            agents = await list_agents(client)
+        assert agents == []
+
+    @respx.mock
+    async def test_omit_capabilities_empty_list(self) -> None:
+        """omit_capabilities_empty: explicit [] from server still defaults to []."""
+        respx.get("https://w.example/agents").mock(
+            return_value=httpx.Response(
+                200,
+                json=[
+                    {
+                        "agent_id": "a",
+                        "name": "A",
+                        "description": "x",
+                        "capabilities": [],
+                    }
+                ],
+            )
+        )
+        async with httpx.AsyncClient(base_url="https://w.example") as client:
+            agents = await list_agents(client)
+        assert agents[0].capabilities == []
+
+    @respx.mock
+    async def test_500_raises_session_api_failed(self) -> None:
+        """500 → SessionApiFailed with status=500."""
+        respx.get("https://w.example/agents").mock(
+            return_value=httpx.Response(500, content=b"oops")
+        )
+        async with httpx.AsyncClient(base_url="https://w.example") as client:
+            with pytest.raises(SessionApiFailed) as excinfo:
+                await list_agents(client)
+        assert excinfo.value.status == 500
+
+    @respx.mock
+    async def test_401_raises_session_api_failed(self) -> None:
+        """401 → SessionApiFailed with status=401."""
+        respx.get("https://w.example/agents").mock(
+            return_value=httpx.Response(401, content=b'{"error":"unauthorized"}')
+        )
+        async with httpx.AsyncClient(base_url="https://w.example") as client:
+            with pytest.raises(SessionApiFailed) as excinfo:
+                await list_agents(client)
+        assert excinfo.value.status == 401
+
+
+class TestGetPersonaState:
+    """Worldtree #204 / v0.28.0 — GET /agents/{agent_id}/persona_state.
+
+    Bootstrap read for the persona snapshot — same shape as `affect_update`'s
+    `current` snapshot. Auth via `persona.read` scope (user-tier default).
+    """
+
+    @respx.mock
+    async def test_happy_full_snapshot(self) -> None:
+        """happy_full_snapshot [happy,tracer]: 200 → snapshot dict with pad +
+        dominant_emotion + emotions_active + baseline_pad + mood_drift.
+        """
+        snapshot = {
+            "agent_id": "mimir",
+            "pad": {"pleasure": 0.52, "arousal": 0.47, "dominance": 0.50},
+            "dominant_emotion": "curiosity",
+            "emotions_active": [
+                {"type": "curiosity", "intensity": 0.6, "decay_remaining_s": 202.7}
+            ],
+            "baseline_pad": {"pleasure": 0.50, "arousal": 0.40, "dominance": 0.50},
+            "mood_drift": {"valence_delta": 0.02, "arousal_delta": 0.07},
+            "last_updated_at": "2026-05-25T22:30:18+00:00",
+        }
+        respx.get("https://w.example/agents/mimir/persona_state").mock(
+            return_value=httpx.Response(200, json=snapshot)
+        )
+        async with httpx.AsyncClient(base_url="https://w.example") as client:
+            result = await get_persona_state(client, "mimir")
+        assert result == snapshot
+
+    @respx.mock
+    async def test_persona_not_configured_404(self) -> None:
+        """persona_not_configured_404 [error]: 404 with error_code
+        persona_not_configured → PersonaNotConfigured. Agent exists but has
+        no persona surface (e.g. domari, muninn, Tier 3).
+        """
+        respx.get("https://w.example/agents/domari/persona_state").mock(
+            return_value=httpx.Response(
+                404, json={"error_code": "persona_not_configured", "message": "no persona"}
+            )
+        )
+        async with httpx.AsyncClient(base_url="https://w.example") as client:
+            with pytest.raises(PersonaNotConfigured) as exc_info:
+                await get_persona_state(client, "domari")
+        assert exc_info.value.agent_id == "domari"
+
+    @respx.mock
+    async def test_agent_not_available_404(self) -> None:
+        """agent_not_available_404 [error]: 404 with error_code
+        agent_not_available → AgentNotAvailable. Distinct from
+        persona_not_configured — the agent_id itself is unknown.
+        """
+        respx.get("https://w.example/agents/bogus/persona_state").mock(
+            return_value=httpx.Response(
+                404, json={"error_code": "agent_not_available", "message": "unknown agent"}
+            )
+        )
+        async with httpx.AsyncClient(base_url="https://w.example") as client:
+            with pytest.raises(AgentNotAvailable) as exc_info:
+                await get_persona_state(client, "bogus")
+        assert exc_info.value.agent_id == "bogus"
+
+    @respx.mock
+    async def test_auth_scope_denied_403(self) -> None:
+        """auth_scope_denied_403 [error]: 403 with error_code auth_scope_denied
+        → AuthScopeDenied. Key lacks `persona.read` scope.
+        """
+        respx.get("https://w.example/agents/mimir/persona_state").mock(
+            return_value=httpx.Response(
+                403,
+                json={"error_code": "auth_scope_denied", "message": "missing persona.read"},
+            )
+        )
+        async with httpx.AsyncClient(base_url="https://w.example") as client:
+            with pytest.raises(AuthScopeDenied) as exc_info:
+                await get_persona_state(client, "mimir")
+        assert exc_info.value.scope == "persona.read"
+
+    @respx.mock
+    async def test_404_unknown_error_code_falls_through(self) -> None:
+        """404_unknown_error_code_falls_through [adversarial]: 404 without the
+        two known error codes → SessionApiFailed (don't swallow novel failure
+        modes as something more specific than they are).
+        """
+        respx.get("https://w.example/agents/mimir/persona_state").mock(
+            return_value=httpx.Response(404, json={"error_code": "novel_404"})
+        )
+        async with httpx.AsyncClient(base_url="https://w.example") as client:
+            with pytest.raises(SessionApiFailed) as exc_info:
+                await get_persona_state(client, "mimir")
+        assert exc_info.value.status == 404
+
+    @respx.mock
+    async def test_500_unexpected_status(self) -> None:
+        """500_unexpected_status [error]: 5xx → SessionApiFailed (matches the
+        list_agents / list_sessions / create_session precedent)."""
+        respx.get("https://w.example/agents/mimir/persona_state").mock(
+            return_value=httpx.Response(500, content=b"boom")
+        )
+        async with httpx.AsyncClient(base_url="https://w.example") as client:
+            with pytest.raises(SessionApiFailed) as exc_info:
+                await get_persona_state(client, "mimir")
+        assert exc_info.value.status == 500
+
+    @respx.mock
+    async def test_auth_scope_denied_detail_envelope(self) -> None:
+        """auth_scope_denied_detail_envelope [regression]: real Worldtree
+        returns `{"detail": {"error_code": "auth_scope_denied", …}}`
+        (FastAPI default), not flat `{"error_code": …}`. Smoke against
+        personal:8081 2026-05-28 surfaced this — pre-fix the response
+        fell through to SessionApiFailed(403) instead of AuthScopeDenied.
+        """
+        respx.get("https://w.example/agents/mimir/persona_state").mock(
+            return_value=httpx.Response(
+                403,
+                json={
+                    "detail": {
+                        "error_code": "auth_scope_denied",
+                        "message": "Missing required scope: persona.read",
+                    }
+                },
+            )
+        )
+        async with httpx.AsyncClient(base_url="https://w.example") as client:
+            with pytest.raises(AuthScopeDenied) as exc_info:
+                await get_persona_state(client, "mimir")
+        assert exc_info.value.scope == "persona.read"
+
+    @respx.mock
+    async def test_persona_not_configured_detail_envelope(self) -> None:
+        """persona_not_configured_detail_envelope [regression]: same
+        envelope-shape unwrap on 404 + persona_not_configured.
+        """
+        respx.get("https://w.example/agents/domari/persona_state").mock(
+            return_value=httpx.Response(
+                404,
+                json={"detail": {"error_code": "persona_not_configured"}},
+            )
+        )
+        async with httpx.AsyncClient(base_url="https://w.example") as client:
+            with pytest.raises(PersonaNotConfigured) as exc_info:
+                await get_persona_state(client, "domari")
+        assert exc_info.value.agent_id == "domari"

tests/test_sse_client.py

@@ -5,6 +5,8 @@ import pytest
 import respx
 
 from ratatoskr.sse_client import (
+    AffectUpdate,
+    AwaitingLlmFirstToken,
     CancelAlreadyCompleted,
     Cancelled,
     CancelResult,
@@ -711,6 +713,47 @@ def _sse_raw_chunk(sse_id: str, raw_data: str) -> bytes:
     return f"id: {sse_id}\ndata: {raw_data}\n\n".encode()
 
 
+def _sse_no_id_chunk(data: str) -> bytes:
+    """SSE frame with NO id line + arbitrary data (v0.8.1: keepalive shape)."""
+    return f"data: {data}\n\n".encode()
+
+
+class TestEmptyIdSkipped:
+    @respx.mock
+    async def test_empty_id_on_first_event_skipped(self) -> None:
+        """empty_id_on_first_event_skipped [v0.8.1]: stream starts with an
+        event carrying NO `id:` line → httpx_sse exposes sse.id == ''
+        (no prior id to inherit). Pre-v0.8.1: MalformedSseId raw='' crashed
+        the turn. v0.8.1: treat same as empty-data keepalive — skip silently.
+
+        Observed 2026-05-25 on Worldtree's qwen3.6-35-a3b-heretic provider:
+        the first stream frame had no id line, every turn died with
+        `[malformed_sse_id] raw=''`.
+        """
+        from ratatoskr.sse_client import Done as _Done
+        from ratatoskr.sse_client import Text as _Text
+
+        # First frame: no id line (httpx_sse → sse.id = ""). Skip it.
+        # Subsequent frames have ids; normal processing resumes.
+        stream = (
+            _sse_no_id_chunk('{"type":"keepalive"}')  # ← skipped (sse.id == "")
+            + _sse_chunk("42:1", {"type": "text", "content": "first"})
+            + _sse_chunk("42:2", _DONE_42_6)
+        )
+        respx.post("https://w.example/sessions/s1/messages").mock(
+            return_value=httpx.Response(
+                200, headers={"content-type": "text/event-stream"}, content=stream
+            )
+        )
+        async with httpx.AsyncClient(base_url="https://w.example") as client:
+            events = [e async for e in stream_turn(client, "s1", "hi")]
+        # 2 events — the no-id frame is invisible (no MalformedSseId crash).
+        assert len(events) == 2
+        assert isinstance(events[0], _Text)
+        assert events[0].content == "first"
+        assert isinstance(events[1], _Done)
+
+
 class TestEmptyDataSkipped:
     @respx.mock
     async def test_empty_data_skipped(self) -> None:
@@ -836,3 +879,164 @@ class TestEmptyDataSkipped:
         assert exc_info.value.raw == "x" * 200
         # Exception message also only contains the truncated form
         assert "x" * 5000 not in str(exc_info.value)
+
+
+class TestAffectUpdate:
+    """Worldtree #204 / v0.28.0 — persona-state observability SSE event.
+
+    Two emissions per qualifying turn (persona-enabled agent, non-ephemeral
+    session): `status: "current"` at turn start with full snapshot, then
+    `status: "scheduled"` near turn end (lightweight, no snapshot).
+
+    See docs/conversation-api-spec.md § affect_update.
+    """
+
+    @respx.mock
+    async def test_current_status_parsed_with_snapshot(self) -> None:
+        """current_status_parsed_with_snapshot [tracer]: status=current carries
+        the full snapshot dict; AffectUpdate.snapshot is populated with the
+        nested PAD / dominant_emotion / emotions_active fields.
+        """
+        snapshot = {
+            "agent_id": "mimir",
+            "pad": {"pleasure": 0.52, "arousal": 0.47, "dominance": 0.50},
+            "dominant_emotion": "curiosity",
+            "emotions_active": [
+                {"type": "curiosity", "intensity": 0.6, "decay_remaining_s": 202.7}
+            ],
+            "baseline_pad": {"pleasure": 0.50, "arousal": 0.40, "dominance": 0.50},
+            "mood_drift": {"valence_delta": 0.02, "arousal_delta": 0.07},
+            "last_updated_at": "2026-05-25T22:30:18+00:00",
+        }
+        stream = _sse_chunk(
+            "42:1",
+            {
+                "type": "affect_update",
+                "status": "current",
+                "turn_id": 42,
+                "snapshot": snapshot,
+            },
+        ) + _sse_chunk("42:2", _DONE_42_6)
+        respx.post("https://w.example/sessions/s1/messages").mock(
+            return_value=httpx.Response(
+                200, headers={"content-type": "text/event-stream"}, content=stream
+            )
+        )
+        async with httpx.AsyncClient(base_url="https://w.example") as client:
+            events = [e async for e in stream_turn(client, "s1", "hi")]
+        affect = events[0]
+        assert isinstance(affect, AffectUpdate)
+        assert affect.status == "current"
+        assert affect.turn_id == 42
+        assert affect.snapshot == snapshot
+        assert affect.sse_id == SseId(42, 1)
+
+    @respx.mock
+    async def test_scheduled_status_parsed_no_snapshot(self) -> None:
+        """scheduled_status_parsed_no_snapshot [trace]: status=scheduled carries
+        no snapshot field; AffectUpdate.snapshot is None.
+        """
+        stream = (
+            _sse_chunk("42:1", {"type": "text", "content": "x"})
+            + _sse_chunk(
+                "42:2",
+                {"type": "affect_update", "status": "scheduled", "turn_id": 42},
+            )
+            + _sse_chunk("42:3", _DONE_42_6)
+        )
+        respx.post("https://w.example/sessions/s1/messages").mock(
+            return_value=httpx.Response(
+                200, headers={"content-type": "text/event-stream"}, content=stream
+            )
+        )
+        async with httpx.AsyncClient(base_url="https://w.example") as client:
+            events = [e async for e in stream_turn(client, "s1", "hi")]
+        affect = next(e for e in events if isinstance(e, AffectUpdate))
+        assert affect.status == "scheduled"
+        assert affect.turn_id == 42
+        assert affect.snapshot is None
+        assert affect.sse_id == SseId(42, 2)
+
+
+class TestAwaitingLlmFirstToken:
+    """Worldtree #201 / v0.29.0 — `awaiting_llm_first_token` SSE heartbeat.
+
+    Top-level event (not a worker_phase extension) fired during the
+    BuildingPrompt → CallingLLM gap at the configured interval (default
+    5s). Server-authoritative elapsed_ms is time.monotonic()-based and
+    monotonically increasing across the heartbeat sequence.
+
+    See docs/conversation-api-spec.md § awaiting_llm_first_token.
+    """
+
+    @respx.mock
+    async def test_single_heartbeat_parsed(self) -> None:
+        """single_heartbeat_parsed [tracer]: type=awaiting_llm_first_token →
+        AwaitingLlmFirstToken(turn_id, elapsed_ms_since_building_prompt).
+        """
+        stream = _sse_chunk(
+            "42:1",
+            {
+                "type": "awaiting_llm_first_token",
+                "turn_id": 42,
+                "elapsed_ms_since_building_prompt": 5012.3,
+            },
+        ) + _sse_chunk("42:2", _DONE_42_6)
+        respx.post("https://w.example/sessions/s1/messages").mock(
+            return_value=httpx.Response(
+                200, headers={"content-type": "text/event-stream"}, content=stream
+            )
+        )
+        async with httpx.AsyncClient(base_url="https://w.example") as client:
+            events = [e async for e in stream_turn(client, "s1", "hi")]
+        beat = events[0]
+        assert isinstance(beat, AwaitingLlmFirstToken)
+        assert beat.turn_id == 42
+        assert beat.elapsed_ms_since_building_prompt == 5012.3
+        assert beat.sse_id == SseId(42, 1)
+
+    @respx.mock
+    async def test_heartbeat_sequence_monotonic(self) -> None:
+        """heartbeat_sequence_monotonic [scenario]: three consecutive heartbeats
+        in one turn — elapsed_ms_since_building_prompt monotonically increases,
+        all carry the same turn_id.
+        """
+        stream = (
+            _sse_chunk(
+                "42:1",
+                {
+                    "type": "awaiting_llm_first_token",
+                    "turn_id": 42,
+                    "elapsed_ms_since_building_prompt": 5000.0,
+                },
+            )
+            + _sse_chunk(
+                "42:2",
+                {
+                    "type": "awaiting_llm_first_token",
+                    "turn_id": 42,
+                    "elapsed_ms_since_building_prompt": 10005.4,
+                },
+            )
+            + _sse_chunk(
+                "42:3",
+                {
+                    "type": "awaiting_llm_first_token",
+                    "turn_id": 42,
+                    "elapsed_ms_since_building_prompt": 15011.8,
+                },
+            )
+            + _sse_chunk("42:4", _DONE_42_6)
+        )
+        respx.post("https://w.example/sessions/s1/messages").mock(
+            return_value=httpx.Response(
+                200, headers={"content-type": "text/event-stream"}, content=stream
+            )
+        )
+        async with httpx.AsyncClient(base_url="https://w.example") as client:
+            events = [e async for e in stream_turn(client, "s1", "hi")]
+        beats = [e for e in events if isinstance(e, AwaitingLlmFirstToken)]
+        assert len(beats) == 3
+        elapsed = [b.elapsed_ms_since_building_prompt for b in beats]
+        assert elapsed == sorted(elapsed)  # monotonically increasing
+        assert all(b.turn_id == 42 for b in beats)

tests/test_tier3.py

@@ -0,0 +1,491 @@
+"""Tests for ratatoskr.tier3 per docs/contracts/issues/15.contract.md."""
+
+from pathlib import Path
+
+import httpx
+import pytest
+import respx
+
+from ratatoskr.sessions import SessionApiFailed
+from ratatoskr.tier3 import (
+    Tier3AgentInfo,
+    Tier3AgentNotFound,
+    Tier3FieldNotMutable,
+    Tier3LayerDeferred,
+    Tier3QuotaExceeded,
+    Tier3UserIdUnsupported,
+    define_agent,
+    delete_agent,
+    main,
+    patch_agent,
+)
+
+_FULL_AGENT_RESP = {
+    "agent_id": "ratatoskr:wizard",
+    "user_id": "ratatoskr",
+    "agent_name": "wizard",
+    "system_prompt": "You are a wizard.",
+    "model": "qwen3.6-35-a3b",
+    "created_at": "2026-05-25T03:20:09.703601+00:00",
+    "updated_at": "2026-05-25T03:20:09.703601+00:00",
+}
+
+
+class TestDefineAgent:
+    @respx.mock
+    async def test_happy_define(self) -> None:
+        """happy_define [happy,tracer]: 201 → fully populated Tier3AgentInfo."""
+        respx.post("https://w.example/agents/define").mock(
+            return_value=httpx.Response(201, json=_FULL_AGENT_RESP)
+        )
+        async with httpx.AsyncClient(base_url="https://w.example") as client:
+            info = await define_agent(
+                client,
+                agent_name="wizard",
+                system_prompt="You are a wizard.",
+                model="qwen3.6-35-a3b",
+            )
+        assert isinstance(info, Tier3AgentInfo)
+        assert info.agent_id == "ratatoskr:wizard"
+        assert info.user_id == "ratatoskr"
+        assert info.agent_name == "wizard"
+        assert info.model == "qwen3.6-35-a3b"
+
+    @respx.mock
+    async def test_request_body_shape(self) -> None:
+        """request_body_shape [trace]: outbound JSON is exactly the three keys."""
+        import json as _json
+
+        route = respx.post("https://w.example/agents/define").mock(
+            return_value=httpx.Response(201, json=_FULL_AGENT_RESP)
+        )
+        async with httpx.AsyncClient(base_url="https://w.example") as client:
+            await define_agent(
+                client,
+                agent_name="wizard",
+                system_prompt="You are a wizard.",
+                model="qwen3.6-35-a3b",
+            )
+        body = _json.loads(route.calls[0].request.content)
+        # INV-001: exactly these three keys — no layer fields, no metadata.
+        assert body == {
+            "agent_name": "wizard",
+            "system_prompt": "You are a wizard.",
+            "model": "qwen3.6-35-a3b",
+        }
+
+    @respx.mock
+    async def test_quota_exceeded(self) -> None:
+        """quota_exceeded [error]: 429 + Retry-After → Tier3QuotaExceeded."""
+        respx.post("https://w.example/agents/define").mock(
+            return_value=httpx.Response(
+                429,
+                headers={"Retry-After": "0"},
+                json={"detail": {"error_code": "agent_quota_exceeded"}},
+            )
+        )
+        async with httpx.AsyncClient(base_url="https://w.example") as client:
+            with pytest.raises(Tier3QuotaExceeded) as exc:
+                await define_agent(
+                    client,
+                    agent_name="overflow",
+                    system_prompt="x",
+                    model="m",
+                )
+        assert exc.value.retry_after == 0
+
+    @respx.mock
+    async def test_user_id_unsupported(self) -> None:
+        """user_id_unsupported [error]: 403 + error_code → Tier3UserIdUnsupported."""
+        respx.post("https://w.example/agents/define").mock(
+            return_value=httpx.Response(
+                403, json={"detail": {"error_code": "tier3_user_id_unsupported"}}
+            )
+        )
+        async with httpx.AsyncClient(base_url="https://w.example") as client:
+            with pytest.raises(Tier3UserIdUnsupported):
+                await define_agent(
+                    client, agent_name="wizard", system_prompt="x", model="m"
+                )
+
+    @respx.mock
+    async def test_layer_deferred(self) -> None:
+        """layer_deferred [error]: 422 + layer_deferred → Tier3LayerDeferred(field)."""
+        respx.post("https://w.example/agents/define").mock(
+            return_value=httpx.Response(
+                422,
+                json={"detail": {"error_code": "layer_deferred", "field": "persona"}},
+            )
+        )
+        async with httpx.AsyncClient(base_url="https://w.example") as client:
+            with pytest.raises(Tier3LayerDeferred) as exc:
+                await define_agent(
+                    client, agent_name="wizard", system_prompt="x", model="m"
+                )
+        assert exc.value.field == "persona"
+
+    @respx.mock
+    async def test_bad_slug_assert(self) -> None:
+        """bad_slug_assert [adversarial]: agent_name with uppercase → AssertionError, no HTTP."""
+        route = respx.post("https://w.example/agents/define").mock(
+            return_value=httpx.Response(201, json=_FULL_AGENT_RESP)
+        )
+        async with httpx.AsyncClient(base_url="https://w.example") as client:
+            with pytest.raises(AssertionError):
+                await define_agent(
+                    client, agent_name="Wizard", system_prompt="x", model="m"
+                )
+        assert route.call_count == 0
+
+    @respx.mock
+    async def test_short_slug_assert(self) -> None:
+        """short_slug_assert [adversarial]: agent_name len < 3 → AssertionError."""
+        route = respx.post("https://w.example/agents/define").mock(
+            return_value=httpx.Response(201, json=_FULL_AGENT_RESP)
+        )
+        async with httpx.AsyncClient(base_url="https://w.example") as client:
+            with pytest.raises(AssertionError):
+                await define_agent(
+                    client, agent_name="ab", system_prompt="x", model="m"
+                )
+        assert route.call_count == 0
+
+    @respx.mock
+    async def test_empty_prompt_assert(self) -> None:
+        """empty_prompt_assert [adversarial]: empty system_prompt → AssertionError."""
+        route = respx.post("https://w.example/agents/define").mock(
+            return_value=httpx.Response(201, json=_FULL_AGENT_RESP)
+        )
+        async with httpx.AsyncClient(base_url="https://w.example") as client:
+            with pytest.raises(AssertionError):
+                await define_agent(
+                    client, agent_name="wizard", system_prompt="", model="m"
+                )
+        assert route.call_count == 0
+
+    @respx.mock
+    async def test_other_5xx(self) -> None:
+        """other_5xx [error]: 503 → SessionApiFailed(status=503)."""
+        respx.post("https://w.example/agents/define").mock(
+            return_value=httpx.Response(503, content=b"upstream out")
+        )
+        async with httpx.AsyncClient(base_url="https://w.example") as client:
+            with pytest.raises(SessionApiFailed) as exc:
+                await define_agent(
+                    client, agent_name="wizard", system_prompt="x", model="m"
+                )
+        assert exc.value.status == 503
+
+
+class TestPatchAgent:
+    @respx.mock
+    async def test_happy_patch_both_fields(self) -> None:
+        """happy_patch_both_fields: both fields set → request body has both."""
+        import json as _json
+
+        updated = {
+            **_FULL_AGENT_RESP,
+            "system_prompt": "new prompt",
+            "model": "different-model",
+        }
+        route = respx.patch("https://w.example/agents/ratatoskr:wizard").mock(
+            return_value=httpx.Response(200, json=updated)
+        )
+        async with httpx.AsyncClient(base_url="https://w.example") as client:
+            info = await patch_agent(
+                client,
+                "ratatoskr:wizard",
+                system_prompt="new prompt",
+                model="different-model",
+            )
+        body = _json.loads(route.calls[0].request.content)
+        assert body == {"system_prompt": "new prompt", "model": "different-model"}
+        assert info.system_prompt == "new prompt"
+        assert info.model == "different-model"
+
+    @respx.mock
+    async def test_happy_patch_single_field(self) -> None:
+        """happy_patch_single_field: omit model → body has system_prompt only."""
+        import json as _json
+
+        updated = {**_FULL_AGENT_RESP, "system_prompt": "only this"}
+        route = respx.patch("https://w.example/agents/ratatoskr:wizard").mock(
+            return_value=httpx.Response(200, json=updated)
+        )
+        async with httpx.AsyncClient(base_url="https://w.example") as client:
+            await patch_agent(client, "ratatoskr:wizard", system_prompt="only this")
+        body = _json.loads(route.calls[0].request.content)
+        # INV-002: body omits the None-valued field entirely
+        assert body == {"system_prompt": "only this"}
+
+    @respx.mock
+    async def test_field_not_mutable(self) -> None:
+        """field_not_mutable [error]: 422 + error_code → Tier3FieldNotMutable(field)."""
+        respx.patch("https://w.example/agents/ratatoskr:wizard").mock(
+            return_value=httpx.Response(
+                422,
+                json={
+                    "detail": {"error_code": "field_not_mutable", "field": "agent_name"}
+                },
+            )
+        )
+        async with httpx.AsyncClient(base_url="https://w.example") as client:
+            with pytest.raises(Tier3FieldNotMutable) as exc:
+                await patch_agent(
+                    client, "ratatoskr:wizard", system_prompt="x"
+                )
+        assert exc.value.field == "agent_name"
+
+    @respx.mock
+    async def test_404(self) -> None:
+        """404 [error]: PATCH on non-existent agent → Tier3AgentNotFound."""
+        respx.patch("https://w.example/agents/ratatoskr:ghost").mock(
+            return_value=httpx.Response(404, content=b"")
+        )
+        async with httpx.AsyncClient(base_url="https://w.example") as client:
+            with pytest.raises(Tier3AgentNotFound) as exc:
+                await patch_agent(
+                    client, "ratatoskr:ghost", system_prompt="x"
+                )
+        assert exc.value.agent_id == "ratatoskr:ghost"
+
+    @respx.mock
+    async def test_no_fields_assert(self) -> None:
+        """no_fields_assert [adversarial]: both None → AssertionError, no HTTP."""
+        route = respx.patch("https://w.example/agents/ratatoskr:wizard").mock(
+            return_value=httpx.Response(200, json=_FULL_AGENT_RESP)
+        )
+        async with httpx.AsyncClient(base_url="https://w.example") as client:
+            with pytest.raises(AssertionError):
+                await patch_agent(client, "ratatoskr:wizard")
+        assert route.call_count == 0
+
+    @respx.mock
+    async def test_non_tier3_id_assert(self) -> None:
+        """non_tier3_id_assert [adversarial]: agent_id without `:` → AssertionError."""
+        route = respx.patch("https://w.example/agents/mimir").mock(
+            return_value=httpx.Response(200, json=_FULL_AGENT_RESP)
+        )
+        async with httpx.AsyncClient(base_url="https://w.example") as client:
+            with pytest.raises(AssertionError):
+                await patch_agent(client, "mimir", system_prompt="x")
+        assert route.call_count == 0
+
+
+class TestDeleteAgent:
+    @respx.mock
+    async def test_happy_delete(self) -> None:
+        """happy_delete [happy,tracer]: 204 → returns None."""
+        respx.delete("https://w.example/agents/ratatoskr:wizard").mock(
+            return_value=httpx.Response(204)
+        )
+        async with httpx.AsyncClient(base_url="https://w.example") as client:
+            result = await delete_agent(client, "ratatoskr:wizard")
+        assert result is None
+
+    @respx.mock
+    async def test_404(self) -> None:
+        """404 [error]: DELETE on non-existent agent → Tier3AgentNotFound."""
+        respx.delete("https://w.example/agents/ratatoskr:ghost").mock(
+            return_value=httpx.Response(404)
+        )
+        async with httpx.AsyncClient(base_url="https://w.example") as client:
+            with pytest.raises(Tier3AgentNotFound) as exc:
+                await delete_agent(client, "ratatoskr:ghost")
+        assert exc.value.agent_id == "ratatoskr:ghost"
+
+    @respx.mock
+    async def test_non_tier3_id_assert(self) -> None:
+        """non_tier3_id_assert [adversarial]: agent_id without `:` → AssertionError."""
+        route = respx.delete("https://w.example/agents/mimir").mock(
+            return_value=httpx.Response(204)
+        )
+        async with httpx.AsyncClient(base_url="https://w.example") as client:
+            with pytest.raises(AssertionError):
+                await delete_agent(client, "mimir")
+        assert route.call_count == 0
+
+    @respx.mock
+    async def test_other_5xx(self) -> None:
+        """other_5xx [error]: 500 → SessionApiFailed."""
+        respx.delete("https://w.example/agents/ratatoskr:wizard").mock(
+            return_value=httpx.Response(500, content=b"oops")
+        )
+        async with httpx.AsyncClient(base_url="https://w.example") as client:
+            with pytest.raises(SessionApiFailed) as exc:
+                await delete_agent(client, "ratatoskr:wizard")
+        assert exc.value.status == 500
+
+
+@pytest.fixture
+def _isolated_local_agents(
+    tmp_path: "Path", monkeypatch: pytest.MonkeyPatch
+) -> "Path":
+    """Isolate the v0.8.0 local-tier-3 index from the operator's real file."""
+    path = tmp_path / "local_agents.json"
+    monkeypatch.setenv("RATATOSKR_LOCAL_AGENTS", str(path))
+    return path
+
+
+class TestCli:
+    @respx.mock
+    def test_cli_define_happy(
+        self,
+        capsys: pytest.CaptureFixture[str],
+        monkeypatch: pytest.MonkeyPatch,
+        _isolated_local_agents: "Path",
+    ) -> None:
+        """cli_define_happy [happy]: argv → 201 mock → stdout confirmation;
+        local index updated with the new entry (v0.8.0 hook).
+        """
+        from ratatoskr.local_agents import load_local_agents
+
+        monkeypatch.setenv("WORLDTREE_API_URL", "https://w.example")
+        monkeypatch.setenv("WORLDTREE_API_KEY", "k")
+        respx.post("https://w.example/agents/define").mock(
+            return_value=httpx.Response(201, json=_FULL_AGENT_RESP)
+        )
+        rc = main([
+            "define",
+            "--name", "wizard",
+            "--system-prompt", "You are a wizard.",
+            "--model", "qwen3.6-35-a3b",
+        ])
+        out = capsys.readouterr()
+        assert rc == 0
+        assert out.out.strip() == "defined ratatoskr:wizard (qwen3.6-35-a3b)"
+        # v0.8.0: local index now has the new entry.
+        entries = load_local_agents()
+        assert len(entries) == 1
+        assert entries[0].agent_id == "ratatoskr:wizard"
+        assert entries[0].model == "qwen3.6-35-a3b"
+
+    @respx.mock
+    def test_cli_patch_happy(
+        self,
+        capsys: pytest.CaptureFixture[str],
+        monkeypatch: pytest.MonkeyPatch,
+        _isolated_local_agents: "Path",
+    ) -> None:
+        """cli_patch_happy [happy]: argv → 200 mock → stdout confirmation;
+        local index refreshed with the post-patch state.
+        """
+        from ratatoskr.local_agents import load_local_agents
+
+        monkeypatch.setenv("WORLDTREE_API_URL", "https://w.example")
+        monkeypatch.setenv("WORLDTREE_API_KEY", "k")
+        respx.patch("https://w.example/agents/ratatoskr:wizard").mock(
+            return_value=httpx.Response(200, json=_FULL_AGENT_RESP)
+        )
+        rc = main(["patch", "ratatoskr:wizard", "--system-prompt", "new"])
+        out = capsys.readouterr()
+        assert rc == 0
+        assert out.out.strip() == "patched ratatoskr:wizard"
+        entries = load_local_agents()
+        assert len(entries) == 1
+        assert entries[0].agent_id == "ratatoskr:wizard"
+
+    @respx.mock
+    def test_cli_delete_happy(
+        self,
+        capsys: pytest.CaptureFixture[str],
+        monkeypatch: pytest.MonkeyPatch,
+        _isolated_local_agents: "Path",
+    ) -> None:
+        """cli_delete_happy [happy]: argv → 204 mock → stdout confirmation;
+        local index entry removed (v0.8.0 hook).
+        """
+        from ratatoskr.local_agents import (
+            LocalAgentEntry,
+            add_local_agent,
+            load_local_agents,
+        )
+
+        # Pre-populate so we can verify removal.
+        add_local_agent(LocalAgentEntry(
+            agent_id="ratatoskr:wizard",
+            agent_name="wizard",
+            model="m",
+            description="d",
+            defined_at="t",
+        ))
+        monkeypatch.setenv("WORLDTREE_API_URL", "https://w.example")
+        monkeypatch.setenv("WORLDTREE_API_KEY", "k")
+        respx.delete("https://w.example/agents/ratatoskr:wizard").mock(
+            return_value=httpx.Response(204)
+        )
+        rc = main(["delete", "ratatoskr:wizard"])
+        out = capsys.readouterr()
+        assert rc == 0
+        assert out.out.strip() == "deleted ratatoskr:wizard"
+        assert load_local_agents() == []
+
+    def test_cli_missing_auth(
+        self, capsys: pytest.CaptureFixture[str], monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        """cli_missing_auth [error]: no api-key → stderr [auth_error] + exit 11."""
+        monkeypatch.delenv("WORLDTREE_API_KEY", raising=False)
+        rc = main([
+            "define",
+            "--name", "wizard",
+            "--system-prompt", "x",
+            "--model", "m",
+        ])
+        err = capsys.readouterr().err
+        assert rc == 11
+        assert "[auth_error]" in err
+
+    @respx.mock
+    def test_cli_api_failed(
+        self, capsys: pytest.CaptureFixture[str], monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        """cli_api_failed [error]: 500 → stderr [api_failed] + exit 20."""
+        monkeypatch.setenv("WORLDTREE_API_URL", "https://w.example")
+        monkeypatch.setenv("WORLDTREE_API_KEY", "k")
+        respx.post("https://w.example/agents/define").mock(
+            return_value=httpx.Response(500, content=b"upstream out")
+        )
+        rc = main([
+            "define",
+            "--name", "wizard",
+            "--system-prompt", "x",
+            "--model", "m",
+        ])
+        err = capsys.readouterr().err
+        assert rc == 20
+        assert "[api_failed]" in err
+
+    @respx.mock
+    def test_cli_quota_exceeded(
+        self, capsys: pytest.CaptureFixture[str], monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        """cli_quota_exceeded [error]: 429 → stderr [quota_exceeded] + exit 20."""
+        monkeypatch.setenv("WORLDTREE_API_URL", "https://w.example")
+        monkeypatch.setenv("WORLDTREE_API_KEY", "k")
+        respx.post("https://w.example/agents/define").mock(
+            return_value=httpx.Response(
+                429,
+                headers={"Retry-After": "0"},
+                json={"detail": {"error_code": "agent_quota_exceeded"}},
+            )
+        )
+        rc = main([
+            "define",
+            "--name", "wizard",
+            "--system-prompt", "x",
+            "--model", "m",
+        ])
+        err = capsys.readouterr().err
+        assert rc == 20
+        assert "[quota_exceeded]" in err
+
+    def test_cli_patch_no_fields(
+        self, capsys: pytest.CaptureFixture[str], monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        """cli_patch_no_fields [error]: patch with no flags → [usage_error] + exit 10."""
+        monkeypatch.setenv("WORLDTREE_API_URL", "https://w.example")
+        monkeypatch.setenv("WORLDTREE_API_KEY", "k")
+        rc = main(["patch", "ratatoskr:wizard"])
+        err = capsys.readouterr().err
+        assert rc == 10
+        assert "[usage_error]" in err

tests/test_web_packaging.py

@@ -0,0 +1,154 @@
+"""Packaging + lazy-import discipline tests for ratatoskr.web per issue #16.
+
+- `index.html` resolvable via importlib.resources (ships in wheel)
+- `ratatoskr.web.entrypoint` importable without starlette+uvicorn,
+  prints install-hint and exits non-zero in that mode
+"""
+
+from importlib.resources import files
+
+
+def test_index_html_in_package() -> None:
+    """static/index.html is locatable via importlib.resources.
+
+    INV-009 packaging discipline. The asset must be part of the
+    installed package — `_static_dir()` in the server uses this exact
+    resolution path at startup.
+    """
+    path = files("ratatoskr.web") / "static" / "index.html"
+    assert path.is_file(), f"index.html missing at {path}"
+    content = path.read_text()
+    assert "<html" in content
+    assert "ratatoskr-web" in content
+
+
+def test_entrypoint_no_top_level_starlette_import() -> None:
+    """INV-001: importing `ratatoskr.web.entrypoint` MUST NOT import
+    starlette or uvicorn at the module level. Verified by AST inspection
+    of the source — checks no top-level `import starlette` /
+    `from starlette` / `import uvicorn` / `from uvicorn` statements.
+    """
+    import ast
+    from importlib.resources import files
+
+    src = (files("ratatoskr.web") / "entrypoint.py").read_text()
+    tree = ast.parse(src)
+    banned = {"starlette", "uvicorn"}
+    for node in tree.body:
+        if isinstance(node, ast.Import):
+            for alias in node.names:
+                top = alias.name.split(".")[0]
+                assert top not in banned, (
+                    f"top-level `import {alias.name}` violates INV-001 "
+                    "lazy-import discipline"
+                )
+        elif isinstance(node, ast.ImportFrom):
+            mod = (node.module or "").split(".")[0]
+            assert mod not in banned, (
+                f"top-level `from {node.module} import ...` violates "
+                "INV-001 lazy-import discipline"
+            )
+
+
+def test_entrypoint_missing_api_key_returns_11(monkeypatch) -> None:
+    """missing_api_key [error]: WORLDTREE_API_KEY unset → exit 11."""
+    monkeypatch.delenv("WORLDTREE_API_KEY", raising=False)
+    from ratatoskr.web.entrypoint import main
+
+    rc = main(["--port", "0"])
+    assert rc == 11
+
+
+def test_entrypoint_missing_extras_returns_12(monkeypatch) -> None:
+    """missing_extras [error]: starlette unimportable → exit 12.
+
+    v0.16.0: the missing-extras probe is scoped to the OPTIONAL extras
+    (starlette / uvicorn) only. Simulated by shadowing `starlette` to
+    None in sys.modules so its import raises ImportError inside the
+    narrow try-block.
+    """
+    import sys
+
+    monkeypatch.setenv("WORLDTREE_API_KEY", "k")
+    monkeypatch.setenv("WORLDTREE_API_URL", "https://example.com")
+    monkeypatch.setitem(sys.modules, "starlette", None)
+
+    from ratatoskr.web.entrypoint import main
+
+    rc = main(["--port", "0"])
+    assert rc == 12
+
+
+def test_entrypoint_real_import_bug_propagates(monkeypatch) -> None:
+    """v0.16.0: an ImportError from a BASELINE module (not an extra) MUST
+    propagate as a real traceback, not be masked as exit-12 missing-extras.
+    Shadowing ratatoskr.web.server (a first-party module, present with or
+    without the [web] extras) should raise, not return 12.
+    """
+    import sys
+
+    import pytest as _pytest
+
+    monkeypatch.setenv("WORLDTREE_API_KEY", "k")
+    monkeypatch.setenv("WORLDTREE_API_URL", "https://example.com")
+    monkeypatch.setitem(sys.modules, "ratatoskr.web.server", None)
+
+    from ratatoskr.web.entrypoint import main
+
+    with _pytest.raises(ImportError):
+        main(["--port", "0"])
+
+
+class TestEntrypointArgs:
+    """FN main argparse + serve-loop traces (contract TESTS)."""
+
+    def test_default_host_is_zero(self) -> None:
+        """default_host_is_zero [trace]: argv=[] → host == '0.0.0.0'."""
+        from ratatoskr.web.entrypoint import _build_arg_parser
+        args = _build_arg_parser().parse_args([])
+        assert args.host == "0.0.0.0"
+        assert args.port == 8765
+        assert args.open is False
+
+    def test_port_zero_supported(self) -> None:
+        """port_zero_supported [trace]: argv=['--port','0'] → port == 0."""
+        from ratatoskr.web.entrypoint import _build_arg_parser
+        args = _build_arg_parser().parse_args(["--port", "0"])
+        assert args.port == 0
+
+    def test_happy_argv_serves_and_returns_zero(self, monkeypatch) -> None:
+        """happy_argv [tracer]: env set + uvicorn.run mocked → main returns 0."""
+        import uvicorn
+        monkeypatch.setenv("WORLDTREE_API_KEY", "k")
+        monkeypatch.setenv("WORLDTREE_API_URL", "https://example.com")
+        calls = {}
+        monkeypatch.setattr(uvicorn, "run", lambda app, **kw: calls.update(kw))
+        from ratatoskr.web.entrypoint import main
+        rc = main(["--port", "0"])
+        assert rc == 0
+        assert calls["host"] == "0.0.0.0"
+        assert calls["port"] == 0
+
+    def test_open_flag_calls_webbrowser(self, monkeypatch) -> None:
+        """open_flag_calls_webbrowser [trace]: --open → webbrowser.open called."""
+        import uvicorn
+        import webbrowser
+        monkeypatch.setenv("WORLDTREE_API_KEY", "k")
+        monkeypatch.setattr(uvicorn, "run", lambda app, **kw: None)
+        opened = []
+        monkeypatch.setattr(webbrowser, "open", lambda url: opened.append(url))
+        from ratatoskr.web.entrypoint import main
+        main(["--port", "0", "--open"])
+        assert len(opened) == 1
+
+    def test_no_open_default(self, monkeypatch) -> None:
+        """no_open_default [trace]: argv without --open → webbrowser.open NOT called."""
+        import uvicorn
+        import webbrowser
+        monkeypatch.setenv("WORLDTREE_API_KEY", "k")
+        monkeypatch.setattr(uvicorn, "run", lambda app, **kw: None)
+        opened = []
+        monkeypatch.setattr(webbrowser, "open", lambda url: opened.append(url))
+        from ratatoskr.web.entrypoint import main
+        main(["--port", "0"])
+        assert opened == []

tests/test_web_presentation_contract.py

@@ -0,0 +1,162 @@
+"""Drift-detection between TUI presentation discipline and web JS
+presenter per issue #16 INV-008.
+
+The JSON fixture at `tests/fixtures/presentation_contract.json`
+enumerates the expected browser-facing event payload for each Event
+type. Server-side serialization (`_event_to_browser_payload`) is
+unit-tested against the fixture. JS-side rendering in
+`src/ratatoskr/web/static/index.html` consumes the same shape — if
+this fixture changes, both sides update in lockstep.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from ratatoskr.sse_client import (
+    AffectUpdate,
+    AwaitingLlmFirstToken,
+    Cancelled,
+    Done,
+    Error,
+    SseId,
+    Text,
+    TextBoundary,
+    Thinking,
+    ToolResult,
+    ToolStart,
+    WorkerPhase,
+)
+from ratatoskr.web.server import _event_to_browser_payload
+
+
+def _load_fixture() -> dict:
+    path = Path(__file__).parent / "fixtures" / "presentation_contract.json"
+    return json.loads(path.read_text())
+
+
+def _check(name: str, event: object) -> None:
+    """Assert (event_type, data) for `event` matches the fixture entry."""
+    fixture = _load_fixture()
+    assert name in fixture, f"fixture missing entry for {name!r}"
+    expected = fixture[name]
+    event_type, data = _event_to_browser_payload(event)
+    assert event_type == expected["event_type"], (
+        f"{name}: event_type {event_type!r} != fixture {expected['event_type']!r}"
+    )
+    assert data == expected["data"], (
+        f"{name}: data mismatch\n  got: {data}\n  fixture: {expected['data']}"
+    )
+
+
+def test_worker_phase_matches_fixture() -> None:
+    _check(
+        "worker_phase",
+        WorkerPhase(sse_id=SseId(42, 3), phase="BuildingPrompt", turn_id=42),
+    )
+
+
+def test_thinking_matches_fixture() -> None:
+    _check(
+        "thinking",
+        Thinking(sse_id=SseId(42, 5), content="Let me think..."),
+    )
+
+
+def test_text_matches_fixture() -> None:
+    _check(
+        "text",
+        Text(sse_id=SseId(42, 7), content="Hello there"),
+    )
+
+
+def test_text_boundary_matches_fixture() -> None:
+    _check(
+        "text_boundary",
+        TextBoundary(
+            sse_id=SseId(42, 8), kind="sentence",
+            char_offset=11, ts="2026-05-28T00:00:00Z",
+        ),
+    )
+
+
+def test_tool_start_matches_fixture() -> None:
+    _check(
+        "tool_start",
+        ToolStart(sse_id=SseId(42, 9), name="search", arguments={"q": "ratatoskr"}),
+    )
+
+
+def test_tool_result_matches_fixture() -> None:
+    _check(
+        "tool_result",
+        ToolResult(
+            sse_id=SseId(42, 10), name="search",
+            result={"n": 1}, duration_ms=12,
+        ),
+    )
+
+
+def test_done_matches_fixture() -> None:
+    _check(
+        "done",
+        Done(
+            sse_id=SseId(42, 11), phase="succeeded", response="Hello there",
+            model="qwen3.6-35-a3b", duration_ms=1234,
+            usage={
+                "prompt_tokens": 100, "completion_tokens": 50,
+                "total_tokens": 150, "cached_input_tokens": 0,
+            },
+        ),
+    )
+
+
+def test_error_matches_fixture() -> None:
+    _check(
+        "error",
+        Error(
+            sse_id=SseId(42, 11), phase="failed",
+            message="llm output invalid", error_code="llm_output_invalid",
+        ),
+    )
+
+
+def test_cancelled_matches_fixture() -> None:
+    _check(
+        "cancelled",
+        Cancelled(
+            sse_id=SseId(42, 11), phase="cancelled", turn_id=42,
+            reason="user_cancel", partial_message_id=None,
+        ),
+    )
+
+
+def test_affect_update_matches_fixture() -> None:
+    _check(
+        "affect_update",
+        AffectUpdate(
+            sse_id=SseId(42, 1), status="current", turn_id=42,
+            snapshot={
+                "agent_id": "mimir",
+                "pad": {"pleasure": 0.52, "arousal": 0.47, "dominance": 0.50},
+                "dominant_emotion": "curiosity",
+                "emotions_active": [
+                    {"type": "curiosity", "intensity": 0.6, "decay_remaining_s": 202.7}
+                ],
+                "baseline_pad": {"pleasure": 0.50, "arousal": 0.40, "dominance": 0.50},
+                "mood_drift": {"valence_delta": 0.02, "arousal_delta": 0.07},
+                "last_updated_at": "2026-05-28T00:00:00+00:00",
+            },
+        ),
+    )
+
+
+def test_awaiting_llm_first_token_matches_fixture() -> None:
+    _check(
+        "awaiting_llm_first_token",
+        AwaitingLlmFirstToken(
+            sse_id=SseId(42, 2), turn_id=42,
+            elapsed_ms_since_building_prompt=5012.3,
+        ),
+    )

tests/test_web_server.py

@@ -0,0 +1,794 @@
+"""Tests for ratatoskr.web.server per docs/contracts/issues/16.contract.md.
+
+The TestClient drives the Starlette app with a respx-mocked upstream
+httpx client. No live network. See INV-002: create_app takes a
+client_factory callable; tests pass a factory returning a respx-mocked
+AsyncClient.
+"""
+
+import httpx
+import pytest
+import respx
+from starlette.testclient import TestClient
+
+
+def _mock_client_factory() -> "object":
+    """A client_factory that returns a no-base-url AsyncClient suitable
+    for respx-mocking absolute URLs. Endpoints that hit upstream use the
+    same factory in tests as in prod; respx intercepts at the transport
+    layer.
+    """
+    def factory() -> httpx.AsyncClient:
+        return httpx.AsyncClient(base_url="https://w.example")
+    return factory
+
+
+class TestVersionEndpoint:
+    """version_endpoint FN — tracer per contract issue #16."""
+
+    def test_happy_returns_current_version(self) -> None:
+        """happy [tracer]: GET /version → 200, body == {"ratatoskr": "<current-version>"}.
+
+        Validates: Starlette app boots, route registers, JSON shape correct,
+        version derived from package metadata (importlib.metadata).
+        """
+        from importlib.metadata import version
+
+        from ratatoskr.web.server import create_app
+
+        app = create_app(_mock_client_factory())
+        client = TestClient(app)
+        resp = client.get("/version")
+        assert resp.status_code == 200
+        assert resp.json() == {"ratatoskr": version("ratatoskr")}
+
+
+class TestAgentsEndpoint:
+    """agents_endpoint FN — proxy upstream /agents + merge with local tier3 index."""
+
+    @respx.mock
+    def test_happy_merges_upstream_and_local(self, monkeypatch: pytest.MonkeyPatch, tmp_path) -> None:
+        """happy [tracer]: respx mock /agents 200 → response merges upstream + local index."""
+        # Isolate local agents index to tmp
+        monkeypatch.setenv("RATATOSKR_LOCAL_AGENTS", str(tmp_path / "local_agents.json"))
+        respx.get("https://w.example/agents").mock(
+            return_value=httpx.Response(
+                200,
+                json=[
+                    {"agent_id": "mimir", "name": "Mimir", "description": "k"},
+                ],
+            )
+        )
+        # Add one local tier3 agent to the index
+        from ratatoskr.local_agents import LocalAgentEntry, add_local_agent
+
+        add_local_agent(
+            LocalAgentEntry(
+                agent_id="ratatoskr:sindra",
+                agent_name="sindra",
+                model="artemis-31b-v1i",
+                description="(tier 3) IDENTITY",
+                defined_at="2026-05-28T00:00:00+00:00",
+            )
+        )
+
+        from ratatoskr.web.server import create_app
+
+        app = create_app(_mock_client_factory())
+        client = TestClient(app)
+        resp = client.get("/api/agents")
+        assert resp.status_code == 200
+        body = resp.json()
+        ids = [a["agent_id"] for a in body]
+        assert "mimir" in ids
+        assert "ratatoskr:sindra" in ids
+
+    @respx.mock
+    def test_upstream_500_returns_500_envelope(self, monkeypatch, tmp_path) -> None:
+        """upstream_500 [error]: respx 500 → 500 with error_code envelope."""
+        monkeypatch.setenv("RATATOSKR_LOCAL_AGENTS", str(tmp_path / "local_agents.json"))
+        respx.get("https://w.example/agents").mock(return_value=httpx.Response(500, content=b"boom"))
+        from ratatoskr.web.server import create_app
+        app = create_app(_mock_client_factory())
+        resp = TestClient(app).get("/api/agents")
+        assert resp.status_code == 500
+        assert resp.json()["error_code"] == "session_api_failed"
+
+    @respx.mock
+    def test_network_error_returns_502(self, monkeypatch, tmp_path) -> None:
+        """network_error [error]: connection refused → 502 with network_error envelope."""
+        monkeypatch.setenv("RATATOSKR_LOCAL_AGENTS", str(tmp_path / "local_agents.json"))
+        respx.get("https://w.example/agents").mock(side_effect=httpx.ConnectError("refused"))
+        from ratatoskr.web.server import create_app
+        app = create_app(_mock_client_factory())
+        resp = TestClient(app).get("/api/agents")
+        assert resp.status_code == 502
+        assert resp.json()["error_code"] == "network_error"
+
+    @respx.mock
+    def test_local_dedup(self, monkeypatch, tmp_path) -> None:
+        """local_dedup [scenario]: local entry with same agent_id as upstream → no duplicate."""
+        monkeypatch.setenv("RATATOSKR_LOCAL_AGENTS", str(tmp_path / "local_agents.json"))
+        respx.get("https://w.example/agents").mock(
+            return_value=httpx.Response(
+                200,
+                json=[{"agent_id": "ratatoskr:sindra", "name": "Sindra-from-server", "description": ""}],
+            )
+        )
+        from ratatoskr.local_agents import LocalAgentEntry, add_local_agent
+        add_local_agent(
+            LocalAgentEntry(
+                agent_id="ratatoskr:sindra", agent_name="sindra", model="m",
+                description="local-tier3", defined_at="2026-05-28T00:00:00+00:00",
+            )
+        )
+        from ratatoskr.web.server import create_app
+        app = create_app(_mock_client_factory())
+        resp = TestClient(app).get("/api/agents")
+        assert resp.status_code == 200
+        body = resp.json()
+        ids = [a["agent_id"] for a in body]
+        assert ids.count("ratatoskr:sindra") == 1
+        # Upstream entry wins (it's first in the merge); local is deduped
+        assert body[0]["name"] == "Sindra-from-server"
+
+
+_CREATE_OK = {
+    "session_id": "s-1",
+    "agent_id": "mimir",
+    "message_count": 0,
+    "created_at": "2026-05-28T00:00:00+00:00",
+    "last_active": "2026-05-28T00:00:00+00:00",
+    "metadata": {},
+}
+
+
+class TestCreateSessionEndpoint:
+    """create_session_endpoint FN — proxy POST /sessions to upstream."""
+
+    @respx.mock
+    def test_happy_returns_201(self) -> None:
+        """happy [tracer]: respx mock 201 → endpoint returns 201 with session JSON."""
+        respx.post("https://w.example/sessions").mock(return_value=httpx.Response(201, json=_CREATE_OK))
+        from ratatoskr.web.server import create_app
+        app = create_app(_mock_client_factory())
+        resp = TestClient(app).post("/api/sessions", json={"agent_id": "mimir"})
+        assert resp.status_code == 201
+        assert resp.json()["session_id"] == "s-1"
+
+    @respx.mock
+    def test_unknown_agent_returns_404(self) -> None:
+        """unknown_agent [error]: respx 404 → 404 with agent_not_found envelope."""
+        respx.post("https://w.example/sessions").mock(
+            return_value=httpx.Response(404, json={"error": "unknown_agent_id"})
+        )
+        from ratatoskr.web.server import create_app
+        app = create_app(_mock_client_factory())
+        resp = TestClient(app).post("/api/sessions", json={"agent_id": "ghost"})
+        assert resp.status_code == 404
+        assert resp.json()["error_code"] == "agent_not_found"
+
+    def test_missing_agent_id_returns_400(self) -> None:
+        """missing_agent_id [adversarial]: body without agent_id → 400."""
+        from ratatoskr.web.server import create_app
+        app = create_app(_mock_client_factory())
+        resp = TestClient(app).post("/api/sessions", json={})
+        assert resp.status_code == 400
+
+
+_SNAPSHOT = {
+    "agent_id": "mimir",
+    "pad": {"pleasure": 0.5, "arousal": 0.4, "dominance": 0.5},
+    "dominant_emotion": "curiosity",
+}
+
+
+class TestPersonaStateEndpoint:
+    """persona_state_endpoint FN — proxy upstream GET /agents/{id}/persona_state."""
+
+    @respx.mock
+    def test_happy_returns_snapshot(self) -> None:
+        """happy [tracer]: respx 200 → 200 with snapshot."""
+        respx.get("https://w.example/agents/mimir/persona_state").mock(
+            return_value=httpx.Response(200, json=_SNAPSHOT)
+        )
+        from ratatoskr.web.server import create_app
+        app = create_app(_mock_client_factory())
+        resp = TestClient(app).get("/api/agents/mimir/persona_state")
+        assert resp.status_code == 200
+        assert resp.json()["dominant_emotion"] == "curiosity"
+
+    @respx.mock
+    def test_persona_not_configured(self) -> None:
+        """persona_not_configured [error]: 404 + persona_not_configured → 404 envelope."""
+        respx.get("https://w.example/agents/domari/persona_state").mock(
+            return_value=httpx.Response(404, json={"error_code": "persona_not_configured"})
+        )
+        from ratatoskr.web.server import create_app
+        app = create_app(_mock_client_factory())
+        resp = TestClient(app).get("/api/agents/domari/persona_state")
+        assert resp.status_code == 404
+        assert resp.json()["error_code"] == "persona_not_configured"
+
+    @respx.mock
+    def test_agent_not_available(self) -> None:
+        """agent_not_available [error]: 404 + agent_not_available → 404 envelope."""
+        respx.get("https://w.example/agents/bogus/persona_state").mock(
+            return_value=httpx.Response(404, json={"error_code": "agent_not_available"})
+        )
+        from ratatoskr.web.server import create_app
+        app = create_app(_mock_client_factory())
+        resp = TestClient(app).get("/api/agents/bogus/persona_state")
+        assert resp.status_code == 404
+        assert resp.json()["error_code"] == "agent_not_available"
+
+    @respx.mock
+    def test_auth_scope_denied(self) -> None:
+        """auth_scope_denied [error]: 403 + auth_scope_denied → 403 envelope."""
+        respx.get("https://w.example/agents/mimir/persona_state").mock(
+            return_value=httpx.Response(403, json={"error_code": "auth_scope_denied"})
+        )
+        from ratatoskr.web.server import create_app
+        app = create_app(_mock_client_factory())
+        resp = TestClient(app).get("/api/agents/mimir/persona_state")
+        assert resp.status_code == 403
+        assert resp.json()["error_code"] == "auth_scope_denied"
+
+
+class TestSubmitTurnEndpoint:
+    """submit_turn_endpoint FN — allocate turn_id, register in turn_registry."""
+
+    def test_happy_returns_turn_id(self) -> None:
+        """happy [tracer]: POST {"content": "hi"} → 200 with turn_id; registry populated."""
+        from ratatoskr.web.server import create_app
+        app = create_app(_mock_client_factory())
+        resp = TestClient(app).post("/api/turns/s-1", json={"content": "hello"})
+        assert resp.status_code == 200
+        body = resp.json()
+        assert isinstance(body["turn_id"], int)
+        assert body["turn_id"] > 0
+        # Registry has the entry
+        handle = app.state.turn_registry[("s-1", body["turn_id"])]
+        assert handle.content == "hello"
+        assert handle.status == "queued"
+
+    def test_missing_content_returns_400(self) -> None:
+        """missing_content [adversarial]: body without content → 400."""
+        from ratatoskr.web.server import create_app
+        app = create_app(_mock_client_factory())
+        resp = TestClient(app).post("/api/turns/s-1", json={})
+        assert resp.status_code == 400
+
+    def test_monotonic_turn_ids(self) -> None:
+        """monotonic_turn_ids [trace]: two submits → second turn_id > first."""
+        from ratatoskr.web.server import create_app
+        app = create_app(_mock_client_factory())
+        c = TestClient(app)
+        first = c.post("/api/turns/s-1", json={"content": "a"}).json()["turn_id"]
+        second = c.post("/api/turns/s-2", json={"content": "b"}).json()["turn_id"]
+        assert second > first
+
+
+_DONE_BODY = {
+    "type": "done",
+    "phase": "succeeded",
+    "response": "hello",
+    "model": "m",
+    "duration_ms": 1,
+    "usage": {"prompt_tokens": 0, "completion_tokens": 0, "total_tokens": 0, "cached_input_tokens": 0},
+}
+
+
+def _sse_chunk(sse_id: str, body: dict) -> bytes:
+    import json as _j
+    return f"id: {sse_id}\ndata: {_j.dumps(body)}\n\n".encode()
+
+
+def _sse_resp(stream: bytes) -> httpx.Response:
+    return httpx.Response(200, headers={"content-type": "text/event-stream"}, content=stream)
+
+
+def _sse_resp_stream(body: httpx.AsyncByteStream) -> httpx.Response:
+    """SSE response backed by a live AsyncByteStream (for gated/hanging
+    streams in disconnect tests)."""
+    return httpx.Response(
+        200, headers={"content-type": "text/event-stream"}, stream=body
+    )
+
+
+def _parse_browser_sse(raw: bytes) -> list[dict]:
+    """Parse a server-to-browser SSE stream into [{"event": str, "data": dict}, ...]."""
+    import json as _j
+    events: list[dict] = []
+    for block in raw.decode().split("\n\n"):
+        block = block.strip()
+        if not block:
+            continue
+        event_type = None
+        data_str = None
+        for line in block.splitlines():
+            if line.startswith("event: "):
+                event_type = line[len("event: "):]
+            elif line.startswith("data: "):
+                data_str = line[len("data: "):]
+        if event_type and data_str is not None:
+            events.append({"event": event_type, "data": _j.loads(data_str)})
+    return events
+
+
+class TestStreamTurnEndpoint:
+    """stream_turn_endpoint FN — open upstream SSE, proxy events to browser."""
+
+    @respx.mock
+    def test_happy_text_done(self) -> None:
+        """happy [tracer]: respx mock one text+done → SSE stream yields text + done events."""
+        stream = _sse_chunk("42:1", {"type": "text", "content": "hello"}) + _sse_chunk("42:2", _DONE_BODY)
+        respx.post("https://w.example/sessions/s-1/messages").mock(return_value=_sse_resp(stream))
+        from ratatoskr.web.server import create_app
+        app = create_app(_mock_client_factory())
+        c = TestClient(app)
+        turn_id = c.post("/api/turns/s-1", json={"content": "hi"}).json()["turn_id"]
+        with c.stream("GET", f"/api/turns/s-1/stream?turn_id={turn_id}") as resp:
+            assert resp.status_code == 200
+            raw = b"".join(resp.iter_bytes())
+        events = _parse_browser_sse(raw)
+        types = [e["event"] for e in events]
+        assert "text" in types
+        assert "done" in types
+        # Registry cleaned up
+        assert ("s-1", turn_id) not in app.state.turn_registry
+
+    def test_unknown_turn_returns_404(self) -> None:
+        """unknown_turn [error]: GET with turn_id not in registry → 404."""
+        from ratatoskr.web.server import create_app
+        app = create_app(_mock_client_factory())
+        resp = TestClient(app).get("/api/turns/s-x/stream?turn_id=999")
+        assert resp.status_code == 404
+
+    @respx.mock
+    def test_upstream_error_synthetic_event(self) -> None:
+        """upstream_error [error]: respx 500 → synthetic error SSE event."""
+        respx.post("https://w.example/sessions/s-1/messages").mock(
+            return_value=httpx.Response(500, content=b"boom")
+        )
+        from ratatoskr.web.server import create_app
+        app = create_app(_mock_client_factory())
+        c = TestClient(app)
+        turn_id = c.post("/api/turns/s-1", json={"content": "hi"}).json()["turn_id"]
+        with c.stream("GET", f"/api/turns/s-1/stream?turn_id={turn_id}") as resp:
+            raw = b"".join(resp.iter_bytes())
+        events = _parse_browser_sse(raw)
+        types = [e["event"] for e in events]
+        assert "error" in types
+        # Surfaces upstream's exception type for the operator
+        err = next(e for e in events if e["event"] == "error")
+        assert err["data"]["exception"] == "SseConnectFailed"
+
+
+_CANCEL_OK = {"turn_id": 42, "cancelled": True, "reason": None, "partial_message_id": None}
+
+
+class TestCancelTurnEndpoint:
+    """cancel_turn_endpoint FN — proxy upstream cancel for registered turn."""
+
+    @respx.mock
+    def test_happy_cancels(self) -> None:
+        """happy [tracer]: registered turn (upstream started) → POST cancel
+        → 200, upstream cancel called against the upstream turn_id.
+        """
+        from ratatoskr.web.server import create_app
+        app = create_app(_mock_client_factory())
+        c = TestClient(app)
+        turn_id = c.post("/api/turns/s-1", json={"content": "hi"}).json()["turn_id"]
+        # Simulate that the upstream stream has started (turn_id 42 upstream).
+        app.state.turn_registry[("s-1", turn_id)].status = "streaming"
+        app.state.turn_registry[("s-1", turn_id)].upstream_turn_id = 42
+        respx.post("https://w.example/sessions/s-1/turns/42/cancel").mock(
+            return_value=httpx.Response(200, json={**_CANCEL_OK, "turn_id": 42})
+        )
+        resp = c.post(f"/api/turns/s-1/cancel?turn_id={turn_id}")
+        assert resp.status_code == 200
+        assert resp.json()["cancelled"] is True
+        assert ("s-1", turn_id) not in app.state.turn_registry
+
+    def test_unknown_turn_returns_404(self) -> None:
+        """unknown_turn [error]: not in registry → 404."""
+        from ratatoskr.web.server import create_app
+        app = create_app(_mock_client_factory())
+        resp = TestClient(app).post("/api/turns/s-x/cancel?turn_id=999")
+        assert resp.status_code == 404
+
+    @respx.mock
+    def test_already_completed_race(self) -> None:
+        """already_completed [race]: upstream 409 → 200 reason=race_or_completed."""
+        from ratatoskr.web.server import create_app
+        app = create_app(_mock_client_factory())
+        c = TestClient(app)
+        turn_id = c.post("/api/turns/s-1", json={"content": "hi"}).json()["turn_id"]
+        app.state.turn_registry[("s-1", turn_id)].status = "streaming"
+        app.state.turn_registry[("s-1", turn_id)].upstream_turn_id = 42
+        respx.post("https://w.example/sessions/s-1/turns/42/cancel").mock(
+            return_value=httpx.Response(409)
+        )
+        resp = c.post(f"/api/turns/s-1/cancel?turn_id={turn_id}")
+        assert resp.status_code == 200
+        assert resp.json()["cancelled"] is False
+        assert resp.json()["reason"] == "race_or_completed"
+
+    @respx.mock
+    def test_cancel_failed_500(self) -> None:
+        """cancel_failed [error]: upstream 500 → 500 with cancel_failed envelope."""
+        from ratatoskr.web.server import create_app
+        app = create_app(_mock_client_factory())
+        c = TestClient(app)
+        turn_id = c.post("/api/turns/s-1", json={"content": "hi"}).json()["turn_id"]
+        app.state.turn_registry[("s-1", turn_id)].status = "streaming"
+        app.state.turn_registry[("s-1", turn_id)].upstream_turn_id = 42
+        respx.post("https://w.example/sessions/s-1/turns/42/cancel").mock(
+            return_value=httpx.Response(500, content=b"boom")
+        )
+        resp = c.post(f"/api/turns/s-1/cancel?turn_id={turn_id}")
+        assert resp.status_code == 500
+        assert resp.json()["error_code"] == "cancel_failed"
+        assert ("s-1", turn_id) not in app.state.turn_registry
+
+
+class TestStaticServing:
+    """root_endpoint FN + /static mount — index.html + static asset serving."""
+
+    def test_root_returns_html(self) -> None:
+        """happy [tracer]: GET / → 200, content-type text/html, body contains '<html'."""
+        from ratatoskr.web.server import create_app
+        app = create_app(_mock_client_factory())
+        resp = TestClient(app).get("/")
+        assert resp.status_code == 200
+        assert "text/html" in resp.headers["content-type"]
+        assert "<html" in resp.text
+
+
+class TestLifespanShutdown:
+    """lifespan_shutdown FN — INV-006: drain turn_registry within 5s budget."""
+
+    @respx.mock
+    def test_happy_drains_registry(self) -> None:
+        """happy [tracer]: 2 in-flight turns + shutdown → upstream cancels called."""
+        from ratatoskr.web.server import TurnHandle, create_app
+
+        cancel_routes = []
+        for tid in (101, 102):
+            cancel_routes.append(
+                respx.post(f"https://w.example/sessions/s-1/turns/{tid}/cancel").mock(
+                    return_value=httpx.Response(200, json={
+                        "turn_id": tid, "cancelled": True, "reason": None,
+                        "partial_message_id": None,
+                    })
+                )
+            )
+        app = create_app(_mock_client_factory())
+        with TestClient(app) as client:
+            # Two turns in-flight (status=streaming, upstream_turn_id set =
+            # local tid here for test simplicity).
+            for tid in (101, 102):
+                app.state.turn_registry[("s-1", tid)] = TurnHandle(
+                    session_id="s-1", turn_id=tid, content="x",
+                    status="streaming", upstream_turn_id=tid,
+                )
+            # The exit of the `with` triggers lifespan shutdown
+        # After lifespan shutdown:
+        for route in cancel_routes:
+            assert route.called, "upstream cancel should have been issued for each in-flight turn"
+        assert app.state.turn_registry == {}
+
+
+class TestUpstreamTurnIdCancel:
+    """v0.16.0 — cancel paths must target the UPSTREAM turn_id, not the
+    browser-local turn_id. The local _TURN_COUNTER allocates 1,2,3…; the
+    real upstream turn_id only arrives via the first SSE event's
+    sse_id.turn_id. Heid panel (Hulda) load-bearing finding.
+    """
+
+    @respx.mock
+    def test_cancel_targets_upstream_turn_id(self) -> None:
+        """A registered handle whose local turn_id (1) differs from its
+        captured upstream_turn_id (42) → POST cancel hits the UPSTREAM URL
+        /sessions/s-1/turns/42/cancel, not /turns/1/cancel.
+        """
+        from ratatoskr.web.server import TurnHandle, create_app
+
+        # Only the upstream-id cancel URL is mocked. If the code uses the
+        # local id (1), it'll miss this route → the test catches the bug.
+        upstream_route = respx.post(
+            "https://w.example/sessions/s-1/turns/42/cancel"
+        ).mock(return_value=httpx.Response(200, json={
+            "turn_id": 42, "cancelled": True, "reason": None,
+            "partial_message_id": None,
+        }))
+        app = create_app(_mock_client_factory())
+        app.state.turn_registry[("s-1", 1)] = TurnHandle(
+            session_id="s-1", turn_id=1, content="x",
+            status="streaming", upstream_turn_id=42,
+        )
+        resp = TestClient(app).post("/api/turns/s-1/cancel?turn_id=1")
+        assert resp.status_code == 200
+        assert resp.json()["cancelled"] is True
+        assert upstream_route.called, "cancel must target the upstream turn_id"
+        assert ("s-1", 1) not in app.state.turn_registry
+
+    def test_cancel_before_upstream_started_is_noop(self) -> None:
+        """A handle with upstream_turn_id still None (turn never opened the
+        upstream stream) → cancel is a no-op: 200 {cancelled: false,
+        reason: not_started}, no upstream call, registry cleaned.
+        """
+        from ratatoskr.web.server import TurnHandle, create_app
+
+        app = create_app(_mock_client_factory())
+        app.state.turn_registry[("s-1", 1)] = TurnHandle(
+            session_id="s-1", turn_id=1, content="x",
+            status="queued", upstream_turn_id=None,
+        )
+        resp = TestClient(app).post("/api/turns/s-1/cancel?turn_id=1")
+        assert resp.status_code == 200
+        assert resp.json()["cancelled"] is False
+        assert resp.json()["reason"] == "not_started"
+        assert ("s-1", 1) not in app.state.turn_registry
+
+    @respx.mock
+    def test_stream_captures_upstream_turn_id(self) -> None:
+        """The stream generator captures upstream turn_id from the first
+        event's sse_id. After a happy text+done stream against upstream
+        turn 42 (local turn 1), the cancel mid-stream would have targeted 42.
+        Verified indirectly: drive the stream, assert events carry turn 42.
+        """
+        stream = _sse_chunk("42:1", {"type": "text", "content": "hi"}) + _sse_chunk("42:2", _DONE_BODY)
+        respx.post("https://w.example/sessions/s-1/messages").mock(return_value=_sse_resp(stream))
+        from ratatoskr.web.server import create_app
+        app = create_app(_mock_client_factory())
+        c = TestClient(app)
+        turn_id = c.post("/api/turns/s-1", json={"content": "hi"}).json()["turn_id"]
+        assert turn_id == 1 or turn_id > 0  # local counter
+        with c.stream("GET", f"/api/turns/s-1/stream?turn_id={turn_id}") as resp:
+            raw = b"".join(resp.iter_bytes())
+        events = _parse_browser_sse(raw)
+        # Every browser-facing event carries the upstream turn_id (42), not local
+        text_ev = next(e for e in events if e["event"] == "text")
+        assert text_ev["data"]["sse_id"].startswith("42:")
+
+
+class TestServerSideEndUserId:
+    """v0.16.0 — end_user_id is server-configured (RATATOSKR_END_USER_ID via
+    create_app), NOT accepted from the browser body. Heid panel finding +
+    contract FN main STEPS 2.
+    """
+
+    @respx.mock
+    def test_create_session_uses_server_end_user_id(self) -> None:
+        """create_app(end_user_id=...) → POST /api/sessions threads that id
+        into the upstream POST body even when the browser sends none.
+        """
+        import json as _j
+
+        route = respx.post("https://w.example/sessions").mock(
+            return_value=httpx.Response(201, json={**_CREATE_OK, "agent_id": "lofn"})
+        )
+        from ratatoskr.web.server import create_app
+        app = create_app(_mock_client_factory(), end_user_id="ratatoskr-tui")
+        resp = TestClient(app).post("/api/sessions", json={"agent_id": "lofn"})
+        assert resp.status_code == 201
+        sent = _j.loads(route.calls[0].request.content)
+        assert sent == {"agent_id": "lofn", "end_user_id": "ratatoskr-tui"}
+
+    @respx.mock
+    def test_create_session_ignores_body_end_user_id(self) -> None:
+        """A browser-supplied end_user_id is IGNORED — the server's
+        configured value wins. Prevents a client from impersonating an
+        arbitrary end-user partition.
+        """
+        import json as _j
+
+        route = respx.post("https://w.example/sessions").mock(
+            return_value=httpx.Response(201, json={**_CREATE_OK, "agent_id": "lofn"})
+        )
+        from ratatoskr.web.server import create_app
+        app = create_app(_mock_client_factory(), end_user_id="ratatoskr-tui")
+        TestClient(app).post(
+            "/api/sessions", json={"agent_id": "lofn", "end_user_id": "attacker"}
+        )
+        sent = _j.loads(route.calls[0].request.content)
+        assert sent.get("end_user_id") == "ratatoskr-tui"
+
+    @respx.mock
+    def test_create_session_no_end_user_id_when_unset(self) -> None:
+        """When create_app gets no end_user_id, the upstream body omits it
+        (matches create_session's default-omit shape)."""
+        import json as _j
+
+        route = respx.post("https://w.example/sessions").mock(
+            return_value=httpx.Response(201, json=_CREATE_OK)
+        )
+        from ratatoskr.web.server import create_app
+        app = create_app(_mock_client_factory())  # no end_user_id
+        TestClient(app).post("/api/sessions", json={"agent_id": "mimir"})
+        sent = _j.loads(route.calls[0].request.content)
+        assert "end_user_id" not in sent
+
+
+class TestCreateAppShape:
+    """create_app FN — route registration + state wiring (contract TESTS)."""
+
+    def test_routes_registered(self) -> None:
+        """routes_registered [tracer]: app.routes contains all 9 path patterns."""
+        from ratatoskr.web.server import create_app
+        app = create_app(_mock_client_factory())
+        paths = {getattr(r, "path", None) for r in app.routes}
+        for expected in (
+            "/", "/version", "/api/agents", "/api/sessions",
+            "/api/agents/{agent_id}/persona_state",
+            "/api/turns/{session_id}", "/api/turns/{session_id}/stream",
+            "/api/turns/{session_id}/cancel",
+        ):
+            assert expected in paths, f"missing route {expected}"
+        # /static is a Mount — its path is "/static"
+        assert "/static" in paths
+
+    def test_state_attached(self) -> None:
+        """state_attached [trace]: app.state.turn_registry is empty dict."""
+        from ratatoskr.web.server import create_app
+        app = create_app(_mock_client_factory())
+        assert app.state.turn_registry == {}
+
+    def test_factory_stored(self) -> None:
+        """factory_stored [trace]: app.state.client_factory is the same callable."""
+        from ratatoskr.web.server import create_app
+        f = _mock_client_factory()
+        app = create_app(f)
+        assert app.state.client_factory is f
+
+
+class TestStreamFullEventVocab:
+    """stream_turn_endpoint full_event_vocab — one of each Event type proxied."""
+
+    def _drive_stream(self, app, stream: bytes) -> list[str]:
+        respx.post("https://w.example/sessions/s-1/messages").mock(
+            return_value=_sse_resp(stream)
+        )
+        c = TestClient(app)
+        tid = c.post("/api/turns/s-1", json={"content": "hi"}).json()["turn_id"]
+        with c.stream("GET", f"/api/turns/s-1/stream?turn_id={tid}") as resp:
+            raw = b"".join(resp.iter_bytes())
+        return [e["event"] for e in _parse_browser_sse(raw)]
+
+    @respx.mock
+    def test_full_event_vocab(self) -> None:
+        """full_event_vocab [scenario]: a stream with the non-terminal Event
+        types (incl. AffectUpdate) + Done → each serialized to its fixture-
+        shaped browser event. Error / Cancelled are terminal and exclusive
+        with Done, so they get dedicated tests below.
+        """
+        from ratatoskr.web.server import create_app
+
+        stream = b"".join([
+            _sse_chunk("42:1", {"type": "affect_update", "status": "current", "turn_id": 42,
+                                "snapshot": {"agent_id": "mimir", "pad": {}, "dominant_emotion": "x"}}),
+            _sse_chunk("42:2", {"type": "worker_phase", "phase": "BuildingPrompt", "turn_id": 42}),
+            _sse_chunk("42:3", {"type": "thinking", "content": "hmm"}),
+            _sse_chunk("42:4", {"type": "text", "content": "hi"}),
+            _sse_chunk("42:5", {"type": "text_boundary", "kind": "sentence", "char_offset": 2, "ts": "t"}),
+            _sse_chunk("42:6", {"type": "tool_start", "name": "s", "arguments": {"q": "x"}}),
+            _sse_chunk("42:7", {"type": "tool_result", "name": "s", "result": {"n": 1}, "duration_ms": 3}),
+            _sse_chunk("42:8", {"type": "awaiting_llm_first_token", "turn_id": 42,
+                                "elapsed_ms_since_building_prompt": 5000.0}),
+            _sse_chunk("42:9", _DONE_BODY),
+        ])
+        types = self._drive_stream(create_app(_mock_client_factory()), stream)
+        for expected in ("affect_update", "worker_phase", "thinking", "text", "text_boundary",
+                         "tool_start", "tool_result", "awaiting_llm_first_token", "done"):
+            assert expected in types, f"missing browser event {expected}"
+
+    @respx.mock
+    def test_error_terminal_event(self) -> None:
+        """error terminal [scenario]: an SSE `error` event (distinct from the
+        synthetic connection-error event) proxies to a browser `error` event.
+        """
+        from ratatoskr.web.server import create_app
+
+        stream = _sse_chunk("42:1", {"type": "text", "content": "x"}) + _sse_chunk(
+            "42:2", {"type": "error", "phase": "failed",
+                     "error_code": "llm_output_invalid", "message": "boom"},
+        )
+        types = self._drive_stream(create_app(_mock_client_factory()), stream)
+        assert "error" in types
+
+    @respx.mock
+    def test_cancelled_terminal_event(self) -> None:
+        """cancelled terminal [scenario]: an SSE `cancelled` event proxies to
+        a browser `cancelled` event."""
+        from ratatoskr.web.server import create_app
+
+        stream = _sse_chunk("42:1", {"type": "text", "content": "x"}) + _sse_chunk(
+            "42:2", {"type": "cancelled", "phase": "cancelled", "turn_id": 42,
+                     "reason": "user_cancel", "partial_message_id": None},
+        )
+        types = self._drive_stream(create_app(_mock_client_factory()), stream)
+        assert "cancelled" in types
+
+
+class TestDisconnectCancel:
+    """stream_turn_endpoint INV-005 — browser disconnect mid-stream triggers
+    upstream cancel against the UPSTREAM turn_id. The load-bearing test that
+    would have caught the v0.15.x turn_id bug.
+
+    Drives the endpoint's StreamingResponse body_iterator directly and
+    cancels the consuming task to simulate the disconnect. This avoids the
+    ASGITransport stream-context-exit deadlock against a gated upstream
+    generator, while exercising the real `except asyncio.CancelledError`
+    cleanup path inside the generator.
+    """
+
+    @respx.mock
+    async def test_disconnect_triggers_upstream_cancel(self) -> None:
+        import asyncio
+
+        from starlette.requests import Request
+
+        from ratatoskr.web.server import TurnHandle, _stream_turn_endpoint, create_app
+
+        gate = asyncio.Event()
+
+        class _GatedAfterFirst(httpx.AsyncByteStream):
+            async def __aiter__(self):
+                yield _sse_chunk("42:1", {"type": "text", "content": "x"})
+                await gate.wait()
+
+            async def aclose(self) -> None:
+                return None
+
+        respx.post("https://w.example/sessions/s-1/messages").mock(
+            return_value=_sse_resp_stream(_GatedAfterFirst())
+        )
+        cancel_route = respx.post("https://w.example/sessions/s-1/turns/42/cancel").mock(
+            return_value=httpx.Response(200, json={
+                "turn_id": 42, "cancelled": True, "reason": None, "partial_message_id": None,
+            })
+        )
+        app = create_app(_mock_client_factory())
+        app.state.turn_registry[("s-1", 1)] = TurnHandle(
+            session_id="s-1", turn_id=1, content="x",
+        )
+        request = Request({
+            "type": "http", "method": "GET", "path": "/api/turns/s-1/stream",
+            "path_params": {"session_id": "s-1"},
+            "query_string": b"turn_id=1", "headers": [], "app": app,
+        })
+        response = await _stream_turn_endpoint(request)
+        body_iter = response.body_iterator  # type: ignore[attr-defined]
+
+        async def consume() -> None:
+            async for _chunk in body_iter:
+                pass
+
+        task = asyncio.create_task(consume())
+        # Wait until the generator has captured the upstream turn_id (first
+        # event consumed). The handle is popped in finally, so check it
+        # before cancelling.
+        for _ in range(100):
+            h = app.state.turn_registry.get(("s-1", 1))
+            if h is not None and h.upstream_turn_id == 42:
+                break
+            await asyncio.sleep(0.02)
+        else:
+            gate.set()
+            raise AssertionError("upstream_turn_id was never captured")
+
+        # Simulate browser disconnect: cancel the consuming task.
+        task.cancel()
+        try:
+            await task
+        except asyncio.CancelledError:
+            pass
+
+        for _ in range(50):
+            if cancel_route.called:
+                break
+            await asyncio.sleep(0.02)
+        gate.set()
+        assert cancel_route.called, "browser disconnect must cancel the UPSTREAM turn (42)"

uv.lock

@@ -329,6 +329,42 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl", hash = "sha256:2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55", size = 78784 },
 ]
 
+[[package]]
+name = "httptools"
+version = "0.8.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/43/e5/d471fcb0e14523fe1c3f4ba58ca52480e7bd70ad7109a3846bc75892f7fb/httptools-0.8.0.tar.gz", hash = "sha256:6b2a32f18d97e16e90827d7a819ffa8dbd8cc245fc4e1fa9d1095b54ef4bd999", size = 271342 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/14/88/1d21a36da8f5cb0fa49eafd4b169eba5608d57e75bbcf61845cbc6243216/httptools-0.8.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:880490234c10f70a9830743097e8958d6e4b9f5a0ffc24515023afeef984054d", size = 208247 },
+    { url = "https://files.pythonhosted.org/packages/a5/42/cc4feea2945cb3051038f090c9b36bd5b8a9d7f5a894a506a8983e33fd1c/httptools-0.8.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:5931891fb7b441b8a3853cf1b85c82c903defce084dd5f6771ca46e31bf862c5", size = 113064 },
+    { url = "https://files.pythonhosted.org/packages/e3/a6/febbb8b8db0f58b38e44ad6cb946e6a255ae49b55f2e8543408fb7501ccd/httptools-0.8.0-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:b15fc622b0f869d19207c4089a501d9bcc63ca5e071ffdd2f03f922df882dcb2", size = 523851 },
+    { url = "https://files.pythonhosted.org/packages/b7/e4/f90a0df0b83beff265b7e3b65f2a4cefd95792d4be0ac3e16049f2acd3c2/httptools-0.8.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:425f83884fd6343828d8c565f046cb72b6d19063f6924093e11bcd8e1548cd09", size = 518842 },
+    { url = "https://files.pythonhosted.org/packages/9e/2d/0c9ac76dd2c893841fbf6498d6acec4f2442e1b7067f6e3e316a80e494e8/httptools-0.8.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:ef7c3c97f4311c7be57e2986629df89d49cb434dbff78eafcd48c2bff986b15a", size = 501238 },
+    { url = "https://files.pythonhosted.org/packages/ca/42/906adc91ae3a5fa9c59c0a2f21c139725bd7e5b41ae6acd485cd14123ebf/httptools-0.8.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:a1afd7c9fbff0d9f5d489c4ce2768bd09c84a46ddefc7161e6aa82ae35c85745", size = 509567 },
+    { url = "https://files.pythonhosted.org/packages/05/0b/4240efeb672751ee5b9b380cb0e3fdc050bc05f68adc7a8aefc4fcd9a69a/httptools-0.8.0-cp312-cp312-win_amd64.whl", hash = "sha256:cd96f29b4bab1d42fa6e3d008711c75e0f79e94e06827330160e3a304227f150", size = 90918 },
+    { url = "https://files.pythonhosted.org/packages/5e/e5/8cfcabc5546e8022f168be28bcdaa128a240a0befdd03b59d558b4f18bd6/httptools-0.8.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:614ceea8ea606848bece2338ac03b3ce5324bcb4be8dc7d377ed708012fa4db8", size = 205148 },
+    { url = "https://files.pythonhosted.org/packages/2a/0e/0fb14848c19a686c8062ff9067c1a48793e3224b47bc5b201535b6036fce/httptools-0.8.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:2d689918c15a013c65ef52d9fd495d766893ab831a2c8d89f2ac5940a5df847c", size = 111368 },
+    { url = "https://files.pythonhosted.org/packages/2e/1b/46f1cecf06b9bbde8e4b8c88034ac7908989e5ff7a3a388ef38392949c1f/httptools-0.8.0-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:eb3028cca2fc0a6d720e52ef61d8ebb62fcbfeb1de56874546d858d3f25a26b7", size = 486447 },
+    { url = "https://files.pythonhosted.org/packages/77/00/258bfc0837221f81d9725c45f9b948a6a6b2994a147a4fb66e85100c668f/httptools-0.8.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:88bdd940f2b5d487b4d032c6afa5489a7dc4694410d43de3c38c4fb3af0dc45d", size = 482448 },
+    { url = "https://files.pythonhosted.org/packages/04/ab/d1cef3b5523f4d272a70f42a776c3169a2dddfe3a54de4b2ce4a36341528/httptools-0.8.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:6a43c9dd399758ccc0531acb0a3c4a6c299ee893ee9400e9c893b7bdcfae0681", size = 464460 },
+    { url = "https://files.pythonhosted.org/packages/ce/48/5d1d072442277bb2b3434e0e60690b8e8c23840ef7de8b6ea54040a536d3/httptools-0.8.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:0770728beb05094c809b98e814edff5fef69d26ad7d21185f2f6d5884a0ba683", size = 471312 },
+    { url = "https://files.pythonhosted.org/packages/0d/66/b96623b27e51a68199ef4efdda0613cced9233fe3062ac74e50749c5ad37/httptools-0.8.0-cp313-cp313-win_amd64.whl", hash = "sha256:7685df791fad561384bfb139e77fde27a1ffd93134e016f95a0db424ffbf77b1", size = 90117 },
+    { url = "https://files.pythonhosted.org/packages/1a/12/fa3fbf5f9517b273edea2dc982aa82a8c634091e67c590792b729017bc6f/httptools-0.8.0-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:de242a49b5d18e0a8776e654e9f6bf6d89f3875a5c35b425a0e7ce940feb3fd6", size = 206183 },
+    { url = "https://files.pythonhosted.org/packages/30/fc/5e7c4cb443370f2090a3aba0453a07384d29ff66b7435bb90e77e1037599/httptools-0.8.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:159e9ab5f701ccd42e555a12f1ad8ff69702910fc1c996cf2bb66e5fcb7a231b", size = 112079 },
+    { url = "https://files.pythonhosted.org/packages/ba/53/771bd891eb0f236f32145d6a1775777ec85745f3cc983a1f23d1a3b8ddfe/httptools-0.8.0-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:c4a9f1707e4823d54dfec6c33fa3697d302aed536ed352a7ebb5a061ddb869d0", size = 481596 },
+    { url = "https://files.pythonhosted.org/packages/62/42/94e15bc68ce3d423243c45d7f1b0c7561f13844f97dc52ae23182fb65628/httptools-0.8.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d76ad7b951387e3632c8716a9bb03ac5b45c5f16119aa409db0459520887944e", size = 480865 },
+    { url = "https://files.pythonhosted.org/packages/1c/7c/fe2980fc03723272e30f135b62360b075f513dfe7cc73aef36c7f04012bd/httptools-0.8.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:a3b7387147361c3fd47a0bde763c5c91b5b4cd4dc9989b8ece84ff436c99843b", size = 463189 },
+    { url = "https://files.pythonhosted.org/packages/15/1b/47fc5fff68acd1bfa20b4734059c9a06cadb88119dcd5258b5b0d21d91c8/httptools-0.8.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:f256d6ce930c52ca1cb2a960b7da03548c454e7d28b06059ad41bfe789036ce0", size = 466610 },
+    { url = "https://files.pythonhosted.org/packages/60/bd/07b13c93ffd9bec9546e0d43f8e19378dd696dbd278511406bc07371ef1f/httptools-0.8.0-cp314-cp314-win_amd64.whl", hash = "sha256:19d1ee275bb59ba2643ba9a3a1e51cc0c788caf2b8df506368e03f56fdd08527", size = 92705 },
+    { url = "https://files.pythonhosted.org/packages/fd/c4/121648f68ce066d7bd762d6b6d97e620847642d38d54f3d90ff11d947629/httptools-0.8.0-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:de1ed58a974e75d56560acc7e7fed01a454994429456f65209789992e41f2568", size = 215023 },
+    { url = "https://files.pythonhosted.org/packages/b9/b0/312a062ae741ae3e8baa8c8bf20be81b2e67337b259ab4349bebc7b6142e/httptools-0.8.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:e93c227b595c6926c1acee96891dd9da4be338cfbe82e5cd3bb9d8dd7dc4ac0b", size = 117405 },
+    { url = "https://files.pythonhosted.org/packages/fc/37/fccd705f795386bb05bf413012fecff2a33e5aa8c2f069096de3e9fd8702/httptools-0.8.0-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:2a021c3a8e65cc125390d72f59b968afca3bdcaff25bd67965e0a055a14946ca", size = 558497 },
+    { url = "https://files.pythonhosted.org/packages/bd/39/f172e8003576de35f5ba77ff417cf0e34429d35dc014deef15afa337a72c/httptools-0.8.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:48774d39cbb70e2b1f71f88852a3087ae1d3a1eb80482bb48c13067ab080c14f", size = 571585 },
+    { url = "https://files.pythonhosted.org/packages/3e/b9/f5564760af99f3dbbf3f9104dc00e5da27e96cf433c6bdcf77617f70bf3f/httptools-0.8.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:88eead8ec8680a9f146c655bc88445a325bd7921cfd8194c7337e9467282427d", size = 543297 },
+    { url = "https://files.pythonhosted.org/packages/99/67/8d9f2c313618e161b82f3873188e7196126da1d6e29688df40eb3997c77a/httptools-0.8.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:2c032fa028f46871ec7e1fc59fc15e8023eab3e6bbe6ece786a1611719a5d081", size = 539535 },
+    { url = "https://files.pythonhosted.org/packages/48/63/b906c01e53f50d432c0defe43ce52764a111dc1bdd028bafbeb54dcfd008/httptools-0.8.0-cp314-cp314t-win_amd64.whl", hash = "sha256:384c17174464c8e873398b7af24f0b1f44d992c820328413951a625323155d77", size = 108209 },
+]
+
 [[package]]
 name = "httpx"
 version = "0.28.1"
@@ -920,6 +956,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/e5/35/f8b19922b6a25bc0880171a2f1a003eaeb93657475193ab516fd87cac9da/pytest_asyncio-1.3.0-py3-none-any.whl", hash = "sha256:611e26147c7f77640e6d0a92a38ed17c3e9848063698d5c93d5aa7aa11cebff5", size = 15075 },
 ]
 
+[[package]]
+name = "python-dotenv"
+version = "1.2.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/82/ed/0301aeeac3e5353ef3d94b6ec08bbcabd04a72018415dcb29e588514bba8/python_dotenv-1.2.2.tar.gz", hash = "sha256:2c371a91fbd7ba082c2c1dc1f8bf89ca22564a087c2c287cd9b662adde799cf3", size = 50135 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0b/d7/1959b9648791274998a9c3526f6d0ec8fd2233e4d4acce81bbae76b44b2a/python_dotenv-1.2.2-py3-none-any.whl", hash = "sha256:1d8214789a24de455a8b8bd8ae6fe3c6b69a5e3d64aa8a8e5d68e694bbcb285a", size = 22101 },
+]
+
 [[package]]
 name = "pyyaml"
 version = "6.0.3"
@@ -968,7 +1013,7 @@ wheels = [
 
 [[package]]
 name = "ratatoskr"
-version = "0.2.0"
+version = "0.17.0"
 source = { editable = "." }
 dependencies = [
     { name = "httpx" },
@@ -984,7 +1029,13 @@ dev = [
     { name = "pyyaml" },
     { name = "respx" },
     { name = "ruff" },
+    { name = "starlette" },
     { name = "textual-dev" },
+    { name = "uvicorn", extra = ["standard"] },
+]
+web = [
+    { name = "starlette" },
+    { name = "uvicorn", extra = ["standard"] },
 ]
 
 [package.metadata]
@@ -995,12 +1046,15 @@ requires-dist = [
     { name = "pytest", marker = "extra == 'dev'", specifier = ">=8" },
     { name = "pytest-asyncio", marker = "extra == 'dev'", specifier = ">=0.24" },
     { name = "pyyaml", marker = "extra == 'dev'", specifier = ">=6" },
+    { name = "ratatoskr", extras = ["web"], marker = "extra == 'dev'" },
     { name = "respx", marker = "extra == 'dev'", specifier = ">=0.21" },
     { name = "ruff", marker = "extra == 'dev'", specifier = ">=0.6" },
+    { name = "starlette", marker = "extra == 'web'", specifier = ">=0.40" },
     { name = "textual", specifier = ">=0.85" },
     { name = "textual-dev", marker = "extra == 'dev'", specifier = ">=1.5" },
+    { name = "uvicorn", extras = ["standard"], marker = "extra == 'web'", specifier = ">=0.30" },
 ]
-provides-extras = ["dev"]
+provides-extras = ["web", "dev"]
 
 [[package]]
 name = "respx"
@@ -1052,6 +1106,19 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/9b/36/9c015cd052fca743dae8cb2aeb16b551444787467db42ceab0fc968865af/ruff-0.15.13-py3-none-win_arm64.whl", hash = "sha256:2471da9bd1068c8c064b5fd9c0c4b6dddffd6369cb1cd68b29993b1709ff1b21", size = 11179336 },
 ]
 
+[[package]]
+name = "starlette"
+version = "1.1.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio" },
+    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/95/66/4d20cdf39a8d6a51e663b7038e3b828ff211d3891a43a713fe7e4643f3a8/starlette-1.1.0.tar.gz", hash = "sha256:e83c7fe0ddecd8719c5b840080325aec0260acec86e9832899e377b91d65e90f", size = 2660060 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/93/79/920b8e0a8b20f793e8d64855095cb8febabf6175b8550b6f7a547d813891/starlette-1.1.0-py3-none-any.whl", hash = "sha256:7f0dfd38e428aad5cb6f9f667f0ca1d2d8ca3f3385dccac8305f79ec98458382", size = 72899 },
+]
+
 [[package]]
 name = "textual"
 version = "8.2.7"
@@ -1120,6 +1187,193 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/61/73/d21edf5b204d1467e06500080a50f79d49ef2b997c79123a536d4a17d97c/uc_micro_py-2.0.0-py3-none-any.whl", hash = "sha256:3603a3859af53e5a39bc7677713c78ea6589ff188d70f4fee165db88e22b242c", size = 6383 },
 ]
 
+[[package]]
+name = "uvicorn"
+version = "0.48.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "click" },
+    { name = "h11" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/e6/bf/f6544ba992ddb9a6077343a576f9844f7f8f06ab819aefd00206e9255f18/uvicorn-0.48.0.tar.gz", hash = "sha256:a5504207195d08c2511bf9125ede5ac4a4b71725d519e758d01dcf0bc2d31c37", size = 91074 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/01/be/72532be3da7acc5fdfbccdb95215cd04f995a0886532a5b423f929cda4cc/uvicorn-0.48.0-py3-none-any.whl", hash = "sha256:48097851328b87ec36117d3d575234519eb58c2b22d79666e9bbc6c49a761dad", size = 71410 },
+]
+
+[package.optional-dependencies]
+standard = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+    { name = "httptools" },
+    { name = "python-dotenv" },
+    { name = "pyyaml" },
+    { name = "uvloop", marker = "platform_python_implementation != 'PyPy' and sys_platform != 'cygwin' and sys_platform != 'win32'" },
+    { name = "watchfiles" },
+    { name = "websockets" },
+]
+
+[[package]]
+name = "uvloop"
+version = "0.22.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/06/f0/18d39dbd1971d6d62c4629cc7fa67f74821b0dc1f5a77af43719de7936a7/uvloop-0.22.1.tar.gz", hash = "sha256:6c84bae345b9147082b17371e3dd5d42775bddce91f885499017f4607fdaf39f", size = 2443250 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3d/ff/7f72e8170be527b4977b033239a83a68d5c881cc4775fca255c677f7ac5d/uvloop-0.22.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:fe94b4564e865d968414598eea1a6de60adba0c040ba4ed05ac1300de402cd42", size = 1359936 },
+    { url = "https://files.pythonhosted.org/packages/c3/c6/e5d433f88fd54d81ef4be58b2b7b0cea13c442454a1db703a1eea0db1a59/uvloop-0.22.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:51eb9bd88391483410daad430813d982010f9c9c89512321f5b60e2cddbdddd6", size = 752769 },
+    { url = "https://files.pythonhosted.org/packages/24/68/a6ac446820273e71aa762fa21cdcc09861edd3536ff47c5cd3b7afb10eeb/uvloop-0.22.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:700e674a166ca5778255e0e1dc4e9d79ab2acc57b9171b79e65feba7184b3370", size = 4317413 },
+    { url = "https://files.pythonhosted.org/packages/5f/6f/e62b4dfc7ad6518e7eff2516f680d02a0f6eb62c0c212e152ca708a0085e/uvloop-0.22.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7b5b1ac819a3f946d3b2ee07f09149578ae76066d70b44df3fa990add49a82e4", size = 4426307 },
+    { url = "https://files.pythonhosted.org/packages/90/60/97362554ac21e20e81bcef1150cb2a7e4ffdaf8ea1e5b2e8bf7a053caa18/uvloop-0.22.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e047cc068570bac9866237739607d1313b9253c3051ad84738cbb095be0537b2", size = 4131970 },
+    { url = "https://files.pythonhosted.org/packages/99/39/6b3f7d234ba3964c428a6e40006340f53ba37993f46ed6e111c6e9141d18/uvloop-0.22.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:512fec6815e2dd45161054592441ef76c830eddaad55c8aa30952e6fe1ed07c0", size = 4296343 },
+    { url = "https://files.pythonhosted.org/packages/89/8c/182a2a593195bfd39842ea68ebc084e20c850806117213f5a299dfc513d9/uvloop-0.22.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:561577354eb94200d75aca23fbde86ee11be36b00e52a4eaf8f50fb0c86b7705", size = 1358611 },
+    { url = "https://files.pythonhosted.org/packages/d2/14/e301ee96a6dc95224b6f1162cd3312f6d1217be3907b79173b06785f2fe7/uvloop-0.22.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:1cdf5192ab3e674ca26da2eada35b288d2fa49fdd0f357a19f0e7c4e7d5077c8", size = 751811 },
+    { url = "https://files.pythonhosted.org/packages/b7/02/654426ce265ac19e2980bfd9ea6590ca96a56f10c76e63801a2df01c0486/uvloop-0.22.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6e2ea3d6190a2968f4a14a23019d3b16870dd2190cd69c8180f7c632d21de68d", size = 4288562 },
+    { url = "https://files.pythonhosted.org/packages/15/c0/0be24758891ef825f2065cd5db8741aaddabe3e248ee6acc5e8a80f04005/uvloop-0.22.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0530a5fbad9c9e4ee3f2b33b148c6a64d47bbad8000ea63704fa8260f4cf728e", size = 4366890 },
+    { url = "https://files.pythonhosted.org/packages/d2/53/8369e5219a5855869bcee5f4d317f6da0e2c669aecf0ef7d371e3d084449/uvloop-0.22.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:bc5ef13bbc10b5335792360623cc378d52d7e62c2de64660616478c32cd0598e", size = 4119472 },
+    { url = "https://files.pythonhosted.org/packages/f8/ba/d69adbe699b768f6b29a5eec7b47dd610bd17a69de51b251126a801369ea/uvloop-0.22.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:1f38ec5e3f18c8a10ded09742f7fb8de0108796eb673f30ce7762ce1b8550cad", size = 4239051 },
+    { url = "https://files.pythonhosted.org/packages/90/cd/b62bdeaa429758aee8de8b00ac0dd26593a9de93d302bff3d21439e9791d/uvloop-0.22.1-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:3879b88423ec7e97cd4eba2a443aa26ed4e59b45e6b76aabf13fe2f27023a142", size = 1362067 },
+    { url = "https://files.pythonhosted.org/packages/0d/f8/a132124dfda0777e489ca86732e85e69afcd1ff7686647000050ba670689/uvloop-0.22.1-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:4baa86acedf1d62115c1dc6ad1e17134476688f08c6efd8a2ab076e815665c74", size = 752423 },
+    { url = "https://files.pythonhosted.org/packages/a3/94/94af78c156f88da4b3a733773ad5ba0b164393e357cc4bd0ab2e2677a7d6/uvloop-0.22.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:297c27d8003520596236bdb2335e6b3f649480bd09e00d1e3a99144b691d2a35", size = 4272437 },
+    { url = "https://files.pythonhosted.org/packages/b5/35/60249e9fd07b32c665192cec7af29e06c7cd96fa1d08b84f012a56a0b38e/uvloop-0.22.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c1955d5a1dd43198244d47664a5858082a3239766a839b2102a269aaff7a4e25", size = 4292101 },
+    { url = "https://files.pythonhosted.org/packages/02/62/67d382dfcb25d0a98ce73c11ed1a6fba5037a1a1d533dcbb7cab033a2636/uvloop-0.22.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:b31dc2fccbd42adc73bc4e7cdbae4fc5086cf378979e53ca5d0301838c5682c6", size = 4114158 },
+    { url = "https://files.pythonhosted.org/packages/f0/7a/f1171b4a882a5d13c8b7576f348acfe6074d72eaf52cccef752f748d4a9f/uvloop-0.22.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:93f617675b2d03af4e72a5333ef89450dfaa5321303ede6e67ba9c9d26878079", size = 4177360 },
+    { url = "https://files.pythonhosted.org/packages/79/7b/b01414f31546caf0919da80ad57cbfe24c56b151d12af68cee1b04922ca8/uvloop-0.22.1-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:37554f70528f60cad66945b885eb01f1bb514f132d92b6eeed1c90fd54ed6289", size = 1454790 },
+    { url = "https://files.pythonhosted.org/packages/d4/31/0bb232318dd838cad3fa8fb0c68c8b40e1145b32025581975e18b11fab40/uvloop-0.22.1-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:b76324e2dc033a0b2f435f33eb88ff9913c156ef78e153fb210e03c13da746b3", size = 796783 },
+    { url = "https://files.pythonhosted.org/packages/42/38/c9b09f3271a7a723a5de69f8e237ab8e7803183131bc57c890db0b6bb872/uvloop-0.22.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:badb4d8e58ee08dad957002027830d5c3b06aea446a6a3744483c2b3b745345c", size = 4647548 },
+    { url = "https://files.pythonhosted.org/packages/c1/37/945b4ca0ac27e3dc4952642d4c900edd030b3da6c9634875af6e13ae80e5/uvloop-0.22.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b91328c72635f6f9e0282e4a57da7470c7350ab1c9f48546c0f2866205349d21", size = 4467065 },
+    { url = "https://files.pythonhosted.org/packages/97/cc/48d232f33d60e2e2e0b42f4e73455b146b76ebe216487e862700457fbf3c/uvloop-0.22.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:daf620c2995d193449393d6c62131b3fbd40a63bf7b307a1527856ace637fe88", size = 4328384 },
+    { url = "https://files.pythonhosted.org/packages/e4/16/c1fd27e9549f3c4baf1dc9c20c456cd2f822dbf8de9f463824b0c0357e06/uvloop-0.22.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:6cde23eeda1a25c75b2e07d39970f3374105d5eafbaab2a4482be82f272d5a5e", size = 4296730 },
+]
+
+[[package]]
+name = "watchfiles"
+version = "1.2.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/cd/41/5e1a4bb12aac5f1493fa1bdc11154eca3b258ca4eba65d39c473fe19d8e9/watchfiles-1.2.0.tar.gz", hash = "sha256:c995fba777f1ea992f090f9236e9284cf7a5d1a0130dd5a3d82c598cacd76838", size = 108252 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b8/2f/e42c992d2afda3108ea1c02acecc991b9f31d05c14adc2a7cee9ee211fc4/watchfiles-1.2.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:bc13eb17538be00c874699dc0abe4ee2bc8d50bb1166a6b9e175ef3fd7eb8f26", size = 400115 },
+    { url = "https://files.pythonhosted.org/packages/5f/8f/6af2ea19065c91d8b0ea3516fdfc8c0d349f407e8e9fbf4e5a17360de8ad/watchfiles-1.2.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:2d95ddc1eb6914154253d239089900813f6a767e174b8e6a50e7fdacb7e4236c", size = 393659 },
+    { url = "https://files.pythonhosted.org/packages/13/01/b32a967c56fb3e3e5be3db52c3d3b87fa4513aa367d8ed1ad96d42952e5f/watchfiles-1.2.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8f70d8b291ef6e88d19b1f297a6905ddb978888d9272b0d05e6f53309856bcfc", size = 453207 },
+    { url = "https://files.pythonhosted.org/packages/04/98/97557a812180338cb1abd32e1cffcc4588f59b5f23e0cb006b2ba95ba64a/watchfiles-1.2.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:56d8641cf834c2836922899105bd3ce3d0dfc69291d52edf0b4d0436829b34c0", size = 459273 },
+    { url = "https://files.pythonhosted.org/packages/e8/a8/b4b08dcb7653b8087c6586f7ce649505900e866bbcfe40dc9587af02e686/watchfiles-1.2.0-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:2581a94056e55d7d0a31a823ea92bf73749c489ca2285bfdc0fbe6b2bb49d50c", size = 489927 },
+    { url = "https://files.pythonhosted.org/packages/50/94/3dceea03545d2e5ddfd839f0ddd5e1cecbf1697b5a428d5ba11cef6af95d/watchfiles-1.2.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:41bc1199f7523b3f82843c88cbb979180c949caef0342cf90968f178e5d49b01", size = 570476 },
+    { url = "https://files.pythonhosted.org/packages/cc/f2/d39a5450c3532092b91f81d274360e613c2371bc874a89c7a1a3c5e8d138/watchfiles-1.2.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7571e4464cb6e434958f867f7f730b8ab0b75e3f8e5eac0499168486ab3c33a8", size = 465650 },
+    { url = "https://files.pythonhosted.org/packages/22/24/ed72f68cbc1333ca9b9f2200aa048bb6658ae41709bc1caad4310f4bdffd/watchfiles-1.2.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e53a384f76b631c3ae5334ce6a52f0baa3a911eb94a4eac7f160079868b716d5", size = 456398 },
+    { url = "https://files.pythonhosted.org/packages/0d/64/982ef4a4e5bab5b6e5b6becc8cd5e732f6130a78b855f0abec6439a9a135/watchfiles-1.2.0-cp312-cp312-manylinux_2_31_riscv64.whl", hash = "sha256:d20029a60a71a052a24c4db7673bc4de39ab89adbaccbfb5d67987c5d73f424d", size = 465140 },
+    { url = "https://files.pythonhosted.org/packages/a0/0c/95282abf4ed680b6096010bcfc30c5fa7a041fc5aa5a2ad17a2cc6c75bba/watchfiles-1.2.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:2cb93af48550faf1cea04c303107c8b75833de7013e57ce27d3b8d21d8d0f58c", size = 630259 },
+    { url = "https://files.pythonhosted.org/packages/30/45/607c1de1530c4bdcf2cf1d1ecc2505ddba5d96bd43ba9f2b0e79876f850f/watchfiles-1.2.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:2995c176de7692b86a2e4c58d9ec718f753150a979cb4a754e2b4ffa38e70906", size = 659859 },
+    { url = "https://files.pythonhosted.org/packages/fa/08/d9e2e0f9e8e6791d33aefc694ad7eefa7f901f63caff84a81ded38692f9c/watchfiles-1.2.0-cp312-cp312-win32.whl", hash = "sha256:7a2cffd17d27d2ecbb310c2b1d8174f222a5495b1a721894afa88ec11e25b898", size = 275480 },
+    { url = "https://files.pythonhosted.org/packages/1c/e6/9d42569c0102645cc8cea5d8c7d8a1e9d4ada2cb7f05f75e554b8aa2202a/watchfiles-1.2.0-cp312-cp312-win_amd64.whl", hash = "sha256:f155b3a1b2a5fc89cdc70d47ee5d54e3b75e88efa34982028a35daef9ba00379", size = 288718 },
+    { url = "https://files.pythonhosted.org/packages/0a/26/88e0dc6ee3898169d7fa22bb6a69cabf2502d2ee25cb8c876d1262d204f8/watchfiles-1.2.0-cp312-cp312-win_arm64.whl", hash = "sha256:8fa585ede612ee9f9e91b18bebf9ba11b9ae29a4e3a0d0cf6fca3e382133f0d5", size = 281026 },
+    { url = "https://files.pythonhosted.org/packages/d1/4d/70a7feced9f87e2ff26dba42667290f41694fc64646c67261fbb8cab5d5c/watchfiles-1.2.0-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:01ea8d66f0693b9b60a6541c8d10263091ca9a9060d242f3c1f3143f9aad2c98", size = 399730 },
+    { url = "https://files.pythonhosted.org/packages/31/3a/0da302f2307aee316922806ebd5726c542cbd787c938271cf14a074c7daf/watchfiles-1.2.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:7ba0480b9a74af058f43b337e937a451e109295c420916d68ad24e3dc02f5e44", size = 392842 },
+    { url = "https://files.pythonhosted.org/packages/db/ef/d5bdb705c224dbc256aa0c1ec47bf4e61ec52558f2afb44a71a1fe4d7015/watchfiles-1.2.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4f34e26a19f91f710c08e0183429f0d1d15df734e6bc78c31e77b9ea9c433658", size = 452989 },
+    { url = "https://files.pythonhosted.org/packages/71/29/5495f2c1661949ef7a35e4d71111d129cfe7606414a26887a919d0a55406/watchfiles-1.2.0-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:b4e77f6a55f858504069abd35d336a637555c09bca453dde1ee1e5ada8a6a1fb", size = 458978 },
+    { url = "https://files.pythonhosted.org/packages/d5/8c/7f9c07c433811c2fffd93e13fdfb7135de9aab5f2ae41be08960fa0047dc/watchfiles-1.2.0-cp313-cp313-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0cb4d80e212f116474a545c21c912b445f16bb0cef9e6a73a498164223e14e2f", size = 490248 },
+    { url = "https://files.pythonhosted.org/packages/3c/11/d93632febc52fbc21be90231bb7c17fd5387f46c9076fd40a5f9c2ae6910/watchfiles-1.2.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b974946a10af379d425e2eef5b62f5c6ebeaccf91d45eaad6f5b27ecd4f91aa0", size = 571847 },
+    { url = "https://files.pythonhosted.org/packages/55/b4/383173e73aabb07ad1d9c7aa859d95437ac46a6d6a1e11005facda0c9d19/watchfiles-1.2.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:86bc13c25a8d1fcd70b51d0ce7c9b65e90de5666fcbfd3e34957cc73ee19aeb5", size = 465974 },
+    { url = "https://files.pythonhosted.org/packages/a7/6c/89b1a230a78f57c52dd8893adb1f92f94411721b6ec12596c56d98c74356/watchfiles-1.2.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ca148d73dea36c9763aaa351e4d7a51780ec1584217c45276f4fe8239c768b71", size = 454782 },
+    { url = "https://files.pythonhosted.org/packages/24/62/1732118367cfff0a9fce3bf62ff4bfded09ef5df21d9d446b858b3f70a96/watchfiles-1.2.0-cp313-cp313-manylinux_2_31_riscv64.whl", hash = "sha256:c525543d91961c6955b2636b308569e84a1d1c5f5f2932041ab9ef46422f43e3", size = 465182 },
+    { url = "https://files.pythonhosted.org/packages/28/96/716f7e5f51339bf22963f3345f9f27d7f3b30e2eadc597e257c881dd3c53/watchfiles-1.2.0-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:a204794696ffb8f9b10fba6f7cb5216d42f3b2b71860ccac6b6e42f5f10973b0", size = 629841 },
+    { url = "https://files.pythonhosted.org/packages/4c/fe/c40783950fd771ccf66ab3ec2722d188a9af1c7f96c6e811f36e40c6e03f/watchfiles-1.2.0-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:10d86db20695afe7997ac9e1717637d6714a8d0220458c33f3d2061f54cec427", size = 658028 },
+    { url = "https://files.pythonhosted.org/packages/71/72/4508db1856d1d87fcbb3b63f4839bab1b5682cb0e8d224d122263c09654a/watchfiles-1.2.0-cp313-cp313-win32.whl", hash = "sha256:eb283ee99e21ad6443c8cdb06ac5b34b1308c329cbdf03fa02b445363714c799", size = 275183 },
+    { url = "https://files.pythonhosted.org/packages/f9/36/14b76ca57652e5cc5fd1c11f32a261292c08a0d19a00351013c2549cbfb2/watchfiles-1.2.0-cp313-cp313-win_amd64.whl", hash = "sha256:a0f27f01bee51861392bb6b7c4fdb290b27d1eb194e9e28788d68102a0e898d9", size = 288059 },
+    { url = "https://files.pythonhosted.org/packages/1b/8d/0a85e395398d8d20fadfe5c5d32c726eee17a519e78fb356f2cf7531bffe/watchfiles-1.2.0-cp313-cp313-win_arm64.whl", hash = "sha256:3651aa7058595e9cfb75d35dd5ada2bf9f48a5b8a0f3562821d3e210c507e077", size = 280186 },
+    { url = "https://files.pythonhosted.org/packages/37/68/36db056f1fdcc5f07302f56e631774d6835bcd6fa3ace402304621d5f9e5/watchfiles-1.2.0-cp313-cp313t-macosx_10_12_x86_64.whl", hash = "sha256:faea288b6f0ab1902ef08f4ca6de005dccf856c4e0c4f21b8c5fce02d90a1b08", size = 399031 },
+    { url = "https://files.pythonhosted.org/packages/c1/64/01a9d6f66a82a5c101ce939274106cc72759d62427e153f01edd2b9f87c2/watchfiles-1.2.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:01859b11fd9fbca670f4d5da00fbac282cfea9bd67a2125d8b2833a3b5617ea9", size = 391205 },
+    { url = "https://files.pythonhosted.org/packages/84/2c/0a44fe058cb4bb7b8ede6b6670698bbb7c0400740e378d00022189b7b31d/watchfiles-1.2.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fff610d7bb2256a317bb1e96f0d7862c7aa8076733ee5df0fd41bbe76a24a4f4", size = 451892 },
+    { url = "https://files.pythonhosted.org/packages/67/a1/351e0d56cd35e6488b5c8b4fb11a809a5bc923e8fe8fed9faf8920be0c89/watchfiles-1.2.0-cp313-cp313t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:b141a4891c995a039cd89e9a49e62df1dc8a559a5d1a6e4c7106d16c12777a55", size = 458867 },
+    { url = "https://files.pythonhosted.org/packages/d5/7d/9d09605187f1b838998624049fcf8bf47b73c1a3b76901fcac1782f62277/watchfiles-1.2.0-cp313-cp313t-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f22943b7770483f6ea0721c6b11d022947a98eb0acae14694de034f4d0d38925", size = 490217 },
+    { url = "https://files.pythonhosted.org/packages/60/5d/a17a16eccb182f04188cd308ec24b1a71a9b5c4e7098269cf35d9fa56d02/watchfiles-1.2.0-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1bc6195825b7dcd217968bb1f801a60fd4c16e8eeab5bedc7fe917d7d5995ab4", size = 571458 },
+    { url = "https://files.pythonhosted.org/packages/d3/3d/4dd457062083ab1938e5dfd45032eb425cee2ac817287ca8ff4356183e5d/watchfiles-1.2.0-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d4a4b147f5dca2a5d325a06a832fb43f345751adfbc63204aec30e0d9ca965a2", size = 464707 },
+    { url = "https://files.pythonhosted.org/packages/c6/71/ea8c57b128f5383de74d0c7d2d9c57ad7c9a65a930c451bd25d524b295b7/watchfiles-1.2.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4543579a9bdb0c9560039b4ffddbdb39545707659fbc430ce4c10f3f68d557f9", size = 454663 },
+    { url = "https://files.pythonhosted.org/packages/53/fd/2e812bf938406d7db351f0703ddd3fc6c061cf30d96153a77bc79a943a44/watchfiles-1.2.0-cp313-cp313t-manylinux_2_31_riscv64.whl", hash = "sha256:20aa0e708b920bde876a4aa82dc7dd6ebea228a63a67cda6632c2fc87b787efa", size = 463537 },
+    { url = "https://files.pythonhosted.org/packages/86/56/d17a7f1dd1bc3035f1072694a551301272f1739c2d8e319c927cb9e29b38/watchfiles-1.2.0-cp313-cp313t-musllinux_1_1_aarch64.whl", hash = "sha256:d413349d565dab74297f2a63e84a097936be69bf8f3b3801f27f380e32040f44", size = 629194 },
+    { url = "https://files.pythonhosted.org/packages/be/06/f1ff66bf5cae50aa4062779a0ecd0bbaf15e466195719074078947d9a17d/watchfiles-1.2.0-cp313-cp313t-musllinux_1_1_x86_64.whl", hash = "sha256:f28b2725eb8cce327b9b3ab02415c853011dc55c95832fe90de6bc56f5315f72", size = 656194 },
+    { url = "https://files.pythonhosted.org/packages/e7/54/a9c7ea9a82a4ac65e7004c0a03920b5cdd2f9c3b678757d9cd425aa51d53/watchfiles-1.2.0-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:b8c8358484d5fa12ef34f05b7f4168eaf1932f408725ff6d023c33ec17bd79d4", size = 400205 },
+    { url = "https://files.pythonhosted.org/packages/aa/5d/c9ab3534374a4a67450696905d6ef16a04405448b8dc52bd752ae50423d4/watchfiles-1.2.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:9f04b092229ad2c50126dd3c922c8822e51e605993764a33058d4a791ab42281", size = 392508 },
+    { url = "https://files.pythonhosted.org/packages/26/ca/1ad30103535cf0cecd7b993e8d50edc5351b1820e38f2d22e3df58962feb/watchfiles-1.2.0-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7a7ce236284f002a156f70add88efe5c70879cccbb658be0822c54b1306fc09d", size = 452448 },
+    { url = "https://files.pythonhosted.org/packages/37/a1/ceee2cdf2afbd715fa07758d39c9859513eae411b23196f7fd039e5feedd/watchfiles-1.2.0-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:b9909cc2b48468b575eefa944919e1fe8a36c5849d5c7c168f80a8c1db69398e", size = 459605 },
+    { url = "https://files.pythonhosted.org/packages/e8/f6/421e30fd1cb3907a84ed92ab3f1983e37ba2dca015e9a894a048418417a2/watchfiles-1.2.0-cp314-cp314-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0a37faaed405c67e28e6be45a1fa4f206ef5a2860f27c237db9fa30704c38242", size = 490757 },
+    { url = "https://files.pythonhosted.org/packages/41/b0/55ed1b97ed08be7bba6f9a541cac15f2a858e1d74d2b07b6da70a82aab00/watchfiles-1.2.0-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9649193aa27bd9ff2e80ff29bfaa93085496c7a3a377592823cc58b77ee88add", size = 568672 },
+    { url = "https://files.pythonhosted.org/packages/d1/cf/d8ae8a80dd7bafab395ea7681c10237311bbf34d37704a8c744e7cf31fc7/watchfiles-1.2.0-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4e4ff8e37f99cf1da89e255e07c9c4b37c214038c4283707bdec308cb1b0ea1f", size = 464197 },
+    { url = "https://files.pythonhosted.org/packages/7c/8a/3076c496ca8dafe0e8cd03fcebdfc47be4b1174b4e5b24ff6e396e6b3af2/watchfiles-1.2.0-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:054dc20fd2e3132b4c3883b4a00d72fd6e1f56fdaf89fccd12e8057d74cd74d7", size = 453181 },
+    { url = "https://files.pythonhosted.org/packages/e5/10/9745e17c98e7b8a86454df0a3c7b5686bd650383f1e9f26e4ebcbd6cc0c0/watchfiles-1.2.0-cp314-cp314-manylinux_2_31_riscv64.whl", hash = "sha256:e140ed30ebde76796b686e67c182cff10ea2fbab186fafd1560f74bb5a473a6e", size = 465109 },
+    { url = "https://files.pythonhosted.org/packages/8f/95/8ef4a95481d3e0cb52d62a06fa6e972e81424be2d9698b91a2fecca9904c/watchfiles-1.2.0-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:bb7e52ecf68ba46d22df23467b87cffeb2146908aa523ebfe803019618cfda06", size = 630653 },
+    { url = "https://files.pythonhosted.org/packages/fd/e4/3b3bf36b0f829b50c6ebcb8d031583863c59f923d6a6af3d485e470d0fac/watchfiles-1.2.0-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:23282a321c8baf9b3a3c4afff673f9fe65eb7fdc2338d765ccad9d3d1916a5ba", size = 657838 },
+    { url = "https://files.pythonhosted.org/packages/21/b1/6cbbb50c1f3002ab568777d44aa21206dfb8807a840990c4037523b51812/watchfiles-1.2.0-cp314-cp314-win32.whl", hash = "sha256:c0db965c5f79aa49fe672d297cf1febc5ad149b658594944f49a54a2b96270a7", size = 275108 },
+    { url = "https://files.pythonhosted.org/packages/92/45/190ce6db8dcb4536682cf75d3889ff1a27182a58cb519d343cb6d9ea63d8/watchfiles-1.2.0-cp314-cp314-win_amd64.whl", hash = "sha256:71283b39fd17e5408eb123bd37aeecfd9d54c81fc184421943208aadb879d103", size = 288441 },
+    { url = "https://files.pythonhosted.org/packages/74/0d/3eae1c2313ab08378431d907c3f8095ecca00f3eda33111cf4f0f2591799/watchfiles-1.2.0-cp314-cp314-win_arm64.whl", hash = "sha256:c5c19526f4e54a00f2666a6c0e9e40d582c09e865055ea7378bf0009aab857b3", size = 280684 },
+    { url = "https://files.pythonhosted.org/packages/b1/75/fb64e6c25d6b5ca636d03df34ffb1c6e9873303e76d27967e045f8df088f/watchfiles-1.2.0-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:d73a585accffa5ae39c17264c36ec3166d2fad7000c780f5ef83b2722afb9dd2", size = 398857 },
+    { url = "https://files.pythonhosted.org/packages/73/4e/9f7adf01754cbf81843722ccfec169d8f26c69778281a302855cecd2ee08/watchfiles-1.2.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:ae99b14c5f21e026e0e9d96f40e07d8570ebee6cafd9d8fc318354606daa7a28", size = 392413 },
+    { url = "https://files.pythonhosted.org/packages/47/c8/bec626bcc2d69f44b9acb24ce7d60ed7b16b73628eea747fcbd169d8edda/watchfiles-1.2.0-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4429f3b105524a10b72c3a819b091c495d2811d419c1e1e8df773a5a5974f831", size = 452409 },
+    { url = "https://files.pythonhosted.org/packages/00/b7/b6362068e81e7c556d155a34c35d40ac3ef42d747b06d7f6e5bf58e359c2/watchfiles-1.2.0-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:43d818978d06062d9b22c4fab2ebe44cf5213d42dc8e62bda8c2760cfa2eeb33", size = 458827 },
+    { url = "https://files.pythonhosted.org/packages/67/f8/9a813fa42afb1e0b4625e75f0479826644d3ee8dc287e093799bc01f390c/watchfiles-1.2.0-cp314-cp314t-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b9f732dc58b2dbe69e464ccf8fff7a03b0dd0be439da4c0720d3558527d3d6b4", size = 490104 },
+    { url = "https://files.pythonhosted.org/packages/2f/bf/27dfb6094ca4c9aad21298b5525b6c53cb36121ee454331d05161e58d130/watchfiles-1.2.0-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8f200104103feb097de4cab8fe4f5dd18a2026934c7dea98c55a2f5fd6d5a33b", size = 571360 },
+    { url = "https://files.pythonhosted.org/packages/fb/39/44a096d67270ea93df91d33877dbe91fbda3aa4f8ec2edf799d93eda8736/watchfiles-1.2.0-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:63ac26eefbf4af1741247d6fb68b11c49a25b2f7413fbd318a83a12aaa9cf666", size = 464644 },
+    { url = "https://files.pythonhosted.org/packages/0e/80/c7472203bad6268e3ef1ad260739704847898938ad7ea8b63a5131f46b50/watchfiles-1.2.0-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0c4997d4e4a55f0d02b6cde327322daf3a0400e5df6c6b15948994bf72497925", size = 454771 },
+    { url = "https://files.pythonhosted.org/packages/51/cf/3b10b268b4b7f0fc26e9debb5eef1998b515887840f444cd3ec80c688755/watchfiles-1.2.0-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:4c887eba18b7945ac73067a8b4a66f21cd46c2539b2bc68588f7be6c7eb6d26b", size = 463494 },
+    { url = "https://files.pythonhosted.org/packages/3d/3e/a4302545cd589262a0dc7d140e86f7688eba3f9c72776c27f7e23b8864c4/watchfiles-1.2.0-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:3416ff151bb6b5a8d8d11664974fbef4d9305b9b2957839ab5a270468fd8df30", size = 629383 },
+    { url = "https://files.pythonhosted.org/packages/db/99/d5649df0a9a410d45b7c882304d0b790903ac9b6e8f2cfd12114e0c6b9f2/watchfiles-1.2.0-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:0e831a271c035d89789cffc386b6aa1375f39f1cd25eb7ca0997e4970d152fc5", size = 656093 },
+    { url = "https://files.pythonhosted.org/packages/92/b9/362702539275019a54dd2e94511b31a9b89c5f9e6a21966de7eb692549fc/watchfiles-1.2.0-cp315-cp315-macosx_10_12_x86_64.whl", hash = "sha256:37a6721cdf3f65dbb13aa9503510ccb4451603ac837e44d265d7992a597e1374", size = 400109 },
+    { url = "https://files.pythonhosted.org/packages/8f/75/71d5ba62db781e5587bded1d944c675374bc4aa37ff33d5018d98e8b6538/watchfiles-1.2.0-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:2b37d10b5a63bd4d87e18472d80fa525bd670586fae62e5dd580452764879b65", size = 392167 },
+    { url = "https://files.pythonhosted.org/packages/3c/01/c66dd95d0423fe30d31820e2d1d5bda773764131bbb6ac0cb1cf303ac328/watchfiles-1.2.0-cp315-cp315-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0a105bc2283f67e8fbec74253ec2d94925de92ed72c0393f1206bf326b7b7b69", size = 452372 },
+    { url = "https://files.pythonhosted.org/packages/91/15/2fe99557e72f85627c6a8eed50d889e8d101623e060a22ad75b875cb932d/watchfiles-1.2.0-cp315-cp315-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:5327989a465505f05cfe06f04fa9d0c2fd5432bb243e10e6f012b1bdca3c8579", size = 459596 },
+    { url = "https://files.pythonhosted.org/packages/ed/23/d4acfa0023367428ed48351b3b9b267893037b6cadae55620c61c24bcfd4/watchfiles-1.2.0-cp315-cp315-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ecb47f183a8025b2aa18b546725c3657e542112ae9c0613a2af79b4fa8d04ad7", size = 490869 },
+    { url = "https://files.pythonhosted.org/packages/a4/5f/3164cbdce06c9fb95c4f7b9e2f9760b5e2797af43a9ecc317ef42a23a278/watchfiles-1.2.0-cp315-cp315-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8520a4ab0e37f770afc34459c4f8f7019e153f9124dc101c15538365875d1ab2", size = 571641 },
+    { url = "https://files.pythonhosted.org/packages/41/e6/85d3731c55e65cd7690f3f803d24c139588aaf863e4bf2148fe7a7fa1a19/watchfiles-1.2.0-cp315-cp315-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:71cd71740ed2c15211ebb237ced4e39a1cdf6f80566e5fe95428da1626f4fde6", size = 464444 },
+    { url = "https://files.pythonhosted.org/packages/f4/7d/562641012b8b09872742c3b8adf9629ec479fd78f8d68ae4a0c13da8add6/watchfiles-1.2.0-cp315-cp315-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f88af53d6ddaf72179ef613ddc905e6f4785f712b49b80b3bef9f3525e6194b4", size = 453593 },
+    { url = "https://files.pythonhosted.org/packages/56/fe/cb8ef3d6f929d14158fdaaad9925985b7310abc9384dcd4d82dd0016fb59/watchfiles-1.2.0-cp315-cp315-manylinux_2_31_riscv64.whl", hash = "sha256:cee9d5efd929efdac5f7e58f72b3376f676b64050a91c5b99a7094c5b2317488", size = 465096 },
+    { url = "https://files.pythonhosted.org/packages/25/91/80908e835e100527a9267147b08c0eee1fa6ab0ffec15edc04d1d44885f7/watchfiles-1.2.0-cp315-cp315-musllinux_1_1_aarch64.whl", hash = "sha256:b718bf356bbc15e559bd8ef41782b573b8ae0e3f177ab244b440568d7ea02cfb", size = 630638 },
+    { url = "https://files.pythonhosted.org/packages/46/4b/95ab2f256bb4af3cb2eb23b9317bda984ee6e0f11733a5c004a6c95b06e3/watchfiles-1.2.0-cp315-cp315-musllinux_1_1_x86_64.whl", hash = "sha256:922c0e019fe68b3ae392965a766b02a71ba1168c932cebc3733cd52c5fe5b377", size = 657684 },
+]
+
+[[package]]
+name = "websockets"
+version = "16.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/04/24/4b2031d72e840ce4c1ccb255f693b15c334757fc50023e4db9537080b8c4/websockets-16.0.tar.gz", hash = "sha256:5f6261a5e56e8d5c42a4497b364ea24d94d9563e8fbd44e78ac40879c60179b5", size = 179346 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/84/7b/bac442e6b96c9d25092695578dda82403c77936104b5682307bd4deb1ad4/websockets-16.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:71c989cbf3254fbd5e84d3bff31e4da39c43f884e64f2551d14bb3c186230f00", size = 177365 },
+    { url = "https://files.pythonhosted.org/packages/b0/fe/136ccece61bd690d9c1f715baaeefd953bb2360134de73519d5df19d29ca/websockets-16.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:8b6e209ffee39ff1b6d0fa7bfef6de950c60dfb91b8fcead17da4ee539121a79", size = 175038 },
+    { url = "https://files.pythonhosted.org/packages/40/1e/9771421ac2286eaab95b8575b0cb701ae3663abf8b5e1f64f1fd90d0a673/websockets-16.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:86890e837d61574c92a97496d590968b23c2ef0aeb8a9bc9421d174cd378ae39", size = 175328 },
+    { url = "https://files.pythonhosted.org/packages/18/29/71729b4671f21e1eaa5d6573031ab810ad2936c8175f03f97f3ff164c802/websockets-16.0-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:9b5aca38b67492ef518a8ab76851862488a478602229112c4b0d58d63a7a4d5c", size = 184915 },
+    { url = "https://files.pythonhosted.org/packages/97/bb/21c36b7dbbafc85d2d480cd65df02a1dc93bf76d97147605a8e27ff9409d/websockets-16.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e0334872c0a37b606418ac52f6ab9cfd17317ac26365f7f65e203e2d0d0d359f", size = 186152 },
+    { url = "https://files.pythonhosted.org/packages/4a/34/9bf8df0c0cf88fa7bfe36678dc7b02970c9a7d5e065a3099292db87b1be2/websockets-16.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:a0b31e0b424cc6b5a04b8838bbaec1688834b2383256688cf47eb97412531da1", size = 185583 },
+    { url = "https://files.pythonhosted.org/packages/47/88/4dd516068e1a3d6ab3c7c183288404cd424a9a02d585efbac226cb61ff2d/websockets-16.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:485c49116d0af10ac698623c513c1cc01c9446c058a4e61e3bf6c19dff7335a2", size = 184880 },
+    { url = "https://files.pythonhosted.org/packages/91/d6/7d4553ad4bf1c0421e1ebd4b18de5d9098383b5caa1d937b63df8d04b565/websockets-16.0-cp312-cp312-win32.whl", hash = "sha256:eaded469f5e5b7294e2bdca0ab06becb6756ea86894a47806456089298813c89", size = 178261 },
+    { url = "https://files.pythonhosted.org/packages/c3/f0/f3a17365441ed1c27f850a80b2bc680a0fa9505d733fe152fdf5e98c1c0b/websockets-16.0-cp312-cp312-win_amd64.whl", hash = "sha256:5569417dc80977fc8c2d43a86f78e0a5a22fee17565d78621b6bb264a115d4ea", size = 178693 },
+    { url = "https://files.pythonhosted.org/packages/cc/9c/baa8456050d1c1b08dd0ec7346026668cbc6f145ab4e314d707bb845bf0d/websockets-16.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:878b336ac47938b474c8f982ac2f7266a540adc3fa4ad74ae96fea9823a02cc9", size = 177364 },
+    { url = "https://files.pythonhosted.org/packages/7e/0c/8811fc53e9bcff68fe7de2bcbe75116a8d959ac699a3200f4847a8925210/websockets-16.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:52a0fec0e6c8d9a784c2c78276a48a2bdf099e4ccc2a4cad53b27718dbfd0230", size = 175039 },
+    { url = "https://files.pythonhosted.org/packages/aa/82/39a5f910cb99ec0b59e482971238c845af9220d3ab9fa76dd9162cda9d62/websockets-16.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:e6578ed5b6981005df1860a56e3617f14a6c307e6a71b4fff8c48fdc50f3ed2c", size = 175323 },
+    { url = "https://files.pythonhosted.org/packages/bd/28/0a25ee5342eb5d5f297d992a77e56892ecb65e7854c7898fb7d35e9b33bd/websockets-16.0-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:95724e638f0f9c350bb1c2b0a7ad0e83d9cc0c9259f3ea94e40d7b02a2179ae5", size = 184975 },
+    { url = "https://files.pythonhosted.org/packages/f9/66/27ea52741752f5107c2e41fda05e8395a682a1e11c4e592a809a90c6a506/websockets-16.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c0204dc62a89dc9d50d682412c10b3542d748260d743500a85c13cd1ee4bde82", size = 186203 },
+    { url = "https://files.pythonhosted.org/packages/37/e5/8e32857371406a757816a2b471939d51c463509be73fa538216ea52b792a/websockets-16.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:52ac480f44d32970d66763115edea932f1c5b1312de36df06d6b219f6741eed8", size = 185653 },
+    { url = "https://files.pythonhosted.org/packages/9b/67/f926bac29882894669368dc73f4da900fcdf47955d0a0185d60103df5737/websockets-16.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6e5a82b677f8f6f59e8dfc34ec06ca6b5b48bc4fcda346acd093694cc2c24d8f", size = 184920 },
+    { url = "https://files.pythonhosted.org/packages/3c/a1/3d6ccdcd125b0a42a311bcd15a7f705d688f73b2a22d8cf1c0875d35d34a/websockets-16.0-cp313-cp313-win32.whl", hash = "sha256:abf050a199613f64c886ea10f38b47770a65154dc37181bfaff70c160f45315a", size = 178255 },
+    { url = "https://files.pythonhosted.org/packages/6b/ae/90366304d7c2ce80f9b826096a9e9048b4bb760e44d3b873bb272cba696b/websockets-16.0-cp313-cp313-win_amd64.whl", hash = "sha256:3425ac5cf448801335d6fdc7ae1eb22072055417a96cc6b31b3861f455fbc156", size = 178689 },
+    { url = "https://files.pythonhosted.org/packages/f3/1d/e88022630271f5bd349ed82417136281931e558d628dd52c4d8621b4a0b2/websockets-16.0-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:8cc451a50f2aee53042ac52d2d053d08bf89bcb31ae799cb4487587661c038a0", size = 177406 },
+    { url = "https://files.pythonhosted.org/packages/f2/78/e63be1bf0724eeb4616efb1ae1c9044f7c3953b7957799abb5915bffd38e/websockets-16.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:daa3b6ff70a9241cf6c7fc9e949d41232d9d7d26fd3522b1ad2b4d62487e9904", size = 175085 },
+    { url = "https://files.pythonhosted.org/packages/bb/f4/d3c9220d818ee955ae390cf319a7c7a467beceb24f05ee7aaaa2414345ba/websockets-16.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:fd3cb4adb94a2a6e2b7c0d8d05cb94e6f1c81a0cf9dc2694fb65c7e8d94c42e4", size = 175328 },
+    { url = "https://files.pythonhosted.org/packages/63/bc/d3e208028de777087e6fb2b122051a6ff7bbcca0d6df9d9c2bf1dd869ae9/websockets-16.0-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:781caf5e8eee67f663126490c2f96f40906594cb86b408a703630f95550a8c3e", size = 185044 },
+    { url = "https://files.pythonhosted.org/packages/ad/6e/9a0927ac24bd33a0a9af834d89e0abc7cfd8e13bed17a86407a66773cc0e/websockets-16.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:caab51a72c51973ca21fa8a18bd8165e1a0183f1ac7066a182ff27107b71e1a4", size = 186279 },
+    { url = "https://files.pythonhosted.org/packages/b9/ca/bf1c68440d7a868180e11be653c85959502efd3a709323230314fda6e0b3/websockets-16.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:19c4dc84098e523fd63711e563077d39e90ec6702aff4b5d9e344a60cb3c0cb1", size = 185711 },
+    { url = "https://files.pythonhosted.org/packages/c4/f8/fdc34643a989561f217bb477cbc47a3a07212cbda91c0e4389c43c296ebf/websockets-16.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:a5e18a238a2b2249c9a9235466b90e96ae4795672598a58772dd806edc7ac6d3", size = 184982 },
+    { url = "https://files.pythonhosted.org/packages/dd/d1/574fa27e233764dbac9c52730d63fcf2823b16f0856b3329fc6268d6ae4f/websockets-16.0-cp314-cp314-win32.whl", hash = "sha256:a069d734c4a043182729edd3e9f247c3b2a4035415a9172fd0f1b71658a320a8", size = 177915 },
+    { url = "https://files.pythonhosted.org/packages/8a/f1/ae6b937bf3126b5134ce1f482365fde31a357c784ac51852978768b5eff4/websockets-16.0-cp314-cp314-win_amd64.whl", hash = "sha256:c0ee0e63f23914732c6d7e0cce24915c48f3f1512ec1d079ed01fc629dab269d", size = 178381 },
+    { url = "https://files.pythonhosted.org/packages/06/9b/f791d1db48403e1f0a27577a6beb37afae94254a8c6f08be4a23e4930bc0/websockets-16.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:a35539cacc3febb22b8f4d4a99cc79b104226a756aa7400adc722e83b0d03244", size = 177737 },
+    { url = "https://files.pythonhosted.org/packages/bd/40/53ad02341fa33b3ce489023f635367a4ac98b73570102ad2cdd770dacc9a/websockets-16.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:b784ca5de850f4ce93ec85d3269d24d4c82f22b7212023c974c401d4980ebc5e", size = 175268 },
+    { url = "https://files.pythonhosted.org/packages/74/9b/6158d4e459b984f949dcbbb0c5d270154c7618e11c01029b9bbd1bb4c4f9/websockets-16.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:569d01a4e7fba956c5ae4fc988f0d4e187900f5497ce46339c996dbf24f17641", size = 175486 },
+    { url = "https://files.pythonhosted.org/packages/e5/2d/7583b30208b639c8090206f95073646c2c9ffd66f44df967981a64f849ad/websockets-16.0-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:50f23cdd8343b984957e4077839841146f67a3d31ab0d00e6b824e74c5b2f6e8", size = 185331 },
+    { url = "https://files.pythonhosted.org/packages/45/b0/cce3784eb519b7b5ad680d14b9673a31ab8dcb7aad8b64d81709d2430aa8/websockets-16.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:152284a83a00c59b759697b7f9e9cddf4e3c7861dd0d964b472b70f78f89e80e", size = 186501 },
+    { url = "https://files.pythonhosted.org/packages/19/60/b8ebe4c7e89fb5f6cdf080623c9d92789a53636950f7abacfc33fe2b3135/websockets-16.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:bc59589ab64b0022385f429b94697348a6a234e8ce22544e3681b2e9331b5944", size = 186062 },
+    { url = "https://files.pythonhosted.org/packages/88/a8/a080593f89b0138b6cba1b28f8df5673b5506f72879322288b031337c0b8/websockets-16.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:32da954ffa2814258030e5a57bc73a3635463238e797c7375dc8091327434206", size = 185356 },
+    { url = "https://files.pythonhosted.org/packages/c2/b6/b9afed2afadddaf5ebb2afa801abf4b0868f42f8539bfe4b071b5266c9fe/websockets-16.0-cp314-cp314t-win32.whl", hash = "sha256:5a4b4cc550cb665dd8a47f868c8d04c8230f857363ad3c9caf7a0c3bf8c61ca6", size = 178085 },
+    { url = "https://files.pythonhosted.org/packages/9f/3e/28135a24e384493fa804216b79a6a6759a38cc4ff59118787b9fb693df93/websockets-16.0-cp314-cp314t-win_amd64.whl", hash = "sha256:b14dc141ed6d2dde437cddb216004bcac6a1df0935d79656387bd41632ba0bbd", size = 178531 },
+    { url = "https://files.pythonhosted.org/packages/6f/28/258ebab549c2bf3e64d2b0217b973467394a9cea8c42f70418ca2c5d0d2e/websockets-16.0-py3-none-any.whl", hash = "sha256:1637db62fad1dc833276dded54215f2c7fa46912301a24bd94d45d46a011ceec", size = 171598 },
+]
+
 [[package]]
 name = "yarl"
 version = "1.24.2"