diff --git a/.forgeplan/adrs/ADR-010-agent-sdk-onboarding-daemon-in-a-separate-optional-npm-package-launched-by-a-spawn-only-bin-subcommand.md b/.forgeplan/adrs/ADR-010-agent-sdk-onboarding-daemon-in-a-separate-optional-npm-package-launched-by-a-spawn-only-bin-subcommand.md
new file mode 100644
index 0000000..a816288
--- /dev/null
+++ b/.forgeplan/adrs/ADR-010-agent-sdk-onboarding-daemon-in-a-separate-optional-npm-package-launched-by-a-spawn-only-bin-subcommand.md
@@ -0,0 +1,112 @@
+---
+depth: standard
+id: ADR-010
+kind: adr
+links:
+- target: PRD-038
+  relation: based_on
+- target: ADR-003
+  relation: informs
+status: active
+title: Agent SDK + onboarding daemon in a separate optional npm package launched by a spawn-only bin/ subcommand
+---
+
+## Context
+
+Pillar C of the composed-map onboarding program (PRD-038) adds a **live local
+onboarding agent**: the user asks questions in the web chat and a real Claude
+Code session answers, driving the map camera. The fixed design (FD-1..FD-7): use
+the user's LOCAL Claude Code via the **Claude Agent SDK**
+(`@anthropic-ai/claude-agent-sdk`), running in a **localhost daemon-bridge** the
+user launches (the SvelteKit server structurally cannot spawn `claude` — rule
+22 keeps it a read-only mirror).
+
+The trap (PRD-038 **Q1**): **ADR-003 / rule 23** pin `bin/` to a named
+allow-list of exactly `node:*` + `citty`. The Agent SDK is a heavy third-party
+dependency with a large transitive tree. It cannot enter `bin/` without a
+decision, because `bin/` is what `npx @forgeplan/web` runs **before the user has
+installed anything** — the whole point of ADR-003 is that no third-party
+resolution happens at `npx` time.
+
+## Decision
+
+**Selected**: Ship the Agent SDK + onboarding daemon as a **separate, optional
+npm package** (working name `@forgeplan/web-agent`), launched by a **spawn-only**
+`bin/` subcommand.
+
+`bin/forgeplan-web.mjs` gains an `onboard-agent` subcommand that does exactly one
+new thing: `child_process.spawn` the separate package's binary (resolved from the
+user's environment / `npx @forgeplan/web-agent`) and stream its output. **`bin/`
+imports nothing from the agent package** — no `import`, no `require`, only a
+`spawn` of an external process. ADR-003's allow-list (`node:*` + `citty` +
+relative siblings) is therefore **untouched**: the core `@forgeplan/web` stays
+lean and `npx`-fast for the 99% of users who only view the map; the agent is
+opt-in and its heavy dependency tree is resolved **only** when a user
+deliberately runs the agent.
+
+**Why Selected**: it is the only option that keeps ADR-003's `npx`-latency
+guarantee intact while still letting Pillar C "use what already exists" (the
+Agent SDK). The spawn-only boundary is the same trust seam rule 22 uses for the
+`forgeplan` CLI — a process boundary, not an import.
+
+## Alternatives Considered
+
+| Option | Verdict | Why |
+|--------|---------|-----|
+| **A — separate optional npm package + spawn-only `bin/` subcommand** | **Chosen** | Core stays lean + `npx`-fast (ADR-003 intact); SDK resolved only on deliberate agent use; process boundary mirrors rule 22's `forgeplan`/`git` spawn seam. |
+| B — bundled `dist-agent/` image (esbuild-inline, PRD-030/ADR-005 shape) | Rejected | The image discipline (PRD-030) is for **viewer variants** copied by `init`; it would bloat every install with the SDK + its transitive tree even for users who never run the agent, and an esbuild single-file bundle of the Agent SDK (which itself spawns `claude`) is fragile. |
+| C — extend the ADR-003 allow-list to admit the SDK into `bin/` | Rejected | Reintroduces the exact `npx`-time third-party resolution ADR-003 removed — every `init`/`start`/`update` would pay to resolve the SDK before doing its job, for a feature most users never touch. Directly violates ADR-003's invariant I3. |
+
+## Consequences
+
+### Positive
+- Core `@forgeplan/web` unchanged in weight + `npx` latency; ADR-003 / rule 23
+  hold verbatim (verified by the existing bin allow-list grep).
+- The agent is strictly **opt-in**: no SDK, no `claude`, no API key for the
+  view-only user.
+- Security is a natural consequence of the process boundary: the daemon is a
+  separate, user-launched, 127.0.0.1-bound process with a read-only agent
+  profile — the web never gains a code-execution surface.
+
+### Negative (trade-offs)
+- A **second package** to publish + version (`@forgeplan/web-agent`), plus a
+  documented spawn contract between the `onboard-agent` subcommand and that
+  package's binary.
+- The user must install / `npx` the agent package on first use (mitigated by a
+  guided prompt from the `onboard-agent` subcommand when the package is absent).
+
+### Risks
+- **Version skew** between `@forgeplan/web` and `@forgeplan/web-agent` (mitigate:
+  the daemon advertises a protocol version in its WebSocket probe; the web
+  tolerates a missing/older daemon by staying in chat **Tier 0**).
+- The spawn-only subcommand must **validate the agent package's presence** and
+  fail with an actionable install hint, never a raw ENOENT.
+
+## Invariants
+
+- `bin/` imports only `node:*`, `citty`, and relative `bin/` siblings — the
+  `onboard-agent` subcommand adds **only** a `child_process.spawn`, never an
+  `import`/`require` of the agent package (rule 23 grep must still pass).
+- The daemon binds **127.0.0.1 only** and is launched explicitly by the user.
+- The agent runs a **read-only** profile: Read/Glob/Grep + read-only forgeplan
+  MCP; no Write/Edit/Bash.
+- The SvelteKit server (`/api/*`) is never involved in the agent path — the
+  browser talks to the daemon directly (rule 22 intact).
+
+## Evidence Requirements
+
+- A spawn smoke: `bin onboard-agent` spawns the agent package binary (or emits
+  the install hint when absent) — exit-code asserted.
+- Rule-23 verification grep over `bin/` still reports OK (no new bare-specifier
+  imports).
+- The agent package's SDK options object denies Write/Edit/Bash and binds
+  localhost only (asserted in the agent package's own tests).
+
+## Related Artifacts
+
+| Artifact | Type | Relation |
+|----------|------|----------|
+| PRD-038 | PRD | based_on (Pillar C, Q1) |
+| ADR-003 | ADR | informs (the bin/ allow-list this preserves) |
+| RFC (Pillar C daemon, pending) | RFC | based_on (the RFC that presumes this packaging) |
+
diff --git a/.forgeplan/evidence/EVID-096-pillar-c-live-agent-works-end-to-end-daemon-local-cc-answered-grounded-drove-show-on-map-camera-153-tests-smoke-pass.md b/.forgeplan/evidence/EVID-096-pillar-c-live-agent-works-end-to-end-daemon-local-cc-answered-grounded-drove-show-on-map-camera-153-tests-smoke-pass.md
new file mode 100644
index 0000000..298b5e6
--- /dev/null
+++ b/.forgeplan/evidence/EVID-096-pillar-c-live-agent-works-end-to-end-daemon-local-cc-answered-grounded-drove-show-on-map-camera-153-tests-smoke-pass.md
@@ -0,0 +1,95 @@
+---
+depth: standard
+id: EVID-096
+kind: evidence
+last_modified_at: 2026-07-06T15:34:34.875409+00:00
+last_modified_by: claude-code/2.1.201
+links:
+- target: RFC-034
+  relation: informs
+status: active
+title: 'Pillar C live agent works end-to-end: daemon + local CC answered grounded + drove show_on_map camera; 153 tests, smoke PASS'
+---
+
+## Status
+
+draft
+
+## Summary
+
+Prove-phase checkpoint for **RFC-034** (Pillar C, the live onboarding agent) and its packaging
+**ADR-010**. The live agent works **end-to-end**: the localhost daemon boots, a **real local Claude
+Code session** (via the Agent SDK) answered a project question **grounded in the actual repo**, and
+the model **called the `show_on_map` tool** which relayed a camera frame to the client. Plus 153
+web-side tests, `svelte-check` 0, and the daemon smoke — all green.
+
+## Observations (measured, 2026-07-06)
+
+### Live end-to-end turn (the headline — a real model turn, not a mock)
+
+Spawned the daemon: `node agent/bin/agent.mjs --cwd <repo> --port 7461` → printed
+`onboard-agent live on ws://127.0.0.1:7461`. A WebSocket client connected, received
+`{type:"ready", protocolVersion:1, model:"forgeplan-web-agent (claude-agent-sdk)"}`, and sent
+*"What is this project and what is it for? … then use show_on_map to point at the most important
+zone."* The daemon's persistent `query()` session streamed a **grounded** answer (verbatim):
+
+> "**@forgeplan/web** is a tiny zero-install npm CLI that scaffolds a pre-built SvelteKit app into a
+> project's `.forgeplan-web/` folder, then serves a read-only, force-directed map of that project's
+> Forgeplan artifacts… run `npx @forgeplan/web start` and *see* a project's decisions and structure
+> as an interactive graph — no install, no write access to the workspace."
+
+— then emitted `{type:"show_on_map", target:{kind:"zone", id:"z.surfaces"}}`, then continued
+narrating the zone flow (z.surfaces → z.core → z.ui, z.decisions records why) and offered to walk
+deeper. Frames observed: `ready` → `token`* (streamed) → `show_on_map` → `token`* → `done`. The
+answer is factually correct and sourced from the real repo — the read-only agent read the project.
+
+### Automated + smoke (measured)
+
+- `npx vitest run src/widgets/map-chat src/widgets/composed-map` → **14 files / 153 tests PASS**
+  (Tier-0 tier0/chat-store/MapChat + Tier-1 agent-client/chat-store + camera-bus + tour + drill).
+- `npx svelte-check` → **0 errors** (2 pre-existing a11y warnings on the map `<svg>`).
+- `node agent/scripts/smoke.mjs` → **exit 0, ALL CHECKS PASS**: protocol round-trip; `buildOptions`
+  denies Write/Edit/Bash + allows `mcp__onboard__show_on_map`; message-queue generator shape; daemon
+  binds 127.0.0.1, `GET /health` responds, WS sends `{ready}`.
+- Rule-23 allow-list grep over `bin/` → **OK** for all `.mjs` (the `onboard-agent` subcommand is
+  spawn-only; no import of `@forgeplan/web-agent`; root `package.json` untouched).
+
+### Invariants confirmed
+
+- **ADR-010**: the Agent SDK + daemon live in the SEPARATE `@forgeplan/web-agent` package (its own
+  deps `@anthropic-ai/claude-agent-sdk` ^0.3, `ws`, `zod`; own `node_modules`, gitignored). Core
+  `bin/` unchanged in weight; the subcommand only `child_process.spawn`s the package.
+- **Rule 22**: the live path is browser↔daemon over `ws://127.0.0.1`; the SvelteKit `/api/*` server
+  is never involved.
+- **Read-only**: `allowedTools` = Read/Glob/Grep + `show_on_map`; `disallowedTools` =
+  Write/Edit/Bash; the model cannot mutate the workspace.
+
+## Known scope boundary
+
+- The daemon's `--port` default is 7431; the live turn above used 7461 (explicit). Port discovery
+  (fixed-port probe vs a discovery file) is RFC-034 **OQ1**.
+- `cancel` (abort mid-stream) and socket-closed-mid-tool-call are marked `TODO` (Phase-4 hardening),
+  not blockers.
+- `show_on_map(node)` precision depends on marketplace **CM-02** (stable node ids); `zone`/`flow`
+  targeting (demonstrated) is exact.
+- `@forgeplan/web-agent` is not yet published to npm — the subcommand's `npx` fallback is verified
+  against the registry 404 only; re-verify post-publish.
+
+## Structured Fields
+
+verdict: supports
+congruence_level: 3
+evidence_type: test
+
+## Related Artifacts
+
+- **RFC-034** (`informs`) — the daemon/protocol/camera/chat architecture this proves; activation
+  gated on this checkpoint (rule 11, R_eff > 0).
+- **ADR-010** — the packaging decision (separate optional package + spawn-only subcommand) this
+  build realises and confirms.
+- **RFC-033** — the tour camera the agent drives via the `camera-bus` seam (Phase 1).
+- **PRD-038** — parent PRD (Pillar C, FD-1..FD-7).
+- **`docs/MAP-PACK-FINDINGS-FOR-MARKETPLACE.md`** — CM-02 (stable node ids) for precise
+  `show_on_map(node)`.
+
+
diff --git a/.forgeplan/evidence/EVID-097-code-review-of-rfc-035-wave-1-blocker.md b/.forgeplan/evidence/EVID-097-code-review-of-rfc-035-wave-1-blocker.md
new file mode 100644
index 0000000..b7bfe61
--- /dev/null
+++ b/.forgeplan/evidence/EVID-097-code-review-of-rfc-035-wave-1-blocker.md
@@ -0,0 +1,108 @@
+---
+depth: standard
+id: EVID-097
+kind: evidence
+last_modified_at: 2026-07-07T11:58:34.941143+00:00
+last_modified_by: claude-code/2.1.202
+links:
+- target: RFC-035
+  relation: informs
+status: draft
+title: 'Code review of RFC-035 Wave 1: BLOCKER'
+---
+
+## Verdict
+
+BLOCKER
+
+One-line justification: the only two visible-behaviour requirements of RFC-035 Wave 1 (FR-1 float/dock/resize window, FR-2 status header, FR-3 Chat|Info tabs, FR-4 Info tab) were never wired into `MapChat.svelte` — the new `FloatingWindow` primitive and the new `chat-store` tab state are built but orphaned; `MapChat.svelte` has a **zero-line diff** and still renders the old fixed-position panel with the old verbose Badge string.
+
+## Scope
+
+- Parent: RFC-035
+- Diff range: ad-hoc — uncommitted working-tree changes on `feat/idef0-onboard-agent-phase1` vs `HEAD` (`e42040e`)
+- Files reviewed: 6 files touched (2 new, 2 modified, 2 lockfile/manifest), plus full read of `MapChat.svelte` (644 lines) and `chat-store.svelte.ts` diff
+- Files: `template/package.json`, `template/package-lock.json`, `template/src/shared/ui/index.ts`, `template/src/shared/ui/floating-window/FloatingWindow.svelte` (new, 655 lines), `template/src/shared/ui/floating-window/index.ts` (new), `template/src/widgets/map-chat/model/chat-store.svelte.ts` (+22 lines)
+
+## Tools run
+
+| Tool | Exit | Notes |
+|---|---|---|
+| `npx vitest run src/widgets/map-chat src/shared/ui` | 0 | 3 test files, 59 tests, all passed — no regressions, but zero new tests added for `FloatingWindow` |
+| `npx svelte-check --threshold error` | 0 | 1280 files, 0 errors, 8 warnings, 2 files with problems |
+| rule-24 grep (`.claude/rules/24-shared-ui-ownership.md` Verification block) | non-zero (FAIL) | sole match is pre-existing (`MapChat.svelte:516`, file has 0 diff lines this change) — not a new violation, see Findings #5 note |
+
+## Ground-truth verification
+
+- Base..head: `e42040e..<worktree>` (source: current branch HEAD; no PR base/head SHA supplied — ad-hoc uncommitted-diff review)
+- Diff probe: `git diff --stat HEAD -- template/` and `git status --short`
+- Diff state: **DELTA=PRESENT** (package.json/package-lock.json/shared/ui/index.ts/chat-store.svelte.ts modified; `shared/ui/floating-window/` untracked-new)
+- Expected delta token: `FloatingWindow` used as a consumer import inside `template/src/widgets/map-chat/ui/MapChat.svelte` (the token that would prove Wave 1's stated goal — "MapChat becomes floatable/dockable/resizable" — actually landed)
+- Token probe: `grep -rn "FloatingWindow" template/src --include="*.svelte" | grep -v shared/ui/floating-window` → **ABSENT**
+- Verdict floor from ground-truth gate: PRESENT diff + ABSENT expected token → **CONCERNS** floor at minimum; escalated to **BLOCKER** below because the missing token is not an edge case but the entire stated deliverable (see Finding #1)
+
+```
+$ git diff --stat HEAD -- template/
+ template/package-lock.json                      | 18 ++++++++++++++++++
+ template/package.json                            |  1 +
+ template/src/shared/ui/index.ts                  |  1 +
+ .../widgets/map-chat/model/chat-store.svelte.ts  | 22 ++++++++++++++++++++++
+ 4 files changed, 42 insertions(+)
+
+$ git diff HEAD -- template/src/widgets/map-chat/ui/MapChat.svelte
+(empty — zero output, file unchanged)
+
+$ grep -rn "FloatingWindow" template/src --include="*.svelte" --include="*.ts" | grep -v node_modules
+template/src/shared/ui/index.ts:39:export { FloatingWindow, type FloatingWindowMode } from "./floating-window";
+template/src/shared/ui/floating-window/FloatingWindow.svelte:3,50,106,120 (own definition)
+template/src/widgets/map-chat/model/chat-store.svelte.ts:35 (a doc-comment reference only, not an import)
+→ zero import/usage sites in MapChat.svelte, ComposedMapView.svelte, or /playground
+
+$ grep -rn "MapChat" template/src/widgets/composed-map/ui/ComposedMapView.svelte
+87:  import MapChat from "@/widgets/map-chat/ui/MapChat.svelte";
+1137:          <MapChat doc={okDoc} onClose={() => (chatOpen = false)} />
+→ MapChat is mounted exactly as before RFC-035; no FloatingWindow wrapper introduced at the call site either
+```
+
+## Findings
+
+| # | Severity | Category | Location | Description | Recommended fix |
+|---|---|---|---|---|---|
+| 1 | CRITICAL | 🏗 Architecture | `template/src/widgets/map-chat/ui/MapChat.svelte` (0 diff lines) | RFC-035 Wave 1's entire visible scope (FR-1 float/dock/resize, FR-2 simplified 🟢/🔴 status header, FR-3 Chat\|Info `Tabs`, FR-4 Info tab scaffold) is unimplemented in the actual chat widget. The new `FloatingWindow` primitive is exported from `shared/ui/index.ts` but has zero import sites anywhere outside its own folder; `MapChat.svelte` still renders the old `position:fixed` panel with the old verbose `Badge` (`"● live — {model}"`), no `Tabs`, no Info content. This is not a partial landing of a large feature — it is the primitive built in isolation with the integration step skipped entirely. | Wrap `MapChat`'s root in `<FloatingWindow>` (or compose it at the `ComposedMapView.svelte:1137` mount site), replace the header's verbose Badge with a 🟢/🔴 dot, add a `shared/ui` `Tabs` split driven by the already-built (but unused) `getActiveTab()/setActiveTab()`, and build the Info tab body per FR-4. |
+| 2 | HIGH | 🧪 Test gap | `template/src/shared/ui/floating-window/` (no test file exists) | RFC-035's own Test Strategy section requires vitest coverage of "window-state persistence (save/restore/clamp-off-screen), dock↔float transitions, min-size clamp" — none of `loadPersisted`/`persist`/`clampFloating`/`handleDrag`/`handleDragEnd`/`toggleDock` has a single unit test. | Add `FloatingWindow.test.ts` (or a headless logic-extraction test) covering: restore-clamps-off-screen-position, dock→float on header drag, float→dock on edge-snap release, min-size enforcement on resize. |
+| 3 | MEDIUM | 🐛 Bug | `template/src/shared/ui/floating-window/FloatingWindow.svelte:427` | `<div class="fw-header" tabindex="0" role="presentation">` combines a nonnegative `tabindex` with `role="presentation"`. `role="presentation"` strips the element from the accessibility tree entirely, so a screen-reader user tabbing to it lands on a focus stop with no accessible name or role (WCAG 4.1.2 Name/Role/Value) — svelte-check flags this directly (`a11y_no_noninteractive_tabindex`). Contradicts RFC-035's own a11y requirement ("header is focusable") by making it *focusable but semantically invisible*. | Drop `role="presentation"` (or replace with a role that carries a name, e.g. `role="toolbar"`/plain `<div>` with `aria-label`) so the focus stop is announced coherently. |
+| 4 | MEDIUM | 🏗 Architecture | `template/src/routes/playground/` (no reference) | RFC-035's Wave 1 scope and rule 24 both require the new primitive to be "showcased on /playground" before any caller uses it. `grep -rln "FloatingWindow\|floating-window" template/src/routes/playground/` returns nothing — the catalogue does not yet reflect this primitive at all. | Add a `/playground` section demonstrating docked + floating modes, resize, and dock/undock toggle, per rule 24's required-for-new-primitives checklist. |
+| 5 | LOW | 🎨 Style (dead code) | `template/src/widgets/map-chat/model/chat-store.svelte.ts:174-186` (`getActiveTab`/`setActiveTab`) and `:32-38` (`ChatTab` type) | Added but consumed by nothing — `grep -rn "getActiveTab\|setActiveTab\|ChatTab" src` outside this file returns zero hits, and `chat-store.test.ts` has no `activeTab` coverage. Direct symptom of Finding #1: the store-side half of the tab feature landed without its view-side consumer. | Either wire it into `MapChat.svelte`'s Tabs (Finding #1's fix covers this) in the same change, or defer adding it until the consumer lands, to avoid shipping dead exported API surface. |
+
+**Note (not counted as a finding):** the rule-24 verification grep from `.claude/rules/24-shared-ui-ownership.md` exits non-zero (`MapChat.svelte:516 .mc-jump-wrap :global(.btn) { ... }`), but `MapChat.svelte` has a 0-line diff in this change — the match pre-dates RFC-035 Wave 1 and is out of scope for this review (pre-existing condition, not a new regression).
+
+## Positive observations
+
+- `FloatingWindow.svelte` itself (the parts that exist) is well-built: `@neodrag/svelte`'s `Compartment`/`controls`/`bounds`/`position`/`events` API is used correctly and idiomatically (per RFC-035's reuse-first directive) rather than hand-rolled pointer math for the drag/move path; the resize-handle pointer-capture code explicitly reuses `Splitter.svelte`'s reviewed pattern with a proper `rule-24-bits-ui`-style justification comment for why no upstream resizable-window primitive exists.
+- Invariant I4 ("never restore off-screen") is honestly implemented — `clampFloating()` runs on both `loadPersisted()` and the window `resize` listener, and `isPersistedGeometry()` type-guards + version-checks the localStorage payload before trusting it, degrading to defaults on any corruption without throwing.
+- `@neodrag/svelte` was correctly added to `template/package.json#dependencies` (not `devDependencies`), satisfying rule 21; no hardcoded hex colors were found in the new file (token-only styling preserved); all 59 pre-existing `map-chat`/`shared/ui` tests stay green — the (incomplete) change introduces no regressions to what already worked.
+
+## Test coverage delta
+
+- Before: `map-chat` + `shared/ui` — 3 test files / 59 tests (baseline, all passing)
+- After: unchanged — 3 test files / 59 tests (no new test files added for `FloatingWindow` or for the new `chat-store` tab state)
+- Branches gained: none
+- Branches still uncovered: all of `FloatingWindow`'s persistence/clamp/dock-float/resize logic; `chat-store`'s `activeTab` get/set
+
+## Next steps
+
+- {BLOCKER} Halt activation. Dispatch a coder to: (a) integrate `FloatingWindow` into `MapChat.svelte` per Finding #1, (b) add the `/playground` showcase per Finding #4, (c) fix the a11y header per Finding #3, (d) add unit tests per Finding #2, then re-review the patched diff before Wave 1 is considered landed.
+
+## References
+
+- Parent: RFC-035
+- Related EVID: none prior for this RFC
+- Related ADR: none directly; rule 24 (`shared-ui-ownership`) and rule 21 (`template-purity`) both apply
+
+## Structured Fields
+
+verdict: weakens
+congruence_level: 3
+evidence_type: audit
+
+
diff --git a/.forgeplan/rfcs/RFC-034-onboarding-live-agent-bridge-pillar-c-daemon-agent-sdk-show-on-map-camera-relay-two-tier-chat.md b/.forgeplan/rfcs/RFC-034-onboarding-live-agent-bridge-pillar-c-daemon-agent-sdk-show-on-map-camera-relay-two-tier-chat.md
new file mode 100644
index 0000000..a31609c
--- /dev/null
+++ b/.forgeplan/rfcs/RFC-034-onboarding-live-agent-bridge-pillar-c-daemon-agent-sdk-show-on-map-camera-relay-two-tier-chat.md
@@ -0,0 +1,311 @@
+---
+depth: standard
+id: RFC-034
+kind: rfc
+links:
+- target: PRD-038
+  relation: based_on
+- target: ADR-010
+  relation: based_on
+- target: RFC-033
+  relation: refines
+status: active
+title: 'Onboarding live-agent bridge (Pillar C): daemon + Agent SDK + show_on_map camera relay + two-tier chat'
+---
+
+## Status
+
+draft
+
+> **SPARC Architecture phase.** Architects **HOW** PRD-038 **Pillar C** (the live
+> onboarding agent) is built, PRESUMING **ADR-010** (Agent SDK + daemon ship as a
+> **separate optional npm package** `@forgeplan/web-agent`, launched by a
+> spawn-only `bin/ onboard-agent` subcommand). Design is FIXED by FD-1..FD-7 —
+> this RFC records the module/protocol/seam decisions underneath, it does not
+> re-open the direction.
+
+## Summary
+
+Give the composed-map a **live local onboarding agent** without breaking the
+package's two hardest invariants (rule 22 read-only web, rule 23 lean `bin/`).
+
+A **localhost daemon-bridge** — shipped as the optional `@forgeplan/web-agent`
+package (ADR-010), started by the user via `npx @forgeplan/web onboard-agent`
+(a spawn-only `bin/` subcommand) — boots a **persistent Claude Agent SDK
+session** in a **read-only profile** (Read/Glob/Grep + read-only forgeplan MCP;
+Write/Edit/Bash denied), `cwd` = the project root, and binds a **WebSocket on
+127.0.0.1 only**. The browser's new **`widgets/map-chat`** talks to that daemon
+**directly** (not through `/api/*`, so rule 22 is untouched). The daemon
+registers **one** SDK tool — `show_on_map(kind, id)` — and relays each call over
+the WebSocket to the browser, which dispatches it to the **already-built tour
+camera** (RFC-033). So the agent answers in prose **and** drives the map in one
+turn.
+
+The chat is **two-tier and graceful**: **Tier 0** answers client-side from the
+already-loaded `map.json` (zone/node `description_ru`, auto-Connections from
+edges, flows) — instant, model-free, offline, ~80% of onboarding questions; the
+web **probes** for the daemon and **upgrades to Tier 1** (the live agent) when it
+is present. No daemon → Tier 0 still works. No web `/api/*` change, no `map.json`
+change, no core-package weight change.
+
+## Motivation
+
+PRD-038 Pillar C: the map should not just be *looked at* — a newcomer should be
+able to **ask** "where does artifact recording live?" and get an answer that both
+explains and **moves the camera** to the right zone/flow. Pillars A (comprehension
+base) and B (deterministic tour camera) shipped; the camera exists (RFC-033:
+`ComposedMapView.fitToRect` + the tour controller). Pillar C adds the *voice*: a
+real Claude Code session, using the user's own subscription, reading the actual
+repo + `.forgeplan/` + `map.json` — grounded, not hallucinated.
+
+**Load-bearing constraints (why the design is shaped this way):**
+
+- **Rule 22** keeps the SvelteKit server a read-only mirror — it *structurally
+  cannot* spawn `claude`. The agent therefore lives in a **separate user-launched
+  process**, and the browser talks to **it**, not to `/api/*`.
+- **ADR-010** keeps the heavy Agent SDK out of the core `bin/` (rule 23): the
+  daemon + SDK are the optional `@forgeplan/web-agent` package; `bin/` only
+  `spawn`s it.
+- **The camera already exists** (RFC-033). Pillar C **wires to** it via one new
+  seam; it does not re-implement navigation.
+- **Graceful degradation** is mandatory (FD-3 / PRD-038 NFR): the chat must be
+  useful with **no** daemon (Tier 0), so the feature ships value before the user
+  ever installs the agent package.
+
+## Options Considered
+
+The direction (local CC + Agent SDK + localhost daemon + read-only + one relayed
+tool + two-tier chat) is FIXED (FD-1..7). Two implementation surfaces were
+genuinely contested; both ADI cycles were run manually (`forgeplan_reason`
+provider unavailable, same gap PRD-038/RFC-032/033 recorded).
+
+### ADI cycle A — how the browser discovers the daemon's WebSocket
+
+- **A1 — fixed default port + probe.** Daemon binds a fixed `127.0.0.1:<PORT>`
+  (e.g. 7431); the web probes it (a `ready` frame / a tiny HTTP `GET /health`)
+  and upgrades to Tier 1 on success.
+- **A2 — discovery file.** Daemon writes `~/.forgeplan-web/agent.json`
+  `{port, pid, protocolVersion, startedAt}`; the web reads it via a **read-only**
+  `/api/*` mirror (like `/api/instances`) to learn the port, then connects
+  directly to the daemon WS.
+- **A3 — the SvelteKit server proxies the WS.** Rejected on sight: it would put
+  the agent path back through `/api/*`, violating rule 22.
+
+**Deduction / Induction.** A3 is out (rule 22). **A1 (fixed port + probe) is
+chosen for the MVP** — zero new `/api/*` surface, simplest, and the port
+collision risk is low + recoverable (the daemon fails loudly and suggests
+`--port`). **A2 is recorded as the graduation path** (multi-instance / port-in-use
+robustness) and reuses the existing `~/.forgeplan-web/` registry precedent
+(PRD-027) — **OQ1**.
+
+### ADI cycle B — the show_on_map camera seam into RFC-033
+
+- **B1 — imperative store.** Add a tiny widget-scoped store with a
+  `showOnMap({kind,id})` the chat writes and `ComposedMapView` `$effect`-reacts to
+  by calling the existing `fitToRect` / select / highlight.
+- **B2 — prop callback.** Thread an `onExternalTarget` prop down through
+  HomePage → DependencyGraph → ComposedMapView.
+- **B3 — custom DOM event.** `window.dispatchEvent(new CustomEvent('show-on-map'))`.
+
+**Induction.** **B1 (a small dedicated store) is chosen** — it avoids threading a
+prop through two shared, heavily-trafficked files (the same cost that deferred the
+RFC-033 route auto-start), keeps the seam **testable in isolation**, and matches
+the widget's existing rune-store patterns (`node-tabs.svelte.ts`,
+`tour-state.ts`). The store exposes `showOnMap(target)`; `ComposedMapView`
+consumes it and reuses `fitToRect` (zone) / node-select (node) / flow-highlight
+(flow) — **no camera redesign**.
+
+## Proposed Direction
+
+### Module Breakdown
+
+**Agent package — `@forgeplan/web-agent` (NEW, separate npm package; ADR-010):**
+
+- **`bin/agent.mjs`** — the daemon entry. Boots the Agent SDK persistent session
+  with the read-only profile, binds the 127.0.0.1 WebSocket, registers the
+  `show_on_map` tool, and relays. This is where the third-party SDK dependency
+  lives — never in the core `@forgeplan/web` `bin/`.
+- **`lib/profile.mjs`** — the read-only agent profile: `allowedTools`
+  Read/Glob/Grep + the read-only forgeplan MCP subcommands; `disallowedTools`
+  Write/Edit/Bash. `cwd` = project root.
+- **`lib/protocol.mjs`** — the versioned WebSocket message schema (shared shape,
+  see contracts). One source of truth for both ends.
+- **`lib/relay.mjs`** — pumps SDK stream-json events → WS frames (`token`,
+  `show_on_map`, `done`, `error`) and WS `user_message` → the SDK session.
+
+**Core `@forgeplan/web`:**
+
+- **`bin/commands/onboard-agent.mjs`** (NEW, spawn-only) — resolves + `spawn`s the
+  `@forgeplan/web-agent` binary (validates presence; on absence prints an
+  actionable `npx @forgeplan/web-agent` / install hint, never a raw ENOENT). **No
+  import of the agent package** (rule 23 grep must still pass). Registered in
+  `bin/cli.mjs` (citty subcommand).
+
+**Web (`template/`):**
+
+- **`widgets/map-chat/` (NEW)** — the chat UI. `model/chat-store.svelte.ts`
+  (messages, tier, daemon-status), `model/tier0.ts` (client-grounded answering
+  from the loaded `MapDocument` — reuse the `MapNodePanel` connection derivation +
+  flows + zone descriptions), `model/agent-client.ts` (the read-only WebSocket
+  client: probe → connect → stream tokens → dispatch `show_on_map`), and
+  `ui/MapChat.svelte` (composes `shared/ui`, rule 24).
+- **`widgets/composed-map/model/camera-bus.svelte.ts` (NEW)** — the B1 store:
+  `showOnMap(target)` + a `$state` current target; the ONE seam the chat uses to
+  drive the camera.
+- **`widgets/composed-map/ui/ComposedMapView.svelte` (CHANGED, small)** — consume
+  `camera-bus`: on a new target, `fitToRect(zoneRect)` (zone) / select (node) /
+  set `activeFlow` (flow), reusing the RFC-033/030 machinery. No `/api/*` touched.
+
+### Component Diagram (prose)
+
+`MapChat` (browser) owns the chat store. On mount it **probes** `127.0.0.1:<PORT>`
+(A1). **No daemon** → the store stays **Tier 0**; a user question is answered by
+`tier0.ts` purely from the loaded `MapDocument`. **Daemon present** → the store
+flips to **Tier 1**; `agent-client.ts` opens the WebSocket to the daemon. A user
+message goes `MapChat → agent-client → WS → daemon relay → Agent SDK session →
+local Claude Code`. Claude reads the repo/`.forgeplan/`/`map.json` (read-only) and
+streams back: prose `token` frames render in the chat; a `show_on_map` tool-call
+becomes a WS frame that `agent-client` hands to `camera-bus.showOnMap(target)`,
+which `ComposedMapView` reacts to by driving the **existing** tour camera. Data is
+one-way per leg; the SvelteKit `/api/*` server is **never** in this path (rule 22).
+
+### Data Flow
+
+**Tier 0 (no daemon).** `MapChat` question → `tier0.answer(doc, q)` matches the
+question against zone/node labels + `description_ru` + edges (auto-Connections) +
+flows → renders an answer + optionally calls `camera-bus.showOnMap` to point the
+map at the referenced zone/node. Zero network, zero model.
+
+**Tier 1 (daemon up).** probe `ready` → Tier 1. Question → WS `{user_message}` →
+daemon feeds the SDK session → stream: `{token}`* (streamed into the chat bubble),
+`{show_on_map, target}` (→ `camera-bus`), `{done}`. Errors → `{error}` →
+non-fatal chat notice + stay connected. The daemon holds ONE persistent session so
+context accrues across questions.
+
+**Probe / upgrade.** On mount + on an interval, the web checks the daemon health
+frame; `up → Tier 1`, `down → Tier 0` (graceful, reversible mid-session).
+
+### Function Signatures / Contracts
+
+```ts
+// @forgeplan/web-agent lib/protocol.mjs — the versioned WS schema (both ends)
+type ClientMsg =
+  | { type: "user_message"; text: string }
+  | { type: "cancel" };
+type ServerMsg =
+  | { type: "ready"; protocolVersion: number; model: string }
+  | { type: "token"; delta: string }
+  | { type: "show_on_map"; target: { kind: "zone" | "node" | "flow"; id: string } }
+  | { type: "done" }
+  | { type: "error"; message: string };
+```
+
+```ts
+// widgets/composed-map/model/camera-bus.svelte.ts — the B1 seam (NEW)
+export type CameraTarget = { kind: "zone" | "node" | "flow"; id: string };
+export function showOnMap(t: CameraTarget): void;     // chat writes
+export function consumeCameraTarget(): CameraTarget | null; // view reacts (rune $state)
+```
+
+```ts
+// widgets/map-chat/model/tier0.ts — client-grounded answering (NEW, pure)
+export function answerFromMap(doc: MapDocument, question: string):
+  { text: string; target?: CameraTarget };            // never throws; model-free
+```
+
+```ts
+// widgets/map-chat/model/agent-client.ts — read-only WS client (NEW)
+export function probeDaemon(port: number): Promise<{ up: boolean; model?: string }>;
+export function connectAgent(port: number, handlers: {
+  onToken(d: string): void; onShowOnMap(t: CameraTarget): void;
+  onDone(): void; onError(m: string): void; onClose(): void;
+}): { send(text: string): void; cancel(): void; close(): void };
+```
+
+```
+bin/commands/onboard-agent.mjs  (core, spawn-only)
+  - resolve @forgeplan/web-agent bin; if absent -> print install hint, exit 1
+  - child_process.spawn(agentBin, ["--cwd", workspaceRoot, "--port", PORT], {stdio})
+  - NO import of the agent package (rule 23)
+```
+
+### Rule invariants preserved
+
+- **Rule 22**: no new `/api/*` mutation; the chat's live path is browser↔daemon,
+  not browser↔SvelteKit. (If A2 discovery graduates, the only `/api/*` addition is
+  a **read-only** `agent.json` mirror — a fresh amendment, OQ1.)
+- **Rule 23 / ADR-010**: core `bin/` imports stay `node:*`+citty+siblings; the
+  subcommand only `spawn`s.
+- **Rule 24**: `MapChat` composes `shared/ui` primitives, no re-skin.
+
+## Implementation Phases
+
+- **Phase 1 — camera-bus seam + Tier 0 chat (web-only, ships value with NO
+  daemon).** `camera-bus.svelte.ts`, `tier0.ts`, `MapChat.svelte` (Tier 0 mode),
+  `ComposedMapView` consumes the bus. Unit-test tier0 answering + the bus.
+- **Phase 2 — the agent package skeleton.** `@forgeplan/web-agent`:
+  `protocol.mjs`, `profile.mjs` (read-only), `bin/agent.mjs` (WS bind + SDK
+  session boot + `show_on_map` tool + relay). Use context7 for the real Agent SDK
+  API. Smoke: daemon boots, binds 127.0.0.1, answers a canned question.
+- **Phase 3 — spawn-only subcommand + probe/upgrade.** `bin/commands/onboard-agent.mjs`
+  (+ cli registration), `agent-client.ts` (probe → connect → stream), Tier 0→1
+  upgrade wiring. Rule-23 grep green.
+- **Phase 4 — Prove.** Tier 0 offline demo; Tier 1 end-to-end (question → prose +
+  camera move) on the real map; rule 22/23 verification greps; EVID linked
+  `informs` before activation (rule 11, R_eff > 0).
+
+## Risks & Mitigations
+
+| Risk | Likelihood | Impact | Mitigation |
+|---|---|---|---|
+| Localhost WS reachable by any local process / other browser tab | med | high | Bind 127.0.0.1 only; read-only agent profile (no write surface even if reached); daemon is user-launched + ephemeral; consider origin check / one-time token (OQ2) |
+| Agent SDK version skew vs the daemon / model changes | med | med | `ready.protocolVersion`; web tolerates missing/old daemon by staying Tier 0 |
+| Port already in use | med | low | Fail loudly with `--port`; A2 discovery-file graduation (OQ1) |
+| Daemon crash / hang mid-answer | med | med | `agent-client` timeouts + `onClose` → revert to Tier 0; session disposable, relaunch cheap |
+| rule 22 / 23 drift (agent routed through `/api/*` or SDK imported in core `bin/`) | low | high | Verification greps; the subcommand is spawn-only by contract |
+| Tier 0 answers feel worse than Tier 1 → confusion | med | low | Clear tier affordance; Tier 0 is grounded (real `description_ru`), not guessed |
+
+## Test Strategy Hooks
+
+- **tier0.ts** — question→answer over a fixture doc: matches a zone by label; a
+  node by path; returns a `target`; never throws; model-free.
+- **camera-bus** — `showOnMap` then `consumeCameraTarget` round-trips; zone target
+  → `fitToRect(zoneRect)`; node → select; flow → highlight.
+- **protocol** — encode/decode every `ServerMsg`/`ClientMsg`; unknown type
+  ignored; version negotiated.
+- **agent-client** — probe up/down; token stream assembles; `show_on_map` frame →
+  `onShowOnMap`; close → revert.
+- **onboard-agent subcommand** — spawns the agent bin; absent → install hint +
+  non-zero exit, no raw ENOENT; rule-23 grep over `bin/` still OK.
+- **profile** — the SDK options deny Write/Edit/Bash and bind localhost.
+- **Non-regression** — no `/api/*` change; the 9 views + drill-down + tour
+  unchanged with the chat closed.
+
+## Open Questions
+
+- **OQ1 — daemon discovery.** MVP = fixed port + probe (A1); graduate to a
+  `~/.forgeplan-web/agent.json` discovery file + a **read-only** `/api/agent`
+  mirror (A2, rule-22 amendment) for multi-instance / port-in-use.
+- **OQ2 — localhost auth.** Whether to add an origin check / one-time handshake
+  token beyond 127.0.0.1-bind + read-only profile.
+- **OQ3 — Tier-0 answering depth.** How far the model-free matcher goes before
+  "ask the live agent" — measured, not guessed.
+- **OQ4 — camera-target vocabulary.** The `show_on_map` `id` space depends on the
+  map-pack **stable-id** fix (marketplace CM-02) — until node ids are
+  altitude-stable, `show_on_map(node)` is best-effort.
+
+## Related Artifacts
+
+- **PRD-038** — parent (`based_on`); Pillar C, FD-1..FD-7, Q1..Q8.
+- **ADR-010** — (`based_on`) the packaging decision this RFC presumes.
+- **RFC-033** — (`refines`) the tour camera this agent drives via the new
+  `camera-bus` seam; no camera redesign.
+- **RFC-030 / SPEC-006** — the `forgeplan.map/v1` render contract Tier 0 reads.
+- **Rule 22 / Rule 23 (ADR-003) / Rule 24** — the invariants this design keeps.
+- **`docs/MAP-PACK-FINDINGS-FOR-MARKETPLACE.md`** — CM-02 (stable node ids) that
+  `show_on_map(node)` depends on for precise deep targeting.
+- **EvidencePack (pending)** — Tier-0 offline + Tier-1 end-to-end checkpoint,
+  linked `informs` before activation (rule 11).
+
+
+
diff --git a/.forgeplan/rfcs/RFC-035-chat-panel-v2-floatable-dockable-resizable-window-agent-info-tab-status-model-settings-token-usage-instance-discovery.md b/.forgeplan/rfcs/RFC-035-chat-panel-v2-floatable-dockable-resizable-window-agent-info-tab-status-model-settings-token-usage-instance-discovery.md
new file mode 100644
index 0000000..1534e37
--- /dev/null
+++ b/.forgeplan/rfcs/RFC-035-chat-panel-v2-floatable-dockable-resizable-window-agent-info-tab-status-model-settings-token-usage-instance-discovery.md
@@ -0,0 +1,234 @@
+---
+depth: standard
+id: RFC-035
+kind: rfc
+last_modified_at: 2026-07-07T11:18:04.582081+00:00
+last_modified_by: claude-code/2.1.202
+links:
+- target: RFC-034
+  relation: based_on
+status: draft
+title: Chat panel v2 — floatable/dockable/resizable window + agent Info tab (status, model, settings, token usage, instance discovery)
+---
+
+## Summary
+
+Extends the RFC-034 onboarding chat (Pillar C) from a fixed right-docked
+drawer into a **floatable, dockable, resizable** chat window with a two-tab
+layout (**Chat** + **Info**), a simplified status header (🟢 online / 🔴
+offline), and an **Info tab** surfacing live agent diagnostics: model,
+read-only settings, cumulative token usage (input/output), and how many
+*other* forgeplan-web agent instances are running on the machine.
+
+`based_on` RFC-034. The daemon lifecycle fix (lazy `query()` start + close
+teardown + `fetch /health` probe, commit `e42040e`) is a prerequisite —
+this RFC assumes the daemon no longer leaks subprocesses.
+
+## Motivation
+
+The chat is currently a fixed panel a user cannot move, cannot widen for a
+long answer, and which exposes nothing about the agent behind it. Three
+concrete user asks drive this RFC:
+
+1. **Get it out of the way, keep it there.** The window must float (drag to
+   move, stays where dropped) AND dock (pin to an edge), resizable in either
+   mode — so it adapts to how the user is working with the map.
+2. **Know at a glance if the agent is alive.** A compact 🟢 online / 🔴
+   offline status, not a verbose model string.
+3. **See what the agent is and what it costs.** An Info tab with model,
+   settings, token usage (input/output), and cross-project awareness — "the
+   info from the agent that helps me work." This turns the chat from a black
+   box into an instrument panel, and is the concrete UI that justifies the
+   protocol + registry work in FR-5/FR-6.
+
+Without this, the agent's cost and capabilities stay invisible and the panel
+stays in the user's way — friction that undercuts the onboarding value the
+whole Pillar-C arc was built for.
+
+## Context / Problem
+
+Today the chat is a fixed panel pinned bottom/right. Users want to (a) move
+it out of the way and keep it where they dropped it, (b) widen it for long
+answers, and (c) see *what the agent is* — model, settings, cost — not just
+its replies. None of that is visible today. The token-usage and
+instance-count data physically do not reach the browser yet: the daemon
+never forwards the SDK's `result.usage`, and the agent daemon is not in the
+`~/.forgeplan-web/instances.json` registry that already powers the web
+instance switcher (PRD-027 / RFC-023 / ADR-004).
+
+## Proposed Direction
+
+### FR-1 — Window: float + dock + resize (both modes)
+
+The chat window supports BOTH placement modes, remembered across reloads:
+
+- **Docked** (default): pinned to the right edge, as today. Drag the LEFT
+  edge to resize width. Stays pinned.
+- **Floating**: dragging the header detaches it into a free-floating window
+  that moves with the pointer and stays where dropped. Drag any edge/corner
+  to resize.
+- **Re-dock**: dragging a floating window back onto the right edge snaps it
+  back to docked (a snap zone ~24px from the edge), or an explicit dock/undock
+  toggle in the header.
+- Resize works in BOTH modes.
+
+Persisted state (localStorage, one key, versioned): `{ mode: "docked" |
+"floating", x, y, width, height }`. Clamp to the viewport on restore
+(never restore off-screen). Min width/height enforced. Pointer-events use
+Pointer Events API (pointerdown/move/up + setPointerCapture) — not
+mouse-only — and are reduced-motion-aware. Keyboard: header is focusable;
+Esc closes; the resize handle is operable (arrow keys nudge width) for a11y.
+
+### FR-2 — Simplified status header
+
+The header shows a compact status: a colored dot + word — **🟢 online** when
+the daemon probe is up, **🔴 offline** when down. The verbose
+"forgeplan-web-agent (claude-agent-sdk)" model string moves OUT of the header
+into the Info tab (FR-4). Header also carries: New chat, sessions menu, the
+Chat/Info tab switch, dock/undock toggle, close.
+
+### FR-3 — Tabbed layout (Chat | Info)
+
+The panel body is a two-tab surface using the existing `shared/ui` Tabs
+primitive (rule 24 — compose, do not re-skin): **Chat** (the current
+transcript + input) and **Info** (FR-4). Switching tabs never interrupts a
+streaming answer; the Chat tab keeps its scroll position and in-flight state.
+
+### FR-4 — Info tab (agent diagnostics)
+
+The Info tab is a read-only diagnostics panel. Rows, each degrading
+gracefully when its datum is unavailable:
+
+- **Status**: online/offline + protocol version.
+- **Model**: the agent label from the `ready` frame (moved from the header).
+- **Settings**: the read-only profile — allowed tools (Read/Glob/Grep +
+  show_on_map), disallowed (Write/Edit/Bash), workspace cwd. These are
+  known/static from the daemon; surfaced verbatim.
+- **Token usage** (FR-5 data): input tokens / output tokens, this session
+  and cumulative for the connection. "—" until the first `usage` frame.
+- **Other projects** (FR-6 data): "sees N other forgeplan-web agents" with a
+  small list (project name + port). "0" / "just this one" when alone.
+
+### FR-5 — Daemon forwards SDK token usage (protocol addition)
+
+The Agent SDK's `result` message carries `usage` (input_tokens,
+output_tokens, and cost fields). The daemon emits a new versioned frame
+`{ type: "usage", inputTokens, outputTokens, costUsd? }` on each turn's
+`result`, accumulated per connection. The web client sums per-session and
+cumulative and renders them in the Info tab. Additive to the wire schema in
+`agent/lib/protocol.mjs`; unknown frames already degrade to null on the web
+side (forward-compatible). The `ready` frame is extended to advertise a
+`capabilities`/`features` list so an older web build feature-detects the
+`usage` frame instead of assuming it.
+
+### FR-6 — Agent instance discovery (registry integration)
+
+On start, the daemon registers itself in the existing
+`~/.forgeplan-web/instances.json` registry via a NEW `kind: "agent"` row
+(reusing `bin/lib/registry.mjs` `register`/`heartbeat`(30s tick)/`deregister`
+/`sweepStale`/`isAlive`). The row shape mirrors the web-instance row plus
+`kind`. The web client reads the registry (via a small read-only surface —
+either the existing `/api/instances` extended with `kind`, or a dedicated
+`ready`-time count) and shows the count of OTHER live agent rows in the Info
+tab. Same liveness sweep (`process.kill(pid,0)` + heartbeat freshness) as
+the web switcher — no new discovery mechanism.
+
+## Alternatives considered
+
+- **A1 — docked-resize only (no float).** Simpler, but the user explicitly
+  wants "move it and leave it where dropped." Rejected as insufficient.
+- **A2 — a bits-ui primitive for the window.** bits-ui has Dialog/ScrollArea
+  but no draggable+resizable floating window; shadcn-svelte Resizable
+  (paneforge) is for split panes, not a free-floating movable window. So the
+  window shell is a hand-rolled `shared/ui` primitive, carrying a
+  rule-24-bits-ui header justification (no upstream equivalent exists), and
+  showcased on /playground per rule 24.
+- **A3 — mDNS/UDP for instance discovery.** Heavier than the file registry
+  that already exists and works same-machine. Rejected; reuse the registry.
+- **A4 — token counting on the web side.** The browser cannot count tokens
+  the model actually consumed; only the SDK `result.usage` is authoritative.
+  Rejected; must come from the daemon.
+
+## Function signatures / contracts
+
+- `agent/lib/protocol.mjs`: add `usageMessage({inputTokens, outputTokens,
+  costUsd?})` encoder + `decodeUsage`; extend `readyMessage` with
+  `capabilities: string[]`. Additive; PROTOCOL_VERSION bump.
+- `template/src/widgets/map-chat/model/agent-client.ts`: `AgentHandlers`
+  gains optional `onUsage?(u)`; `ServerMsg` union gains `usage`; parse +
+  route additively (unknown → null, unchanged).
+- `template/src/widgets/map-chat/model/chat-store.svelte.ts`: window state
+  (`mode/x/y/width/height` + persistence), tab state (`chat|info`), usage
+  accumulators (session + cumulative), instance-count getter.
+- New `shared/ui/<window-shell>/` primitive (drag/resize/dock) + barrel +
+  `shared/ui/index.ts` re-export + `/playground` showcase (rule 24).
+- `agent/bin/agent.mjs`: register/heartbeat/deregister with the registry on
+  start/exit; emit `usage` on `result`; advertise capabilities on `ready`.
+
+## Invariants
+
+- **I1 — read-only preserved.** The Info tab and registry integration add NO
+  mutation path; the agent daemon stays read-only (Read/Glob/Grep + show_on_map),
+  rule 22 untouched (browser↔daemon direct, not via /api).
+- **I2 — no subprocess regressions.** The window/tab/registry work must not
+  reintroduce eager `query()` starts; a probe/idle window still spawns zero
+  `claude` subprocesses (commit `e42040e` invariant holds).
+- **I3 — forward-compatible wire.** New `usage`/`capabilities` are additive;
+  an older web build ignores unknown frames (degrades to null), never crashes.
+- **I4 — never restore off-screen.** Persisted floating geometry is always
+  clamped to the current viewport on restore.
+- **I5 — single registry writer.** Agent rows reuse `bin/lib/registry.mjs`'s
+  atomic write + heartbeat reconcile; the web `/api/*` reader never mutates
+  the registry (rule 22 verification for `/api/instances`).
+
+## Implementation Phases
+
+- **Wave 1 (web-only, no backend dep)**: FR-1 window (float/dock/resize +
+  persistence), FR-2 status header, FR-3 tabs, FR-4 Info tab scaffold showing
+  what's already known (status, model, settings). Ships visible value with
+  zero daemon change. New `shared/ui` window primitive + /playground showcase.
+- **Wave 2 (daemon/protocol)**: FR-5 usage frames + FR-6 registry
+  integration → fills the Info tab's token + instance rows with live data.
+  Protocol version bump + capabilities handshake + smoke coverage.
+
+## Rollback Plan
+
+- Wave 1 is pure web/localStorage; reverting the commits restores the fixed
+  drawer with no data migration (a stale window-geometry key is ignored by a
+  version guard, or cleared).
+- Wave 2 is additive to the wire: if the `usage`/registry work regresses,
+  revert the daemon commits — the web Info tab rows fall back to "—" / "just
+  this one" via their graceful-degrade path (I3), and the chat keeps working.
+- The registry rows self-expire via the existing heartbeat/`sweepStale`
+  liveness so a rolled-back agent leaves no stale rows beyond the sweep window.
+
+## Risks
+
+- **Off-screen restore**: a persisted floating position can land off-screen
+  after a monitor change — MUST clamp to viewport on restore (I4).
+- **Registry contention**: agent + web instances writing the same
+  `instances.json` — reuse the existing atomic-write + heartbeat reconcile;
+  do not fork the writer (I5).
+- **Rule 24**: the window shell MUST be a `shared/ui` primitive with a
+  /playground showcase, not an inline widget hack, or the catalogue lies.
+- **Pointer capture leaks**: a drag interrupted by a lost pointer MUST release
+  capture on pointercancel; never wedge the UI.
+- **Reduced motion / a11y**: drag+resize must be keyboard-operable and honor
+  `prefers-reduced-motion`.
+
+## Test strategy
+
+- Unit (vitest): window-state persistence (save/restore/clamp-off-screen),
+  dock↔float transitions, min-size clamp, tab switch preserves streaming,
+  usage accumulation (session vs cumulative), instance-count getter, probe
+  status → dot color. `usage` frame parse (present/absent/malformed → null).
+- Daemon (smoke.mjs): `usage` frame round-trips protocol encode/decode;
+  registry register→heartbeat→deregister lifecycle; capabilities on `ready`.
+- Live (Playwright): drag-move persists position; drag-left-edge resizes;
+  dock/undock; 🟢/🔴 flips with daemon up/down; Info tab shows model +
+  settings; after a turn, token counts populate; instance count reflects a
+  second daemon.
+- svelte-check 0 errors; rule-24 grep (no `:global()` re-skin of primitive
+  internals from map-chat).
+
+
diff --git a/agent/README.md b/agent/README.md
new file mode 100644
index 0000000..c227264
--- /dev/null
+++ b/agent/README.md
@@ -0,0 +1,23 @@
+# @forgeplan/web-agent
+
+`@forgeplan/web-agent` is the optional, separately-published daemon-bridge
+behind forgeplan-web's live onboarding chat (RFC-034 Pillar C / ADR-010). It
+boots a persistent Claude Agent SDK session in a **read-only** profile
+(`Read`/`Glob`/`Grep` + one in-process `show_on_map` tool; `Write`/`Edit`/
+`Bash` denied), rooted at the project's `cwd`, and binds a WebSocket **on
+`127.0.0.1` only**. The browser's `map-chat` widget talks to this daemon
+directly — never through forgeplan-web's `/api/*` (which stays a read-only
+proxy per rule 22) — streaming assistant prose back as `token` frames and
+relaying each `show_on_map` tool call as a frame the map camera reacts to.
+
+It is launched via `npx @forgeplan/web onboard-agent`, a spawn-only
+subcommand in the core `@forgeplan/web` package (`bin/` never imports this
+package — it only `child_process.spawn`s the binary shipped here, per
+ADR-010, so the core package's `npx` weight is unaffected for the 99% of
+users who only view the map). Directly: `npx @forgeplan/web-agent --cwd
+<project-root> --port 7431`.
+
+Guarantees: localhost-bind only (no `--host` flag exists by design), a
+read-only Agent SDK profile enforced in `lib/profile.mjs`, and the daemon
+uses the invoking user's own local Claude Code authentication — no API key
+is baked in or required.
diff --git a/agent/bin/agent.mjs b/agent/bin/agent.mjs
new file mode 100755
index 0000000..4e6a579
--- /dev/null
+++ b/agent/bin/agent.mjs
@@ -0,0 +1,716 @@
+#!/usr/bin/env node
+// RFC-034 (Pillar C, Phase 2) / ADR-010 — the onboard-agent daemon. Boots a
+// persistent, read-only Claude Agent SDK session per WebSocket connection,
+// binds 127.0.0.1 ONLY, registers the in-process `show_on_map` tool, and
+// relays SDK stream events <-> WS frames using agent/lib/protocol.mjs's
+// versioned schema. Launched exclusively via the core package's spawn-only
+// `bin/ onboard-agent` subcommand (Phase 3) — never imported by it (rule 23 /
+// ADR-010: the SDK dependency lives ONLY in this separate package).
+//
+// Health/probe choice (documented per RFC-034 task hand-off): this daemon
+// exposes BOTH a plain `GET /health` (via the same http.Server the
+// WebSocketServer attaches to) AND a per-connection `{type:"ready"}` WS
+// frame. `/health` is what the browser's cheap Tier-0→Tier-1 upgrade probe
+// (agent-client.ts#probeDaemon, Phase 3) uses — a plain fetch with no
+// socket lifecycle to manage, safe to poll on an interval. The `{ready}`
+// frame is what a CONNECTED client uses to confirm protocol/model
+// compatibility before sending its first `user_message`. Two signals, two
+// purposes: liveness (HTTP) vs. session-ready (WS).
+
+import { createServer } from "node:http";
+import { existsSync, statSync, realpathSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { WebSocketServer } from "ws";
+import {
+  query,
+  tool,
+  createSdkMcpServer,
+} from "@anthropic-ai/claude-agent-sdk";
+import { z } from "zod";
+import { buildOptions } from "../lib/profile.mjs";
+import {
+  PROTOCOL_VERSION,
+  decodeClientMessage,
+  encode,
+  readyMessage,
+  sessionMessage,
+  tokenMessage,
+  showOnMapMessage,
+  usageMessage,
+  doneMessage,
+  errorMessage,
+} from "../lib/protocol.mjs";
+import {
+  registerAgent,
+  heartbeatAgent,
+  deregisterAgent,
+  readOtherLiveInstances,
+} from "../lib/registry.mjs";
+
+const DEFAULT_PORT = 7431;
+// Localhost-bind is an ADR-010 invariant, not a runtime option — there is no
+// --host flag by design (see RFC-034 Risks: "Localhost WS reachable by any
+// local process / other browser tab").
+const HOST = "127.0.0.1";
+const AGENT_LABEL = "forgeplan-web-agent (claude-agent-sdk)";
+// RFC-035 (Wave 2, FR-5/FR-6) — advertised on every `ready` frame so an
+// older web client feature-detects instead of assuming these frames exist.
+const DAEMON_CAPABILITIES = ["usage", "instances"];
+// RFC-035 (Wave 2, FR-6) — this process's own row id in the shared
+// instance registry, set once `main()`'s `registerAgent()` call succeeds.
+// Module-level rather than threaded through createDaemon/handleConnection:
+// there is exactly one daemon per process (agent/scripts/smoke.mjs spawns
+// each test daemon as its own child process), and every WS connection's
+// `ready` frame needs the CURRENT value to report other live instances.
+// Stays `null` if registration hasn't run yet or failed (fail-open —
+// readOtherLiveInstances(null) degrades to "no self to exclude", which is
+// harmless since no row can exist yet in that case).
+let currentAgentId = null;
+// RFC-035 (Wave 2, FR-6) — heartbeat ticker, unref'd so it never holds the
+// process open; cleared on shutdown by cleanupRegistry() in main().
+let heartbeatTimer = null;
+
+function fail(line, code = 1) {
+  process.stderr.write(`onboard-agent: ${line}\n`);
+  process.exit(code);
+}
+
+export function parseArgs(argv) {
+  const args = { cwd: process.cwd(), port: DEFAULT_PORT };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--cwd") {
+      const v = argv[++i];
+      if (!v) throw new Error("--cwd requires a value");
+      args.cwd = v;
+    } else if (a === "--port") {
+      const v = Number(argv[++i]);
+      if (!Number.isFinite(v) || v < 1 || v > 65_535) {
+        throw new RangeError(`invalid --port value; expected 1..65535`);
+      }
+      args.port = v;
+    }
+  }
+  return args;
+}
+
+// RFC-034 Phase 4c — a resumed session id is only ever compared/threaded
+// through as an opaque string (never shell-interpolated, never used in a
+// filesystem path); this charset is a defensive sanity check against a
+// pathologically malformed query param, not an attempt to pin the exact
+// format the Agent SDK issues.
+const RESUME_SESSION_ID_PATTERN = /^[A-Za-z0-9_-]{1,200}$/;
+
+/**
+ * Extracts and validates a `?resume=<sessionId>` query param from the raw
+ * HTTP upgrade request URL (`request.url`, e.g. `/?resume=abc-123`).
+ * Returns `null` for a missing param, an empty value, a value outside
+ * `RESUME_SESSION_ID_PATTERN`, or an unparseable URL — every one of these
+ * degrades to "start a fresh session" rather than throwing, matching the
+ * live-continue contract ("never break").
+ */
+export function parseResumeSessionId(rawUrl) {
+  if (typeof rawUrl !== "string" || rawUrl.length === 0) return null;
+  let parsed;
+  try {
+    parsed = new URL(rawUrl, "http://localhost");
+  } catch {
+    return null;
+  }
+  const value = parsed.searchParams.get("resume");
+  if (!value || !RESUME_SESSION_ID_PATTERN.test(value)) return null;
+  return value;
+}
+
+/**
+ * A per-connection async message queue: `enqueue(text, turnId)` is called
+ * from the WS `message` handler; `generator()` is the async generator
+ * handed to `query({ prompt })` as its STREAMING INPUT. The generator stays
+ * open for the life of the connection — it awaits a promise that resolves
+ * the moment a new message is enqueued, so the SDK session accrues context
+ * across every question on this connection instead of being torn down
+ * per-turn. `close()` (bugfix — leaked subprocess) ends that life: it wakes
+ * any parked `generator()` and makes it `return` instead of yielding again,
+ * completing the SDK's input async-iterable so `query()` can tear down its
+ * underlying `claude` subprocess instead of leaking it — see
+ * `socket.on("close")` in `handleConnection` below.
+ *
+ * Bugfix #1 (cross-turn frame race) — `getCurrentTurnId()` exposes the
+ * `turnId` of the item most recently shifted off the queue and handed to
+ * the SDK's input generator, i.e. the turn the persistent Query is
+ * CURRENTLY being fed / is actively processing. `handleConnection`'s
+ * message loop reads this at the moment it sends each outgoing
+ * token/usage/show_on_map/done/error frame, so every frame is stamped with
+ * the turn it actually belongs to — this is what lets the browser tell a
+ * straggler frame from a cancelled turn apart from the next turn's frames,
+ * even if timing alone can't guarantee the cancelled turn's stream has
+ * fully stopped before the next one starts.
+ */
+export function createMessageQueue() {
+  const pending = [];
+  let wake = null;
+  // Bugfix (leaked subprocess) — set by `close()` when the owning
+  // WebSocket disconnects; makes `generator()` return instead of parking
+  // forever on an unresolved wake promise, which is what let the
+  // underlying `claude` subprocess leak on every dropped connection.
+  let done = false;
+  let currentTurnId = null;
+
+  function enqueue(text, turnId = null) {
+    pending.push({ text, turnId });
+    if (wake) {
+      const resolve = wake;
+      wake = null;
+      resolve();
+    }
+  }
+
+  /**
+   * Terminates the queue: any generator currently parked awaiting a new
+   * message wakes up and returns instead of yielding another value. Safe to
+   * call even if the generator was never iterated (lazy query start below)
+   * or was already closed.
+   */
+  function close() {
+    done = true;
+    if (wake) {
+      const resolve = wake;
+      wake = null;
+      resolve();
+    }
+  }
+
+  async function* generator() {
+    for (;;) {
+      while (pending.length === 0 && !done) {
+        await new Promise((resolve) => {
+          wake = resolve;
+        });
+      }
+      if (done) return;
+      const item = pending.shift();
+      currentTurnId = item.turnId;
+      yield {
+        type: "user",
+        session_id: "",
+        parent_tool_use_id: null,
+        message: { role: "user", content: item.text },
+      };
+    }
+  }
+
+  return { enqueue, generator, close, getCurrentTurnId: () => currentTurnId };
+}
+
+/**
+ * Builds the ONE registered SDK tool for this connection: `show_on_map`.
+ * Bound to `socket` so its handler can relay the call to the browser as a
+ * `{type:"show_on_map"}` WS frame — this is the entire RFC-034 camera relay.
+ * Bugfix #1 — `getTurnId` (defaults to `() => null`) is read at call time so
+ * the relayed frame is stamped with whichever turn is currently driving the
+ * SDK session, letting the browser attribute the camera move to the right
+ * chat turn.
+ */
+export function buildOnboardServer(socket, getTurnId = () => null) {
+  return createSdkMcpServer({
+    name: "onboard",
+    version: "1.0.0",
+    tools: [
+      tool(
+        "show_on_map",
+        "Move the map camera to a zone, node, or flow so the user can see what you are explaining",
+        {
+          kind: z.enum(["zone", "node", "flow"]),
+          id: z.string(),
+        },
+        async (args) => {
+          try {
+            socket.send(
+              encode(
+                showOnMapMessage({ kind: args.kind, id: args.id }, getTurnId()),
+              ),
+            );
+          } catch {
+            // TODO(socket-closed-mid-tool-call): the WS may have closed
+            // between the tool call starting and this send. The SDK still
+            // gets its ack below so the model's turn completes normally —
+            // the browser simply misses that one camera move.
+          }
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Shown ${args.kind} ${args.id} on the map.`,
+              },
+            ],
+          };
+        },
+      ),
+    ],
+  });
+}
+
+function handleConnection(socket, { cwd, request }) {
+  const messageQueue = createMessageQueue();
+  const onboardServer = buildOnboardServer(socket, () =>
+    messageQueue.getCurrentTurnId(),
+  );
+  const resumeSessionId = parseResumeSessionId(request?.url);
+
+  function buildConnectionOptions(resume) {
+    return {
+      ...buildOptions({ cwd }),
+      mcpServers: { onboard: onboardServer },
+      ...(resume ? { resume } : {}),
+    };
+  }
+
+  let closed = false;
+  // Tracks whether the connection currently has a user turn in flight —
+  // set on the `user_message` that starts it, cleared once the matching
+  // `result` message closes it out. Drives the {type:"cancel"} guard below
+  // ("cancel with no in-flight turn is a no-op") without depending on the
+  // SDK to tell us anything about idle state.
+  let turnActive = false;
+  // Held onto (rather than iterated anonymously) so the `cancel` handler
+  // below can call `activeQuery.interrupt()` on the SAME persistent Query
+  // object the for-await loop is draining — this is the Agent SDK's
+  // documented way to stop the current turn without tearing down the
+  // session (Query#interrupt(): Promise<void>; the session's async
+  // generator prompt keeps accepting further `user_message`s afterward).
+  // Reassigned by `startQuery` (Phase 4c retry-fresh fallback below), so
+  // this must be `let`, not `const`.
+  let activeQuery = null;
+  // Bugfix #1 (cross-turn frame race) — set by `handleCancel` to the
+  // in-flight `activeQuery.interrupt()` promise; cleared once it settles.
+  // `handleUserMessage` AWAITS this before enqueueing the next turn's
+  // prompt into the SAME persistent Query's input stream, so a cancel
+  // immediately followed by a resend cannot enqueue the new turn before the
+  // cancelled one has been told to stop.
+  let cancelPromise = null;
+  // RFC-034 Phase 4c — guards the one-shot "resume failed before any SDK
+  // message arrived, retry fresh" fallback from looping forever.
+  let retriedFreshAfterResume = false;
+  // Bugfix (leaked subprocess) — true once `startQuery` has actually been
+  // called for this connection. Guards against spawning a `claude`
+  // subprocess for EVERY WebSocket connection, including the browser's
+  // liveness probe (which opens and drops a fresh WS every
+  // PROBE_INTERVAL_MS with no `user_message` ever sent): the subprocess is
+  // now started LAZILY, on the first `user_message`, never on connect.
+  let queryStarted = false;
+
+  socket.on("close", () => {
+    closed = true;
+    messageQueue.close();
+    // Bugfix (leaked subprocess) — ACTIVE teardown. Previously the only
+    // signal a closed socket gave the in-flight `for await` loop was the
+    // passive `if (closed) break` below, which only re-evaluates when the
+    // SDK yields a NEW message — a connection with no more turns coming
+    // (an idle chat, or a probe that never sent a user_message) would
+    // never hit it, and the underlying `claude` subprocess leaked forever
+    // (10-20+ orphaned processes observed in minutes, pegging CPU).
+    // interrupt() stops any in-flight turn; return() ends the Query
+    // AsyncGenerator, which tears down the subprocess. Every rejection is
+    // swallowed — a per-connection teardown fault must never crash the
+    // daemon.
+    try {
+      const ir = activeQuery?.interrupt?.();
+      if (ir && typeof ir.catch === "function") ir.catch(() => {});
+    } catch {
+      // interrupt() threw synchronously — return() below still runs.
+    }
+    try {
+      const r = activeQuery?.return?.(undefined);
+      if (r && typeof r.catch === "function") r.catch(() => {});
+    } catch {
+      // return() threw synchronously — nothing further to do here.
+    }
+    activeQuery = null;
+  });
+  socket.on("error", () => {
+    // TODO(ws-error-swallow): a transport-level error already implies the
+    // connection is going away; the subsequent `close` event does cleanup.
+    // Never let a per-connection transport fault crash the daemon.
+  });
+
+  // RFC-035 (Wave 2, FR-5/FR-6) — advertise capabilities + a snapshot of
+  // other live instances at connect time. readOtherLiveInstances is
+  // fail-open (returns [] on any registry fault), so this send is never
+  // gated on the registry being writable.
+  socket.send(
+    encode(
+      readyMessage(AGENT_LABEL, {
+        capabilities: DAEMON_CAPABILITIES,
+        otherInstances: readOtherLiveInstances(currentAgentId),
+      }),
+    ),
+  );
+
+  function startQuery(resume) {
+    // True once ANY message (including the first `system`/`init`) has been
+    // observed from this attempt's query() stream — used below to decide
+    // whether an early failure is plausibly "the requested resume target
+    // doesn't exist" (nothing arrived yet) vs. a fault mid-conversation
+    // (something already arrived; resuming again would just repeat it).
+    let anyMessageSeen = false;
+    const options = buildConnectionOptions(resume);
+    activeQuery = query({ prompt: messageQueue.generator(), options });
+
+    (async () => {
+      try {
+        for await (const message of activeQuery) {
+          if (closed) break;
+          anyMessageSeen = true;
+          if (message.type === "system" && message.subtype === "init") {
+            // RFC-034 Phase 4c — the SDK's authoritative session id for
+            // THIS query(), whether freshly started or resumed. Always
+            // relayed (never assumed to equal the requested `resume`
+            // value) so the browser's persisted id self-corrects to
+            // whatever the daemon/SDK actually used.
+            try {
+              socket.send(encode(sessionMessage(message.session_id)));
+            } catch {
+              // socket already gone — nothing left to notify.
+            }
+          } else if (message.type === "stream_event") {
+            // Token-level streaming (requires options.includePartialMessages,
+            // see lib/profile.mjs). `event` is Anthropic's raw
+            // RawMessageStreamEvent; a text token arrives as a
+            // content_block_delta carrying a text_delta. The complete
+            // `assistant` message that follows at end-of-turn carries the
+            // SAME text in full blocks — it is intentionally NOT re-sent as
+            // `token` frames below, or every answer would render twice.
+            const ev = message.event;
+            if (
+              ev?.type === "content_block_delta" &&
+              ev.delta?.type === "text_delta" &&
+              typeof ev.delta.text === "string"
+            ) {
+              socket.send(
+                encode(
+                  tokenMessage(ev.delta.text, messageQueue.getCurrentTurnId()),
+                ),
+              );
+            }
+          } else if (message.type === "result") {
+            turnActive = false;
+            const turnId = messageQueue.getCurrentTurnId();
+            // RFC-035 (Wave 2, FR-5) — forward the SDK's own usage/cost
+            // figures for this turn, BEFORE `done`, so the web client can
+            // attribute the usage frame to the turn that just completed.
+            // Guard: an absent `usage` (never observed from the SDK today,
+            // but not guaranteed by its types) skips the usage frame
+            // entirely rather than sending zeros that would look like a
+            // real (if empty) turn.
+            if (message.usage) {
+              const inputTokens = message.usage?.input_tokens ?? 0;
+              const outputTokens = message.usage?.output_tokens ?? 0;
+              const costUsd = message.total_cost_usd ?? 0;
+              socket.send(
+                encode(
+                  usageMessage({ inputTokens, outputTokens, costUsd }, turnId),
+                ),
+              );
+            }
+            // Bugfix #6 — the SDK reports a per-turn failure (e.g.
+            // error_during_execution, error_max_turns) as a NORMAL `result`
+            // message with `is_error: true`, not as a thrown exception — the
+            // query() stream stays open, ready for the next turn on this
+            // SAME connection. This is exactly the "connection/session is
+            // fine" case, so it is reported as fatal:false: a recoverable
+            // per-turn notice, not a reason to fall back to Tier 0.
+            if (message.is_error) {
+              const detail =
+                Array.isArray(message.errors) && message.errors.length > 0
+                  ? message.errors.join("; ")
+                  : (message.subtype ?? "the turn failed");
+              try {
+                socket.send(
+                  encode(errorMessage(detail, { fatal: false, turnId })),
+                );
+              } catch {
+                // socket already gone — nothing left to notify.
+              }
+            }
+            socket.send(encode(doneMessage(turnId)));
+          }
+        }
+      } catch (err) {
+        turnActive = false;
+        // TODO(resume-fallback-heuristic): this project has no live-model
+        // harness to exercise an actual "resume target no longer exists"
+        // failure (agent/scripts/smoke.mjs deliberately never starts a
+        // real SDK turn — see its file header), so the exact shape of that
+        // failure from `query({options:{resume}})` is untested. The
+        // heuristic below is deliberately conservative: only retry fresh
+        // when (a) this attempt USED resume, (b) NOTHING arrived yet (not
+        // even `system/init`), and (c) we have not already retried once.
+        // Any failure after the session was actually established is
+        // reported as a normal `{error}` frame instead, same as before
+        // Phase 4c.
+        if (resume && !anyMessageSeen && !retriedFreshAfterResume) {
+          retriedFreshAfterResume = true;
+          startQuery(undefined);
+          return;
+        }
+        if (!closed) {
+          // Bugfix #6 — reaching this point means the `for await` loop over
+          // `activeQuery` itself threw: the SDK's query() cannot continue,
+          // and (barring the resume-retry-fresh branch above) nothing
+          // restarts it for this connection — genuinely connection/session
+          // fatal, so fatal:true (the web should fall back to Tier 0).
+          try {
+            socket.send(
+              encode(
+                errorMessage(err?.message ?? String(err), {
+                  fatal: true,
+                  turnId: messageQueue.getCurrentTurnId(),
+                }),
+              ),
+            );
+          } catch {
+            // socket already gone — nothing left to notify.
+          }
+        }
+      }
+    })();
+  }
+
+  // Bugfix #1 (cross-turn frame race) — if a cancel is currently
+  // interrupting the in-flight turn, this AWAITS that interrupt() before
+  // enqueueing the next turn's prompt into the SAME persistent Query's
+  // input stream, so the cancelled turn's stream is guaranteed to have been
+  // told to stop before the new turn's prompt ever reaches the SDK. (Every
+  // outgoing frame is ALSO stamped with turnId regardless — see
+  // messageQueue.getCurrentTurnId() above — as a second, independent layer:
+  // even a late/unexpected straggler frame from the cancelled turn can
+  // still be told apart from the new turn's frames by the browser.)
+  async function handleUserMessage(msg) {
+    if (cancelPromise) {
+      await cancelPromise;
+    }
+    if (closed) return; // connection dropped while waiting on the cancel
+    turnActive = true;
+    // Bugfix (leaked subprocess) — LAZY query start. A connection that
+    // only ever probes (never sends a user_message, e.g. the browser's
+    // liveness probe) now spawns NO `claude` subprocess at all; the
+    // first real `user_message` on this connection is what starts it.
+    if (!queryStarted) {
+      queryStarted = true;
+      startQuery(resumeSessionId);
+    }
+    messageQueue.enqueue(msg.text, msg.turnId);
+  }
+
+  function handleCancel() {
+    if (!turnActive || !activeQuery) return; // nothing in flight — no-op per protocol contract
+    if (typeof activeQuery.interrupt === "function") {
+      // Bugfix #1 — held as `cancelPromise` so `handleUserMessage` can await
+      // it before enqueueing the NEXT turn's prompt (see above).
+      const interruptPromise = activeQuery.interrupt().catch(() => {
+        // interrupt() rejected — the client already reset its own
+        // pending state locally (chat-store.cancelCurrent) regardless of
+        // what the daemon does, so there is nothing further to relay;
+        // the connection is left open per the cancel contract. Still let
+        // any user_message waiting on cancelPromise proceed (below) rather
+        // than wedging the connection forever.
+      });
+      cancelPromise = interruptPromise;
+      interruptPromise.finally(() => {
+        if (cancelPromise === interruptPromise) cancelPromise = null;
+      });
+    } else {
+      // TODO(sdk-interrupt-unavailable): defensive fallback for an SDK
+      // build without Query#interrupt() (the pinned
+      // @anthropic-ai/claude-agent-sdk ^0.3.201 always has it). Can't stop
+      // the in-flight turn server-side, but still tell the client it's
+      // over so its UI never waits on a done/error frame that this
+      // connection's for-await loop won't otherwise send until the
+      // (uninterrupted) turn eventually finishes on its own.
+      turnActive = false;
+      try {
+        socket.send(encode(doneMessage(messageQueue.getCurrentTurnId())));
+      } catch {
+        // socket already gone — nothing left to notify.
+      }
+    }
+  }
+
+  socket.on("message", (raw) => {
+    const msg = decodeClientMessage(raw.toString());
+    if (!msg) return; // malformed/unknown frame — dropped per protocol contract
+    if (msg.type === "user_message") {
+      void handleUserMessage(msg);
+    } else if (msg.type === "cancel") {
+      handleCancel();
+    }
+  });
+}
+
+export function createDaemon({ cwd }) {
+  const httpServer = createServer((req, res) => {
+    if (req.method === "GET" && req.url === "/health") {
+      res.writeHead(200, {
+        "content-type": "application/json",
+        // Bugfix (CORS) — the daemon binds 127.0.0.1 ONLY (ADR-010), so a
+        // wildcard CORS origin on this read-only liveness endpoint is
+        // safe: only a local browser tab can reach it, and the response
+        // leaks nothing beyond { ok, protocolVersion, model, capabilities,
+        // otherInstances }. This lets the web client's probe use a plain
+        // `fetch` (no WS lifecycle to manage, safe to poll on an interval)
+        // instead of opening a full WebSocket per probe tick — see
+        // agent-client.ts#probeDaemon.
+        "access-control-allow-origin": "*",
+      });
+      // RFC-035 (Wave 2 follow-up) — carry the SAME capabilities +
+      // otherInstances the `ready` frame advertises on this cheap HTTP
+      // probe, so the Info tab's "Other projects" row (and model) populate
+      // on chat open, before the WebSocket ever connects (no subprocess,
+      // no connection lifecycle touched). readOtherLiveInstances is
+      // fail-open on its own, but this daemon's LIVENESS endpoint must
+      // never 500 on a registry read fault, so it gets an explicit
+      // try/catch belt-and-suspenders on top.
+      let otherInstances = [];
+      try {
+        otherInstances = readOtherLiveInstances(currentAgentId);
+      } catch {
+        otherInstances = [];
+      }
+      res.end(
+        JSON.stringify({
+          ok: true,
+          protocolVersion: PROTOCOL_VERSION,
+          model: AGENT_LABEL,
+          capabilities: DAEMON_CAPABILITIES,
+          otherInstances,
+        }),
+      );
+      return;
+    }
+    res.writeHead(404, { "content-type": "application/json" });
+    res.end(JSON.stringify({ ok: false, error: "not found" }));
+  });
+
+  const wss = new WebSocketServer({ server: httpServer });
+  wss.on("connection", (socket, request) => {
+    // RFC-034 Phase 4c — `request` is the HTTP upgrade request; its `.url`
+    // carries an optional `?resume=<sessionId>` the browser sets when
+    // continuing a past chat session (see parseResumeSessionId above).
+    handleConnection(socket, { cwd, request });
+  });
+  wss.on("error", (err) => {
+    process.stderr.write(
+      `onboard-agent: WS server error: ${err?.message ?? err}\n`,
+    );
+  });
+
+  return { httpServer, wss };
+}
+
+function main() {
+  let cwd;
+  let port;
+  try {
+    ({ cwd, port } = parseArgs(process.argv.slice(2)));
+  } catch (err) {
+    fail(err?.message ?? String(err));
+    return;
+  }
+
+  if (!existsSync(cwd) || !statSync(cwd).isDirectory()) {
+    fail(`--cwd "${cwd}" is not an existing directory`);
+    return;
+  }
+
+  const { httpServer } = createDaemon({ cwd });
+
+  // A per-connection SDK/WS fault must never take the whole daemon down
+  // (RFC-034 contract: "Handle errors as {error} frames, never crash the
+  // daemon"). These are the last-resort safety nets above the per-connection
+  // try/catch in handleConnection.
+  process.on("uncaughtException", (err) => {
+    process.stderr.write(
+      `onboard-agent: uncaught exception: ${err?.stack ?? err}\n`,
+    );
+  });
+  process.on("unhandledRejection", (reason) => {
+    process.stderr.write(`onboard-agent: unhandled rejection: ${reason}\n`);
+  });
+
+  // RFC-035 (Wave 2, FR-6) — undoes registerAgent's registry row and stops
+  // the heartbeat ticker. Idempotent (guarded on currentAgentId) so it is
+  // safe to call from both a signal handler and the httpServer 'close'
+  // event without double-deregistering. Never throws — deregisterAgent is
+  // itself fail-open (agent/lib/registry.mjs).
+  function cleanupRegistry() {
+    if (heartbeatTimer) {
+      clearInterval(heartbeatTimer);
+      heartbeatTimer = null;
+    }
+    if (currentAgentId) {
+      deregisterAgent(currentAgentId);
+      currentAgentId = null;
+    }
+  }
+
+  // Registering a SIGINT/SIGTERM listener suppresses Node's default
+  // immediate-exit behaviour for that signal, so this handler MUST call
+  // process.exit() itself once cleanup is done.
+  process.on("SIGINT", () => {
+    cleanupRegistry();
+    process.exit(0);
+  });
+  process.on("SIGTERM", () => {
+    cleanupRegistry();
+    process.exit(0);
+  });
+  httpServer.on("close", cleanupRegistry);
+
+  httpServer.on("error", (err) => {
+    if (err && err.code === "EADDRINUSE") {
+      fail(
+        `port ${port} is already in use on ${HOST}. Pass a different --port.`,
+      );
+      return;
+    }
+    fail(`http server error: ${err?.message ?? err}`);
+  });
+
+  httpServer.listen(port, HOST, () => {
+    process.stdout.write(
+      `onboard-agent live on ws://${HOST}:${port} (cwd ${cwd})\n`,
+    );
+    // RFC-035 (Wave 2, FR-6) — register once listening, then re-heartbeat
+    // every 30s (unref'd — must never hold the process open on its own).
+    // registerAgent/heartbeatAgent are fail-open; the try/catch here is
+    // defense-in-depth against anything else in this block throwing.
+    try {
+      currentAgentId = registerAgent({
+        port,
+        cwd,
+        protocolVersion: PROTOCOL_VERSION,
+      });
+      heartbeatTimer = setInterval(() => {
+        if (currentAgentId) heartbeatAgent(currentAgentId);
+      }, 30_000);
+      heartbeatTimer.unref();
+    } catch (err) {
+      process.stderr.write(
+        `onboard-agent: registry setup failed (non-fatal): ${err?.message ?? err}\n`,
+      );
+    }
+  });
+}
+
+// `process.argv[1]` is the path npm/npx invoked, which for an installed
+// package's node_modules/.bin/<name> is a SYMLINK to this file. A strict
+// `===` against the resolved import.meta.url path silently fails through
+// that symlink (npx never reaches the daemon-boot branch below), so this
+// guard compares the REAL path on both sides.
+const invokedPath = process.argv[1];
+const isMainModule =
+  invokedPath !== undefined &&
+  realpathSync(invokedPath) === fileURLToPath(import.meta.url);
+if (isMainModule) {
+  main();
+}
diff --git a/agent/lib/profile.mjs b/agent/lib/profile.mjs
new file mode 100644
index 0000000..95ef1db
--- /dev/null
+++ b/agent/lib/profile.mjs
@@ -0,0 +1,53 @@
+// RFC-034 (Pillar C, Phase 2) / ADR-010 — the read-only Agent SDK profile.
+// This is the ONLY place the onboarding session's permission surface is
+// defined: Read/Glob/Grep + the in-process `show_on_map` tool are allowed;
+// Write/Edit/Bash are explicitly denied. `mcpServers` is intentionally NOT
+// set here — the daemon (bin/agent.mjs) owns the per-connection `onboard`
+// MCP server instance (it needs a reference to that connection's socket) and
+// merges it into the options object returned by `buildOptions`.
+
+export const ALLOWED_TOOLS = [
+  "Read",
+  "Glob",
+  "Grep",
+  "mcp__onboard__show_on_map",
+];
+
+export const DISALLOWED_TOOLS = ["Write", "Edit", "Bash"];
+
+export const SYSTEM_PROMPT =
+  "You are an onboarding guide for this software project. You have " +
+  "READ-ONLY access to the repo, its .forgeplan/ workspace, and " +
+  ".forgeplan/map/map.json (a forgeplan.map/v1 document describing the " +
+  "project as zones/nodes/edges/flows). Answer the newcomer concisely, in " +
+  "the language they ask in. Whenever you reference a zone, module, or " +
+  "flow, CALL the show_on_map tool so the map camera moves to it. Never " +
+  "invent — use Read/Glob/Grep to check. Prefer map.json + .forgeplan/ for " +
+  "the big picture.";
+
+/**
+ * Builds the Agent SDK `options` object for a persistent onboarding session
+ * rooted at `cwd` (the project root). Callers (bin/agent.mjs) MUST merge in
+ * `mcpServers: { onboard: <per-connection server> }` before passing this to
+ * `query()` — this module has no socket to relay tool calls through.
+ */
+export function buildOptions({ cwd }) {
+  if (!cwd || typeof cwd !== "string") {
+    throw new TypeError(
+      "buildOptions({ cwd }) requires a non-empty string cwd",
+    );
+  }
+  return {
+    cwd,
+    permissionMode: "default",
+    allowedTools: [...ALLOWED_TOOLS],
+    disallowedTools: [...DISALLOWED_TOOLS],
+    systemPrompt: SYSTEM_PROMPT,
+    // Token-level streaming: without this the SDK only yields a complete
+    // `assistant` message per turn (one big text block), so the chat renders
+    // in paragraph chunks instead of a live typewriter stream. With it,
+    // `query()` also yields `stream_event` messages carrying Anthropic's raw
+    // `content_block_delta` events — see bin/agent.mjs's message loop.
+    includePartialMessages: true,
+  };
+}
diff --git a/agent/lib/protocol.mjs b/agent/lib/protocol.mjs
new file mode 100644
index 0000000..7ef3b3f
--- /dev/null
+++ b/agent/lib/protocol.mjs
@@ -0,0 +1,269 @@
+// RFC-034 (Pillar C, Phase 2) — the versioned WebSocket message schema shared
+// by both ends of the onboard-agent bridge: this daemon (agent/bin/agent.mjs)
+// and the browser's Tier-1 client (template/src/widgets/map-chat/model/
+// agent-client.ts, Phase 3). This is the ONE source of truth for the wire
+// shape; bump PROTOCOL_VERSION on any breaking change so the browser can
+// detect skew via the `ready` frame and fall back to Tier 0 gracefully.
+//
+// ClientMsg: { type: "user_message", text, turnId } | { type: "cancel" }
+// ServerMsg: { type: "ready", protocolVersion, model, capabilities, otherInstances }
+//          | { type: "session", sessionId }
+//          | { type: "token", delta, turnId }
+//          | { type: "show_on_map", target: { kind, id }, turnId }
+//          | { type: "usage", inputTokens, outputTokens, costUsd, turnId }
+//          | { type: "done", turnId }
+//          | { type: "error", message, fatal, turnId }
+//
+// RFC-035 (Wave 2, FR-5/FR-6) — `usage` and the `ready` frame's
+// `capabilities`/`otherInstances` fields are ADDITIVE (PROTOCOL_VERSION
+// bumped 1 -> 2). `capabilities`/`otherInstances` default to `[]` when
+// absent so a pre-RFC-035 daemon's `ready` frame still decodes; an
+// unrecognised `usage` frame from an older/newer peer already degrades to
+// `null` per the general "unknown frame -> drop" contract below.
+//
+// RFC-034 (Pillar C, Phase 4c) — live-continue: `{type:"session"}` is a
+// server-only frame the daemon sends once it captures the Agent SDK's own
+// `session_id` (from the `system`/`init` message that starts every query()
+// stream — see agent/bin/agent.mjs). It is NOT sent on the initial `ready`
+// frame because `ready` fires synchronously on connect, before the SDK
+// session has been negotiated. The browser persists this id per chat
+// session (chat-store.svelte.ts) so a later visit can ask the daemon to
+// RESUME it. Resume is NOT a ClientMsg frame: the client requests it at
+// CONNECT time via a `?resume=<sessionId>` query param on the WebSocket
+// URL (parsed from the upgrade request in agent/bin/agent.mjs), which
+// avoids any first-frame ordering race between a hypothetical `{type:
+// "resume"}` frame and the daemon's synchronous `query()` bootstrap.
+//
+// Bugfix #1 (cross-turn frame race, PROTOCOL_VERSION bumped 2 -> 3) — the
+// daemon runs ONE persistent Query per connection; a `cancel` interrupts it
+// but frames already in flight from the interrupted turn could still land
+// after the NEXT `user_message`'s frames start, corrupting the wrong chat
+// bubble. Every outgoing per-turn frame (`token`/`usage`/`show_on_map`/
+// `done`/`error`) now echoes the `turnId` of the `user_message` that started
+// it, so the browser can drop frames whose `turnId` no longer matches the
+// turn it is currently rendering. `turnId` is ADDITIVE and OPTIONAL on
+// decode — a frame missing it (older daemon, or a `cancel`-triggered
+// synthetic `done`) decodes with `turnId: null`, meaning "no correlation
+// available"; callers must treat `null` as "cannot verify, accept as-is" for
+// backward compatibility rather than dropping it.
+//
+// Bugfix #6 (error frame fatal/non-fatal discriminant) — `{type:"error"}`
+// now carries `fatal: boolean`. `fatal: false` means a single turn failed
+// but the connection/session is still usable (the web can show a recoverable
+// notice and let the user try again on the SAME connection); `fatal: true`
+// means the connection/session itself cannot continue (the web should fall
+// back to Tier 0). `decodeServerMessage` defaults `fatal` to `true` when
+// absent, so an older daemon's error frame (pre-bugfix-#6, no `fatal` field)
+// is conservatively treated as fatal — the same behaviour the web already
+// had before this field existed.
+
+export const PROTOCOL_VERSION = 3;
+
+export const CAMERA_TARGET_KINDS = ["zone", "node", "flow"];
+
+export function encode(message) {
+  return JSON.stringify(message);
+}
+
+/**
+ * Decodes a raw client-sent string into a ClientMsg. Returns `null` on any
+ * malformed JSON or unrecognised shape — callers MUST silently ignore a
+ * `null` result (protocol contract: unknown/malformed frames are dropped,
+ * never crash the connection).
+ */
+export function decodeClientMessage(raw) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (!parsed || typeof parsed !== "object") return null;
+
+  if (parsed.type === "user_message") {
+    if (typeof parsed.text !== "string") return null;
+    // Bugfix #1 — turnId is additive/optional on decode: a sender on an
+    // older protocol (or one that simply omits it) still gets a usable
+    // ClientMsg, with turnId: null meaning "no correlation supplied".
+    const turnId = typeof parsed.turnId === "string" ? parsed.turnId : null;
+    return { type: "user_message", text: parsed.text, turnId };
+  }
+  if (parsed.type === "cancel") {
+    return { type: "cancel" };
+  }
+  return null;
+}
+
+/**
+ * Decodes a raw server-sent string into a ServerMsg. Exposed for the
+ * browser client and for this package's own smoke test — the daemon itself
+ * only ever encodes (never decodes) ServerMsg frames.
+ */
+export function decodeServerMessage(raw) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (!parsed || typeof parsed !== "object") return null;
+
+  switch (parsed.type) {
+    case "ready": {
+      if (
+        typeof parsed.protocolVersion !== "number" ||
+        typeof parsed.model !== "string"
+      ) {
+        return null;
+      }
+      // RFC-035 (Wave 2, FR-5/FR-6) — additive fields. Absent (a pre-Wave-2
+      // daemon) defaults to an empty list so the frame still decodes;
+      // present-but-malformed entries are dropped rather than failing the
+      // whole frame.
+      const capabilities = Array.isArray(parsed.capabilities)
+        ? parsed.capabilities.filter((c) => typeof c === "string")
+        : [];
+      const otherInstances = Array.isArray(parsed.otherInstances)
+        ? parsed.otherInstances.filter(
+            (i) =>
+              i &&
+              typeof i === "object" &&
+              typeof i.projectName === "string" &&
+              typeof i.port === "number" &&
+              typeof i.kind === "string",
+          )
+        : [];
+      return {
+        type: "ready",
+        protocolVersion: parsed.protocolVersion,
+        model: parsed.model,
+        capabilities,
+        otherInstances,
+      };
+    }
+    case "session":
+      if (typeof parsed.sessionId !== "string") return null;
+      return { type: "session", sessionId: parsed.sessionId };
+    case "token": {
+      if (typeof parsed.delta !== "string") return null;
+      const turnId = typeof parsed.turnId === "string" ? parsed.turnId : null;
+      return { type: "token", delta: parsed.delta, turnId };
+    }
+    case "show_on_map": {
+      const target = parsed.target;
+      if (
+        !target ||
+        typeof target !== "object" ||
+        !CAMERA_TARGET_KINDS.includes(target.kind) ||
+        typeof target.id !== "string"
+      ) {
+        return null;
+      }
+      const turnId = typeof parsed.turnId === "string" ? parsed.turnId : null;
+      return {
+        type: "show_on_map",
+        target: { kind: target.kind, id: target.id },
+        turnId,
+      };
+    }
+    case "usage": {
+      if (
+        typeof parsed.inputTokens !== "number" ||
+        typeof parsed.outputTokens !== "number" ||
+        typeof parsed.costUsd !== "number"
+      ) {
+        return null;
+      }
+      const turnId = typeof parsed.turnId === "string" ? parsed.turnId : null;
+      return {
+        type: "usage",
+        inputTokens: parsed.inputTokens,
+        outputTokens: parsed.outputTokens,
+        costUsd: parsed.costUsd,
+        turnId,
+      };
+    }
+    case "done": {
+      const turnId = typeof parsed.turnId === "string" ? parsed.turnId : null;
+      return { type: "done", turnId };
+    }
+    case "error": {
+      if (typeof parsed.message !== "string") return null;
+      const turnId = typeof parsed.turnId === "string" ? parsed.turnId : null;
+      // Bugfix #6 — `fatal` defaults to `true` when absent: an older
+      // daemon's error frame (pre-bugfix-#6) predates the discriminant, and
+      // treating it as fatal preserves the exact behaviour the web already
+      // had before this field existed (full tier0 fallback on any error).
+      const fatal = typeof parsed.fatal === "boolean" ? parsed.fatal : true;
+      return { type: "error", message: parsed.message, fatal, turnId };
+    }
+    default:
+      return null;
+  }
+}
+
+/**
+ * RFC-035 (Wave 2, FR-5/FR-6) — `capabilities` advertises which additive
+ * frame types this daemon build actually emits (e.g. `["usage",
+ * "instances"]`) so an older web client feature-detects rather than
+ * assuming; `otherInstances` is the FR-6 instance-discovery snapshot taken
+ * at connect time (`{ projectName, port, kind }[]`, see agent/lib/registry.mjs
+ * #readOtherLiveInstances). Both default to `[]` — a caller that has
+ * nothing to report (or predates this RFC) can omit the second argument.
+ */
+export function readyMessage(
+  model,
+  { capabilities = [], otherInstances = [] } = {},
+) {
+  return {
+    type: "ready",
+    protocolVersion: PROTOCOL_VERSION,
+    model,
+    capabilities,
+    otherInstances,
+  };
+}
+
+/** RFC-034 Phase 4c — the SDK's own session id for this connection's
+ * query(), captured from the `system`/`init` message. Sent once, as soon
+ * as it is known (not on the synchronous `ready` frame — see file header). */
+export function sessionMessage(sessionId) {
+  return { type: "session", sessionId };
+}
+
+/** Bugfix #1 — `turnId` echoes the `user_message.turnId` that started the
+ * turn this token belongs to; `null`/omitted when the caller has no turn
+ * context (kept optional so existing single-arg call sites still work). */
+export function tokenMessage(delta, turnId = null) {
+  return { type: "token", delta, turnId };
+}
+
+export function showOnMapMessage(target, turnId = null) {
+  return { type: "show_on_map", target, turnId };
+}
+
+/** RFC-035 (Wave 2, FR-5) — forwards the Agent SDK's own `result.usage`
+ * (input_tokens/output_tokens) + `result.total_cost_usd` for one completed
+ * turn. Sent right before `done` on every `result` message that carries
+ * `usage` (see agent/bin/agent.mjs); the web client accumulates these
+ * per-session and cumulatively. Bugfix #1 — `turnId` echoes the turn this
+ * usage figure belongs to. */
+export function usageMessage(
+  { inputTokens, outputTokens, costUsd },
+  turnId = null,
+) {
+  return { type: "usage", inputTokens, outputTokens, costUsd, turnId };
+}
+
+export function doneMessage(turnId = null) {
+  return { type: "done", turnId };
+}
+
+/** Bugfix #6 — `fatal` discriminates a recoverable per-turn failure
+ * (`fatal: false`, connection/session still usable) from one that ends the
+ * connection/session (`fatal: true`, the web should fall back to Tier 0).
+ * Bugfix #1 — `turnId` echoes the turn this error belongs to, `null` for a
+ * connection-level error with no specific turn in flight. */
+export function errorMessage(message, { fatal = true, turnId = null } = {}) {
+  return { type: "error", message, fatal, turnId };
+}
diff --git a/agent/lib/registry.mjs b/agent/lib/registry.mjs
new file mode 100644
index 0000000..75e6aa0
--- /dev/null
+++ b/agent/lib/registry.mjs
@@ -0,0 +1,249 @@
+// RFC-035 (Wave 2, FR-6) — a minimal writer for the shared instance
+// registry at `~/.forgeplan-web/instances.json` (PRD-027 / SPEC-003 /
+// ADR-004). This module reuses that registry's WIRE FORMAT (schema
+// version, atomic tmp+rename write, read-modify-write, heartbeat-driven
+// liveness) WITHOUT importing the core package's `bin/lib/registry.mjs` —
+// `@forgeplan/web-agent` is a SEPARATE npm package and cannot depend on the
+// core package's `bin/` at the user's runtime (rule 23 / ADR-010: the SDK
+// dependency lives only in this package; the inverse also holds — this
+// package cannot reach back into the core package's files).
+//
+// Every row this module writes carries an additive `kind: "agent"` field
+// (and `scope: "agent"`, distinct from the core registry's `"user"` /
+// `"project"` scopes) so a reader can tell an onboard-agent daemon row
+// apart from a forgeplan-web instance row. node:*-only (fs, path, os) — no
+// new runtime deps (agent/package.json is otherwise unaffected).
+//
+// Fail-open by design: every exported function swallows its own fs/parse
+// errors and logs to stderr instead of throwing. The daemon's core job
+// (serving the onboarding WS chat) must never go down because this
+// diagnostics side-channel is unwritable (e.g. a read-only home dir).
+
+import { homedir } from "node:os";
+import { basename, join } from "node:path";
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  renameSync,
+  writeFileSync,
+} from "node:fs";
+
+const SCHEMA_VERSION = 1;
+const REGISTRY_DIRNAME = ".forgeplan-web";
+const REGISTRY_FILENAME = "instances.json";
+const HEARTBEAT_STALE_MS = 60_000;
+const HOST = "127.0.0.1";
+
+/**
+ * This process's own registered row(s), keyed by id, minus `heartbeatAt`
+ * (always refreshed at write time). Populated by `registerAgent`, read by
+ * `heartbeatAgent` to re-insert a full row if a concurrent writer's
+ * read-modify-write raced it out of the file, cleared by
+ * `deregisterAgent`. Deliberately in-memory-only — this module never reads
+ * it back from disk, matching the core registry's own documented
+ * best-effort reconcile behaviour (bin/lib/registry.mjs#heartbeat).
+ */
+const lastKnownRow = new Map();
+
+function registryDir() {
+  return join(homedir(), REGISTRY_DIRNAME);
+}
+
+function registryPath() {
+  return join(registryDir(), REGISTRY_FILENAME);
+}
+
+function emptyRegistry() {
+  return { version: SCHEMA_VERSION, instances: [] };
+}
+
+function readRegistry() {
+  const p = registryPath();
+  if (!existsSync(p)) return emptyRegistry();
+  let raw;
+  try {
+    raw = readFileSync(p, "utf8");
+  } catch {
+    return emptyRegistry();
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    // FIXME(corrupt-registry): unreadable JSON treated as empty; next write replaces.
+    return emptyRegistry();
+  }
+  if (!parsed || typeof parsed !== "object") return emptyRegistry();
+  if (parsed.version !== SCHEMA_VERSION) {
+    // TODO(registry-schema-migration): translate older versions when schema bumps.
+    return emptyRegistry();
+  }
+  if (!Array.isArray(parsed.instances)) return emptyRegistry();
+  return { version: SCHEMA_VERSION, instances: parsed.instances };
+}
+
+function writeRegistryAtomic(reg) {
+  const dir = registryDir();
+  mkdirSync(dir, { recursive: true });
+  const p = registryPath();
+  const tmp = `${p}.tmp.${process.pid}.${Date.now()}`;
+  const payload = JSON.stringify(
+    { version: SCHEMA_VERSION, instances: reg.instances },
+    null,
+    2,
+  );
+  writeFileSync(tmp, payload + "\n");
+  renameSync(tmp, p);
+}
+
+function isAlive(pid, heartbeatAt) {
+  if (typeof pid !== "number" || !Number.isFinite(pid) || pid <= 0) {
+    return false;
+  }
+  if (typeof heartbeatAt === "string") {
+    const t = Date.parse(heartbeatAt);
+    if (Number.isFinite(t) && Date.now() - t > HEARTBEAT_STALE_MS) {
+      return false;
+    }
+  }
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (e) {
+    // EPERM — process exists but is owned by another user; treat as alive
+    // (matches the core registry's conservative choice, RFC-023).
+    if (e && e.code === "EPERM") return true;
+    return false;
+  }
+}
+
+function sweepStale(reg) {
+  return {
+    version: SCHEMA_VERSION,
+    instances: (reg?.instances ?? []).filter((row) =>
+      isAlive(row?.pid, row?.heartbeatAt),
+    ),
+  };
+}
+
+export function makeAgentId(port) {
+  return `agent:${HOST}:${port}`;
+}
+
+/**
+ * Registers this daemon in the shared registry (after sweeping stale
+ * rows) and returns the row's `id` for later `heartbeatAgent` /
+ * `deregisterAgent` calls. Fail-open — a write fault is logged to stderr
+ * and swallowed; callers get the id back regardless so `ready` frames can
+ * still reference it (a subsequent `readOtherLiveInstances` call simply
+ * won't find this row on disk if the write failed).
+ */
+export function registerAgent({ port, cwd, protocolVersion }) {
+  const id = makeAgentId(port);
+  const now = new Date().toISOString();
+  const row = {
+    id,
+    host: HOST,
+    port,
+    pid: process.pid,
+    kind: "agent",
+    scope: "agent",
+    workspaceRoot: cwd,
+    projectName: basename(cwd),
+    startedAt: now,
+    heartbeatAt: now,
+    webVersion: null,
+    forgeplanCli: null,
+    protocolVersion,
+  };
+  lastKnownRow.set(id, row);
+  try {
+    const swept = sweepStale(readRegistry());
+    const without = swept.instances.filter((r) => r.id !== id);
+    writeRegistryAtomic({
+      version: SCHEMA_VERSION,
+      instances: [...without, row],
+    });
+  } catch (err) {
+    process.stderr.write(
+      `onboard-agent: registry register failed (non-fatal): ${err?.message ?? err}\n`,
+    );
+  }
+  return id;
+}
+
+/**
+ * Refreshes this daemon's `heartbeatAt` so `isAlive`/`sweepStale` (here and
+ * on any reader) keep treating it as live. If the row was lost — e.g. a
+ * concurrent writer's read-modify-write raced it out — re-inserts the full
+ * row captured at `registerAgent` time (with a fresh `heartbeatAt`) rather
+ * than silently no-opping, since this module knows its own row shape and
+ * the core registry's simplicity budget doesn't need to apply here.
+ */
+export function heartbeatAgent(id) {
+  try {
+    const reg = readRegistry();
+    const idx = reg.instances.findIndex((r) => r.id === id);
+    const now = new Date().toISOString();
+    let instances;
+    if (idx >= 0) {
+      instances = reg.instances.map((r, i) =>
+        i === idx ? { ...r, heartbeatAt: now } : r,
+      );
+    } else {
+      const known = lastKnownRow.get(id);
+      if (!known) return; // nothing to re-add from — never registered, or already deregistered
+      instances = [...reg.instances, { ...known, heartbeatAt: now }];
+    }
+    writeRegistryAtomic({ version: SCHEMA_VERSION, instances });
+  } catch (err) {
+    process.stderr.write(
+      `onboard-agent: registry heartbeat failed (non-fatal): ${err?.message ?? err}\n`,
+    );
+  }
+}
+
+/**
+ * Removes this daemon's row from the shared registry. Safe to call even if
+ * the row was never successfully written (e.g. `registerAgent` failed) or
+ * was already removed — a missing id is simply not found by the filter.
+ */
+export function deregisterAgent(id) {
+  lastKnownRow.delete(id);
+  try {
+    const reg = readRegistry();
+    const instances = reg.instances.filter((r) => r.id !== id);
+    writeRegistryAtomic({ version: SCHEMA_VERSION, instances });
+  } catch (err) {
+    process.stderr.write(
+      `onboard-agent: registry deregister failed (non-fatal): ${err?.message ?? err}\n`,
+    );
+  }
+}
+
+/**
+ * Reads every OTHER live instance in the shared registry (any `kind` — web
+ * or agent), sweeping stale rows via `process.kill(pid,0)` + 60s heartbeat
+ * freshness (same liveness contract as the web instance switcher), mapped
+ * to the Info-tab-friendly shape `{ projectName, port, kind }`. Rows
+ * without a `kind` field (pre-RFC-035 web rows) default to `"web"`.
+ * Fail-open — any fs/parse error yields `[]`.
+ */
+export function readOtherLiveInstances(selfId) {
+  try {
+    const swept = sweepStale(readRegistry());
+    return swept.instances
+      .filter((r) => r?.id !== selfId)
+      .map((r) => ({
+        projectName: typeof r.projectName === "string" ? r.projectName : "?",
+        port: typeof r.port === "number" ? r.port : 0,
+        kind: typeof r.kind === "string" ? r.kind : "web",
+      }));
+  } catch (err) {
+    process.stderr.write(
+      `onboard-agent: registry read failed (non-fatal): ${err?.message ?? err}\n`,
+    );
+    return [];
+  }
+}
diff --git a/agent/package-lock.json b/agent/package-lock.json
new file mode 100644
index 0000000..e50ea38
--- /dev/null
+++ b/agent/package-lock.json
@@ -0,0 +1,1501 @@
+{
+  "name": "@forgeplan/web-agent",
+  "version": "0.1.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "@forgeplan/web-agent",
+      "version": "0.1.0",
+      "license": "MIT",
+      "dependencies": {
+        "@anthropic-ai/claude-agent-sdk": "^0.3.201",
+        "ws": "^8.21.0",
+        "zod": "^4.4.3"
+      },
+      "bin": {
+        "forgeplan-web-agent": "bin/agent.mjs"
+      },
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      }
+    },
+    "node_modules/@anthropic-ai/claude-agent-sdk": {
+      "version": "0.3.201",
+      "resolved": "https://registry.npmjs.org/@anthropic-ai/claude-agent-sdk/-/claude-agent-sdk-0.3.201.tgz",
+      "integrity": "sha512-InT1XLmf2QpldWdtznKDWEoGJT4p+sXh24yxbeBQ++lMJCzMrI0W27MEmmmDWx0otpa+ubdHCF5YQ6oiNt7cmg==",
+      "license": "SEE LICENSE IN README.md",
+      "engines": {
+        "node": ">=18.0.0"
+      },
+      "optionalDependencies": {
+        "@anthropic-ai/claude-agent-sdk-darwin-arm64": "0.3.201",
+        "@anthropic-ai/claude-agent-sdk-darwin-x64": "0.3.201",
+        "@anthropic-ai/claude-agent-sdk-linux-arm64": "0.3.201",
+        "@anthropic-ai/claude-agent-sdk-linux-arm64-musl": "0.3.201",
+        "@anthropic-ai/claude-agent-sdk-linux-x64": "0.3.201",
+        "@anthropic-ai/claude-agent-sdk-linux-x64-musl": "0.3.201",
+        "@anthropic-ai/claude-agent-sdk-win32-arm64": "0.3.201",
+        "@anthropic-ai/claude-agent-sdk-win32-x64": "0.3.201"
+      },
+      "peerDependencies": {
+        "@anthropic-ai/sdk": ">=0.93.0",
+        "@modelcontextprotocol/sdk": "^1.29.0",
+        "zod": "^4.0.0"
+      }
+    },
+    "node_modules/@anthropic-ai/claude-agent-sdk-darwin-arm64": {
+      "version": "0.3.201",
+      "resolved": "https://registry.npmjs.org/@anthropic-ai/claude-agent-sdk-darwin-arm64/-/claude-agent-sdk-darwin-arm64-0.3.201.tgz",
+      "integrity": "sha512-8Mcb3BDyKUGfJWFFTWwt+at37lbDH3ZwVtUNPWGG1toZ75RDCJry5U4kXRvQ2xokvJQlA0E+eNp6keWe5ZH22Q==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "SEE LICENSE IN LICENSE.md",
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
+    },
+    "node_modules/@anthropic-ai/claude-agent-sdk-darwin-x64": {
+      "version": "0.3.201",
+      "resolved": "https://registry.npmjs.org/@anthropic-ai/claude-agent-sdk-darwin-x64/-/claude-agent-sdk-darwin-x64-0.3.201.tgz",
+      "integrity": "sha512-TFR2bu0+ml3RHoMrtsgD0qDK5Oknw8kYGBV7qpQHn+IWmE96gnHhogG1LpJwpHtni08XkJIjfWk1DdlsUYtRkQ==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "SEE LICENSE IN LICENSE.md",
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
+    },
+    "node_modules/@anthropic-ai/claude-agent-sdk-linux-arm64": {
+      "version": "0.3.201",
+      "resolved": "https://registry.npmjs.org/@anthropic-ai/claude-agent-sdk-linux-arm64/-/claude-agent-sdk-linux-arm64-0.3.201.tgz",
+      "integrity": "sha512-mShTo3MwF0gkN4dDw78wWJiB6aBDVRkl81cnApvoBofpdyUBYgm9Gw16CCjDTgelMKeBFqN6ErJpwjI3wbP00A==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "SEE LICENSE IN LICENSE.md",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@anthropic-ai/claude-agent-sdk-linux-arm64-musl": {
+      "version": "0.3.201",
+      "resolved": "https://registry.npmjs.org/@anthropic-ai/claude-agent-sdk-linux-arm64-musl/-/claude-agent-sdk-linux-arm64-musl-0.3.201.tgz",
+      "integrity": "sha512-EiqbpfJIpChfkn+8Uj061Qjyw0eaRcOXtdrvVuHANyj8ZErVOr8HlH6op9PSeIUa9TX0m2+tNgKPQvOGseQckA==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "SEE LICENSE IN LICENSE.md",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@anthropic-ai/claude-agent-sdk-linux-x64": {
+      "version": "0.3.201",
+      "resolved": "https://registry.npmjs.org/@anthropic-ai/claude-agent-sdk-linux-x64/-/claude-agent-sdk-linux-x64-0.3.201.tgz",
+      "integrity": "sha512-jrJBrRWrSuoFKIgjyqxHqmfd6Pb3Bs5Bvakg0knXCTC4fbUXGnC9Q6u7gdDwgXohUNP6/DD+s8U7bivvvVv0dg==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "SEE LICENSE IN LICENSE.md",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@anthropic-ai/claude-agent-sdk-linux-x64-musl": {
+      "version": "0.3.201",
+      "resolved": "https://registry.npmjs.org/@anthropic-ai/claude-agent-sdk-linux-x64-musl/-/claude-agent-sdk-linux-x64-musl-0.3.201.tgz",
+      "integrity": "sha512-IbxnzO5UCbqbm2TnzCHkSyJorAFw2isdKdIsFCTxJJjSs3ZC+v3LC1QSUiVCx0qi+CV6w3MKx6mLI11mrvhbbQ==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "SEE LICENSE IN LICENSE.md",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@anthropic-ai/claude-agent-sdk-win32-arm64": {
+      "version": "0.3.201",
+      "resolved": "https://registry.npmjs.org/@anthropic-ai/claude-agent-sdk-win32-arm64/-/claude-agent-sdk-win32-arm64-0.3.201.tgz",
+      "integrity": "sha512-UsoytRJ/037uHpb3ATrIoe+AgwTf+PwKuFLGjddHAV/11wERJs0hlrnSmcnp43kf0PFxoSNinngme96YYASmQg==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "SEE LICENSE IN LICENSE.md",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@anthropic-ai/claude-agent-sdk-win32-x64": {
+      "version": "0.3.201",
+      "resolved": "https://registry.npmjs.org/@anthropic-ai/claude-agent-sdk-win32-x64/-/claude-agent-sdk-win32-x64-0.3.201.tgz",
+      "integrity": "sha512-PhalN/0cWcqDfbx7iwoLNR2gurjTiqhBk1G6K+NRScxEcQjWuu5xKXCcdbX8ePVpT+nbEMmFEFpn2y+8V8hIdA==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "SEE LICENSE IN LICENSE.md",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@anthropic-ai/sdk": {
+      "version": "0.110.0",
+      "resolved": "https://registry.npmjs.org/@anthropic-ai/sdk/-/sdk-0.110.0.tgz",
+      "integrity": "sha512-hOP4bNYXDFHDxxiEgzlILXrxZIYCDnhe8sry0RDRKD/QnsEpvZcQpablCdm9X/WuD/YgOiSIkkqsL1mLLlTqJw==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "json-schema-to-ts": "^3.1.1",
+        "standardwebhooks": "^1.0.0"
+      },
+      "bin": {
+        "anthropic-ai-sdk": "bin/cli"
+      },
+      "peerDependencies": {
+        "zod": "^3.25.0 || ^4.0.0"
+      },
+      "peerDependenciesMeta": {
+        "zod": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@babel/runtime": {
+      "version": "7.29.7",
+      "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.29.7.tgz",
+      "integrity": "sha512-Nq8OhGWiZIZGV6hLHoyAKLLcJihP/xFeBMGJoUrxTX2psI8dCifzLhZISFb+VWS3wFMRDmCGw5R+dOySCqPLhw==",
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@hono/node-server": {
+      "version": "1.19.14",
+      "resolved": "https://registry.npmjs.org/@hono/node-server/-/node-server-1.19.14.tgz",
+      "integrity": "sha512-GwtvgtXxnWsucXvbQXkRgqksiH2Qed37H9xHZocE5sA3N8O8O8/8FA3uclQXxXVzc9XBZuEOMK7+r02FmSpHtw==",
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">=18.14.1"
+      },
+      "peerDependencies": {
+        "hono": "^4"
+      }
+    },
+    "node_modules/@modelcontextprotocol/sdk": {
+      "version": "1.29.0",
+      "resolved": "https://registry.npmjs.org/@modelcontextprotocol/sdk/-/sdk-1.29.0.tgz",
+      "integrity": "sha512-zo37mZA9hJWpULgkRpowewez1y6ML5GsXJPY8FI0tBBCd77HEvza4jDqRKOXgHNn867PVGCyTdzqpz0izu5ZjQ==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "@hono/node-server": "^1.19.9",
+        "ajv": "^8.17.1",
+        "ajv-formats": "^3.0.1",
+        "content-type": "^1.0.5",
+        "cors": "^2.8.5",
+        "cross-spawn": "^7.0.5",
+        "eventsource": "^3.0.2",
+        "eventsource-parser": "^3.0.0",
+        "express": "^5.2.1",
+        "express-rate-limit": "^8.2.1",
+        "hono": "^4.11.4",
+        "jose": "^6.1.3",
+        "json-schema-typed": "^8.0.2",
+        "pkce-challenge": "^5.0.0",
+        "raw-body": "^3.0.0",
+        "zod": "^3.25 || ^4.0",
+        "zod-to-json-schema": "^3.25.1"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "@cfworker/json-schema": "^4.1.1",
+        "zod": "^3.25 || ^4.0"
+      },
+      "peerDependenciesMeta": {
+        "@cfworker/json-schema": {
+          "optional": true
+        },
+        "zod": {
+          "optional": false
+        }
+      }
+    },
+    "node_modules/@stablelib/base64": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/@stablelib/base64/-/base64-1.0.1.tgz",
+      "integrity": "sha512-1bnPQqSxSuc3Ii6MhBysoWCg58j97aUjuCSZrGSmDxNqtytIi0k8utUenAwTZN4V5mXXYGsVUI9zeBqy+jBOSQ==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/accepts": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/accepts/-/accepts-2.0.0.tgz",
+      "integrity": "sha512-5cvg6CtKwfgdmVqY1WIiXKc3Q1bkRqGLi+2W/6ao+6Y7gu/RCwRuAhGEzh5B4KlszSuTLgZYuqFqo5bImjNKng==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "mime-types": "^3.0.0",
+        "negotiator": "^1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/ajv": {
+      "version": "8.20.0",
+      "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.20.0.tgz",
+      "integrity": "sha512-Thbli+OlOj+iMPYFBVBfJ3OmCAnaSyNn4M1vz9T6Gka5Jt9ba/HIR56joy65tY6kx/FCF5VXNB819Y7/GUrBGA==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "fast-deep-equal": "^3.1.3",
+        "fast-uri": "^3.0.1",
+        "json-schema-traverse": "^1.0.0",
+        "require-from-string": "^2.0.2"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/epoberezkin"
+      }
+    },
+    "node_modules/ajv-formats": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/ajv-formats/-/ajv-formats-3.0.1.tgz",
+      "integrity": "sha512-8iUql50EUR+uUcdRQ3HDqa6EVyo3docL8g5WJ3FNcWmu62IbkGUue/pEyLBW8VGKKucTPgqeks4fIU1DA4yowQ==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "ajv": "^8.0.0"
+      },
+      "peerDependencies": {
+        "ajv": "^8.0.0"
+      },
+      "peerDependenciesMeta": {
+        "ajv": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/body-parser": {
+      "version": "2.3.0",
+      "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-2.3.0.tgz",
+      "integrity": "sha512-2cGmJupaNgg+QUwVLAucDuWuoMZ6EX9iHDRswZ5lsNYEmwPaRknMPCLZz07yTzVq/83p4o/wzbDZbBrTvGGTIw==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "bytes": "^3.1.2",
+        "content-type": "^2.0.0",
+        "debug": "^4.4.3",
+        "http-errors": "^2.0.1",
+        "iconv-lite": "^0.7.2",
+        "on-finished": "^2.4.1",
+        "qs": "^6.15.2",
+        "raw-body": "^3.0.2",
+        "type-is": "^2.1.0"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
+      }
+    },
+    "node_modules/body-parser/node_modules/content-type": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/content-type/-/content-type-2.0.0.tgz",
+      "integrity": "sha512-j/O/d7GcZCyNl7/hwZAb606rzqkyvaDctLmckbxLzHvFBzTJHuGEdodATcP3yIRoDrLHkIATJuvzbFlp/ki2cQ==",
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
+      }
+    },
+    "node_modules/bytes": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/bytes/-/bytes-3.1.2.tgz",
+      "integrity": "sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==",
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/call-bind-apply-helpers": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz",
+      "integrity": "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "es-errors": "^1.3.0",
+        "function-bind": "^1.1.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/call-bound": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/call-bound/-/call-bound-1.0.4.tgz",
+      "integrity": "sha512-+ys997U96po4Kx/ABpBCqhA9EuxJaQWDQg7295H4hBphv3IZg0boBKuwYpt4YXp6MZ5AmZQnU/tyMTlRpaSejg==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "call-bind-apply-helpers": "^1.0.2",
+        "get-intrinsic": "^1.3.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/content-disposition": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/content-disposition/-/content-disposition-1.1.0.tgz",
+      "integrity": "sha512-5jRCH9Z/+DRP7rkvY83B+yGIGX96OYdJmzngqnw2SBSxqCFPd0w2km3s5iawpGX8krnwSGmF0FW5Nhr0Hfai3g==",
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
+      }
+    },
+    "node_modules/content-type": {
+      "version": "1.0.5",
+      "resolved": "https://registry.npmjs.org/content-type/-/content-type-1.0.5.tgz",
+      "integrity": "sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA==",
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/cookie": {
+      "version": "0.7.2",
+      "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.7.2.tgz",
+      "integrity": "sha512-yki5XnKuf750l50uGTllt6kKILY4nQ1eNIQatoXEByZ5dWgnKqbnqmTrBE5B4N7lrMJKQ2ytWMiTO2o0v6Ew/w==",
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/cookie-signature": {
+      "version": "1.2.2",
+      "resolved": "https://registry.npmjs.org/cookie-signature/-/cookie-signature-1.2.2.tgz",
+      "integrity": "sha512-D76uU73ulSXrD1UXF4KE2TMxVVwhsnCgfAyTg9k8P6KGZjlXKrOLe4dJQKI3Bxi5wjesZoFXJWElNWBjPZMbhg==",
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">=6.6.0"
+      }
+    },
+    "node_modules/cors": {
+      "version": "2.8.6",
+      "resolved": "https://registry.npmjs.org/cors/-/cors-2.8.6.tgz",
+      "integrity": "sha512-tJtZBBHA6vjIAaF6EnIaq6laBBP9aq/Y3ouVJjEfoHbRBcHBAHYcMh/w8LDrk2PvIMMq8gmopa5D4V8RmbrxGw==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "object-assign": "^4",
+        "vary": "^1"
+      },
+      "engines": {
+        "node": ">= 0.10"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
+      }
+    },
+    "node_modules/cross-spawn": {
+      "version": "7.0.6",
+      "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz",
+      "integrity": "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "path-key": "^3.1.0",
+        "shebang-command": "^2.0.0",
+        "which": "^2.0.1"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/debug": {
+      "version": "4.4.3",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
+      "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "ms": "^2.1.3"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "peerDependenciesMeta": {
+        "supports-color": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/depd": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/depd/-/depd-2.0.0.tgz",
+      "integrity": "sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==",
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/dunder-proto": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/dunder-proto/-/dunder-proto-1.0.1.tgz",
+      "integrity": "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "call-bind-apply-helpers": "^1.0.1",
+        "es-errors": "^1.3.0",
+        "gopd": "^1.2.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/ee-first": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/ee-first/-/ee-first-1.1.1.tgz",
+      "integrity": "sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/encodeurl": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-2.0.0.tgz",
+      "integrity": "sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg==",
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/es-define-property": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.1.tgz",
+      "integrity": "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==",
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/es-errors": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/es-errors/-/es-errors-1.3.0.tgz",
+      "integrity": "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==",
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/es-object-atoms": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.1.2.tgz",
+      "integrity": "sha512-HWcBoN6NileqtSydK2FqHbS/LoDd2pqrnQHLyJzBj4kOp/ky2MWMN694xOfkK8/SnUsW2DH7EfyVlydKCsm1Zw==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "es-errors": "^1.3.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/escape-html": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/escape-html/-/escape-html-1.0.3.tgz",
+      "integrity": "sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/etag": {
+      "version": "1.8.1",
+      "resolved": "https://registry.npmjs.org/etag/-/etag-1.8.1.tgz",
+      "integrity": "sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg==",
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/eventsource": {
+      "version": "3.0.7",
+      "resolved": "https://registry.npmjs.org/eventsource/-/eventsource-3.0.7.tgz",
+      "integrity": "sha512-CRT1WTyuQoD771GW56XEZFQ/ZoSfWid1alKGDYMmkt2yl8UXrVR4pspqWNEcqKvVIzg6PAltWjxcSSPrboA4iA==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "eventsource-parser": "^3.0.1"
+      },
+      "engines": {
+        "node": ">=18.0.0"
+      }
+    },
+    "node_modules/eventsource-parser": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/eventsource-parser/-/eventsource-parser-3.1.0.tgz",
+      "integrity": "sha512-kJezFj9YFAMLeORyi7aCLxLbD5/qWMQnoMVlVPyHIll7lgRJCc3JVln9Vgl9nwQi0YkMnhdGTMNn7CkRRAptMg==",
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">=18.0.0"
+      }
+    },
+    "node_modules/express": {
+      "version": "5.2.1",
+      "resolved": "https://registry.npmjs.org/express/-/express-5.2.1.tgz",
+      "integrity": "sha512-hIS4idWWai69NezIdRt2xFVofaF4j+6INOpJlVOLDO8zXGpUVEVzIYk12UUi2JzjEzWL3IOAxcTubgz9Po0yXw==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "accepts": "^2.0.0",
+        "body-parser": "^2.2.1",
+        "content-disposition": "^1.0.0",
+        "content-type": "^1.0.5",
+        "cookie": "^0.7.1",
+        "cookie-signature": "^1.2.1",
+        "debug": "^4.4.0",
+        "depd": "^2.0.0",
+        "encodeurl": "^2.0.0",
+        "escape-html": "^1.0.3",
+        "etag": "^1.8.1",
+        "finalhandler": "^2.1.0",
+        "fresh": "^2.0.0",
+        "http-errors": "^2.0.0",
+        "merge-descriptors": "^2.0.0",
+        "mime-types": "^3.0.0",
+        "on-finished": "^2.4.1",
+        "once": "^1.4.0",
+        "parseurl": "^1.3.3",
+        "proxy-addr": "^2.0.7",
+        "qs": "^6.14.0",
+        "range-parser": "^1.2.1",
+        "router": "^2.2.0",
+        "send": "^1.1.0",
+        "serve-static": "^2.2.0",
+        "statuses": "^2.0.1",
+        "type-is": "^2.0.1",
+        "vary": "^1.1.2"
+      },
+      "engines": {
+        "node": ">= 18"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
+      }
+    },
+    "node_modules/express-rate-limit": {
+      "version": "8.5.2",
+      "resolved": "https://registry.npmjs.org/express-rate-limit/-/express-rate-limit-8.5.2.tgz",
+      "integrity": "sha512-5Kb34ipNX694DH48vN9irak1Qx30nb0PLYHXfJgw4YEjiC3ZEmZJhwOp+VfiCYwFzvFTdB9QkArYS5kXa2cx2A==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "ip-address": "^10.2.0"
+      },
+      "engines": {
+        "node": ">= 16"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/express-rate-limit"
+      },
+      "peerDependencies": {
+        "express": ">= 4.11"
+      }
+    },
+    "node_modules/fast-deep-equal": {
+      "version": "3.1.3",
+      "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz",
+      "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/fast-sha256": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/fast-sha256/-/fast-sha256-1.3.0.tgz",
+      "integrity": "sha512-n11RGP/lrWEFI/bWdygLxhI+pVeo1ZYIVwvvPkW7azl/rOy+F3HYRZ2K5zeE9mmkhQppyv9sQFx0JM9UabnpPQ==",
+      "license": "Unlicense",
+      "peer": true
+    },
+    "node_modules/fast-uri": {
+      "version": "3.1.3",
+      "resolved": "https://registry.npmjs.org/fast-uri/-/fast-uri-3.1.3.tgz",
+      "integrity": "sha512-i70LwGWUduXqzicKXWshooq+sWL1K3WUU5rKZNG/0i3a1OSoX3HqhH5WbWwTmqWfor4urUakGPiRQcleRZTwOg==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/fastify"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/fastify"
+        }
+      ],
+      "license": "BSD-3-Clause",
+      "peer": true
+    },
+    "node_modules/finalhandler": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/finalhandler/-/finalhandler-2.1.1.tgz",
+      "integrity": "sha512-S8KoZgRZN+a5rNwqTxlZZePjT/4cnm0ROV70LedRHZ0p8u9fRID0hJUZQpkKLzro8LfmC8sx23bY6tVNxv8pQA==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "debug": "^4.4.0",
+        "encodeurl": "^2.0.0",
+        "escape-html": "^1.0.3",
+        "on-finished": "^2.4.1",
+        "parseurl": "^1.3.3",
+        "statuses": "^2.0.1"
+      },
+      "engines": {
+        "node": ">= 18.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
+      }
+    },
+    "node_modules/forwarded": {
+      "version": "0.2.0",
+      "resolved": "https://registry.npmjs.org/forwarded/-/forwarded-0.2.0.tgz",
+      "integrity": "sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow==",
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/fresh": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/fresh/-/fresh-2.0.0.tgz",
+      "integrity": "sha512-Rx/WycZ60HOaqLKAi6cHRKKI7zxWbJ31MhntmtwMoaTeF7XFH9hhBp8vITaMidfljRQ6eYWCKkaTK+ykVJHP2A==",
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/function-bind": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz",
+      "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==",
+      "license": "MIT",
+      "peer": true,
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/get-intrinsic": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.3.0.tgz",
+      "integrity": "sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "call-bind-apply-helpers": "^1.0.2",
+        "es-define-property": "^1.0.1",
+        "es-errors": "^1.3.0",
+        "es-object-atoms": "^1.1.1",
+        "function-bind": "^1.1.2",
+        "get-proto": "^1.0.1",
+        "gopd": "^1.2.0",
+        "has-symbols": "^1.1.0",
+        "hasown": "^2.0.2",
+        "math-intrinsics": "^1.1.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/get-proto": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/get-proto/-/get-proto-1.0.1.tgz",
+      "integrity": "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "dunder-proto": "^1.0.1",
+        "es-object-atoms": "^1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/gopd": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.2.0.tgz",
+      "integrity": "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==",
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/has-symbols": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.1.0.tgz",
+      "integrity": "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==",
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/hasown": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.4.tgz",
+      "integrity": "sha512-T2UbfbBEF32wiepXIsMlTW9+dDYC6wMh/t/vYA4tuOMKqWz/n3vr1NFSxQiyP+zk2mXsoMA/i/7qV6LKut1t1A==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "function-bind": "^1.1.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/hono": {
+      "version": "4.12.28",
+      "resolved": "https://registry.npmjs.org/hono/-/hono-4.12.28.tgz",
+      "integrity": "sha512-YwUvVpSF7m1yOblFPrU3Hbo8XhPheBoiyfGuII6z19LnOr6JpDnyyp7LFNrfV56wS8tpvtBFGRISHN02pDdLOA==",
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">=16.9.0"
+      }
+    },
+    "node_modules/http-errors": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-2.0.1.tgz",
+      "integrity": "sha512-4FbRdAX+bSdmo4AUFuS0WNiPz8NgFt+r8ThgNWmlrjQjt1Q7ZR9+zTlce2859x4KSXrwIsaeTqDoKQmtP8pLmQ==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "depd": "~2.0.0",
+        "inherits": "~2.0.4",
+        "setprototypeof": "~1.2.0",
+        "statuses": "~2.0.2",
+        "toidentifier": "~1.0.1"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
+      }
+    },
+    "node_modules/iconv-lite": {
+      "version": "0.7.3",
+      "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.7.3.tgz",
+      "integrity": "sha512-IKXpvIzjnC9XTAUbVBcMfGS0EPaIXtW6v+zr+RRp+hqULEpo0owZax6wyRwPOJbWbzjYspQwusTsfVr0ifh4uQ==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "safer-buffer": ">= 2.1.2 < 3.0.0"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
+      }
+    },
+    "node_modules/inherits": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
+      "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==",
+      "license": "ISC",
+      "peer": true
+    },
+    "node_modules/ip-address": {
+      "version": "10.2.0",
+      "resolved": "https://registry.npmjs.org/ip-address/-/ip-address-10.2.0.tgz",
+      "integrity": "sha512-/+S6j4E9AHvW9SWMSEY9Xfy66O5PWvVEJ08O0y5JGyEKQpojb0K0GKpz/v5HJ/G0vi3D2sjGK78119oXZeE0qA==",
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">= 12"
+      }
+    },
+    "node_modules/ipaddr.js": {
+      "version": "1.9.1",
+      "resolved": "https://registry.npmjs.org/ipaddr.js/-/ipaddr.js-1.9.1.tgz",
+      "integrity": "sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g==",
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">= 0.10"
+      }
+    },
+    "node_modules/is-promise": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/is-promise/-/is-promise-4.0.0.tgz",
+      "integrity": "sha512-hvpoI6korhJMnej285dSg6nu1+e6uxs7zG3BYAm5byqDsgJNWwxzM6z6iZiAgQR4TJ30JmBTOwqZUw3WlyH3AQ==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/isexe": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz",
+      "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==",
+      "license": "ISC",
+      "peer": true
+    },
+    "node_modules/jose": {
+      "version": "6.2.3",
+      "resolved": "https://registry.npmjs.org/jose/-/jose-6.2.3.tgz",
+      "integrity": "sha512-YYVDInQKFJfR/xa3ojUTl8c2KoTwiL1R5Wg9YCydwH0x0B9grbzlg5HC7mMjCtUJjbQ/YnGEZIhI5tCgfTb4Hw==",
+      "license": "MIT",
+      "peer": true,
+      "funding": {
+        "url": "https://github.com/sponsors/panva"
+      }
+    },
+    "node_modules/json-schema-to-ts": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/json-schema-to-ts/-/json-schema-to-ts-3.1.1.tgz",
+      "integrity": "sha512-+DWg8jCJG2TEnpy7kOm/7/AxaYoaRbjVB4LFZLySZlWn8exGs3A4OLJR966cVvU26N7X9TWxl+Jsw7dzAqKT6g==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "@babel/runtime": "^7.18.3",
+        "ts-algebra": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=16"
+      }
+    },
+    "node_modules/json-schema-traverse": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz",
+      "integrity": "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/json-schema-typed": {
+      "version": "8.0.2",
+      "resolved": "https://registry.npmjs.org/json-schema-typed/-/json-schema-typed-8.0.2.tgz",
+      "integrity": "sha512-fQhoXdcvc3V28x7C7BMs4P5+kNlgUURe2jmUT1T//oBRMDrqy1QPelJimwZGo7Hg9VPV3EQV5Bnq4hbFy2vetA==",
+      "license": "BSD-2-Clause",
+      "peer": true
+    },
+    "node_modules/math-intrinsics": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz",
+      "integrity": "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==",
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/media-typer": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/media-typer/-/media-typer-1.1.0.tgz",
+      "integrity": "sha512-aisnrDP4GNe06UcKFnV5bfMNPBUw4jsLGaWwWfnH3v02GnBuXX2MCVn5RbrWo0j3pczUilYblq7fQ7Nw2t5XKw==",
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/merge-descriptors": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/merge-descriptors/-/merge-descriptors-2.0.0.tgz",
+      "integrity": "sha512-Snk314V5ayFLhp3fkUREub6WtjBfPdCPY1Ln8/8munuLuiYhsABgBVWsozAG+MWMbVEvcdcpbi9R7ww22l9Q3g==",
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/mime-db": {
+      "version": "1.54.0",
+      "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.54.0.tgz",
+      "integrity": "sha512-aU5EJuIN2WDemCcAp2vFBfp/m4EAhWJnUNSSw0ixs7/kXbd6Pg64EmwJkNdFhB8aWt1sH2CTXrLxo/iAGV3oPQ==",
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/mime-types": {
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-3.0.2.tgz",
+      "integrity": "sha512-Lbgzdk0h4juoQ9fCKXW4by0UJqj+nOOrI9MJ1sSj4nI8aI2eo1qmvQEie4VD1glsS250n15LsWsYtCugiStS5A==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "mime-db": "^1.54.0"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
+      }
+    },
+    "node_modules/ms": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/negotiator": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/negotiator/-/negotiator-1.0.0.tgz",
+      "integrity": "sha512-8Ofs/AUQh8MaEcrlq5xOX0CQ9ypTF5dl78mjlMNfOK08fzpgTHQRQPBxcPlEtIw0yRpws+Zo/3r+5WRby7u3Gg==",
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/object-assign": {
+      "version": "4.1.1",
+      "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz",
+      "integrity": "sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==",
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/object-inspect": {
+      "version": "1.13.4",
+      "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.13.4.tgz",
+      "integrity": "sha512-W67iLl4J2EXEGTbfeHCffrjDfitvLANg0UlX3wFUUSTx92KXRFegMHUVgSqE+wvhAbi4WqjGg9czysTV2Epbew==",
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/on-finished": {
+      "version": "2.4.1",
+      "resolved": "https://registry.npmjs.org/on-finished/-/on-finished-2.4.1.tgz",
+      "integrity": "sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "ee-first": "1.1.1"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/once": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz",
+      "integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==",
+      "license": "ISC",
+      "peer": true,
+      "dependencies": {
+        "wrappy": "1"
+      }
+    },
+    "node_modules/parseurl": {
+      "version": "1.3.3",
+      "resolved": "https://registry.npmjs.org/parseurl/-/parseurl-1.3.3.tgz",
+      "integrity": "sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ==",
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/path-key": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz",
+      "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==",
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/path-to-regexp": {
+      "version": "8.4.2",
+      "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-8.4.2.tgz",
+      "integrity": "sha512-qRcuIdP69NPm4qbACK+aDogI5CBDMi1jKe0ry5rSQJz8JVLsC7jV8XpiJjGRLLol3N+R5ihGYcrPLTno6pAdBA==",
+      "license": "MIT",
+      "peer": true,
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
+      }
+    },
+    "node_modules/pkce-challenge": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/pkce-challenge/-/pkce-challenge-5.0.1.tgz",
+      "integrity": "sha512-wQ0b/W4Fr01qtpHlqSqspcj3EhBvimsdh0KlHhH8HRZnMsEa0ea2fTULOXOS9ccQr3om+GcGRk4e+isrZWV8qQ==",
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">=16.20.0"
+      }
+    },
+    "node_modules/proxy-addr": {
+      "version": "2.0.7",
+      "resolved": "https://registry.npmjs.org/proxy-addr/-/proxy-addr-2.0.7.tgz",
+      "integrity": "sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "forwarded": "0.2.0",
+        "ipaddr.js": "1.9.1"
+      },
+      "engines": {
+        "node": ">= 0.10"
+      }
+    },
+    "node_modules/qs": {
+      "version": "6.15.3",
+      "resolved": "https://registry.npmjs.org/qs/-/qs-6.15.3.tgz",
+      "integrity": "sha512-O9gl3zCl5h5blw1KGUzQKhA5oUXSl8rwUIM5o0S3nCXMliSvy5Dzx7/DJcI+SwgICv+IneSZwhBh1oSyEHA71A==",
+      "license": "BSD-3-Clause",
+      "peer": true,
+      "dependencies": {
+        "es-define-property": "^1.0.1",
+        "side-channel": "^1.1.1"
+      },
+      "engines": {
+        "node": ">=0.6"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/range-parser": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/range-parser/-/range-parser-1.3.0.tgz",
+      "integrity": "sha512-hek2mFQpPuI4E1BBKrSto+BU3e3x4xuarsbiwr3+lf7p44juvFMV0XFWQAP3xUyqXA4RrXLIoaSUGbSt056ZMw==",
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">= 0.6"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
+      }
+    },
+    "node_modules/raw-body": {
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/raw-body/-/raw-body-3.0.2.tgz",
+      "integrity": "sha512-K5zQjDllxWkf7Z5xJdV0/B0WTNqx6vxG70zJE4N0kBs4LovmEYWJzQGxC9bS9RAKu3bgM40lrd5zoLJ12MQ5BA==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "bytes": "~3.1.2",
+        "http-errors": "~2.0.1",
+        "iconv-lite": "~0.7.0",
+        "unpipe": "~1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.10"
+      }
+    },
+    "node_modules/require-from-string": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/require-from-string/-/require-from-string-2.0.2.tgz",
+      "integrity": "sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==",
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/router": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/router/-/router-2.2.0.tgz",
+      "integrity": "sha512-nLTrUKm2UyiL7rlhapu/Zl45FwNgkZGaCpZbIHajDYgwlJCOzLSk+cIPAnsEqV955GjILJnKbdQC1nVPz+gAYQ==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "debug": "^4.4.0",
+        "depd": "^2.0.0",
+        "is-promise": "^4.0.0",
+        "parseurl": "^1.3.3",
+        "path-to-regexp": "^8.0.0"
+      },
+      "engines": {
+        "node": ">= 18"
+      }
+    },
+    "node_modules/safer-buffer": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz",
+      "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/send": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/send/-/send-1.2.1.tgz",
+      "integrity": "sha512-1gnZf7DFcoIcajTjTwjwuDjzuz4PPcY2StKPlsGAQ1+YH20IRVrBaXSWmdjowTJ6u8Rc01PoYOGHXfP1mYcZNQ==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "debug": "^4.4.3",
+        "encodeurl": "^2.0.0",
+        "escape-html": "^1.0.3",
+        "etag": "^1.8.1",
+        "fresh": "^2.0.0",
+        "http-errors": "^2.0.1",
+        "mime-types": "^3.0.2",
+        "ms": "^2.1.3",
+        "on-finished": "^2.4.1",
+        "range-parser": "^1.2.1",
+        "statuses": "^2.0.2"
+      },
+      "engines": {
+        "node": ">= 18"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
+      }
+    },
+    "node_modules/serve-static": {
+      "version": "2.2.1",
+      "resolved": "https://registry.npmjs.org/serve-static/-/serve-static-2.2.1.tgz",
+      "integrity": "sha512-xRXBn0pPqQTVQiC8wyQrKs2MOlX24zQ0POGaj0kultvoOCstBQM5yvOhAVSUwOMjQtTvsPWoNCHfPGwaaQJhTw==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "encodeurl": "^2.0.0",
+        "escape-html": "^1.0.3",
+        "parseurl": "^1.3.3",
+        "send": "^1.2.0"
+      },
+      "engines": {
+        "node": ">= 18"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
+      }
+    },
+    "node_modules/setprototypeof": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/setprototypeof/-/setprototypeof-1.2.0.tgz",
+      "integrity": "sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw==",
+      "license": "ISC",
+      "peer": true
+    },
+    "node_modules/shebang-command": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz",
+      "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "shebang-regex": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/shebang-regex": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz",
+      "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==",
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/side-channel": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.1.1.tgz",
+      "integrity": "sha512-6x6dK6zJdpTzF4sQeNYxwtvBzf6Eg4GtlesS94HOvTudUeyK2WXAaIfmDgsyslYrRBeFIlsi54AYsFGUuhmvrQ==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "es-errors": "^1.3.0",
+        "object-inspect": "^1.13.4",
+        "side-channel-list": "^1.0.1",
+        "side-channel-map": "^1.0.1",
+        "side-channel-weakmap": "^1.0.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/side-channel-list": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/side-channel-list/-/side-channel-list-1.0.1.tgz",
+      "integrity": "sha512-mjn/0bi/oUURjc5Xl7IaWi/OJJJumuoJFQJfDDyO46+hBWsfaVM65TBHq2eoZBhzl9EchxOijpkbRC8SVBQU0w==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "es-errors": "^1.3.0",
+        "object-inspect": "^1.13.4"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/side-channel-map": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/side-channel-map/-/side-channel-map-1.0.1.tgz",
+      "integrity": "sha512-VCjCNfgMsby3tTdo02nbjtM/ewra6jPHmpThenkTYh8pG9ucZ/1P8So4u4FGBek/BjpOVsDCMoLA/iuBKIFXRA==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "call-bound": "^1.0.2",
+        "es-errors": "^1.3.0",
+        "get-intrinsic": "^1.2.5",
+        "object-inspect": "^1.13.3"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/side-channel-weakmap": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/side-channel-weakmap/-/side-channel-weakmap-1.0.2.tgz",
+      "integrity": "sha512-WPS/HvHQTYnHisLo9McqBHOJk2FkHO/tlpvldyrnem4aeQp4hai3gythswg6p01oSoTl58rcpiFAjF2br2Ak2A==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "call-bound": "^1.0.2",
+        "es-errors": "^1.3.0",
+        "get-intrinsic": "^1.2.5",
+        "object-inspect": "^1.13.3",
+        "side-channel-map": "^1.0.1"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/standardwebhooks": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/standardwebhooks/-/standardwebhooks-1.0.0.tgz",
+      "integrity": "sha512-BbHGOQK9olHPMvQNHWul6MYlrRTAOKn03rOe4A8O3CLWhNf4YHBqq2HJKKC+sfqpxiBY52pNeesD6jIiLDz8jg==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "@stablelib/base64": "^1.0.0",
+        "fast-sha256": "^1.3.0"
+      }
+    },
+    "node_modules/statuses": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/statuses/-/statuses-2.0.2.tgz",
+      "integrity": "sha512-DvEy55V3DB7uknRo+4iOGT5fP1slR8wQohVdknigZPMpMstaKJQWhwiYBACJE3Ul2pTnATihhBYnRhZQHGBiRw==",
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/toidentifier": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/toidentifier/-/toidentifier-1.0.1.tgz",
+      "integrity": "sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA==",
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">=0.6"
+      }
+    },
+    "node_modules/ts-algebra": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/ts-algebra/-/ts-algebra-2.0.0.tgz",
+      "integrity": "sha512-FPAhNPFMrkwz76P7cdjdmiShwMynZYN6SgOujD1urY4oNm80Ou9oMdmbR45LotcKOXoy7wSmHkRFE6Mxbrhefw==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/type-is": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/type-is/-/type-is-2.1.0.tgz",
+      "integrity": "sha512-faYHw0anBbc/kWF3zFTEnxSFOAGUX9GFbOBthvDdLsIlEoWOFOtS0zgCiQYwIskL9iGXZL3kAXD8OoZ4GmMATA==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "content-type": "^2.0.0",
+        "media-typer": "^1.1.0",
+        "mime-types": "^3.0.0"
+      },
+      "engines": {
+        "node": ">= 18"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
+      }
+    },
+    "node_modules/type-is/node_modules/content-type": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/content-type/-/content-type-2.0.0.tgz",
+      "integrity": "sha512-j/O/d7GcZCyNl7/hwZAb606rzqkyvaDctLmckbxLzHvFBzTJHuGEdodATcP3yIRoDrLHkIATJuvzbFlp/ki2cQ==",
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
+      }
+    },
+    "node_modules/unpipe": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/unpipe/-/unpipe-1.0.0.tgz",
+      "integrity": "sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ==",
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/vary": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/vary/-/vary-1.1.2.tgz",
+      "integrity": "sha512-BNGbWLfd0eUPabhkXUVm0j8uuvREyTh5ovRa/dyow/BqAbZJyC+5fU+IzQOzmAKzYqYRAISoRhdQr3eIZ/PXqg==",
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/which": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz",
+      "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==",
+      "license": "ISC",
+      "peer": true,
+      "dependencies": {
+        "isexe": "^2.0.0"
+      },
+      "bin": {
+        "node-which": "bin/node-which"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/wrappy": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",
+      "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==",
+      "license": "ISC",
+      "peer": true
+    },
+    "node_modules/ws": {
+      "version": "8.21.0",
+      "resolved": "https://registry.npmjs.org/ws/-/ws-8.21.0.tgz",
+      "integrity": "sha512-Vsp28b7DRcimFQvrqu2Wek3z1iYxDCWqHYB8Qsnk/S4RfaCQzPGPyBNuVjJV3cd6UiKtUtp6sNM77gWvzcCH+g==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=10.0.0"
+      },
+      "peerDependencies": {
+        "bufferutil": "^4.0.1",
+        "utf-8-validate": ">=5.0.2"
+      },
+      "peerDependenciesMeta": {
+        "bufferutil": {
+          "optional": true
+        },
+        "utf-8-validate": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/zod": {
+      "version": "4.4.3",
+      "resolved": "https://registry.npmjs.org/zod/-/zod-4.4.3.tgz",
+      "integrity": "sha512-ytENFjIJFl2UwYglde2jchW2Hwm4GJFLDiSXWdTrJQBIN9Fcyp7n4DhxJEiWNAJMV1/BqWfW/kkg71UDcHJyTQ==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/colinhacks"
+      }
+    },
+    "node_modules/zod-to-json-schema": {
+      "version": "3.25.2",
+      "resolved": "https://registry.npmjs.org/zod-to-json-schema/-/zod-to-json-schema-3.25.2.tgz",
+      "integrity": "sha512-O/PgfnpT1xKSDeQYSCfRI5Gy3hPf91mKVDuYLUHZJMiDFptvP41MSnWofm8dnCm0256ZNfZIM7DSzuSMAFnjHA==",
+      "license": "ISC",
+      "peer": true,
+      "peerDependencies": {
+        "zod": "^3.25.28 || ^4"
+      }
+    }
+  }
+}
diff --git a/agent/package.json b/agent/package.json
new file mode 100644
index 0000000..2794b0c
--- /dev/null
+++ b/agent/package.json
@@ -0,0 +1,42 @@
+{
+  "name": "@forgeplan/web-agent",
+  "version": "0.1.0",
+  "description": "Optional localhost daemon-bridge that boots a persistent, read-only Claude Agent SDK session for forgeplan-web's onboarding chat (RFC-034 Pillar C / ADR-010). Never a dependency of @forgeplan/web's core bin/ — spawned as a separate process.",
+  "type": "module",
+  "bin": {
+    "forgeplan-web-agent": "./bin/agent.mjs"
+  },
+  "files": [
+    "bin",
+    "lib",
+    "README.md"
+  ],
+  "engines": {
+    "node": "^20.19.0 || >=22.12.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "forgeplan",
+    "claude-agent-sdk",
+    "onboarding"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ForgePlan/forgeplan-web.git"
+  },
+  "homepage": "https://github.com/ForgePlan/forgeplan-web#readme",
+  "bugs": {
+    "url": "https://github.com/ForgePlan/forgeplan-web/issues"
+  },
+  "scripts": {
+    "smoke": "node scripts/smoke.mjs"
+  },
+  "dependencies": {
+    "@anthropic-ai/claude-agent-sdk": "^0.3.201",
+    "ws": "^8.21.0",
+    "zod": "^4.4.3"
+  }
+}
diff --git a/agent/scripts/smoke.mjs b/agent/scripts/smoke.mjs
new file mode 100644
index 0000000..a51773d
--- /dev/null
+++ b/agent/scripts/smoke.mjs
@@ -0,0 +1,1066 @@
+#!/usr/bin/env node
+// RFC-034 (Pillar C, Phase 2) — smoke test for @forgeplan/web-agent that
+// runs WITHOUT a live model turn (no Claude Code session needs to actually
+// answer a question). Covers exactly what the task hand-off asked for:
+//   1. protocol.mjs encode/decode round-trips for every message shape.
+//   2. profile.mjs#buildOptions denies Write/Edit/Bash and allows the
+//      onboard tool.
+//   3. The daemon module imports cleanly, its message queue generator
+//      yields the documented shape, and its `show_on_map` tool relays over
+//      a fake socket.
+//   4. The daemon process actually binds 127.0.0.1:<port>, answers
+//      `GET /health` (with an access-control-allow-origin: * header —
+//      bugfix, CORS), and sends a `{type:"ready"}` frame on WS connect.
+//   5. (Phase 4a) A stray {type:"cancel"} with no in-flight turn on a
+//      connection is a no-op — no crash, daemon stays healthy afterward.
+//   6. (bugfix — leaked subprocess) createMessageQueue()'s close() makes
+//      generator() return, both when parked awaiting a message and when
+//      called before the generator is ever iterated.
+//   7. (bugfix — leaked subprocess) a connection that never sends a
+//      user_message receives ONLY the synchronous {type:"ready"} frame —
+//      the black-box signal that lazy query start never spawned a query
+//      for it.
+//   8. Bugfix #1 (cross-turn frame race) — turnId round-trips through
+//      encode/decode on user_message/token/show_on_map/usage/done/error;
+//      createMessageQueue().getCurrentTurnId() tracks whichever item was
+//      most recently shifted to the SDK's input generator; buildOnboardServer
+//      stamps show_on_map frames with the turnId its getTurnId callback
+//      reports at call time.
+//   9. Bugfix #6 (error frame fatal/non-fatal discriminant) — errorMessage()
+//      round-trips fatal:true and fatal:false; a raw error frame with no
+//      `fatal` field (older daemon) decodes defaulting to fatal:true.
+// A full live-model turn (including cancelling one mid-stream via
+// Query#interrupt()) needs the user's own Claude Code session and is
+// verified later (Phase 4) — this script deliberately does not attempt one.
+
+import { spawn } from "node:child_process";
+import {
+  existsSync,
+  mkdtempSync,
+  readFileSync,
+  renameSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import WebSocket from "ws";
+
+import {
+  PROTOCOL_VERSION,
+  decodeClientMessage,
+  decodeServerMessage,
+  doneMessage,
+  encode,
+  errorMessage,
+  readyMessage,
+  sessionMessage,
+  showOnMapMessage,
+  tokenMessage,
+  usageMessage,
+} from "../lib/protocol.mjs";
+import {
+  ALLOWED_TOOLS,
+  DISALLOWED_TOOLS,
+  buildOptions,
+} from "../lib/profile.mjs";
+import {
+  buildOnboardServer,
+  createMessageQueue,
+  parseResumeSessionId,
+} from "../bin/agent.mjs";
+import {
+  deregisterAgent,
+  heartbeatAgent,
+  makeAgentId,
+  readOtherLiveInstances,
+  registerAgent,
+} from "../lib/registry.mjs";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const ROOT = resolve(__dirname, "..");
+const AGENT_BIN = join(ROOT, "bin", "agent.mjs");
+
+let failed = false;
+
+function log(line) {
+  process.stdout.write(`[agent-smoke] ${line}\n`);
+}
+
+function assert(cond, message) {
+  if (!cond) {
+    failed = true;
+    process.stderr.write(`[agent-smoke] FAIL: ${message}\n`);
+  }
+}
+
+function checkProtocolRoundTrip() {
+  log("protocol: encode/decode round-trip");
+
+  const ready = readyMessage("test-model");
+  assert(
+    decodeServerMessage(encode(ready))?.model === "test-model",
+    "ready message did not round-trip",
+  );
+
+  const token = tokenMessage("hello");
+  assert(
+    decodeServerMessage(encode(token))?.delta === "hello",
+    "token message did not round-trip",
+  );
+
+  const show = showOnMapMessage({ kind: "zone", id: "z1" });
+  const decodedShow = decodeServerMessage(encode(show));
+  assert(
+    decodedShow?.type === "show_on_map" &&
+      decodedShow.target.kind === "zone" &&
+      decodedShow.target.id === "z1",
+    "show_on_map message did not round-trip",
+  );
+
+  const done = doneMessage();
+  assert(
+    decodeServerMessage(encode(done))?.type === "done",
+    "done message did not round-trip",
+  );
+
+  const err = errorMessage("boom");
+  assert(
+    decodeServerMessage(encode(err))?.message === "boom",
+    "error message did not round-trip",
+  );
+
+  // RFC-034 Phase 4c — {type:"session"} is the server-only frame carrying
+  // the SDK's own session id, sent once captured from `system`/`init`.
+  const session = sessionMessage("abc-123");
+  const decodedSession = decodeServerMessage(encode(session));
+  assert(
+    decodedSession?.type === "session" &&
+      decodedSession.sessionId === "abc-123",
+    "session message did not round-trip",
+  );
+  assert(
+    decodeServerMessage(encode({ type: "session", sessionId: 42 })) === null,
+    "a session message with a non-string sessionId should decode to null",
+  );
+
+  const userMsg = decodeClientMessage(
+    encode({ type: "user_message", text: "where is X" }),
+  );
+  assert(
+    userMsg?.type === "user_message" && userMsg.text === "where is X",
+    "user_message did not round-trip",
+  );
+
+  const cancelMsg = decodeClientMessage(encode({ type: "cancel" }));
+  assert(cancelMsg?.type === "cancel", "cancel message did not round-trip");
+
+  assert(
+    decodeClientMessage("not json") === null,
+    "malformed client JSON should decode to null",
+  );
+  assert(
+    decodeClientMessage(encode({ type: "unknown_type" })) === null,
+    "unknown client message type should decode to null",
+  );
+  assert(
+    decodeServerMessage(
+      encode({ type: "show_on_map", target: { kind: "bogus", id: "x" } }),
+    ) === null,
+    "show_on_map with an invalid kind should decode to null",
+  );
+
+  assert(
+    typeof PROTOCOL_VERSION === "number",
+    "PROTOCOL_VERSION must be a number",
+  );
+
+  // RFC-035 (Wave 2, FR-5) — usage frame round-trip.
+  const usage = usageMessage({
+    inputTokens: 12,
+    outputTokens: 34,
+    costUsd: 0.0056,
+  });
+  const decodedUsage = decodeServerMessage(encode(usage));
+  assert(
+    decodedUsage?.type === "usage" &&
+      decodedUsage.inputTokens === 12 &&
+      decodedUsage.outputTokens === 34 &&
+      decodedUsage.costUsd === 0.0056,
+    "usage message did not round-trip",
+  );
+  assert(
+    decodeServerMessage(
+      encode({
+        type: "usage",
+        inputTokens: "12",
+        outputTokens: 34,
+        costUsd: 0,
+      }),
+    ) === null,
+    "a usage message with a non-number inputTokens should decode to null",
+  );
+  assert(
+    decodeServerMessage(encode({ type: "usage", inputTokens: 1 })) === null,
+    "a usage message missing outputTokens/costUsd should decode to null",
+  );
+
+  // RFC-035 (Wave 2, FR-5/FR-6) — ready frame carries capabilities +
+  // otherInstances, additively (default [] when absent, e.g. an older peer).
+  const readyWithExtras = readyMessage("test-model", {
+    capabilities: ["usage", "instances"],
+    otherInstances: [{ projectName: "other-proj", port: 5555, kind: "web" }],
+  });
+  const decodedReady = decodeServerMessage(encode(readyWithExtras));
+  assert(
+    Array.isArray(decodedReady?.capabilities) &&
+      decodedReady.capabilities.includes("usage") &&
+      decodedReady.capabilities.includes("instances"),
+    "ready message should carry capabilities",
+  );
+  assert(
+    Array.isArray(decodedReady?.otherInstances) &&
+      decodedReady.otherInstances.length === 1 &&
+      decodedReady.otherInstances[0].projectName === "other-proj" &&
+      decodedReady.otherInstances[0].port === 5555 &&
+      decodedReady.otherInstances[0].kind === "web",
+    "ready message should carry otherInstances",
+  );
+  const decodedBareReady = decodeServerMessage(
+    encode({ type: "ready", protocolVersion: 1, model: "old-daemon" }),
+  );
+  assert(
+    Array.isArray(decodedBareReady?.capabilities) &&
+      decodedBareReady.capabilities.length === 0 &&
+      Array.isArray(decodedBareReady?.otherInstances) &&
+      decodedBareReady.otherInstances.length === 0,
+    "a ready frame missing capabilities/otherInstances (older daemon) should still decode, defaulting both to []",
+  );
+
+  // Bugfix #1 (cross-turn frame race) — turnId round-trips on every
+  // per-turn frame shape, and PROTOCOL_VERSION was bumped for the change.
+  assert(
+    PROTOCOL_VERSION === 3,
+    "PROTOCOL_VERSION must be bumped to 3 for the turnId + fatal additions",
+  );
+
+  const userMsgWithTurn = decodeClientMessage(
+    encode({ type: "user_message", text: "where is X", turnId: "turn-1" }),
+  );
+  assert(
+    userMsgWithTurn?.turnId === "turn-1",
+    "user_message turnId did not round-trip",
+  );
+  assert(
+    decodeClientMessage(encode({ type: "user_message", text: "no turn" }))
+      ?.turnId === null,
+    "user_message missing turnId should decode with turnId: null (backward-compat)",
+  );
+
+  const tokenWithTurn = decodeServerMessage(
+    encode(tokenMessage("hi", "turn-1")),
+  );
+  assert(
+    tokenWithTurn?.delta === "hi" && tokenWithTurn?.turnId === "turn-1",
+    "token message turnId did not round-trip",
+  );
+  assert(
+    decodeServerMessage(encode({ type: "token", delta: "x" }))?.turnId === null,
+    "a token frame missing turnId (older daemon) should decode with turnId: null",
+  );
+
+  const showWithTurn = decodeServerMessage(
+    encode(showOnMapMessage({ kind: "node", id: "n1" }, "turn-2")),
+  );
+  assert(
+    showWithTurn?.turnId === "turn-2",
+    "show_on_map message turnId did not round-trip",
+  );
+
+  const usageWithTurn = decodeServerMessage(
+    encode(
+      usageMessage(
+        { inputTokens: 1, outputTokens: 2, costUsd: 0.01 },
+        "turn-3",
+      ),
+    ),
+  );
+  assert(
+    usageWithTurn?.turnId === "turn-3",
+    "usage message turnId did not round-trip",
+  );
+
+  const doneWithTurn = decodeServerMessage(encode(doneMessage("turn-4")));
+  assert(
+    doneWithTurn?.type === "done" && doneWithTurn?.turnId === "turn-4",
+    "done message turnId did not round-trip",
+  );
+  assert(
+    decodeServerMessage(encode({ type: "done" }))?.turnId === null,
+    "a done frame missing turnId (older daemon) should decode with turnId: null",
+  );
+
+  // Bugfix #6 (error frame fatal/non-fatal discriminant) — both fatal
+  // values round-trip, and turnId rides along on the error frame too.
+  const nonFatalErr = decodeServerMessage(
+    encode(errorMessage("turn failed", { fatal: false, turnId: "turn-5" })),
+  );
+  assert(
+    nonFatalErr?.message === "turn failed" &&
+      nonFatalErr?.fatal === false &&
+      nonFatalErr?.turnId === "turn-5",
+    "a non-fatal error message did not round-trip fatal:false + turnId",
+  );
+  const fatalErr = decodeServerMessage(
+    encode(errorMessage("connection dead", { fatal: true, turnId: "turn-6" })),
+  );
+  assert(
+    fatalErr?.fatal === true && fatalErr?.turnId === "turn-6",
+    "a fatal error message did not round-trip fatal:true + turnId",
+  );
+  assert(
+    decodeServerMessage(encode({ type: "error", message: "legacy" }))?.fatal ===
+      true,
+    "an error frame missing `fatal` (older daemon) should default to fatal:true",
+  );
+  assert(
+    errorMessage("default fatal").fatal === true,
+    "errorMessage() with no options should default to fatal:true",
+  );
+}
+
+function checkProfileDeniesWriteEditBash() {
+  log("profile: buildOptions denies Write/Edit/Bash, allows the onboard tool");
+
+  const options = buildOptions({ cwd: ROOT });
+  assert(options.cwd === ROOT, "buildOptions did not thread cwd through");
+  assert(
+    options.permissionMode === "default",
+    "permissionMode should be default",
+  );
+  assert(
+    Array.isArray(options.disallowedTools) &&
+      ["Write", "Edit", "Bash"].every((t) =>
+        options.disallowedTools.includes(t),
+      ),
+    "disallowedTools must include Write, Edit, and Bash",
+  );
+  assert(
+    Array.isArray(options.allowedTools) &&
+      options.allowedTools.includes("mcp__onboard__show_on_map"),
+    "allowedTools must include mcp__onboard__show_on_map",
+  );
+  assert(
+    !("mcpServers" in options),
+    "buildOptions must not set mcpServers itself",
+  );
+  assert(
+    options.includePartialMessages === true,
+    "buildOptions must set includePartialMessages: true for token-level streaming",
+  );
+  assert(
+    DISALLOWED_TOOLS.includes("Write") &&
+      DISALLOWED_TOOLS.includes("Edit") &&
+      DISALLOWED_TOOLS.includes("Bash"),
+    "DISALLOWED_TOOLS constant drifted from the read-only contract",
+  );
+  assert(
+    ALLOWED_TOOLS.includes("Read") &&
+      ALLOWED_TOOLS.includes("Glob") &&
+      ALLOWED_TOOLS.includes("Grep"),
+    "ALLOWED_TOOLS constant missing a read-only primitive",
+  );
+
+  let threw = false;
+  try {
+    buildOptions({});
+  } catch {
+    threw = true;
+  }
+  assert(threw, "buildOptions({}) (no cwd) must throw, not silently proceed");
+}
+
+function checkResumeSessionIdParsing() {
+  log("agent.mjs: parseResumeSessionId — RFC-034 Phase 4c live-continue");
+
+  assert(
+    parseResumeSessionId("/?resume=abc-123_XYZ") === "abc-123_XYZ",
+    "a well-formed resume param should be extracted verbatim",
+  );
+  assert(
+    parseResumeSessionId("/") === null,
+    "a URL with no resume param should return null",
+  );
+  assert(
+    parseResumeSessionId("/?resume=") === null,
+    "an empty resume value should return null",
+  );
+  assert(
+    parseResumeSessionId("/?other=1") === null,
+    "a URL missing the resume param entirely should return null",
+  );
+  assert(
+    parseResumeSessionId("/?resume=" + "a".repeat(500)) === null,
+    "a pathologically long resume value should be rejected, not throw",
+  );
+  assert(
+    parseResumeSessionId("/?resume=has%20space") === null,
+    "a resume value outside the allow-listed charset should be rejected",
+  );
+  assert(
+    parseResumeSessionId(undefined) === null,
+    "an undefined request URL (e.g. a missing upgrade request) should return null, not throw",
+  );
+  assert(
+    parseResumeSessionId("not a url \0") === null,
+    "an unparseable URL should return null, not throw",
+  );
+}
+
+async function checkMessageQueueAndToolRelay() {
+  log("daemon module: message queue shape + show_on_map tool relay");
+
+  const { enqueue, generator } = createMessageQueue();
+  const gen = generator();
+  const pending = gen.next(); // starts awaiting — queue is empty
+  enqueue("hello agent");
+  const { value, done } = await pending;
+  assert(done !== true, "generator should not be done after first message");
+  assert(value?.type === "user", "queued message should have type 'user'");
+  assert(
+    value?.message?.role === "user" &&
+      value?.message?.content === "hello agent",
+    "queued message content did not match what was enqueued",
+  );
+
+  const sent = [];
+  const fakeSocket = { send: (raw) => sent.push(raw) };
+  const server = buildOnboardServer(fakeSocket);
+  assert(
+    server?.name === "onboard" || server?.type != null,
+    "buildOnboardServer should return an SDK MCP server config object",
+  );
+}
+
+// Bugfix #1 (cross-turn frame race) — createMessageQueue().getCurrentTurnId()
+// must track whichever item was most recently shifted off the queue and
+// handed to the SDK's input generator, updating exactly at that shift point
+// (not eagerly on enqueue) — this is what lets the daemon's message loop
+// stamp outgoing frames with the turn actually being fed to the SDK.
+async function checkMessageQueueTurnIdTracking() {
+  log(
+    "daemon module: message queue getCurrentTurnId() (bugfix #1, cross-turn frame race)",
+  );
+
+  const { enqueue, generator, getCurrentTurnId } = createMessageQueue();
+  assert(
+    getCurrentTurnId() === null,
+    "a fresh queue should report getCurrentTurnId() === null",
+  );
+
+  const gen = generator();
+  const first = gen.next(); // starts awaiting — queue is empty
+  enqueue("first text", "turn-A");
+  await first;
+  assert(
+    getCurrentTurnId() === "turn-A",
+    "getCurrentTurnId() should report the turn just shifted to the generator",
+  );
+
+  const second = gen.next(); // starts awaiting again — queue is empty
+  enqueue("second text", "turn-B");
+  await second;
+  assert(
+    getCurrentTurnId() === "turn-B",
+    "getCurrentTurnId() should advance to the NEXT turn once it is shifted, " +
+      "not the moment it is enqueued",
+  );
+
+  // enqueue() with no turnId (the default) must not throw and must record
+  // turnId: null once shifted — this is the backward-compat shape for a
+  // pre-bugfix-#1 caller that never passes a turnId.
+  const third = gen.next();
+  enqueue("third text");
+  await third;
+  assert(
+    getCurrentTurnId() === null,
+    "enqueue() with an omitted turnId should shift as turnId: null",
+  );
+}
+
+// Bugfix #1 (cross-turn frame race) — buildOnboardServer accepts an
+// optional getTurnId callback (bound by the daemon to
+// messageQueue.getCurrentTurnId()) so its show_on_map relay can stamp the
+// outgoing frame with whichever turn is currently driving the SDK session.
+// This is a CONSTRUCTION-level check only: invoking the tool's handler
+// requires going through the SDK's own MCP request cycle (buildOnboardServer
+// hands the handler to createSdkMcpServer and does not expose it directly),
+// which this script deliberately does not attempt — same "no live-model
+// turn" boundary as the rest of this file (see file header). The actual
+// wire shape produced by `showOnMapMessage(target, turnId)` — the one
+// statement the tool handler calls — is covered end-to-end by
+// checkProtocolRoundTrip() above.
+function checkBuildOnboardServerAcceptsGetTurnId() {
+  log(
+    "daemon module: buildOnboardServer accepts an optional getTurnId callback (bugfix #1)",
+  );
+
+  const fakeSocket = { send: () => {} };
+  const server = buildOnboardServer(fakeSocket, () => "turn-X");
+  assert(
+    typeof server === "object" && server !== null,
+    "buildOnboardServer with a getTurnId callback should still return an SDK MCP server config object",
+  );
+
+  // buildOnboardServer with NO getTurnId argument must not throw — the
+  // parameter defaults to `() => null` (backward-compat for any caller that
+  // omits it, e.g. this file's own checkMessageQueueAndToolRelay above).
+  const serverDefault = buildOnboardServer(fakeSocket);
+  assert(
+    typeof serverDefault === "object" && serverDefault !== null,
+    "buildOnboardServer() with no getTurnId argument should still return a server config object",
+  );
+}
+
+async function checkMessageQueueClose() {
+  log("daemon module: message queue close() — bugfix (leaked subprocess)");
+
+  // Case 1: close() while a generator is PARKED awaiting a message (the
+  // steady-state shape for an idle connection) must wake it up and make it
+  // return, rather than leaving it awaiting forever — this is what lets
+  // query()'s input async-iterable COMPLETE on socket close so the
+  // underlying `claude` subprocess can exit instead of leaking.
+  const parked = createMessageQueue();
+  const parkedGen = parked.generator();
+  const parkedNext = parkedGen.next(); // starts awaiting — queue is empty
+  parked.close();
+  const parkedResult = await parkedNext;
+  assert(
+    parkedResult.done === true,
+    "generator() must be done after close() while parked awaiting a message",
+  );
+
+  // Case 2: close() called before the generator is ever iterated (the
+  // shape for a probe-only connection under lazy query start — the queue
+  // is created but generator() never gets pulled by query()) must still
+  // leave the generator well-behaved: the first .next() after close()
+  // resolves done immediately instead of hanging.
+  const neverStarted = createMessageQueue();
+  neverStarted.close();
+  const neverStartedGen = neverStarted.generator();
+  const neverStartedResult = await neverStartedGen.next();
+  assert(
+    neverStartedResult.done === true,
+    "generator() must resolve done immediately when close() preceded the first iteration",
+  );
+}
+
+// RFC-035 (Wave 2, FR-6) — since the daemon now writes into
+// `<HOME>/.forgeplan-web/instances.json` on start and removes it on
+// SIGTERM (see agent/bin/agent.mjs's cleanupRegistry), every test below
+// that points HOME at its own `scratch` dir must wait for the child to
+// actually finish exiting before recursively removing that same
+// directory — otherwise the child's in-flight deregister write (or its
+// tmp-file rename) races the parent's rmSync and intermittently fails
+// with ENOTEMPTY/ENOENT. A timeout fallback keeps a hung child from
+// wedging the suite.
+async function waitForExit(child, timeoutMs = 5_000) {
+  if (child.exitCode !== null || child.signalCode !== null) return;
+  await new Promise((resolvePromise) => {
+    const timer = setTimeout(resolvePromise, timeoutMs);
+    child.once("exit", () => {
+      clearTimeout(timer);
+      resolvePromise();
+    });
+  });
+}
+
+async function waitForLine(child, predicate, timeoutMs = 15_000) {
+  return new Promise((resolvePromise, rejectPromise) => {
+    let buf = "";
+    const timer = setTimeout(() => {
+      rejectPromise(new Error(`timed out waiting for daemon stdout: ${buf}`));
+    }, timeoutMs);
+    child.stdout.on("data", (chunk) => {
+      buf += chunk.toString();
+      if (predicate(buf)) {
+        clearTimeout(timer);
+        resolvePromise(buf);
+      }
+    });
+    child.stderr.on("data", (chunk) => {
+      buf += chunk.toString();
+    });
+  });
+}
+
+async function checkDaemonProcess() {
+  log("daemon process: binds 127.0.0.1, /health responds, WS sends ready");
+
+  const scratch = mkdtempSync(join(tmpdir(), "fpw-agent-smoke-"));
+  const port = 17400 + Math.floor(Math.random() * 200);
+
+  const child = spawn(
+    process.execPath,
+    [AGENT_BIN, "--cwd", scratch, "--port", String(port)],
+    {
+      cwd: ROOT,
+      stdio: ["ignore", "pipe", "pipe"],
+      // RFC-035 (Wave 2, FR-6) — the daemon now registers itself in
+      // `~/.forgeplan-web/instances.json` on start. Point HOME/USERPROFILE
+      // at this test's own scratch dir so the smoke suite never touches
+      // the developer's real registry file.
+      env: { ...process.env, HOME: scratch, USERPROFILE: scratch },
+    },
+  );
+
+  try {
+    await waitForLine(child, (buf) => buf.includes("onboard-agent live on"));
+    log(`daemon reported live on port ${port}`);
+
+    const healthResponse = await fetch(`http://127.0.0.1:${port}/health`);
+    assert(
+      healthResponse.headers.get("access-control-allow-origin") === "*",
+      "GET /health must carry access-control-allow-origin: * (bugfix — " +
+        "CORS, lets the web client's probe use a plain fetch)",
+    );
+    const health = await healthResponse.json();
+    assert(health.ok === true, "/health should report ok: true");
+    assert(
+      health.protocolVersion === PROTOCOL_VERSION,
+      "/health protocolVersion should match PROTOCOL_VERSION",
+    );
+    // RFC-035 (Wave 2 follow-up) — /health now mirrors the same
+    // capabilities/otherInstances the ready frame advertises, so the web
+    // client's probe (no WS connection) can populate the Info tab on chat
+    // open. This is the ONLY daemon registered under this scratch HOME, so
+    // otherInstances excludes itself down to [].
+    assert(
+      Array.isArray(health.capabilities) &&
+        health.capabilities.includes("usage") &&
+        health.capabilities.includes("instances"),
+      "/health should carry capabilities, matching the ready frame",
+    );
+    assert(
+      Array.isArray(health.otherInstances) &&
+        health.otherInstances.length === 0,
+      "/health otherInstances should be [] (this is the only daemon registered)",
+    );
+
+    const readyFrame = await new Promise((resolvePromise, rejectPromise) => {
+      const ws = new WebSocket(`ws://127.0.0.1:${port}`);
+      const timer = setTimeout(() => {
+        ws.terminate();
+        rejectPromise(new Error("timed out waiting for {type:ready} frame"));
+      }, 5_000);
+      ws.on("message", (raw) => {
+        clearTimeout(timer);
+        const msg = decodeServerMessage(raw.toString());
+        ws.close();
+        resolvePromise(msg);
+      });
+      ws.on("error", (err) => {
+        clearTimeout(timer);
+        rejectPromise(err);
+      });
+    });
+    assert(
+      readyFrame?.type === "ready",
+      "first WS frame should be {type:'ready'}",
+    );
+    assert(
+      readyFrame?.protocolVersion === PROTOCOL_VERSION,
+      "ready frame protocolVersion should match PROTOCOL_VERSION",
+    );
+    log(`WS ready frame: model="${readyFrame?.model}"`);
+  } finally {
+    child.kill("SIGTERM");
+    await waitForExit(child);
+    rmSync(scratch, { recursive: true, force: true });
+  }
+}
+
+async function checkCancelIsNoOpWithoutInFlightTurn() {
+  log(
+    "daemon process: cancel(RFC-034 Phase 4a) — a stray cancel with no in-flight turn is a no-op",
+  );
+
+  const scratch = mkdtempSync(join(tmpdir(), "fpw-agent-smoke-cancel-"));
+  const port = 17700 + Math.floor(Math.random() * 200);
+
+  const child = spawn(
+    process.execPath,
+    [AGENT_BIN, "--cwd", scratch, "--port", String(port)],
+    {
+      cwd: ROOT,
+      stdio: ["ignore", "pipe", "pipe"],
+      // RFC-035 (Wave 2, FR-6) — the daemon now registers itself in
+      // `~/.forgeplan-web/instances.json` on start. Point HOME/USERPROFILE
+      // at this test's own scratch dir so the smoke suite never touches
+      // the developer's real registry file.
+      env: { ...process.env, HOME: scratch, USERPROFILE: scratch },
+    },
+  );
+
+  try {
+    await waitForLine(child, (buf) => buf.includes("onboard-agent live on"));
+
+    // No user_message was ever sent on this connection, so the daemon's
+    // per-connection turnActive guard must treat the cancel below as a
+    // no-op: no crash, no frame, and the connection/daemon stay healthy
+    // afterward (verified via /health once the socket closes).
+    await new Promise((resolvePromise, rejectPromise) => {
+      const ws = new WebSocket(`ws://127.0.0.1:${port}`);
+      const timer = setTimeout(() => {
+        ws.terminate();
+        rejectPromise(new Error("timed out exercising a no-op cancel"));
+      }, 5_000);
+      ws.on("message", (raw) => {
+        const msg = decodeServerMessage(raw.toString());
+        if (msg?.type !== "ready") return;
+        ws.send(encode({ type: "cancel" }));
+        // Give the daemon a moment to (not) misbehave before closing —
+        // any crash would surface as the subsequent /health check failing
+        // or this process having already exited.
+        setTimeout(() => {
+          clearTimeout(timer);
+          ws.close();
+          resolvePromise();
+        }, 300);
+      });
+      ws.on("error", (err) => {
+        clearTimeout(timer);
+        rejectPromise(err);
+      });
+    });
+
+    assert(
+      child.exitCode === null && !child.killed,
+      "daemon process must still be running after a no-op cancel",
+    );
+    const health = await fetch(`http://127.0.0.1:${port}/health`).then((r) =>
+      r.json(),
+    );
+    assert(
+      health.ok === true,
+      "daemon should still answer /health after a no-op cancel",
+    );
+  } finally {
+    child.kill("SIGTERM");
+    await waitForExit(child);
+    rmSync(scratch, { recursive: true, force: true });
+  }
+}
+
+async function checkResumeQueryParamConnectionStaysHealthy() {
+  log(
+    "daemon process: RFC-034 Phase 4c — a ?resume=<id> connection (target " +
+      "obviously nonexistent) still handshakes and leaves the daemon healthy",
+  );
+
+  const scratch = mkdtempSync(join(tmpdir(), "fpw-agent-smoke-resume-"));
+  const port = 17900 + Math.floor(Math.random() * 200);
+
+  const child = spawn(
+    process.execPath,
+    [AGENT_BIN, "--cwd", scratch, "--port", String(port)],
+    {
+      cwd: ROOT,
+      stdio: ["ignore", "pipe", "pipe"],
+      // RFC-035 (Wave 2, FR-6) — the daemon now registers itself in
+      // `~/.forgeplan-web/instances.json` on start. Point HOME/USERPROFILE
+      // at this test's own scratch dir so the smoke suite never touches
+      // the developer's real registry file.
+      env: { ...process.env, HOME: scratch, USERPROFILE: scratch },
+    },
+  );
+
+  try {
+    await waitForLine(child, (buf) => buf.includes("onboard-agent live on"));
+
+    // A resume target that cannot possibly exist on this fresh --cwd
+    // scratch dir. This exercises parseResumeSessionId reading a REAL `ws`
+    // upgrade request URL end-to-end, and the query()-with-resume /
+    // retry-fresh wiring in bin/agent.mjs, without depending on an actual
+    // live-model turn succeeding (see file header — no live turn here).
+    const readyFrame = await new Promise((resolvePromise, rejectPromise) => {
+      const ws = new WebSocket(
+        `ws://127.0.0.1:${port}/?resume=smoke-test-nonexistent-session`,
+      );
+      const timer = setTimeout(() => {
+        ws.terminate();
+        rejectPromise(
+          new Error(
+            "timed out waiting for {type:ready} on a ?resume= connection",
+          ),
+        );
+      }, 5_000);
+      ws.on("message", (raw) => {
+        clearTimeout(timer);
+        const msg = decodeServerMessage(raw.toString());
+        ws.close();
+        resolvePromise(msg);
+      });
+      ws.on("error", (err) => {
+        clearTimeout(timer);
+        rejectPromise(err);
+      });
+    });
+    assert(
+      readyFrame?.type === "ready",
+      "a ?resume= connection should still get the synchronous {type:'ready'} frame",
+    );
+
+    // Give the daemon a moment to (not) misbehave in the background before
+    // checking /health — same pattern as checkCancelIsNoOpWithoutInFlightTurn.
+    await new Promise((resolvePromise) => setTimeout(resolvePromise, 300));
+    assert(
+      child.exitCode === null && !child.killed,
+      "daemon process must still be running after a ?resume= connection with a bogus id",
+    );
+    const health = await fetch(`http://127.0.0.1:${port}/health`).then((r) =>
+      r.json(),
+    );
+    assert(
+      health.ok === true,
+      "daemon should still answer /health after a ?resume= connection with a bogus id",
+    );
+  } finally {
+    child.kill("SIGTERM");
+    await waitForExit(child);
+    rmSync(scratch, { recursive: true, force: true });
+  }
+}
+
+async function checkLazyQueryStartOnProbeOnlyConnection() {
+  log(
+    "daemon process: bugfix (leaked subprocess) — a connection that never " +
+      "sends user_message gets ONLY the ready frame, nothing more",
+  );
+
+  const scratch = mkdtempSync(join(tmpdir(), "fpw-agent-smoke-lazy-"));
+  const port = 18100 + Math.floor(Math.random() * 200);
+
+  const child = spawn(
+    process.execPath,
+    [AGENT_BIN, "--cwd", scratch, "--port", String(port)],
+    {
+      cwd: ROOT,
+      stdio: ["ignore", "pipe", "pipe"],
+      // RFC-035 (Wave 2, FR-6) — the daemon now registers itself in
+      // `~/.forgeplan-web/instances.json` on start. Point HOME/USERPROFILE
+      // at this test's own scratch dir so the smoke suite never touches
+      // the developer's real registry file.
+      env: { ...process.env, HOME: scratch, USERPROFILE: scratch },
+    },
+  );
+
+  try {
+    await waitForLine(child, (buf) => buf.includes("onboard-agent live on"));
+
+    // Connect, collect every frame that arrives within a window, then
+    // close — no user_message is ever sent. Before the lazy-start bugfix
+    // the daemon called startQuery() unconditionally on connect, spawning
+    // a `claude` subprocess immediately; that subprocess would eventually
+    // push a `system`/`init` message through to a `{type:"session"}`
+    // frame, or an `{type:"error"}` frame if the spawn itself failed.
+    // Receiving ONLY the synchronous `ready` frame in this window, with no
+    // session/error frame ever following, is the black-box signal that no
+    // query() was ever started for a connection that never sent a
+    // user_message (this script deliberately avoids depending on the
+    // ability to actually spawn `claude` — see file header — so it cannot
+    // assert subprocess absence directly).
+    const frames = await new Promise((resolvePromise, rejectPromise) => {
+      const seen = [];
+      const ws = new WebSocket(`ws://127.0.0.1:${port}`);
+      const timer = setTimeout(() => {
+        ws.close();
+        resolvePromise(seen);
+      }, 500);
+      ws.on("message", (raw) => {
+        const msg = decodeServerMessage(raw.toString());
+        if (msg) seen.push(msg.type);
+      });
+      ws.on("error", (err) => {
+        clearTimeout(timer);
+        rejectPromise(err);
+      });
+    });
+    assert(
+      frames.length === 1 && frames[0] === "ready",
+      `a probe-only connection (no user_message sent) should receive ONLY ` +
+        `{type:"ready"}, got: ${JSON.stringify(frames)}`,
+    );
+
+    assert(
+      child.exitCode === null && !child.killed,
+      "daemon process must still be running after a probe-only connection closes",
+    );
+    const health = await fetch(`http://127.0.0.1:${port}/health`).then((r) =>
+      r.json(),
+    );
+    assert(
+      health.ok === true,
+      "daemon should still answer /health after a probe-only connection closes",
+    );
+  } finally {
+    child.kill("SIGTERM");
+    await waitForExit(child);
+    rmSync(scratch, { recursive: true, force: true });
+  }
+}
+
+function checkRegistryRoundTrip() {
+  log(
+    "registry: register/heartbeat/deregister round-trips a row; " +
+      "readOtherLiveInstances excludes self and defaults kind to 'web'",
+  );
+
+  // RFC-035 (Wave 2, FR-6) — registry.mjs resolves its path from
+  // os.homedir(), which reads HOME (POSIX) / USERPROFILE (Windows) at call
+  // time. Overriding both here, in-process, for the duration of this one
+  // synchronous check keeps the smoke suite from ever touching the
+  // developer's real ~/.forgeplan-web/instances.json.
+  const scratchHome = mkdtempSync(join(tmpdir(), "fpw-agent-smoke-registry-"));
+  const originalHome = process.env.HOME;
+  const originalUserProfile = process.env.USERPROFILE;
+  process.env.HOME = scratchHome;
+  process.env.USERPROFILE = scratchHome;
+
+  try {
+    const port = 19999;
+    const selfId = registerAgent({
+      port,
+      cwd: ROOT,
+      protocolVersion: PROTOCOL_VERSION,
+    });
+    assert(
+      selfId === makeAgentId(port),
+      "registerAgent should return the agent:host:port id shape",
+    );
+
+    const registryFile = join(scratchHome, ".forgeplan-web", "instances.json");
+    assert(
+      existsSync(registryFile),
+      "registerAgent should write ~/.forgeplan-web/instances.json",
+    );
+    const written = JSON.parse(readFileSync(registryFile, "utf8"));
+    const row = written.instances.find((r) => r.id === selfId);
+    assert(row?.kind === "agent", "registered row should carry kind:'agent'");
+    assert(row?.scope === "agent", "registered row should carry scope:'agent'");
+    assert(
+      row?.pid === process.pid,
+      "registered row pid should be this process",
+    );
+    assert(
+      row?.workspaceRoot === ROOT && row?.projectName !== undefined,
+      "registered row should carry workspaceRoot/projectName from cwd",
+    );
+
+    // Seed a second, independently-alive row (same live pid as this test
+    // process, so isAlive() treats it as live) with NO `kind` field — the
+    // shape of a pre-RFC-035 web-instance row — to exercise the "default
+    // missing kind to 'web'" fallback.
+    const otherRow = {
+      id: "web:127.0.0.1:5555",
+      host: "127.0.0.1",
+      port: 5555,
+      pid: process.pid,
+      scope: "project",
+      workspaceRoot: ROOT,
+      projectName: "other-project",
+      startedAt: new Date().toISOString(),
+      heartbeatAt: new Date().toISOString(),
+      webVersion: "0.1.0",
+      forgeplanCli: null,
+    };
+    const before = JSON.parse(readFileSync(registryFile, "utf8"));
+    const seededInstances = [...before.instances, otherRow];
+    // Reuse the same atomic-write shape the module itself uses (tmp+rename)
+    // to seed this row without importing bin/lib/registry.mjs.
+    const tmp = `${registryFile}.tmp.seed.${Date.now()}`;
+    writeFileSync(
+      tmp,
+      JSON.stringify({ version: 1, instances: seededInstances }, null, 2) +
+        "\n",
+    );
+    renameSync(tmp, registryFile);
+
+    const others = readOtherLiveInstances(selfId);
+    assert(
+      !others.some((o) => o.port === port),
+      "readOtherLiveInstances should exclude the self row",
+    );
+    const other = others.find((o) => o.port === 5555);
+    assert(
+      other?.projectName === "other-project" && other?.kind === "web",
+      "readOtherLiveInstances should include the other live row, defaulting kind to 'web'",
+    );
+
+    heartbeatAgent(selfId);
+    const afterHeartbeat = JSON.parse(readFileSync(registryFile, "utf8"));
+    const rowAfterHeartbeat = afterHeartbeat.instances.find(
+      (r) => r.id === selfId,
+    );
+    assert(
+      rowAfterHeartbeat &&
+        Date.parse(rowAfterHeartbeat.heartbeatAt) >=
+          Date.parse(row.heartbeatAt),
+      "heartbeatAgent should refresh heartbeatAt",
+    );
+
+    deregisterAgent(selfId);
+    const afterDeregister = JSON.parse(readFileSync(registryFile, "utf8"));
+    assert(
+      !afterDeregister.instances.some((r) => r.id === selfId),
+      "deregisterAgent should remove the row",
+    );
+
+    // heartbeatAgent on an id with no live row and no in-memory
+    // last-known-row (a fresh module instance would have none; here we
+    // just deregistered, which clears the cache too) must not throw.
+    let threw = false;
+    try {
+      heartbeatAgent(selfId);
+    } catch {
+      threw = true;
+    }
+    assert(
+      !threw,
+      "heartbeatAgent on an unknown id after deregister should be a safe no-op",
+    );
+  } finally {
+    if (originalHome === undefined) delete process.env.HOME;
+    else process.env.HOME = originalHome;
+    if (originalUserProfile === undefined) delete process.env.USERPROFILE;
+    else process.env.USERPROFILE = originalUserProfile;
+    rmSync(scratchHome, { recursive: true, force: true });
+  }
+}
+
+async function main() {
+  checkProtocolRoundTrip();
+  checkProfileDeniesWriteEditBash();
+  checkResumeSessionIdParsing();
+  checkRegistryRoundTrip();
+  await checkMessageQueueAndToolRelay();
+  await checkMessageQueueTurnIdTracking();
+  checkBuildOnboardServerAcceptsGetTurnId();
+  await checkMessageQueueClose();
+  await checkDaemonProcess();
+  await checkCancelIsNoOpWithoutInFlightTurn();
+  await checkResumeQueryParamConnectionStaysHealthy();
+  await checkLazyQueryStartOnProbeOnlyConnection();
+
+  if (failed) {
+    process.stderr.write("[agent-smoke] FAIL — see above\n");
+    process.exit(1);
+  }
+  log("ALL CHECKS PASS (no live-model turn exercised — see file header)");
+}
+
+main().catch((err) => {
+  process.stderr.write(`[agent-smoke] unhandled: ${err?.stack ?? err}\n`);
+  process.exit(1);
+});
diff --git a/bin/cli.mjs b/bin/cli.mjs
index 68f812f..b30aa79 100644
--- a/bin/cli.mjs
+++ b/bin/cli.mjs
@@ -12,5 +12,7 @@ export default defineCommand({
     init: () => import("./commands/init.mjs").then((m) => m.default),
     update: () => import("./commands/update.mjs").then((m) => m.default),
     start: () => import("./commands/start.mjs").then((m) => m.default),
+    "onboard-agent": () =>
+      import("./commands/onboard-agent.mjs").then((m) => m.default),
   },
 });
diff --git a/bin/commands/onboard-agent.mjs b/bin/commands/onboard-agent.mjs
new file mode 100644
index 0000000..3b247a9
--- /dev/null
+++ b/bin/commands/onboard-agent.mjs
@@ -0,0 +1,164 @@
+import { defineCommand } from "citty";
+import { spawn } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+
+// RFC-034 (Pillar C, Phase 3a) / ADR-010: this subcommand is SPAWN-ONLY. It
+// never imports `@forgeplan/web-agent` — only `child_process.spawn`s its
+// binary once resolved. The heavy Agent SDK dependency tree lives entirely
+// in that separate, optional package (rule 23 / ADR-003 invariant: bin/
+// stays `node:*` + citty + relative siblings only).
+
+const AGENT_PKG = "@forgeplan/web-agent";
+const AGENT_BIN_NAME = "forgeplan-web-agent";
+const DEFAULT_PORT = 7431;
+
+function fail(line, code = 1) {
+  process.stderr.write(`forgeplan-web: ${line}\n`);
+  process.exit(code);
+}
+
+function printInstallHint() {
+  process.stderr.write(
+    "forgeplan-web: the onboarding agent is an optional package.\n" +
+      `       Install it with: npx ${AGENT_PKG}\n` +
+      `       (or: npm i -g ${AGENT_PKG})\n`,
+  );
+}
+
+function localBinCandidates(cwd) {
+  const base = join(cwd, "node_modules", ".bin", AGENT_BIN_NAME);
+  return process.platform === "win32"
+    ? [`${base}.cmd`, `${base}.ps1`, base]
+    : [base];
+}
+
+/**
+ * Resolves an already-installed `@forgeplan/web-agent` binary without ever
+ * loading the package's code. Two lookup strategies, in order:
+ *   1. Node's own module resolution (`require.resolve`) walking up from
+ *      `cwd` — resolves the package's `package.json#bin` entry to a real
+ *      filesystem path and invokes it as `node <resolvedPath>`. This is the
+ *      preferred strategy: it always launches via a fully-resolved path
+ *      regardless of how the package was linked into `node_modules`, so it
+ *      is robust to `node_modules/.bin` being a symlink (the standard npm
+ *      layout on POSIX). It only resolves a filesystem PATH; it never
+ *      executes or imports the package itself (rule 23).
+ *   2. `node_modules/.bin/<bin-name>` next to `cwd` — a plain fallback for
+ *      the (rare) case where module resolution above fails to locate the
+ *      package's `package.json` even though a `.bin` entry exists.
+ * Returns `null` when the package cannot be found locally at all — callers
+ * fall back to `npx` on-demand resolution.
+ */
+function resolvePackageBin(cwd) {
+  try {
+    // createRequire's argument only anchors the resolution directory; it
+    // does not need to exist on disk.
+    const requireFromCwd = createRequire(join(cwd, "noop.cjs"));
+    const pkgJsonPath = requireFromCwd.resolve(`${AGENT_PKG}/package.json`);
+    const pkgJson = JSON.parse(readFileSync(pkgJsonPath, "utf8"));
+    const binField = pkgJson.bin;
+    const binRelative =
+      typeof binField === "string" ? binField : binField?.[AGENT_BIN_NAME];
+    if (binRelative) {
+      const resolvedBin = join(dirname(pkgJsonPath), binRelative);
+      if (existsSync(resolvedBin)) {
+        return { cmd: process.execPath, args: [resolvedBin] };
+      }
+    }
+  } catch {
+    // Not resolvable via node module resolution — fall through to the
+    // node_modules/.bin check, then to the npx fallback in run().
+  }
+
+  for (const candidate of localBinCandidates(cwd)) {
+    if (existsSync(candidate)) return { cmd: candidate, args: [] };
+  }
+
+  return null;
+}
+
+export default defineCommand({
+  meta: {
+    name: "onboard-agent",
+    description:
+      "Launch the optional @forgeplan/web-agent daemon (RFC-034 Pillar C / ADR-010): a localhost-only live onboarding agent the web chat upgrades to when present. Spawn-only — never imports the agent package.",
+  },
+  args: {
+    port: {
+      type: "string",
+      default: String(DEFAULT_PORT),
+      description: "port the daemon binds on 127.0.0.1",
+      valueHint: String(DEFAULT_PORT),
+    },
+    cwd: {
+      type: "string",
+      description:
+        "project root the agent reads from (default: current directory)",
+      valueHint: "/path/to/project",
+    },
+  },
+  async run({ args }) {
+    const cwd =
+      typeof args.cwd === "string" && args.cwd.length > 0
+        ? args.cwd
+        : process.cwd();
+
+    const portNum = Number(args.port);
+    if (!Number.isFinite(portNum) || portNum < 1 || portNum > 65_535) {
+      fail(`invalid --port value "${args.port}"; expected 1..65535.`);
+    }
+    const port = String(portNum);
+    const agentArgs = ["--cwd", cwd, "--port", port];
+
+    const resolved = resolvePackageBin(cwd);
+
+    let cmd;
+    let cmdArgs;
+    if (resolved) {
+      cmd = resolved.cmd;
+      cmdArgs = [...resolved.args, ...agentArgs];
+    } else {
+      // Not installed locally — fall back to on-demand resolution via npx.
+      // npx performs its own "is it published/cached" check; we only guard
+      // the spawn() boundary below against ENOENT (e.g. npx itself missing
+      // from PATH), never surfacing a raw ENOENT to the user.
+      cmd = "npx";
+      cmdArgs = ["--yes", AGENT_PKG, ...agentArgs];
+    }
+
+    const isDirectNodeInvocation = cmd === process.execPath;
+    const useShell = process.platform === "win32" && !isDirectNodeInvocation;
+
+    const child = spawn(cmd, cmdArgs, {
+      stdio: "inherit",
+      shell: useShell,
+    });
+
+    const forward = (sig) => {
+      if (!child.killed) child.kill(sig);
+    };
+    process.on("SIGINT", () => forward("SIGINT"));
+    process.on("SIGTERM", () => forward("SIGTERM"));
+
+    return new Promise((resolvePromise) => {
+      child.on("error", (err) => {
+        if (err && err.code === "ENOENT") {
+          printInstallHint();
+          process.exit(1);
+        } else {
+          fail(`failed to launch onboarding agent: ${err?.message ?? err}`);
+        }
+        resolvePromise();
+      });
+      child.on("exit", (code, signal) => {
+        if (signal) {
+          process.exit(1);
+        } else {
+          process.exit(code ?? 0);
+        }
+      });
+    });
+  },
+});
diff --git a/template/package-lock.json b/template/package-lock.json
index 2265a17..d21a80d 100644
--- a/template/package-lock.json
+++ b/template/package-lock.json
@@ -9,6 +9,7 @@
       "version": "0.2.4",
       "dependencies": {
         "@lucide/svelte": "^1.14.0",
+        "@neodrag/svelte": "3.0.0-next.8",
         "@sveltejs/kit": "^2.59.0",
         "bits-ui": "^2.18.1",
         "d3-force": "^3.0.0",
@@ -19,7 +20,9 @@
         "d3-zoom": "^3.0.0",
         "dompurify": "^3.4.2",
         "marked": "^18.0.3",
+        "rehype-highlight": "^7.0.2",
         "svelte": "^5.55.5",
+        "svelte-exmarkdown": "^5.0.2",
         "svelte-sonner": "^1.1.1"
       },
       "devDependencies": {
@@ -182,6 +185,23 @@
         "@emnapi/runtime": "^1.7.1"
       }
     },
+    "node_modules/@neodrag/core": {
+      "version": "3.0.0-next.8",
+      "resolved": "https://registry.npmjs.org/@neodrag/core/-/core-3.0.0-next.8.tgz",
+      "integrity": "sha512-RNFwbo2w6M7BEzCh7pls68X2h3n+ofFDW1XnGyIzhtJ2bb8J/2VqixOpOlw9NfSJ61xgUC5ymGQbQFg5BKsWBA==",
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/@neodrag/svelte": {
+      "version": "3.0.0-next.8",
+      "resolved": "https://registry.npmjs.org/@neodrag/svelte/-/svelte-3.0.0-next.8.tgz",
+      "integrity": "sha512-VkTnOqiHpAaEK5jp2PqQPEEx5AaNGVoKeoC2TuWd2xuteGOVq7NqQjNC4sxk0HAVysfYOC9YhYOsVyRiKo2LFw==",
+      "license": "MIT",
+      "peerDependencies": {
+        "@neodrag/core": "3.0.0-next.8",
+        "svelte": "^3 || ^4 || ^5"
+      }
+    },
     "node_modules/@oxc-project/types": {
       "version": "0.127.0",
       "resolved": "https://registry.npmjs.org/@oxc-project/types/-/types-0.127.0.tgz",
@@ -1122,6 +1142,15 @@
         "@types/d3-selection": "*"
       }
     },
+    "node_modules/@types/debug": {
+      "version": "4.1.13",
+      "resolved": "https://registry.npmjs.org/@types/debug/-/debug-4.1.13.tgz",
+      "integrity": "sha512-KSVgmQmzMwPlmtljOomayoR89W4FynCAi3E8PPs7vmDVPe84hT+vGPKkJfThkmXs0x0jAaa9U8uW8bbfyS2fWw==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/ms": "*"
+      }
+    },
     "node_modules/@types/deep-eql": {
       "version": "4.0.2",
       "resolved": "https://registry.npmjs.org/@types/deep-eql/-/deep-eql-4.0.2.tgz",
@@ -1145,6 +1174,30 @@
       "integrity": "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==",
       "license": "MIT"
     },
+    "node_modules/@types/hast": {
+      "version": "3.0.4",
+      "resolved": "https://registry.npmjs.org/@types/hast/-/hast-3.0.4.tgz",
+      "integrity": "sha512-WPs+bbQw5aCj+x6laNGWLH3wviHtoCv/P3+otBhbOhJgG8qtpdAMlTCxLtsTWA7LH1Oh/bFCHsBn0TPS5m30EQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/unist": "*"
+      }
+    },
+    "node_modules/@types/mdast": {
+      "version": "4.0.4",
+      "resolved": "https://registry.npmjs.org/@types/mdast/-/mdast-4.0.4.tgz",
+      "integrity": "sha512-kGaNbPh1k7AFzgpud/gMdvIm5xuECykRR+JnWKQno9TAXVa6WIVCGTPvYGekIDL4uwCZQSYbUxNBSb1aUo79oA==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/unist": "*"
+      }
+    },
+    "node_modules/@types/ms": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/@types/ms/-/ms-2.1.0.tgz",
+      "integrity": "sha512-GsCCIZDE/p3i96vtEqx+7dBUGXrc7zeSK3wwPHIaRThS+9OhWIXRqzs4d6k1SVU8g91DrNRWxWUGhp5KXQb2VA==",
+      "license": "MIT"
+    },
     "node_modules/@types/node": {
       "version": "20.19.39",
       "resolved": "https://registry.npmjs.org/@types/node/-/node-20.19.39.tgz",
@@ -1168,6 +1221,12 @@
       "integrity": "sha512-ScaPdn1dQczgbl0QFTeTOmVHFULt394XJgOQNoyVhZ6r2vLnMLJfBPd53SB52T/3G36VI1/g2MZaX0cwDuXsfw==",
       "license": "MIT"
     },
+    "node_modules/@types/unist": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/@types/unist/-/unist-3.0.3.tgz",
+      "integrity": "sha512-ko/gIFJRv177XgZsZcBwnqJN5x/Gien8qNOn0D5bQU/zAzVf9Zt3BlcUiLqhV9y4ARk0GbT3tnUiPNgnTXzc/Q==",
+      "license": "MIT"
+    },
     "node_modules/@types/whatwg-mimetype": {
       "version": "3.0.2",
       "resolved": "https://registry.npmjs.org/@types/whatwg-mimetype/-/whatwg-mimetype-3.0.2.tgz",
@@ -1185,6 +1244,12 @@
         "@types/node": "*"
       }
     },
+    "node_modules/@ungap/structured-clone": {
+      "version": "1.3.2",
+      "resolved": "https://registry.npmjs.org/@ungap/structured-clone/-/structured-clone-1.3.2.tgz",
+      "integrity": "sha512-5jsZFwgR5rTdKwidH9Qmat75RKwqfpKlWWB1frDkljN127mwqBu8K0PYo7/hFpF03IEJpfVPpCQDY/eDx3iHvA==",
+      "license": "ISC"
+    },
     "node_modules/@vitest/expect": {
       "version": "4.1.5",
       "resolved": "https://registry.npmjs.org/@vitest/expect/-/expect-4.1.5.tgz",
@@ -1348,6 +1413,16 @@
         "node": ">= 0.4"
       }
     },
+    "node_modules/bail": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/bail/-/bail-2.0.2.tgz",
+      "integrity": "sha512-0xO6mYd7JB2YesxDKplafRpsiOzPt9V02ddPCLbY1xYGPOX24NTyN50qnUxgCPcSoYMhKpAuBTjQoRZCAkUDRw==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
     "node_modules/bits-ui": {
       "version": "2.18.1",
       "resolved": "https://registry.npmjs.org/bits-ui/-/bits-ui-2.18.1.tgz",
@@ -1372,6 +1447,16 @@
         "svelte": "^5.33.0"
       }
     },
+    "node_modules/ccount": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/ccount/-/ccount-2.0.1.tgz",
+      "integrity": "sha512-eyrF0jiFpY+3drT6383f1qhkbGsLSifNAjA61IUjZjmLCWjItY6LB9ft9YhoDgwfmclB2zhu51Lc7+95b8NRAg==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
     "node_modules/chai": {
       "version": "6.2.2",
       "resolved": "https://registry.npmjs.org/chai/-/chai-6.2.2.tgz",
@@ -1382,6 +1467,16 @@
         "node": ">=18"
       }
     },
+    "node_modules/character-entities": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/character-entities/-/character-entities-2.0.2.tgz",
+      "integrity": "sha512-shx7oQ0Awen/BRIdkjkvz54PnEEI/EjwXDSIZp86/KKdbafHh1Df/RYGBhn4hbe2+uKC9FnT5UCEdyPz3ai9hQ==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
     "node_modules/chokidar": {
       "version": "4.0.3",
       "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-4.0.3.tgz",
@@ -1626,6 +1721,36 @@
         "node": ">=12"
       }
     },
+    "node_modules/debug": {
+      "version": "4.4.3",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
+      "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==",
+      "license": "MIT",
+      "dependencies": {
+        "ms": "^2.1.3"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "peerDependenciesMeta": {
+        "supports-color": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/decode-named-character-reference": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/decode-named-character-reference/-/decode-named-character-reference-1.3.0.tgz",
+      "integrity": "sha512-GtpQYB283KrPp6nRw50q3U9/VfOutZOe103qlN7BPP6Ad27xYnOIWv4lPzo8HCAL+mMZofJ9KEy30fq6MfaK6Q==",
+      "license": "MIT",
+      "dependencies": {
+        "character-entities": "^2.0.0"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
     "node_modules/deepmerge": {
       "version": "4.3.1",
       "resolved": "https://registry.npmjs.org/deepmerge/-/deepmerge-4.3.1.tgz",
@@ -1659,6 +1784,19 @@
       "integrity": "sha512-2zA9pFEsnp7vWBZbXF5JAgAq0fsUIt/1XPbRiAmRV3lp/2C3upzH+sADiyy66aFCihoLEsrQHxNM5w1gIDfsBg==",
       "license": "MIT"
     },
+    "node_modules/devlop": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/devlop/-/devlop-1.1.0.tgz",
+      "integrity": "sha512-RWmIqhcFf1lRYBvNmr7qTNuyCt/7/ns2jbpp1+PalgE/rDQcBT0fioSMUpJ93irlUhC5hrg4cYqe6U+0ImW0rA==",
+      "license": "MIT",
+      "dependencies": {
+        "dequal": "^2.0.0"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
     "node_modules/dompurify": {
       "version": "3.4.2",
       "resolved": "https://registry.npmjs.org/dompurify/-/dompurify-3.4.2.tgz",
@@ -1698,6 +1836,18 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/escape-string-regexp": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-5.0.0.tgz",
+      "integrity": "sha512-/veY75JbMK4j1yjvuUxuVsiS/hr/4iHs9FTT6cgTexxdE0Ly/glccBAkloH/DofkjRbZU3bnoj38mOmhkZ0lHw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
     "node_modules/esm-env": {
       "version": "1.2.2",
       "resolved": "https://registry.npmjs.org/esm-env/-/esm-env-1.2.2.tgz",
@@ -1738,6 +1888,12 @@
         "node": ">=12.0.0"
       }
     },
+    "node_modules/extend": {
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/extend/-/extend-3.0.2.tgz",
+      "integrity": "sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g==",
+      "license": "MIT"
+    },
     "node_modules/fdir": {
       "version": "6.5.0",
       "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz",
@@ -1810,6 +1966,44 @@
         "node": ">= 0.4"
       }
     },
+    "node_modules/hast-util-is-element": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/hast-util-is-element/-/hast-util-is-element-3.0.0.tgz",
+      "integrity": "sha512-Val9mnv2IWpLbNPqc/pUem+a7Ipj2aHacCwgNfTiK0vJKl0LF+4Ba4+v1oPHFpf3bLYmreq0/l3Gud9S5OH42g==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/hast": "^3.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/hast-util-to-text": {
+      "version": "4.0.2",
+      "resolved": "https://registry.npmjs.org/hast-util-to-text/-/hast-util-to-text-4.0.2.tgz",
+      "integrity": "sha512-KK6y/BN8lbaq654j7JgBydev7wuNMcID54lkRav1P0CaE1e47P72AWWPiGKXTJU271ooYzcvTAn/Zt0REnvc7A==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/hast": "^3.0.0",
+        "@types/unist": "^3.0.0",
+        "hast-util-is-element": "^3.0.0",
+        "unist-util-find-after": "^5.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/highlight.js": {
+      "version": "11.11.1",
+      "resolved": "https://registry.npmjs.org/highlight.js/-/highlight.js-11.11.1.tgz",
+      "integrity": "sha512-Xwwo44whKBVCYoliBQwaPvtd/2tYFkRQtXDWj1nackaV2JPXx3L0+Jvd8/qCJ2p+ML0/XVkJ2q+Mr+UVdpJK5w==",
+      "license": "BSD-3-Clause",
+      "engines": {
+        "node": ">=12.0.0"
+      }
+    },
     "node_modules/inline-style-parser": {
       "version": "0.2.7",
       "resolved": "https://registry.npmjs.org/inline-style-parser/-/inline-style-parser-0.2.7.tgz",
@@ -1845,6 +2039,18 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/is-plain-obj": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/is-plain-obj/-/is-plain-obj-4.1.0.tgz",
+      "integrity": "sha512-+Pgi+vMuUNkJyExiMBt5IlFoMyKnr5zhJ4Uspz58WOhBF5QoIZkFyNHIbBAtHwzVAgk5RtndVNsDRN61/mmDqg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
     "node_modules/is-reference": {
       "version": "1.2.1",
       "resolved": "https://registry.npmjs.org/is-reference/-/is-reference-1.2.1.tgz",
@@ -2119,6 +2325,31 @@
       "integrity": "sha512-SW13ws7BjaeJ6p7Q6CO2nchbYEc3X3J6WrmTTDto7yMPqVSZTUyY5Tjbid+Ab8gLnATtygYtiDIJGQRRn2ZOiA==",
       "license": "MIT"
     },
+    "node_modules/longest-streak": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/longest-streak/-/longest-streak-3.1.0.tgz",
+      "integrity": "sha512-9Ri+o0JYgehTaVBBDoMqIl8GXtbWg711O3srftcHhZ0dqnETqLaoIK0x17fUw9rFSlK/0NlsKe0Ahhyl5pXE2g==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/lowlight": {
+      "version": "3.3.0",
+      "resolved": "https://registry.npmjs.org/lowlight/-/lowlight-3.3.0.tgz",
+      "integrity": "sha512-0JNhgFoPvP6U6lE/UdVsSq99tn6DhjjpAj5MxG49ewd2mOBVtwWYIT8ClyABhq198aXXODMU6Ox8DrGy/CpTZQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/hast": "^3.0.0",
+        "devlop": "^1.0.0",
+        "highlight.js": "~11.11.0"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
     "node_modules/lz-string": {
       "version": "1.5.0",
       "resolved": "https://registry.npmjs.org/lz-string/-/lz-string-1.5.0.tgz",
@@ -2137,6 +2368,16 @@
         "@jridgewell/sourcemap-codec": "^1.5.5"
       }
     },
+    "node_modules/markdown-table": {
+      "version": "3.0.4",
+      "resolved": "https://registry.npmjs.org/markdown-table/-/markdown-table-3.0.4.tgz",
+      "integrity": "sha512-wiYz4+JrLyb/DqW2hkFJxP7Vd7JuTDm77fvbM8VfEQdmSMqcImWeeRbHwZjBjIFki/VaMK2BhFi7oUUZeM5bqw==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
     "node_modules/marked": {
       "version": "18.0.3",
       "resolved": "https://registry.npmjs.org/marked/-/marked-18.0.3.tgz",
@@ -2149,135 +2390,997 @@
         "node": ">= 20"
       }
     },
-    "node_modules/mri": {
-      "version": "1.2.0",
-      "resolved": "https://registry.npmjs.org/mri/-/mri-1.2.0.tgz",
-      "integrity": "sha512-tzzskb3bG8LvYGFF/mDTpq3jpI6Q9wc3LEmBaghu+DdCssd1FakN7Bc0hVNmEyGq1bq3RgfkCb3cmQLpNPOroA==",
-      "dev": true,
+    "node_modules/mdast-util-find-and-replace": {
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/mdast-util-find-and-replace/-/mdast-util-find-and-replace-3.0.2.tgz",
+      "integrity": "sha512-Tmd1Vg/m3Xz43afeNxDIhWRtFZgM2VLyaf4vSTYwudTyeuTneoL3qtWMA5jeLyz/O1vDJmmV4QuScFCA2tBPwg==",
       "license": "MIT",
-      "engines": {
-        "node": ">=4"
+      "dependencies": {
+        "@types/mdast": "^4.0.0",
+        "escape-string-regexp": "^5.0.0",
+        "unist-util-is": "^6.0.0",
+        "unist-util-visit-parents": "^6.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
       }
     },
-    "node_modules/mrmime": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/mrmime/-/mrmime-2.0.1.tgz",
-      "integrity": "sha512-Y3wQdFg2Va6etvQ5I82yUhGdsKrcYox6p7FfL1LbK2J4V01F9TGlepTIhnK24t7koZibmg82KGglhA1XK5IsLQ==",
+    "node_modules/mdast-util-from-markdown": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/mdast-util-from-markdown/-/mdast-util-from-markdown-2.0.3.tgz",
+      "integrity": "sha512-W4mAWTvSlKvf8L6J+VN9yLSqQ9AOAAvHuoDAmPkz4dHf553m5gVj2ejadHJhoJmcmxEnOv6Pa8XJhpxE93kb8Q==",
       "license": "MIT",
-      "engines": {
-        "node": ">=10"
+      "dependencies": {
+        "@types/mdast": "^4.0.0",
+        "@types/unist": "^3.0.0",
+        "decode-named-character-reference": "^1.0.0",
+        "devlop": "^1.0.0",
+        "mdast-util-to-string": "^4.0.0",
+        "micromark": "^4.0.0",
+        "micromark-util-decode-numeric-character-reference": "^2.0.0",
+        "micromark-util-decode-string": "^2.0.0",
+        "micromark-util-normalize-identifier": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0",
+        "unist-util-stringify-position": "^4.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
       }
     },
-    "node_modules/nanoid": {
-      "version": "3.3.12",
-      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.12.tgz",
-      "integrity": "sha512-ZB9RH/39qpq5Vu6Y+NmUaFhQR6pp+M2Xt76XBnEwDaGcVAqhlvxrl3B2bKS5D3NH3QR76v3aSrKaF/Kiy7lEtQ==",
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/ai"
-        }
-      ],
+    "node_modules/mdast-util-gfm": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/mdast-util-gfm/-/mdast-util-gfm-3.1.0.tgz",
+      "integrity": "sha512-0ulfdQOM3ysHhCJ1p06l0b0VKlhU0wuQs3thxZQagjcjPrlFRqY215uZGHHJan9GEAXd9MbfPjFJz+qMkVR6zQ==",
       "license": "MIT",
-      "bin": {
-        "nanoid": "bin/nanoid.cjs"
+      "dependencies": {
+        "mdast-util-from-markdown": "^2.0.0",
+        "mdast-util-gfm-autolink-literal": "^2.0.0",
+        "mdast-util-gfm-footnote": "^2.0.0",
+        "mdast-util-gfm-strikethrough": "^2.0.0",
+        "mdast-util-gfm-table": "^2.0.0",
+        "mdast-util-gfm-task-list-item": "^2.0.0",
+        "mdast-util-to-markdown": "^2.0.0"
       },
-      "engines": {
-        "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1"
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
       }
     },
-    "node_modules/obug": {
-      "version": "2.1.1",
-      "resolved": "https://registry.npmjs.org/obug/-/obug-2.1.1.tgz",
-      "integrity": "sha512-uTqF9MuPraAQ+IsnPf366RG4cP9RtUi7MLO1N3KEc+wb0a6yKpeL0lmk2IB1jY5KHPAlTc6T/JRdC/YqxHNwkQ==",
-      "funding": [
-        "https://github.com/sponsors/sxzz",
-        "https://opencollective.com/debug"
-      ],
-      "license": "MIT"
-    },
-    "node_modules/path-parse": {
-      "version": "1.0.7",
-      "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.7.tgz",
-      "integrity": "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/pathe": {
-      "version": "2.0.3",
-      "resolved": "https://registry.npmjs.org/pathe/-/pathe-2.0.3.tgz",
-      "integrity": "sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/picocolors": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
-      "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==",
-      "license": "ISC"
-    },
-    "node_modules/picomatch": {
-      "version": "4.0.4",
-      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.4.tgz",
-      "integrity": "sha512-QP88BAKvMam/3NxH6vj2o21R6MjxZUAd6nlwAS/pnGvN9IVLocLHxGYIzFhg6fUQ+5th6P4dv4eW9jX3DSIj7A==",
+    "node_modules/mdast-util-gfm-autolink-literal": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/mdast-util-gfm-autolink-literal/-/mdast-util-gfm-autolink-literal-2.0.1.tgz",
+      "integrity": "sha512-5HVP2MKaP6L+G6YaxPNjuL0BPrq9orG3TsrZ9YXbA3vDw/ACI4MEsnoDpn6ZNm7GnZgtAcONJyPhOP8tNJQavQ==",
       "license": "MIT",
-      "engines": {
-        "node": ">=12"
+      "dependencies": {
+        "@types/mdast": "^4.0.0",
+        "ccount": "^2.0.0",
+        "devlop": "^1.0.0",
+        "mdast-util-find-and-replace": "^3.0.0",
+        "micromark-util-character": "^2.0.0"
       },
       "funding": {
-        "url": "https://github.com/sponsors/jonschlinkert"
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
       }
     },
-    "node_modules/postcss": {
-      "version": "8.5.13",
-      "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.13.tgz",
-      "integrity": "sha512-qif0+jGGZoLWdHey3UFHHWP0H7Gbmsk8T5VEqyYFbWqPr1XqvLGBbk/sl8V5exGmcYJklJOhOQq1pV9IcsiFag==",
-      "funding": [
-        {
-          "type": "opencollective",
-          "url": "https://opencollective.com/postcss/"
-        },
-        {
-          "type": "tidelift",
-          "url": "https://tidelift.com/funding/github/npm/postcss"
-        },
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/ai"
-        }
-      ],
+    "node_modules/mdast-util-gfm-footnote": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/mdast-util-gfm-footnote/-/mdast-util-gfm-footnote-2.1.0.tgz",
+      "integrity": "sha512-sqpDWlsHn7Ac9GNZQMeUzPQSMzR6Wv0WKRNvQRg0KqHh02fpTz69Qc1QSseNX29bhz1ROIyNyxExfawVKTm1GQ==",
       "license": "MIT",
       "dependencies": {
-        "nanoid": "^3.3.11",
-        "picocolors": "^1.1.1",
-        "source-map-js": "^1.2.1"
+        "@types/mdast": "^4.0.0",
+        "devlop": "^1.1.0",
+        "mdast-util-from-markdown": "^2.0.0",
+        "mdast-util-to-markdown": "^2.0.0",
+        "micromark-util-normalize-identifier": "^2.0.0"
       },
-      "engines": {
-        "node": "^10 || ^12 || >=14"
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
       }
     },
-    "node_modules/readdirp": {
-      "version": "4.1.2",
-      "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-4.1.2.tgz",
-      "integrity": "sha512-GDhwkLfywWL2s6vEjyhri+eXmfH6j1L7JE27WhqLeYzoh/A3DBaYGEj2H/HFZCn/kMfim73FXxEJTw06WtxQwg==",
-      "dev": true,
+    "node_modules/mdast-util-gfm-strikethrough": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/mdast-util-gfm-strikethrough/-/mdast-util-gfm-strikethrough-2.0.0.tgz",
+      "integrity": "sha512-mKKb915TF+OC5ptj5bJ7WFRPdYtuHv0yTRxK2tJvi+BDqbkiG7h7u/9SI89nRAYcmap2xHQL9D+QG/6wSrTtXg==",
       "license": "MIT",
-      "engines": {
-        "node": ">= 14.18.0"
+      "dependencies": {
+        "@types/mdast": "^4.0.0",
+        "mdast-util-from-markdown": "^2.0.0",
+        "mdast-util-to-markdown": "^2.0.0"
       },
       "funding": {
-        "type": "individual",
-        "url": "https://paulmillr.com/funding/"
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
       }
     },
-    "node_modules/resolve": {
-      "version": "1.22.12",
-      "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.22.12.tgz",
-      "integrity": "sha512-TyeJ1zif53BPfHootBGwPRYT1RUt6oGWsaQr8UyZW/eAm9bKoijtvruSDEmZHm92CwS9nj7/fWttqPCgzep8CA==",
-      "dev": true,
+    "node_modules/mdast-util-gfm-table": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/mdast-util-gfm-table/-/mdast-util-gfm-table-2.0.0.tgz",
+      "integrity": "sha512-78UEvebzz/rJIxLvE7ZtDd/vIQ0RHv+3Mh5DR96p7cS7HsBhYIICDBCu8csTNWNO6tBWfqXPWekRuj2FNOGOZg==",
       "license": "MIT",
       "dependencies": {
-        "es-errors": "^1.3.0",
+        "@types/mdast": "^4.0.0",
+        "devlop": "^1.0.0",
+        "markdown-table": "^3.0.0",
+        "mdast-util-from-markdown": "^2.0.0",
+        "mdast-util-to-markdown": "^2.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/mdast-util-gfm-task-list-item": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/mdast-util-gfm-task-list-item/-/mdast-util-gfm-task-list-item-2.0.0.tgz",
+      "integrity": "sha512-IrtvNvjxC1o06taBAVJznEnkiHxLFTzgonUdy8hzFVeDun0uTjxxrRGVaNFqkU1wJR3RBPEfsxmU6jDWPofrTQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/mdast": "^4.0.0",
+        "devlop": "^1.0.0",
+        "mdast-util-from-markdown": "^2.0.0",
+        "mdast-util-to-markdown": "^2.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/mdast-util-phrasing": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/mdast-util-phrasing/-/mdast-util-phrasing-4.1.0.tgz",
+      "integrity": "sha512-TqICwyvJJpBwvGAMZjj4J2n0X8QWp21b9l0o7eXyVJ25YNWYbJDVIyD1bZXE6WtV6RmKJVYmQAKWa0zWOABz2w==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/mdast": "^4.0.0",
+        "unist-util-is": "^6.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/mdast-util-to-hast": {
+      "version": "13.2.1",
+      "resolved": "https://registry.npmjs.org/mdast-util-to-hast/-/mdast-util-to-hast-13.2.1.tgz",
+      "integrity": "sha512-cctsq2wp5vTsLIcaymblUriiTcZd0CwWtCbLvrOzYCDZoWyMNV8sZ7krj09FSnsiJi3WVsHLM4k6Dq/yaPyCXA==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/hast": "^3.0.0",
+        "@types/mdast": "^4.0.0",
+        "@ungap/structured-clone": "^1.0.0",
+        "devlop": "^1.0.0",
+        "micromark-util-sanitize-uri": "^2.0.0",
+        "trim-lines": "^3.0.0",
+        "unist-util-position": "^5.0.0",
+        "unist-util-visit": "^5.0.0",
+        "vfile": "^6.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/mdast-util-to-markdown": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/mdast-util-to-markdown/-/mdast-util-to-markdown-2.1.2.tgz",
+      "integrity": "sha512-xj68wMTvGXVOKonmog6LwyJKrYXZPvlwabaryTjLh9LuvovB/KAH+kvi8Gjj+7rJjsFi23nkUxRQv1KqSroMqA==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/mdast": "^4.0.0",
+        "@types/unist": "^3.0.0",
+        "longest-streak": "^3.0.0",
+        "mdast-util-phrasing": "^4.0.0",
+        "mdast-util-to-string": "^4.0.0",
+        "micromark-util-classify-character": "^2.0.0",
+        "micromark-util-decode-string": "^2.0.0",
+        "unist-util-visit": "^5.0.0",
+        "zwitch": "^2.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/mdast-util-to-string": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/mdast-util-to-string/-/mdast-util-to-string-4.0.0.tgz",
+      "integrity": "sha512-0H44vDimn51F0YwvxSJSm0eCDOJTRlmN0R1yBh4HLj9wiV1Dn0QoXGbvFAWj2hSItVTlCmBF1hqKlIyUBVFLPg==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/mdast": "^4.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/micromark": {
+      "version": "4.0.2",
+      "resolved": "https://registry.npmjs.org/micromark/-/micromark-4.0.2.tgz",
+      "integrity": "sha512-zpe98Q6kvavpCr1NPVSCMebCKfD7CA2NqZ+rykeNhONIJBpc1tFKt9hucLGwha3jNTNI8lHpctWJWoimVF4PfA==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "@types/debug": "^4.0.0",
+        "debug": "^4.0.0",
+        "decode-named-character-reference": "^1.0.0",
+        "devlop": "^1.0.0",
+        "micromark-core-commonmark": "^2.0.0",
+        "micromark-factory-space": "^2.0.0",
+        "micromark-util-character": "^2.0.0",
+        "micromark-util-chunked": "^2.0.0",
+        "micromark-util-combine-extensions": "^2.0.0",
+        "micromark-util-decode-numeric-character-reference": "^2.0.0",
+        "micromark-util-encode": "^2.0.0",
+        "micromark-util-normalize-identifier": "^2.0.0",
+        "micromark-util-resolve-all": "^2.0.0",
+        "micromark-util-sanitize-uri": "^2.0.0",
+        "micromark-util-subtokenize": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      }
+    },
+    "node_modules/micromark-core-commonmark": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/micromark-core-commonmark/-/micromark-core-commonmark-2.0.3.tgz",
+      "integrity": "sha512-RDBrHEMSxVFLg6xvnXmb1Ayr2WzLAWjeSATAoxwKYJV94TeNavgoIdA0a9ytzDSVzBy2YKFK+emCPOEibLeCrg==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "decode-named-character-reference": "^1.0.0",
+        "devlop": "^1.0.0",
+        "micromark-factory-destination": "^2.0.0",
+        "micromark-factory-label": "^2.0.0",
+        "micromark-factory-space": "^2.0.0",
+        "micromark-factory-title": "^2.0.0",
+        "micromark-factory-whitespace": "^2.0.0",
+        "micromark-util-character": "^2.0.0",
+        "micromark-util-chunked": "^2.0.0",
+        "micromark-util-classify-character": "^2.0.0",
+        "micromark-util-html-tag-name": "^2.0.0",
+        "micromark-util-normalize-identifier": "^2.0.0",
+        "micromark-util-resolve-all": "^2.0.0",
+        "micromark-util-subtokenize": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      }
+    },
+    "node_modules/micromark-extension-gfm": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/micromark-extension-gfm/-/micromark-extension-gfm-3.0.0.tgz",
+      "integrity": "sha512-vsKArQsicm7t0z2GugkCKtZehqUm31oeGBV/KVSorWSy8ZlNAv7ytjFhvaryUiCUJYqs+NoE6AFhpQvBTM6Q4w==",
+      "license": "MIT",
+      "dependencies": {
+        "micromark-extension-gfm-autolink-literal": "^2.0.0",
+        "micromark-extension-gfm-footnote": "^2.0.0",
+        "micromark-extension-gfm-strikethrough": "^2.0.0",
+        "micromark-extension-gfm-table": "^2.0.0",
+        "micromark-extension-gfm-tagfilter": "^2.0.0",
+        "micromark-extension-gfm-task-list-item": "^2.0.0",
+        "micromark-util-combine-extensions": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/micromark-extension-gfm-autolink-literal": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/micromark-extension-gfm-autolink-literal/-/micromark-extension-gfm-autolink-literal-2.1.0.tgz",
+      "integrity": "sha512-oOg7knzhicgQ3t4QCjCWgTmfNhvQbDDnJeVu9v81r7NltNCVmhPy1fJRX27pISafdjL+SVc4d3l48Gb6pbRypw==",
+      "license": "MIT",
+      "dependencies": {
+        "micromark-util-character": "^2.0.0",
+        "micromark-util-sanitize-uri": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/micromark-extension-gfm-footnote": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/micromark-extension-gfm-footnote/-/micromark-extension-gfm-footnote-2.1.0.tgz",
+      "integrity": "sha512-/yPhxI1ntnDNsiHtzLKYnE3vf9JZ6cAisqVDauhp4CEHxlb4uoOTxOCJ+9s51bIB8U1N1FJ1RXOKTIlD5B/gqw==",
+      "license": "MIT",
+      "dependencies": {
+        "devlop": "^1.0.0",
+        "micromark-core-commonmark": "^2.0.0",
+        "micromark-factory-space": "^2.0.0",
+        "micromark-util-character": "^2.0.0",
+        "micromark-util-normalize-identifier": "^2.0.0",
+        "micromark-util-sanitize-uri": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/micromark-extension-gfm-strikethrough": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/micromark-extension-gfm-strikethrough/-/micromark-extension-gfm-strikethrough-2.1.0.tgz",
+      "integrity": "sha512-ADVjpOOkjz1hhkZLlBiYA9cR2Anf8F4HqZUO6e5eDcPQd0Txw5fxLzzxnEkSkfnD0wziSGiv7sYhk/ktvbf1uw==",
+      "license": "MIT",
+      "dependencies": {
+        "devlop": "^1.0.0",
+        "micromark-util-chunked": "^2.0.0",
+        "micromark-util-classify-character": "^2.0.0",
+        "micromark-util-resolve-all": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/micromark-extension-gfm-table": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/micromark-extension-gfm-table/-/micromark-extension-gfm-table-2.1.1.tgz",
+      "integrity": "sha512-t2OU/dXXioARrC6yWfJ4hqB7rct14e8f7m0cbI5hUmDyyIlwv5vEtooptH8INkbLzOatzKuVbQmAYcbWoyz6Dg==",
+      "license": "MIT",
+      "dependencies": {
+        "devlop": "^1.0.0",
+        "micromark-factory-space": "^2.0.0",
+        "micromark-util-character": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/micromark-extension-gfm-tagfilter": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/micromark-extension-gfm-tagfilter/-/micromark-extension-gfm-tagfilter-2.0.0.tgz",
+      "integrity": "sha512-xHlTOmuCSotIA8TW1mDIM6X2O1SiX5P9IuDtqGonFhEK0qgRI4yeC6vMxEV2dgyr2TiD+2PQ10o+cOhdVAcwfg==",
+      "license": "MIT",
+      "dependencies": {
+        "micromark-util-types": "^2.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/micromark-extension-gfm-task-list-item": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/micromark-extension-gfm-task-list-item/-/micromark-extension-gfm-task-list-item-2.1.0.tgz",
+      "integrity": "sha512-qIBZhqxqI6fjLDYFTBIa4eivDMnP+OZqsNwmQ3xNLE4Cxwc+zfQEfbs6tzAo2Hjq+bh6q5F+Z8/cksrLFYWQQw==",
+      "license": "MIT",
+      "dependencies": {
+        "devlop": "^1.0.0",
+        "micromark-factory-space": "^2.0.0",
+        "micromark-util-character": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/micromark-factory-destination": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/micromark-factory-destination/-/micromark-factory-destination-2.0.1.tgz",
+      "integrity": "sha512-Xe6rDdJlkmbFRExpTOmRj9N3MaWmbAgdpSrBQvCFqhezUn4AHqJHbaEnfbVYYiexVSs//tqOdY/DxhjdCiJnIA==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "micromark-util-character": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      }
+    },
+    "node_modules/micromark-factory-label": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/micromark-factory-label/-/micromark-factory-label-2.0.1.tgz",
+      "integrity": "sha512-VFMekyQExqIW7xIChcXn4ok29YE3rnuyveW3wZQWWqF4Nv9Wk5rgJ99KzPvHjkmPXF93FXIbBp6YdW3t71/7Vg==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "devlop": "^1.0.0",
+        "micromark-util-character": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      }
+    },
+    "node_modules/micromark-factory-space": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/micromark-factory-space/-/micromark-factory-space-2.0.1.tgz",
+      "integrity": "sha512-zRkxjtBxxLd2Sc0d+fbnEunsTj46SWXgXciZmHq0kDYGnck/ZSGj9/wULTV95uoeYiK5hRXP2mJ98Uo4cq/LQg==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "micromark-util-character": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      }
+    },
+    "node_modules/micromark-factory-title": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/micromark-factory-title/-/micromark-factory-title-2.0.1.tgz",
+      "integrity": "sha512-5bZ+3CjhAd9eChYTHsjy6TGxpOFSKgKKJPJxr293jTbfry2KDoWkhBb6TcPVB4NmzaPhMs1Frm9AZH7OD4Cjzw==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "micromark-factory-space": "^2.0.0",
+        "micromark-util-character": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      }
+    },
+    "node_modules/micromark-factory-whitespace": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/micromark-factory-whitespace/-/micromark-factory-whitespace-2.0.1.tgz",
+      "integrity": "sha512-Ob0nuZ3PKt/n0hORHyvoD9uZhr+Za8sFoP+OnMcnWK5lngSzALgQYKMr9RJVOWLqQYuyn6ulqGWSXdwf6F80lQ==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "micromark-factory-space": "^2.0.0",
+        "micromark-util-character": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      }
+    },
+    "node_modules/micromark-util-character": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/micromark-util-character/-/micromark-util-character-2.1.1.tgz",
+      "integrity": "sha512-wv8tdUTJ3thSFFFJKtpYKOYiGP2+v96Hvk4Tu8KpCAsTMs6yi+nVmGh1syvSCsaxz45J6Jbw+9DD6g97+NV67Q==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      }
+    },
+    "node_modules/micromark-util-chunked": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/micromark-util-chunked/-/micromark-util-chunked-2.0.1.tgz",
+      "integrity": "sha512-QUNFEOPELfmvv+4xiNg2sRYeS/P84pTW0TCgP5zc9FpXetHY0ab7SxKyAQCNCc1eK0459uoLI1y5oO5Vc1dbhA==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "micromark-util-symbol": "^2.0.0"
+      }
+    },
+    "node_modules/micromark-util-classify-character": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/micromark-util-classify-character/-/micromark-util-classify-character-2.0.1.tgz",
+      "integrity": "sha512-K0kHzM6afW/MbeWYWLjoHQv1sgg2Q9EccHEDzSkxiP/EaagNzCm7T/WMKZ3rjMbvIpvBiZgwR3dKMygtA4mG1Q==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "micromark-util-character": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      }
+    },
+    "node_modules/micromark-util-combine-extensions": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/micromark-util-combine-extensions/-/micromark-util-combine-extensions-2.0.1.tgz",
+      "integrity": "sha512-OnAnH8Ujmy59JcyZw8JSbK9cGpdVY44NKgSM7E9Eh7DiLS2E9RNQf0dONaGDzEG9yjEl5hcqeIsj4hfRkLH/Bg==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "micromark-util-chunked": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      }
+    },
+    "node_modules/micromark-util-decode-numeric-character-reference": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/micromark-util-decode-numeric-character-reference/-/micromark-util-decode-numeric-character-reference-2.0.2.tgz",
+      "integrity": "sha512-ccUbYk6CwVdkmCQMyr64dXz42EfHGkPQlBj5p7YVGzq8I7CtjXZJrubAYezf7Rp+bjPseiROqe7G6foFd+lEuw==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "micromark-util-symbol": "^2.0.0"
+      }
+    },
+    "node_modules/micromark-util-decode-string": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/micromark-util-decode-string/-/micromark-util-decode-string-2.0.1.tgz",
+      "integrity": "sha512-nDV/77Fj6eH1ynwscYTOsbK7rR//Uj0bZXBwJZRfaLEJ1iGBR6kIfNmlNqaqJf649EP0F3NWNdeJi03elllNUQ==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "decode-named-character-reference": "^1.0.0",
+        "micromark-util-character": "^2.0.0",
+        "micromark-util-decode-numeric-character-reference": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0"
+      }
+    },
+    "node_modules/micromark-util-encode": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/micromark-util-encode/-/micromark-util-encode-2.0.1.tgz",
+      "integrity": "sha512-c3cVx2y4KqUnwopcO9b/SCdo2O67LwJJ/UyqGfbigahfegL9myoEFoDYZgkT7f36T0bLrM9hZTAaAyH+PCAXjw==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT"
+    },
+    "node_modules/micromark-util-html-tag-name": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/micromark-util-html-tag-name/-/micromark-util-html-tag-name-2.0.1.tgz",
+      "integrity": "sha512-2cNEiYDhCWKI+Gs9T0Tiysk136SnR13hhO8yW6BGNyhOC4qYFnwF1nKfD3HFAIXA5c45RrIG1ub11GiXeYd1xA==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT"
+    },
+    "node_modules/micromark-util-normalize-identifier": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/micromark-util-normalize-identifier/-/micromark-util-normalize-identifier-2.0.1.tgz",
+      "integrity": "sha512-sxPqmo70LyARJs0w2UclACPUUEqltCkJ6PhKdMIDuJ3gSf/Q+/GIe3WKl0Ijb/GyH9lOpUkRAO2wp0GVkLvS9Q==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "micromark-util-symbol": "^2.0.0"
+      }
+    },
+    "node_modules/micromark-util-resolve-all": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/micromark-util-resolve-all/-/micromark-util-resolve-all-2.0.1.tgz",
+      "integrity": "sha512-VdQyxFWFT2/FGJgwQnJYbe1jjQoNTS4RjglmSjTUlpUMa95Htx9NHeYW4rGDJzbjvCsl9eLjMQwGeElsqmzcHg==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "micromark-util-types": "^2.0.0"
+      }
+    },
+    "node_modules/micromark-util-sanitize-uri": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/micromark-util-sanitize-uri/-/micromark-util-sanitize-uri-2.0.1.tgz",
+      "integrity": "sha512-9N9IomZ/YuGGZZmQec1MbgxtlgougxTodVwDzzEouPKo3qFWvymFHWcnDi2vzV1ff6kas9ucW+o3yzJK9YB1AQ==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "micromark-util-character": "^2.0.0",
+        "micromark-util-encode": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0"
+      }
+    },
+    "node_modules/micromark-util-subtokenize": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/micromark-util-subtokenize/-/micromark-util-subtokenize-2.1.0.tgz",
+      "integrity": "sha512-XQLu552iSctvnEcgXw6+Sx75GflAPNED1qx7eBJ+wydBb2KCbRZe+NwvIEEMM83uml1+2WSXpBAcp9IUCgCYWA==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "devlop": "^1.0.0",
+        "micromark-util-chunked": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      }
+    },
+    "node_modules/micromark-util-symbol": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/micromark-util-symbol/-/micromark-util-symbol-2.0.1.tgz",
+      "integrity": "sha512-vs5t8Apaud9N28kgCrRUdEed4UJ+wWNvicHLPxCa9ENlYuAY31M0ETy5y1vA33YoNPDFTghEbnh6efaE8h4x0Q==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT"
+    },
+    "node_modules/micromark-util-types": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/micromark-util-types/-/micromark-util-types-2.0.2.tgz",
+      "integrity": "sha512-Yw0ECSpJoViF1qTU4DC6NwtC4aWGt1EkzaQB8KPPyCRR8z9TWeV0HbEFGTO+ZY1wB22zmxnJqhPyTpOVCpeHTA==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT"
+    },
+    "node_modules/mri": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/mri/-/mri-1.2.0.tgz",
+      "integrity": "sha512-tzzskb3bG8LvYGFF/mDTpq3jpI6Q9wc3LEmBaghu+DdCssd1FakN7Bc0hVNmEyGq1bq3RgfkCb3cmQLpNPOroA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/mrmime": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/mrmime/-/mrmime-2.0.1.tgz",
+      "integrity": "sha512-Y3wQdFg2Va6etvQ5I82yUhGdsKrcYox6p7FfL1LbK2J4V01F9TGlepTIhnK24t7koZibmg82KGglhA1XK5IsLQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/ms": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+      "license": "MIT"
+    },
+    "node_modules/nanoid": {
+      "version": "3.3.12",
+      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.12.tgz",
+      "integrity": "sha512-ZB9RH/39qpq5Vu6Y+NmUaFhQR6pp+M2Xt76XBnEwDaGcVAqhlvxrl3B2bKS5D3NH3QR76v3aSrKaF/Kiy7lEtQ==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "bin": {
+        "nanoid": "bin/nanoid.cjs"
+      },
+      "engines": {
+        "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1"
+      }
+    },
+    "node_modules/obug": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/obug/-/obug-2.1.1.tgz",
+      "integrity": "sha512-uTqF9MuPraAQ+IsnPf366RG4cP9RtUi7MLO1N3KEc+wb0a6yKpeL0lmk2IB1jY5KHPAlTc6T/JRdC/YqxHNwkQ==",
+      "funding": [
+        "https://github.com/sponsors/sxzz",
+        "https://opencollective.com/debug"
+      ],
+      "license": "MIT"
+    },
+    "node_modules/path-parse": {
+      "version": "1.0.7",
+      "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.7.tgz",
+      "integrity": "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/pathe": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/pathe/-/pathe-2.0.3.tgz",
+      "integrity": "sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/picocolors": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
+      "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==",
+      "license": "ISC"
+    },
+    "node_modules/picomatch": {
+      "version": "4.0.4",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.4.tgz",
+      "integrity": "sha512-QP88BAKvMam/3NxH6vj2o21R6MjxZUAd6nlwAS/pnGvN9IVLocLHxGYIzFhg6fUQ+5th6P4dv4eW9jX3DSIj7A==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/jonschlinkert"
+      }
+    },
+    "node_modules/postcss": {
+      "version": "8.5.13",
+      "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.13.tgz",
+      "integrity": "sha512-qif0+jGGZoLWdHey3UFHHWP0H7Gbmsk8T5VEqyYFbWqPr1XqvLGBbk/sl8V5exGmcYJklJOhOQq1pV9IcsiFag==",
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/postcss/"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/postcss"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "nanoid": "^3.3.11",
+        "picocolors": "^1.1.1",
+        "source-map-js": "^1.2.1"
+      },
+      "engines": {
+        "node": "^10 || ^12 || >=14"
+      }
+    },
+    "node_modules/readdirp": {
+      "version": "4.1.2",
+      "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-4.1.2.tgz",
+      "integrity": "sha512-GDhwkLfywWL2s6vEjyhri+eXmfH6j1L7JE27WhqLeYzoh/A3DBaYGEj2H/HFZCn/kMfim73FXxEJTw06WtxQwg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 14.18.0"
+      },
+      "funding": {
+        "type": "individual",
+        "url": "https://paulmillr.com/funding/"
+      }
+    },
+    "node_modules/rehype-highlight": {
+      "version": "7.0.2",
+      "resolved": "https://registry.npmjs.org/rehype-highlight/-/rehype-highlight-7.0.2.tgz",
+      "integrity": "sha512-k158pK7wdC2qL3M5NcZROZ2tR/l7zOzjxXd5VGdcfIyoijjQqpHd3JKtYSBDpDZ38UI2WJWuFAtkMDxmx5kstA==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/hast": "^3.0.0",
+        "hast-util-to-text": "^4.0.0",
+        "lowlight": "^3.0.0",
+        "unist-util-visit": "^5.0.0",
+        "vfile": "^6.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-gfm": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/remark-gfm/-/remark-gfm-4.0.1.tgz",
+      "integrity": "sha512-1quofZ2RQ9EWdeN34S79+KExV1764+wCUGop5CPL1WGdD0ocPpu91lzPGbwWMECpEpd42kJGQwzRfyov9j4yNg==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/mdast": "^4.0.0",
+        "mdast-util-gfm": "^3.0.0",
+        "micromark-extension-gfm": "^3.0.0",
+        "remark-parse": "^11.0.0",
+        "remark-stringify": "^11.0.0",
+        "unified": "^11.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-parse": {
+      "version": "11.0.0",
+      "resolved": "https://registry.npmjs.org/remark-parse/-/remark-parse-11.0.0.tgz",
+      "integrity": "sha512-FCxlKLNGknS5ba/1lmpYijMUzX2esxW5xQqjWxw2eHFfS2MSdaHVINFmhjo+qN1WhZhNimq0dZATN9pH0IDrpA==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/mdast": "^4.0.0",
+        "mdast-util-from-markdown": "^2.0.0",
+        "micromark-util-types": "^2.0.0",
+        "unified": "^11.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-rehype": {
+      "version": "11.1.2",
+      "resolved": "https://registry.npmjs.org/remark-rehype/-/remark-rehype-11.1.2.tgz",
+      "integrity": "sha512-Dh7l57ianaEoIpzbp0PC9UKAdCSVklD8E5Rpw7ETfbTl3FqcOOgq5q2LVDhgGCkaBv7p24JXikPdvhhmHvKMsw==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/hast": "^3.0.0",
+        "@types/mdast": "^4.0.0",
+        "mdast-util-to-hast": "^13.0.0",
+        "unified": "^11.0.0",
+        "vfile": "^6.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-stringify": {
+      "version": "11.0.0",
+      "resolved": "https://registry.npmjs.org/remark-stringify/-/remark-stringify-11.0.0.tgz",
+      "integrity": "sha512-1OSmLd3awB/t8qdoEOMazZkNsfVTeY4fTsgzcQFdXNq8ToTN4ZGwrMnlda4K6smTFKD+GRV6O48i6Z4iKgPPpw==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/mdast": "^4.0.0",
+        "mdast-util-to-markdown": "^2.0.0",
+        "unified": "^11.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/resolve": {
+      "version": "1.22.12",
+      "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.22.12.tgz",
+      "integrity": "sha512-TyeJ1zif53BPfHootBGwPRYT1RUt6oGWsaQr8UyZW/eAm9bKoijtvruSDEmZHm92CwS9nj7/fWttqPCgzep8CA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "es-errors": "^1.3.0",
         "is-core-module": "^2.16.1",
         "path-parse": "^1.0.7",
         "supports-preserve-symlinks-flag": "^1.0.0"
@@ -2530,6 +3633,21 @@
         "typescript": ">=5.0.0"
       }
     },
+    "node_modules/svelte-exmarkdown": {
+      "version": "5.0.2",
+      "resolved": "https://registry.npmjs.org/svelte-exmarkdown/-/svelte-exmarkdown-5.0.2.tgz",
+      "integrity": "sha512-/GhWbh0TBd7OPsL6IhQZm4BVuglP5MP4lVwBDnIF8IYfmHfwfY0z/nu78L8FDwJM2pP+DW8045g+jUhM357U1w==",
+      "license": "MIT",
+      "dependencies": {
+        "remark-gfm": "^4.0.1",
+        "remark-parse": "^11.0.0",
+        "remark-rehype": "^11.1.2",
+        "unified": "^11.0.5"
+      },
+      "peerDependencies": {
+        "svelte": "^5.1.3"
+      }
+    },
     "node_modules/svelte-sonner": {
       "version": "1.1.1",
       "resolved": "https://registry.npmjs.org/svelte-sonner/-/svelte-sonner-1.1.1.tgz",
@@ -2645,6 +3763,26 @@
         "node": ">=6"
       }
     },
+    "node_modules/trim-lines": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/trim-lines/-/trim-lines-3.0.1.tgz",
+      "integrity": "sha512-kRj8B+YHZCc9kQYdWfJB2/oUl9rA99qbowYYBtr4ui4mZyAQ2JpvVBd/6U2YloATfqBhBTSMhTpgBHtU0Mf3Rg==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/trough": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/trough/-/trough-2.2.0.tgz",
+      "integrity": "sha512-tmMpK00BjZiUyVyvrBK7knerNgmgvcV/KLVyuma/SC+TQN167GrMRciANTz09+k3zW8L8t60jWO1GpfkZdjTaw==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
     "node_modules/tslib": {
       "version": "2.8.1",
       "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
@@ -2672,6 +3810,135 @@
       "devOptional": true,
       "license": "MIT"
     },
+    "node_modules/unified": {
+      "version": "11.0.5",
+      "resolved": "https://registry.npmjs.org/unified/-/unified-11.0.5.tgz",
+      "integrity": "sha512-xKvGhPWw3k84Qjh8bI3ZeJjqnyadK+GEFtazSfZv/rKeTkTjOJho6mFqh2SM96iIcZokxiOpg78GazTSg8+KHA==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/unist": "^3.0.0",
+        "bail": "^2.0.0",
+        "devlop": "^1.0.0",
+        "extend": "^3.0.0",
+        "is-plain-obj": "^4.0.0",
+        "trough": "^2.0.0",
+        "vfile": "^6.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/unist-util-find-after": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/unist-util-find-after/-/unist-util-find-after-5.0.0.tgz",
+      "integrity": "sha512-amQa0Ep2m6hE2g72AugUItjbuM8X8cGQnFoHk0pGfrFeT9GZhzN5SW8nRsiGKK7Aif4CrACPENkA6P/Lw6fHGQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/unist": "^3.0.0",
+        "unist-util-is": "^6.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/unist-util-is": {
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-6.0.1.tgz",
+      "integrity": "sha512-LsiILbtBETkDz8I9p1dQ0uyRUWuaQzd/cuEeS1hoRSyW5E5XGmTzlwY1OrNzzakGowI9Dr/I8HVaw4hTtnxy8g==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/unist": "^3.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/unist-util-position": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/unist-util-position/-/unist-util-position-5.0.0.tgz",
+      "integrity": "sha512-fucsC7HjXvkB5R3kTCO7kUjRdrS0BJt3M/FPxmHMBOm8JQi2BsHAHFsy27E0EolP8rp0NzXsJ+jNPyDWvOJZPA==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/unist": "^3.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/unist-util-stringify-position": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/unist-util-stringify-position/-/unist-util-stringify-position-4.0.0.tgz",
+      "integrity": "sha512-0ASV06AAoKCDkS2+xw5RXJywruurpbC4JZSm7nr7MOt1ojAzvyyaO+UxZf18j8FCF6kmzCZKcAgN/yu2gm2XgQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/unist": "^3.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/unist-util-visit": {
+      "version": "5.1.0",
+      "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-5.1.0.tgz",
+      "integrity": "sha512-m+vIdyeCOpdr/QeQCu2EzxX/ohgS8KbnPDgFni4dQsfSCtpz8UqDyY5GjRru8PDKuYn7Fq19j1CQ+nJSsGKOzg==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/unist": "^3.0.0",
+        "unist-util-is": "^6.0.0",
+        "unist-util-visit-parents": "^6.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/unist-util-visit-parents": {
+      "version": "6.0.2",
+      "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-6.0.2.tgz",
+      "integrity": "sha512-goh1s1TBrqSqukSc8wrjwWhL0hiJxgA8m4kFxGlQ+8FYQ3C/m11FcTs4YYem7V664AhHVvgoQLk890Ssdsr2IQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/unist": "^3.0.0",
+        "unist-util-is": "^6.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/vfile": {
+      "version": "6.0.3",
+      "resolved": "https://registry.npmjs.org/vfile/-/vfile-6.0.3.tgz",
+      "integrity": "sha512-KzIbH/9tXat2u30jf+smMwFCsno4wHVdNmzFyL+T/L3UGqqk6JKfVqOFOZEpZSHADH1k40ab6NUIXZq422ov3Q==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/unist": "^3.0.0",
+        "vfile-message": "^4.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/vfile-message": {
+      "version": "4.0.3",
+      "resolved": "https://registry.npmjs.org/vfile-message/-/vfile-message-4.0.3.tgz",
+      "integrity": "sha512-QTHzsGd1EhbZs4AsQ20JX1rC3cOlt/IWJruk893DfLRr57lcnOeMaWG4K0JrRta4mIJZKth2Au3mM3u03/JWKw==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/unist": "^3.0.0",
+        "unist-util-stringify-position": "^4.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
     "node_modules/vite": {
       "version": "8.0.10",
       "resolved": "https://registry.npmjs.org/vite/-/vite-8.0.10.tgz",
@@ -2912,6 +4179,16 @@
       "resolved": "https://registry.npmjs.org/zimmerframe/-/zimmerframe-1.1.4.tgz",
       "integrity": "sha512-B58NGBEoc8Y9MWWCQGl/gq9xBCe4IiKM0a2x7GZdQKOW5Exr8S1W24J6OgM1njK8xCRGvAJIL/MxXHf6SkmQKQ==",
       "license": "MIT"
+    },
+    "node_modules/zwitch": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/zwitch/-/zwitch-2.0.4.tgz",
+      "integrity": "sha512-bXE4cR/kVZhKZX/RjPEflHaKVhUVl85noU3v6b8apfQEc1x4A+zBxjZ4lN8LqGd6WZ3dl98pY4o717VFmoPp+A==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
     }
   }
 }
diff --git a/template/package.json b/template/package.json
index d4ab426..ca5ed1b 100644
--- a/template/package.json
+++ b/template/package.json
@@ -34,6 +34,7 @@
   },
   "dependencies": {
     "@lucide/svelte": "^1.14.0",
+    "@neodrag/svelte": "3.0.0-next.8",
     "@sveltejs/kit": "^2.59.0",
     "bits-ui": "^2.18.1",
     "d3-force": "^3.0.0",
@@ -44,7 +45,9 @@
     "d3-zoom": "^3.0.0",
     "dompurify": "^3.4.2",
     "marked": "^18.0.3",
+    "rehype-highlight": "^7.0.2",
     "svelte": "^5.55.5",
+    "svelte-exmarkdown": "^5.0.2",
     "svelte-sonner": "^1.1.1"
   },
   "overrides": {
diff --git a/template/src/app/styles/app.css b/template/src/app/styles/app.css
index 7fe3818..c70e8d1 100644
--- a/template/src/app/styles/app.css
+++ b/template/src/app/styles/app.css
@@ -35,6 +35,9 @@
   --warn: #ff5a1f;
   --bad: #ef4444;
   --info: var(--fg-2);
+  /* RFC-035 — compact chat status dot (online/offline). */
+  --ok: var(--good);
+  --danger: var(--bad);
 
   /* Lines. */
   --line: rgba(255, 255, 255, 0.06);
@@ -128,6 +131,9 @@
   --warn: #ff5a1f;
   --bad: #dc2626;
   --info: var(--fg-2);
+  /* RFC-035 — compact chat status dot (online/offline). */
+  --ok: var(--good);
+  --danger: var(--bad);
 
   /* Lines — softer than before so cards/dividers don't feel heavy on cream. */
   --line: rgba(0, 0, 0, 0.05);
@@ -207,6 +213,9 @@
   --warn: #b9a8ff;
   --bad: #d97a7a;
   --info: var(--fg-2);
+  /* RFC-035 — compact chat status dot (online/offline). */
+  --ok: var(--good);
+  --danger: var(--bad);
 
   --line: rgba(255, 255, 255, 0.04);
   --line-2: rgba(255, 255, 255, 0.08);
diff --git a/template/src/routes/onboard/+page.svelte b/template/src/routes/onboard/+page.svelte
index bbf7c0d..6c9711f 100644
--- a/template/src/routes/onboard/+page.svelte
+++ b/template/src/routes/onboard/+page.svelte
@@ -17,6 +17,15 @@
    * per RFC-033 SCOPE ("ship the in-view tour regardless... the route
    * never blocks the tour"). Until then, the newcomer clicks the widget's
    * own "Start tour" affordance once landing here.
+   *
+   * RFC-035 — the chat launcher used to live in THIS header as its own
+   * `variant="magic"`/star button, with `showChatLauncher={false}` +
+   * `bind:chatOpen` suppressing and re-driving the widget's own launcher.
+   * That's been retired: the launcher now lives inside `ComposedMapView`'s
+   * own top chips toolbar (left of "All", via `FlowChips`'s `leading`
+   * slot) for EVERY host, so this route no longer needs any chat-related
+   * prop or state of its own — it mounts the widget exactly like the
+   * dashboard host (DependencyGraph.svelte) does.
    */
   import ComposedMapView from "@/widgets/composed-map/ui/ComposedMapView.svelte";
 </script>
@@ -28,7 +37,9 @@
 <div class="onboard-shell">
   <header class="onboard-header">
     <span class="onboard-title">Project Map — Onboarding</span>
-    <a class="onboard-exit" href="/">Exit to standard view →</a>
+    <div class="onboard-header-right">
+      <a class="onboard-exit" href="/">Exit to standard view →</a>
+    </div>
   </header>
   <div class="onboard-canvas">
     <ComposedMapView isLive={true} />
@@ -63,6 +74,12 @@
     letter-spacing: 0.02em;
   }
 
+  .onboard-header-right {
+    display: flex;
+    align-items: center;
+    gap: 14px;
+  }
+
   .onboard-exit {
     font-size: 12px;
     color: var(--accent);
diff --git a/template/src/routes/playground/+page.svelte b/template/src/routes/playground/+page.svelte
index 162eb8e..083b3e1 100644
--- a/template/src/routes/playground/+page.svelte
+++ b/template/src/routes/playground/+page.svelte
@@ -27,16 +27,19 @@
     CommandList,
     CommandSeparator,
     Field,
+    FloatingWindow,
     Input,
     InputGroup,
     Item,
     Label,
+    MagicStar,
     Popover,
     PopoverContent,
     PopoverTrigger,
     Progress,
     Radio,
     RadioGroup,
+    ScrollArea,
     Separator,
     Skeleton,
     Slider,
@@ -70,6 +73,7 @@
   let inputValue = $state('');
   let invalidValue = $state('not-an-email');
   let cmdValue = $state('');
+  let floatingDemoOpen = $state(false);
 
   const comboboxOptions: { value: string; label: string }[] = [
     { value: 'project-a', label: 'Project A' },
@@ -156,6 +160,22 @@
         <Button variant="secondary" size="icon" aria-label="Close">×</Button>
         <Button variant="ghost" size="icon" aria-label="Settings">⚙</Button>
       </div>
+      <Separator />
+      <div class="row gap-md">
+        <Button variant="primary">Primary</Button>
+        <Button variant="secondary">Secondary</Button>
+        <Button variant="ghost">Ghost</Button>
+        <Button variant="ghost-mono">Ghost mono</Button>
+      </div>
+      <Separator />
+      <div class="row gap-md">
+        <MagicStar size={16} />
+        <MagicStar size={20} />
+        <MagicStar size={28} />
+        <Button variant="ghost" size="icon" aria-label="Ask the map">
+          <MagicStar />
+        </Button>
+      </div>
     </Card>
   </section>
 
@@ -417,6 +437,67 @@
       </div>
     </Card>
   </section>
+
+  <section>
+    <h2>ScrollArea</h2>
+    <Card>
+      <p class="muted">
+        Wraps bits-ui's ScrollArea — native scrollbar hidden, custom
+        token-styled thumb. Used by the map-chat message list.
+      </p>
+      <div class="scroll-demo">
+        <ScrollArea class="scroll-demo-area">
+          <div class="scroll-demo-content">
+            {#each Array.from({ length: 24 }, (_, i) => i) as i (i)}
+              <p>Scrollable row {i + 1}</p>
+            {/each}
+          </div>
+        </ScrollArea>
+      </div>
+    </Card>
+  </section>
+
+  <section>
+    <h2>FloatingWindow</h2>
+    <Card>
+      <p class="muted">
+        A dockable, floatable, resizable window shell (RFC-035) — hand-rolled per
+        rule 24 (no upstream draggable+resizable window primitive exists; see the
+        rule-24-bits-ui note in the component). Drag the header to float it; drag
+        it back near the right edge to re-dock, or use the pin icon. While
+        floating, grab any of the 4 edges (top/right/bottom/left, one axis each)
+        or any of the 4 corners (two axes at once, e.g. dragging the bottom-right
+        corner resizes width and height together) to resize, standard-window
+        style; while docked only the left edge is wired (width only — docked
+        height is full-height by design). Geometry persists in localStorage
+        across reloads.
+      </p>
+      <div class="row gap-md">
+        <Button
+          variant="primary"
+          onclick={() => (floatingDemoOpen = true)}
+          disabled={floatingDemoOpen}
+        >
+          Open demo window
+        </Button>
+      </div>
+      {#if floatingDemoOpen}
+        <FloatingWindow
+          storageKey="playground-demo"
+          ariaLabel="Playground demo window"
+          onClose={() => (floatingDemoOpen = false)}
+        >
+          {#snippet header()}
+            <span class="fw-demo-title">Demo window</span>
+          {/snippet}
+          <div class="fw-demo-body">
+            <p>Drag me by the header. Resize from any edge or corner. Dock/undock via the pin icon.</p>
+            <p class="muted">Geometry persists in localStorage across reloads.</p>
+          </div>
+        </FloatingWindow>
+      {/if}
+    </Card>
+  </section>
 </div>
 
 <Toaster position="bottom-right" />
@@ -518,4 +599,20 @@
     color: var(--fg-3);
     font-size: 11px;
   }
+
+  .fw-demo-title {
+    font-family: var(--font-sans);
+    font-weight: 500;
+    font-size: 12.5px;
+    color: var(--fg-1);
+  }
+
+  .fw-demo-body {
+    padding: 14px 16px;
+    display: flex;
+    flex-direction: column;
+    gap: 8px;
+    font-size: 12.5px;
+    color: var(--fg-2);
+  }
 </style>
diff --git a/template/src/shared/ui/README.md b/template/src/shared/ui/README.md
index 696697c..ae34b4c 100644
--- a/template/src/shared/ui/README.md
+++ b/template/src/shared/ui/README.md
@@ -72,6 +72,12 @@ The `modalManager` _service_ itself lives under
 | `Popover` | `Popover, PopoverTrigger, PopoverContent` | Portal-based, optional Arrow                                                                             |
 | `Toaster` | `Toaster`, `toast()`                      | Wraps `svelte-sonner`; 6 corner positions; `toast.info/success/warning/danger` (danger → sonner `error`) |
 
+### Layout
+
+| Primitive    | Import                                     | Notes                                                                                                                                                                               |
+| ------------ | ------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `ScrollArea` | `import { ScrollArea } from '@/shared/ui'` | Wraps bits-ui ScrollArea; hides the native scrollbar for a token-styled custom thumb; `bind:viewportRef` exposes the real scrolling element (`scrollTop`/`scrollHeight`/`scrollTo`) |
+
 ### Command palette
 
 | Primitive  | Import                                                                                   | Notes                                                                                                                                              |
@@ -83,7 +89,8 @@ The `modalManager` _service_ itself lives under
 
 | Primitive   | Import                                    | Purpose                                                                     |
 | ----------- | ----------------------------------------- | --------------------------------------------------------------------------- |
-| `Button`    | `import { Button } from '@/shared/ui'`    | `variant` (primary/secondary/ghost/**ghost-mono**), `size` (sm/md/**icon**) |
+| `Button`    | `import { Button } from '@/shared/ui'`    | `variant` (primary/secondary/ghost/ghost-mono), `size` (sm/md/**icon**) |
+| `MagicStar` | `import { MagicStar } from '@/shared/ui'` | Decorative SVG 5-point star, outline-only stroke carrying the extraboost.ai signature gradient (fixed, theme-independent), animated rotation honoring `prefers-reduced-motion`; `size` (px, default 20). Pair with `Button variant="ghost" size="icon"` for the AI-action launcher affordance. |
 | `Code`      | `import { Code } from '@/shared/ui'`      | Monospaced block (or inline) with copy-to-clipboard                         |
 | `Dialog`    | `import { Dialog } from '@/shared/ui'`    | `<dialog>` wrapper                                                          |
 | `ModalRoot` | `import { ModalRoot } from '@/shared/ui'` | Iterates the modalManager stack — mount in `+layout.svelte`                 |
diff --git a/template/src/shared/ui/floating-window/FloatingWindow.render.test.ts b/template/src/shared/ui/floating-window/FloatingWindow.render.test.ts
new file mode 100644
index 0000000..ee86f86
--- /dev/null
+++ b/template/src/shared/ui/floating-window/FloatingWindow.render.test.ts
@@ -0,0 +1,541 @@
+// @vitest-environment happy-dom
+/**
+ * RFC-035 Wave 1 (EVID-097 Finding #2) — unit coverage for `FloatingWindow`'s
+ * persistence/clamp/dock-float/resize logic. happy-dom implements
+ * `setPointerCapture`/`releasePointerCapture` as no-ops (present, not
+ * throwing), so the pointer-capture resize path under test doesn't need a
+ * pointer-capture mock. Mirrors the mount()/flushSync() harness used by
+ * MapChat.render.test.ts.
+ */
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import { mount, unmount, flushSync } from "svelte";
+import FloatingWindow from "./FloatingWindow.svelte";
+
+const STORAGE_KEY = "forgeplan-web:floating-window:test-window:v1";
+
+let host: HTMLElement | null = null;
+let instance: unknown = null;
+
+function mountWindow(props: Partial<Record<string, unknown>> = {}) {
+  host = document.createElement("div");
+  document.body.appendChild(host);
+  instance = mount(FloatingWindow, {
+    target: host,
+    props: {
+      storageKey: "test-window",
+      ariaLabel: "Test window",
+      ...props,
+    },
+  });
+  flushSync();
+  return host;
+}
+
+function getRoot(root: HTMLElement): HTMLElement {
+  const el = root.querySelector<HTMLElement>(".fw-root");
+  expect(el).not.toBeNull();
+  return el!;
+}
+
+function getHeader(root: HTMLElement): HTMLElement {
+  const el = root.querySelector<HTMLElement>(".fw-header");
+  expect(el).not.toBeNull();
+  return el!;
+}
+
+function getDockToggle(root: HTMLElement): HTMLButtonElement {
+  const btn = root.querySelector<HTMLButtonElement>(
+    '[aria-label="Undock (float)"], [aria-label="Dock to edge"]',
+  );
+  expect(btn).not.toBeNull();
+  return btn!;
+}
+
+function widthPx(el: HTMLElement): number {
+  const match = /width:\s*([\d.]+)px/.exec(el.getAttribute("style") ?? "");
+  expect(match).not.toBeNull();
+  return Number(match![1]);
+}
+
+function heightPx(el: HTMLElement): number {
+  const match = /height:\s*([\d.]+)px/.exec(el.getAttribute("style") ?? "");
+  expect(match).not.toBeNull();
+  return Number(match![1]);
+}
+
+beforeEach(() => {
+  localStorage.clear();
+  window.innerWidth = 1280;
+  window.innerHeight = 800;
+});
+
+afterEach(() => {
+  if (instance) {
+    unmount(instance as object);
+    instance = null;
+  }
+  host?.remove();
+  host = null;
+  localStorage.clear();
+  vi.restoreAllMocks();
+});
+
+describe("FloatingWindow — persisted geometry restore", () => {
+  it("clamps an off-screen persisted floating position back into the viewport", () => {
+    // A position from a since-shrunk/changed monitor: way outside the
+    // current 1280x800 viewport (invariant I4 — never restore off-screen).
+    localStorage.setItem(
+      STORAGE_KEY,
+      JSON.stringify({
+        v: 1,
+        mode: "floating",
+        dockedWidth: 420,
+        floatX: 5000,
+        floatY: 4000,
+        floatWidth: 420,
+        floatHeight: 560,
+      }),
+    );
+
+    const root = mountWindow();
+    const fw = getRoot(root);
+    const xMatch = /transform:\s*translate\(([\d.]+)px,\s*([\d.]+)px\)/.exec(
+      fw.style.transform ? `transform: ${fw.style.transform}` : "",
+    );
+    void xMatch;
+
+    // The clamp is expressed through width/height + neodrag's position
+    // compartment; assert the sizes are clamped within the viewport bounds
+    // (the direct, environment-independent signal `clampFloating()` guarantees).
+    expect(widthPx(fw)).toBeLessThanOrEqual(1280);
+    expect(heightPx(fw)).toBeLessThanOrEqual(800);
+  });
+
+  it("degrades to default docked geometry when the persisted payload is unparsable JSON", () => {
+    // Genuinely malformed JSON throws inside loadPersisted's try/catch —
+    // the catch leaves the already-in-place defaults alone and does NOT
+    // touch storage (unlike the valid-JSON-wrong-shape path below), so the
+    // raw string survives; the component just never trusts it.
+    localStorage.setItem(STORAGE_KEY, "{not json");
+    const root = mountWindow();
+    const fw = getRoot(root);
+    expect(fw.classList.contains("docked")).toBe(true);
+  });
+
+  it("degrades to default docked geometry AND clears the key when the persisted payload has a stale version", () => {
+    localStorage.setItem(
+      STORAGE_KEY,
+      JSON.stringify({
+        v: 999,
+        mode: "floating",
+        dockedWidth: 420,
+        floatX: 10,
+        floatY: 10,
+        floatWidth: 420,
+        floatHeight: 560,
+      }),
+    );
+    const root = mountWindow();
+    const fw = getRoot(root);
+    expect(fw.classList.contains("docked")).toBe(true);
+    // Valid JSON but the wrong shape/version IS actively cleared, rather
+    // than re-fought on every future mount (rollback plan: "a stale
+    // window-geometry key is ignored by a version guard, or cleared").
+    expect(localStorage.getItem(STORAGE_KEY)).toBeNull();
+  });
+});
+
+describe("FloatingWindow — dock <-> float toggle", () => {
+  it("starts docked by default", () => {
+    const root = mountWindow();
+    const fw = getRoot(root);
+    expect(fw.classList.contains("docked")).toBe(true);
+    expect(fw.classList.contains("floating")).toBe(false);
+  });
+
+  it("toggling the pin control flips docked -> floating", () => {
+    const root = mountWindow();
+    const fw = getRoot(root);
+    expect(fw.classList.contains("docked")).toBe(true);
+
+    getDockToggle(root).dispatchEvent(
+      new MouseEvent("click", { bubbles: true }),
+    );
+    flushSync();
+
+    expect(fw.classList.contains("floating")).toBe(true);
+    expect(fw.classList.contains("docked")).toBe(false);
+  });
+
+  it("toggling twice returns to docked", () => {
+    const root = mountWindow();
+    const fw = getRoot(root);
+
+    getDockToggle(root).dispatchEvent(
+      new MouseEvent("click", { bubbles: true }),
+    );
+    flushSync();
+    expect(fw.classList.contains("floating")).toBe(true);
+
+    getDockToggle(root).dispatchEvent(
+      new MouseEvent("click", { bubbles: true }),
+    );
+    flushSync();
+    expect(fw.classList.contains("docked")).toBe(true);
+  });
+
+  it("persists mode across a toggle so a remount restores floating", () => {
+    const root = mountWindow();
+    getDockToggle(root).dispatchEvent(
+      new MouseEvent("click", { bubbles: true }),
+    );
+    flushSync();
+
+    unmount(instance as object);
+    instance = null;
+    host?.remove();
+
+    const root2 = mountWindow();
+    const fw2 = getRoot(root2);
+    expect(fw2.classList.contains("floating")).toBe(true);
+  });
+});
+
+describe("FloatingWindow — min-size clamp on resize", () => {
+  it("does not shrink narrower than minWidth when dragging the left (width) resize handle", () => {
+    const root = mountWindow({ minWidth: 320, defaultWidth: 420 });
+    const fw = getRoot(root);
+    const handle = root.querySelector<HTMLElement>(".fw-resize-left");
+    expect(handle).not.toBeNull();
+
+    handle!.dispatchEvent(
+      new PointerEvent("pointerdown", {
+        clientX: 0,
+        clientY: 0,
+        pointerId: 1,
+        bubbles: true,
+      }),
+    );
+    // Dragging the left edge far to the right shrinks width — attempt to
+    // go well past the 320px floor.
+    handle!.dispatchEvent(
+      new PointerEvent("pointermove", {
+        clientX: 900,
+        clientY: 0,
+        pointerId: 1,
+        bubbles: true,
+      }),
+    );
+    flushSync();
+
+    expect(widthPx(fw)).toBeGreaterThanOrEqual(320);
+
+    handle!.dispatchEvent(
+      new PointerEvent("pointerup", {
+        clientX: 900,
+        clientY: 0,
+        pointerId: 1,
+        bubbles: true,
+      }),
+    );
+    flushSync();
+  });
+
+  it("keyboard ArrowLeft/ArrowRight on the resize handle nudges width and respects the floor", () => {
+    const root = mountWindow({ minWidth: 320, defaultWidth: 330 });
+    const fw = getRoot(root);
+    const handle = root.querySelector<HTMLElement>(".fw-resize-left");
+    expect(handle).not.toBeNull();
+
+    const before = widthPx(fw);
+    // ArrowRight narrows (per startResize("left") convention: dragging the
+    // left edge right shrinks width) — repeated presses must not cross the
+    // 320px floor.
+    for (let i = 0; i < 5; i++) {
+      handle!.dispatchEvent(
+        new KeyboardEvent("keydown", { key: "ArrowRight", bubbles: true }),
+      );
+    }
+    flushSync();
+
+    expect(widthPx(fw)).toBeLessThanOrEqual(before);
+    expect(widthPx(fw)).toBeGreaterThanOrEqual(320);
+  });
+});
+
+describe("FloatingWindow — persist -> restore round trip", () => {
+  it("round-trips mode + geometry through the storage key after a dock/undock + remount", () => {
+    const root = mountWindow();
+    getDockToggle(root).dispatchEvent(
+      new MouseEvent("click", { bubbles: true }),
+    );
+    flushSync();
+
+    const raw = localStorage.getItem(STORAGE_KEY);
+    expect(raw).not.toBeNull();
+    const persisted = JSON.parse(raw!);
+    expect(persisted.v).toBe(1);
+    expect(persisted.mode).toBe("floating");
+
+    unmount(instance as object);
+    instance = null;
+    host?.remove();
+
+    const root2 = mountWindow();
+    const fw2 = getRoot(root2);
+    expect(fw2.classList.contains("floating")).toBe(true);
+    expect(widthPx(fw2)).toBe(persisted.floatWidth);
+    expect(heightPx(fw2)).toBe(persisted.floatHeight);
+  });
+
+  it("writes nothing to storage before any interaction (defaults only, no spurious persist)", () => {
+    mountWindow();
+    expect(localStorage.getItem(STORAGE_KEY)).toBeNull();
+  });
+});
+
+describe("FloatingWindow — resize grip inventory per mode", () => {
+  it("docked mode wires only the left-edge width grip", () => {
+    const root = mountWindow();
+    expect(root.querySelector(".fw-resize-left")).not.toBeNull();
+    expect(root.querySelector(".fw-resize-right")).toBeNull();
+    expect(root.querySelector(".fw-resize-top")).toBeNull();
+    expect(root.querySelector(".fw-resize-bottom")).toBeNull();
+    expect(root.querySelector(".fw-resize-top-left")).toBeNull();
+    expect(root.querySelector(".fw-resize-top-right")).toBeNull();
+    expect(root.querySelector(".fw-resize-bottom-left")).toBeNull();
+    expect(root.querySelector(".fw-resize-bottom-right")).toBeNull();
+  });
+
+  it("floating mode wires all 4 edges + all 4 corners", () => {
+    const root = mountWindow();
+    getDockToggle(root).dispatchEvent(
+      new MouseEvent("click", { bubbles: true }),
+    );
+    flushSync();
+    for (const cls of [
+      "fw-resize-left",
+      "fw-resize-right",
+      "fw-resize-top",
+      "fw-resize-bottom",
+      "fw-resize-top-left",
+      "fw-resize-top-right",
+      "fw-resize-bottom-left",
+      "fw-resize-bottom-right",
+    ]) {
+      expect(root.querySelector(`.${cls}`)).not.toBeNull();
+    }
+  });
+});
+
+describe("FloatingWindow — corner/edge resize (floating mode)", () => {
+  function toFloating(root: HTMLElement): void {
+    getDockToggle(root).dispatchEvent(
+      new MouseEvent("click", { bubbles: true }),
+    );
+    flushSync();
+  }
+
+  /** `persist()` (called synchronously from the resize `up()` handler on
+   * pointerup) is the one reliable synchronous read of `floatX`/`floatY` —
+   * position is otherwise only reflected in the DOM via neodrag's
+   * `requestAnimationFrame`-scheduled paint effect, which doesn't resolve
+   * within `flushSync()`. */
+  function readPersisted(): {
+    floatX: number;
+    floatY: number;
+    floatWidth: number;
+    floatHeight: number;
+  } {
+    const raw = localStorage.getItem(STORAGE_KEY);
+    expect(raw).not.toBeNull();
+    return JSON.parse(raw!);
+  }
+
+  function drag(handle: HTMLElement, dx: number, dy: number): void {
+    handle.dispatchEvent(
+      new PointerEvent("pointerdown", {
+        clientX: 0,
+        clientY: 0,
+        pointerId: 1,
+        bubbles: true,
+      }),
+    );
+    handle.dispatchEvent(
+      new PointerEvent("pointermove", {
+        clientX: dx,
+        clientY: dy,
+        pointerId: 1,
+        bubbles: true,
+      }),
+    );
+    flushSync();
+    handle.dispatchEvent(
+      new PointerEvent("pointerup", {
+        clientX: dx,
+        clientY: dy,
+        pointerId: 1,
+        bubbles: true,
+      }),
+    );
+    flushSync();
+  }
+
+  it("dragging the bottom-right corner changes BOTH width and height together", () => {
+    const root = mountWindow({
+      minWidth: 320,
+      minHeight: 320,
+      defaultWidth: 420,
+      defaultHeight: 560,
+    });
+    const fw = getRoot(root);
+    toFloating(root);
+    const before = { w: widthPx(fw), h: heightPx(fw) };
+
+    const corner = root.querySelector<HTMLElement>(".fw-resize-bottom-right")!;
+    // Floating height seeds at the viewport-derived ceiling on detach (Wave
+    // 1 behaviour), so grow width but shrink height to stay clear of both
+    // the ceiling and the floor while still exercising both axes at once.
+    drag(corner, 40, -30);
+
+    expect(widthPx(fw)).toBe(before.w + 40);
+    expect(heightPx(fw)).toBe(before.h - 30);
+  });
+
+  it("dragging the bottom-right corner far past the floor clamps BOTH axes at their minimums", () => {
+    const root = mountWindow({
+      minWidth: 320,
+      minHeight: 320,
+      defaultWidth: 420,
+      defaultHeight: 560,
+    });
+    const fw = getRoot(root);
+    toFloating(root);
+
+    const corner = root.querySelector<HTMLElement>(".fw-resize-bottom-right")!;
+    drag(corner, -900, -900);
+
+    expect(widthPx(fw)).toBe(320);
+    expect(heightPx(fw)).toBe(320);
+  });
+
+  it("dragging the right edge changes only width, not height", () => {
+    const root = mountWindow({ defaultWidth: 420, defaultHeight: 560 });
+    const fw = getRoot(root);
+    toFloating(root);
+    const beforeH = heightPx(fw);
+
+    const handle = root.querySelector<HTMLElement>(".fw-resize-right")!;
+    drag(handle, 35, 200);
+
+    expect(widthPx(fw)).toBe(420 + 35);
+    expect(heightPx(fw)).toBe(beforeH);
+  });
+
+  it("dragging the bottom edge changes only height, not width", () => {
+    const root = mountWindow({ defaultWidth: 420, defaultHeight: 560 });
+    const fw = getRoot(root);
+    toFloating(root);
+    const beforeW = widthPx(fw);
+    const beforeH = heightPx(fw);
+
+    const handle = root.querySelector<HTMLElement>(".fw-resize-bottom")!;
+    // Floating height seeds at the viewport-derived ceiling on detach, so
+    // shrink (negative dy) to observe a change instead of hitting the clamp.
+    drag(handle, 200, -25);
+
+    expect(heightPx(fw)).toBe(beforeH - 25);
+    expect(widthPx(fw)).toBe(beforeW);
+  });
+
+  it("the left grip keeps the right edge fixed (floatX + floatWidth constant) while growing width", () => {
+    const root = mountWindow({
+      minWidth: 320,
+      defaultWidth: 420,
+      defaultHeight: 560,
+    });
+    toFloating(root);
+    const initial = readPersisted();
+    const rightEdge = initial.floatX + initial.floatWidth;
+
+    const handle = root.querySelector<HTMLElement>(".fw-resize-left")!;
+    // Dragging the left edge leftward (negative dx) grows width.
+    drag(handle, -60, 0);
+
+    const after = readPersisted();
+    expect(after.floatWidth).toBe(initial.floatWidth + 60);
+    expect(after.floatX + after.floatWidth).toBe(rightEdge);
+  });
+
+  it("the top grip keeps the bottom edge fixed (floatY + floatHeight constant) while resizing height", () => {
+    const root = mountWindow({
+      minHeight: 320,
+      defaultWidth: 420,
+      defaultHeight: 560,
+    });
+    toFloating(root);
+    const initial = readPersisted();
+    const bottomEdge = initial.floatY + initial.floatHeight;
+
+    const handle = root.querySelector<HTMLElement>(".fw-resize-top")!;
+    // Floating height seeds at the viewport-derived ceiling on detach, so
+    // drag the top edge downward (positive dy) to shrink height rather than
+    // grow it — same "opposite edge fixed" invariant either direction.
+    drag(handle, 0, 45);
+
+    const after = readPersisted();
+    expect(after.floatHeight).toBe(initial.floatHeight - 45);
+    expect(after.floatY + after.floatHeight).toBe(bottomEdge);
+  });
+
+  it("the top-left corner moves both origin axes to keep the bottom-right corner fixed", () => {
+    const root = mountWindow({
+      minWidth: 320,
+      minHeight: 320,
+      defaultWidth: 420,
+      defaultHeight: 560,
+    });
+    toFloating(root);
+    const initial = readPersisted();
+    const rightEdge = initial.floatX + initial.floatWidth;
+    const bottomEdge = initial.floatY + initial.floatHeight;
+
+    const handle = root.querySelector<HTMLElement>(".fw-resize-top-left")!;
+    // Width has headroom to grow (negative dx); height seeds at the
+    // viewport-derived ceiling on detach, so shrink it (positive dy) —
+    // both axes still move together through one corner grip.
+    drag(handle, -20, 15);
+
+    const after = readPersisted();
+    expect(after.floatWidth).toBe(initial.floatWidth + 20);
+    expect(after.floatHeight).toBe(initial.floatHeight - 15);
+    expect(after.floatX + after.floatWidth).toBe(rightEdge);
+    expect(after.floatY + after.floatHeight).toBe(bottomEdge);
+  });
+});
+
+describe("FloatingWindow — header + close", () => {
+  it("the header is keyboard-focusable and carries an accessible name (no role=presentation)", () => {
+    const root = mountWindow();
+    const header = getHeader(root);
+    expect(header.getAttribute("tabindex")).toBe("0");
+    expect(header.getAttribute("role")).not.toBe("presentation");
+    expect(header.getAttribute("aria-label")).toContain("Test window");
+  });
+
+  it("Escape fires onClose", () => {
+    const onClose = vi.fn();
+    const root = mountWindow({ onClose });
+    const fw = getRoot(root);
+    fw.dispatchEvent(
+      new KeyboardEvent("keydown", { key: "Escape", bubbles: true }),
+    );
+    flushSync();
+    expect(onClose).toHaveBeenCalledTimes(1);
+  });
+
+  it("omits the close button when onClose is not provided", () => {
+    const root = mountWindow();
+    expect(root.querySelector('[aria-label="Close"]')).toBeNull();
+  });
+});
diff --git a/template/src/shared/ui/floating-window/FloatingWindow.svelte b/template/src/shared/ui/floating-window/FloatingWindow.svelte
new file mode 100644
index 0000000..9d6168d
--- /dev/null
+++ b/template/src/shared/ui/floating-window/FloatingWindow.svelte
@@ -0,0 +1,806 @@
+<script module lang="ts">
+  // Module context (not instance): `shared/ui/index.ts` re-exports this as
+  // `export { FloatingWindow, type FloatingWindowMode } from "./floating-window"`,
+  // and a type re-exported by a barrel file must originate from a
+  // module-level export — an instance-script export is invisible to
+  // consumers importing only the type.
+  export type FloatingWindowMode = "docked" | "floating";
+</script>
+
+<script lang="ts">
+  /**
+   * FloatingWindow — RFC-035 Wave 1. A generic dockable / floatable /
+   * resizable window shell.
+   *
+   * rule-24-bits-ui: bits-ui/shadcn-svelte ship no draggable+resizable
+   * floating-window primitive — `Dialog` is a blocking modal overlay,
+   * paneforge/`Resizable` is for split panes inside a fixed layout, neither
+   * is a free-floating, dockable window. RFC-035 Alternative A2: this is a
+   * hand-rolled `shared/ui` primitive for exactly that reason.
+   *
+   * Reuse (per RFC-035's reuse-first directive):
+   * - MOVE: `@neodrag/svelte`'s `draggable` attachment, restricted to the
+   *   `.fw-header` zone via the `controls` plugin, clamped to the viewport
+   *   via `bounds`, two-way bound to `{x,y}` via the `position` plugin
+   *   (Compartment-reactive, per neodrag's documented Svelte pattern).
+   * - RESIZE: the pointer-capture pattern already reviewed in
+   *   `widgets/mosaic/ui/Splitter.svelte` (pointerdown → setPointerCapture →
+   *   pointermove/up/cancel + keyboard arrow-key nudge) — neodrag itself is
+   *   a move library with no resize primitive, so this is the RFC's
+   *   pre-approved second reuse path, not a hand-roll.
+   *
+   * Positioning model: the root is always `position: fixed; top:0; left:0`
+   * and is moved entirely via neodrag's CSS transform from `{x, y}` — so
+   * "docked" is just a viewport-derived `{x, y, width, height}` rather than
+   * a different CSS layout. That is what makes dragging the header while
+   * docked detach into floating with no visual jump (see `handleDrag`): the
+   * docked position IS the floating seed the moment the gesture starts.
+   *
+   * Persistence: one versioned localStorage key per `storageKey` prop.
+   * Floating geometry is always clamped to the current viewport on restore
+   * and on live resize (invariant I4 — never end up off-screen).
+   */
+  import type { Snippet } from "svelte";
+  import { onMount } from "svelte";
+  import {
+    draggable,
+    controls,
+    ControlFrom,
+    bounds,
+    BoundsFrom,
+    position,
+    events,
+    Compartment,
+  } from "@neodrag/svelte";
+  import Pin from "@lucide/svelte/icons/pin";
+  import PinOff from "@lucide/svelte/icons/pin-off";
+  import X from "@lucide/svelte/icons/x";
+
+  interface Props {
+    /** localStorage key suffix — final key is
+     * `forgeplan-web:floating-window:<storageKey>:v1`. Give every mounted
+     * instance a distinct value. */
+    storageKey: string;
+    ariaLabel: string;
+    closeAriaLabel?: string;
+    defaultWidth?: number;
+    defaultHeight?: number;
+    minWidth?: number;
+    minHeight?: number;
+    /** Gap (px) between the window and the viewport edge in docked mode,
+     * and the margin floating geometry's max size is clamped against. */
+    dockMargin?: number;
+    /** Distance (px) from the right edge within which releasing a dragged
+     * floating window snaps it back to docked. */
+    dockSnapPx?: number;
+    onClose?: () => void;
+    header?: Snippet;
+    children?: Snippet;
+    class?: string;
+  }
+
+  let {
+    storageKey,
+    ariaLabel,
+    closeAriaLabel = "Close",
+    defaultWidth = 420,
+    defaultHeight = 560,
+    minWidth = 320,
+    minHeight = 320,
+    dockMargin = 16,
+    dockSnapPx = 24,
+    onClose,
+    header,
+    children,
+    class: className,
+  }: Props = $props();
+
+  const STORAGE_VERSION = 1;
+  const storageKeyFull = `forgeplan-web:floating-window:${storageKey}:v1`;
+  const RESIZE_KEY_STEP_PX = 8;
+
+  function clamp(value: number, min: number, max: number): number {
+    return Math.min(Math.max(value, min), max);
+  }
+
+  function readViewport(): { w: number; h: number } {
+    if (typeof window === "undefined") return { w: 1280, h: 800 };
+    return { w: window.innerWidth, h: window.innerHeight };
+  }
+
+  const initialViewport = readViewport();
+
+  let mode = $state<FloatingWindowMode>("docked");
+  let viewportW = $state(initialViewport.w);
+  let viewportH = $state(initialViewport.h);
+  // Bug #4 — clamped against the viewport already known at construction
+  // time. An unclamped seed (bare `defaultWidth`) rendered partly
+  // off-screen on a narrow first visit with no persisted geometry; the
+  // onResize handler below re-clamps on every live resize, this covers the
+  // gap before the first resize event ever fires.
+  let dockedWidth = $state(clamp(defaultWidth, minWidth, maxWidth()));
+  let floatX = $state(0);
+  let floatY = $state(dockMargin);
+  let floatWidth = $state(defaultWidth);
+  let floatHeight = $state(defaultHeight);
+  let isDragging = $state(false);
+  let isResizing = $state(false);
+  let reducedMotion = $state(false);
+
+  interface PersistedGeometry {
+    v: number;
+    mode: FloatingWindowMode;
+    dockedWidth: number;
+    floatX: number;
+    floatY: number;
+    floatWidth: number;
+    floatHeight: number;
+  }
+
+  function isPersistedGeometry(value: unknown): value is PersistedGeometry {
+    if (typeof value !== "object" || value === null) return false;
+    const g = value as Record<string, unknown>;
+    return (
+      g.v === STORAGE_VERSION &&
+      (g.mode === "docked" || g.mode === "floating") &&
+      typeof g.dockedWidth === "number" &&
+      typeof g.floatX === "number" &&
+      typeof g.floatY === "number" &&
+      typeof g.floatWidth === "number" &&
+      typeof g.floatHeight === "number"
+    );
+  }
+
+  // Bug #7 — the "at least minWidth/minHeight" floor alone let a
+  // sub-minWidth (or sub-minHeight) viewport spill off-screen once
+  // viewportW/H dropped below minWidth/minHeight + 2*dockMargin: the floor
+  // always won and nothing ever capped the result back down to what
+  // actually fits. Capping against the raw viewport too means a very
+  // narrow viewport shrinks the window below its nominal minimum instead
+  // of spilling. Unaffected on normal (wide) viewports, where the
+  // uncapped result is already <= viewportW/H.
+  function maxWidth(): number {
+    return Math.min(Math.max(minWidth, viewportW - dockMargin * 2), viewportW);
+  }
+  function maxHeight(): number {
+    return Math.min(Math.max(minHeight, viewportH - dockMargin * 2), viewportH);
+  }
+
+  /** Clamps floating geometry so the window is always fully on-screen when
+   * it fits (invariant I4). Called on restore and on every live viewport
+   * resize. */
+  function clampFloating(): void {
+    floatWidth = clamp(floatWidth, minWidth, maxWidth());
+    floatHeight = clamp(floatHeight, minHeight, maxHeight());
+    floatX = clamp(floatX, 0, Math.max(0, viewportW - floatWidth));
+    floatY = clamp(floatY, 0, Math.max(0, viewportH - floatHeight));
+  }
+
+  /** Best-effort, never throws — a missing/corrupted/blocked localStorage
+   * degrades to the default docked geometry. A version mismatch (or
+   * unparsable payload) clears the stale key rather than fighting it on
+   * every future mount (rollback plan: "a stale window-geometry key is
+   * ignored by a version guard, or cleared"). */
+  function loadPersisted(): void {
+    if (typeof localStorage === "undefined") return;
+    try {
+      const raw = localStorage.getItem(storageKeyFull);
+      if (!raw) return;
+      const parsed: unknown = JSON.parse(raw);
+      if (!isPersistedGeometry(parsed)) {
+        localStorage.removeItem(storageKeyFull);
+        return;
+      }
+      mode = parsed.mode;
+      dockedWidth = clamp(parsed.dockedWidth, minWidth, maxWidth());
+      floatX = parsed.floatX;
+      floatY = parsed.floatY;
+      floatWidth = parsed.floatWidth;
+      floatHeight = parsed.floatHeight;
+      clampFloating();
+    } catch {
+      // Corrupted/unavailable storage — defaults already in place.
+    }
+  }
+
+  /** Best-effort, never throws (private browsing / full storage). */
+  function persist(): void {
+    if (typeof localStorage === "undefined") return;
+    try {
+      const payload: PersistedGeometry = {
+        v: STORAGE_VERSION,
+        mode,
+        dockedWidth,
+        floatX,
+        floatY,
+        floatWidth,
+        floatHeight,
+      };
+      localStorage.setItem(storageKeyFull, JSON.stringify(payload));
+    } catch {
+      // Storage full/blocked — geometry won't survive reload, chat still
+      // works for the rest of this page session.
+    }
+  }
+
+  // The single value neodrag's `position` plugin forces the root to —
+  // derived from the viewport while docked, freely set while floating.
+  // Bug #7 — floor at 0 so an extreme sub-minWidth viewport (dockedWidth
+  // clamped up to viewportW by maxWidth() above) never pushes the docked
+  // window's left edge negative; the right edge stays pinned at
+  // viewportW - dockMargin (or viewportW when dockedWidth == viewportW).
+  const x = $derived(
+    mode === "docked"
+      ? Math.max(0, viewportW - dockedWidth - dockMargin)
+      : floatX,
+  );
+  const y = $derived(mode === "docked" ? dockMargin : floatY);
+  const width = $derived(mode === "docked" ? dockedWidth : floatWidth);
+  const height = $derived(
+    mode === "docked" ? viewportH - dockMargin * 2 : floatHeight,
+  );
+
+  function handleDragStart(): void {
+    isDragging = true;
+  }
+
+  /** Any header-drag movement — including the very first pixel while
+   * docked — detaches into floating, seeded from wherever the window
+   * currently is (`x`/`y` above), so the gesture continues with no visual
+   * jump (FR-1: "dragging the header detaches it into a free-floating
+   * window"). */
+  function handleDrag(data: { offset: { x: number; y: number } }): void {
+    if (mode === "docked") {
+      floatWidth = dockedWidth;
+      floatHeight = viewportH - dockMargin * 2;
+      mode = "floating";
+    }
+    floatX = data.offset.x;
+    floatY = data.offset.y;
+  }
+
+  /** FR-1 re-dock: releasing within `dockSnapPx` of the right edge snaps
+   * back to docked, carrying the user's chosen width across. */
+  function handleDragEnd(data: { offset: { x: number; y: number } }): void {
+    isDragging = false;
+    if (mode === "floating") {
+      floatX = data.offset.x;
+      floatY = data.offset.y;
+      if (floatX + floatWidth >= viewportW - dockSnapPx) {
+        dockedWidth = clamp(floatWidth, minWidth, maxWidth());
+        mode = "docked";
+      }
+    }
+    persist();
+  }
+
+  /** FR-2's explicit header dock/undock toggle — the non-drag path for
+   * both directions. */
+  function toggleDock(): void {
+    if (mode === "docked") {
+      floatX = x;
+      floatY = y;
+      floatWidth = dockedWidth;
+      floatHeight = height;
+      mode = "floating";
+    } else {
+      dockedWidth = clamp(floatWidth, minWidth, maxWidth());
+      mode = "docked";
+    }
+    persist();
+  }
+
+  type ResizeEdge =
+    | "left"
+    | "right"
+    | "top"
+    | "bottom"
+    | "top-left"
+    | "top-right"
+    | "bottom-left"
+    | "bottom-right";
+
+  function edgeWantsLeft(edge: ResizeEdge): boolean {
+    return edge === "left" || edge === "top-left" || edge === "bottom-left";
+  }
+  function edgeWantsRight(edge: ResizeEdge): boolean {
+    return edge === "right" || edge === "top-right" || edge === "bottom-right";
+  }
+  function edgeWantsTop(edge: ResizeEdge): boolean {
+    return edge === "top" || edge === "top-left" || edge === "top-right";
+  }
+  function edgeWantsBottom(edge: ResizeEdge): boolean {
+    return edge === "bottom" || edge === "bottom-left" || edge === "bottom-right";
+  }
+
+  /** Splitter.svelte's pointer-capture pattern, generalised to 4 edges + 4
+   * corners. Docked mode only ever wires up the `left` edge (see markup) —
+   * width only, right edge pinned, height untouched (docked height is
+   * viewport-derived full-height by design, see `height` above). Floating
+   * wires all edges + all four corners; a corner combines its two edges'
+   * axes (e.g. `bottom-right` grows width via `right`-style dx and height
+   * via `bottom`-style dy simultaneously). A `left`/`top` component moves
+   * the origin as it resizes so the opposite (right/bottom) edge stays
+   * fixed in place — the same "moving edge" trick the plain `left` edge
+   * already used before this generalisation. */
+  function startResize(edge: ResizeEdge) {
+    return (e: PointerEvent): void => {
+      e.preventDefault();
+      const target = e.currentTarget as HTMLElement;
+      target.setPointerCapture(e.pointerId);
+      isResizing = true;
+      const startClientX = e.clientX;
+      const startClientY = e.clientY;
+      const startWidth = width;
+      const startHeight = height;
+      const startFloatX = floatX;
+      const startFloatY = floatY;
+      const wantsLeft = edgeWantsLeft(edge);
+      const wantsRight = edgeWantsRight(edge);
+      const wantsTop = edgeWantsTop(edge);
+      const wantsBottom = edgeWantsBottom(edge);
+
+      function move(ev: PointerEvent): void {
+        const dx = ev.clientX - startClientX;
+        const dy = ev.clientY - startClientY;
+
+        if (wantsLeft) {
+          const next = clamp(startWidth - dx, minWidth, maxWidth());
+          if (mode === "docked") {
+            dockedWidth = next;
+          } else {
+            floatWidth = next;
+            floatX = startFloatX + startWidth - next;
+          }
+        } else if (wantsRight) {
+          floatWidth = clamp(startWidth + dx, minWidth, maxWidth());
+        }
+
+        if (wantsTop) {
+          const next = clamp(startHeight - dy, minHeight, maxHeight());
+          floatHeight = next;
+          floatY = startFloatY + startHeight - next;
+        } else if (wantsBottom) {
+          floatHeight = clamp(startHeight + dy, minHeight, maxHeight());
+        }
+      }
+      function up(): void {
+        target.removeEventListener("pointermove", move);
+        target.removeEventListener("pointerup", up);
+        target.removeEventListener("pointercancel", up);
+        isResizing = false;
+        persist();
+      }
+      target.addEventListener("pointermove", move);
+      target.addEventListener("pointerup", up);
+      target.addEventListener("pointercancel", up);
+    };
+  }
+
+  /** Keyboard-operable resize (a11y) — mirrors Splitter.svelte's arrow-key
+   * nudge, generalised to 4 edges + 4 corners. Only the `left` edge is
+   * reachable in docked mode; every other value is floating-only (see
+   * markup). Horizontal arrows (Left/Right) drive the width axis when the
+   * edge has a left/right component, vertical arrows (Up/Down) drive the
+   * height axis when it has a top/bottom component — a corner responds to
+   * both, matching the pointer-drag behaviour above. */
+  function resizeKeydown(edge: ResizeEdge) {
+    const wantsLeft = edgeWantsLeft(edge);
+    const wantsRight = edgeWantsRight(edge);
+    const wantsTop = edgeWantsTop(edge);
+    const wantsBottom = edgeWantsBottom(edge);
+    return (e: KeyboardEvent): void => {
+      let handled = false;
+      if (wantsLeft && (e.key === "ArrowLeft" || e.key === "ArrowRight")) {
+        const delta = e.key === "ArrowLeft" ? RESIZE_KEY_STEP_PX : -RESIZE_KEY_STEP_PX;
+        const next = clamp(width + delta, minWidth, maxWidth());
+        if (mode === "docked") {
+          dockedWidth = next;
+        } else {
+          floatX = floatX - (next - width);
+          floatWidth = next;
+        }
+        handled = true;
+      } else if (wantsRight && (e.key === "ArrowRight" || e.key === "ArrowLeft")) {
+        const delta = e.key === "ArrowRight" ? RESIZE_KEY_STEP_PX : -RESIZE_KEY_STEP_PX;
+        floatWidth = clamp(floatWidth + delta, minWidth, maxWidth());
+        handled = true;
+      }
+      if (wantsTop && (e.key === "ArrowUp" || e.key === "ArrowDown")) {
+        const delta = e.key === "ArrowUp" ? RESIZE_KEY_STEP_PX : -RESIZE_KEY_STEP_PX;
+        const next = clamp(height + delta, minHeight, maxHeight());
+        floatY = floatY - (next - height);
+        floatHeight = next;
+        handled = true;
+      } else if (wantsBottom && (e.key === "ArrowDown" || e.key === "ArrowUp")) {
+        const delta = e.key === "ArrowDown" ? RESIZE_KEY_STEP_PX : -RESIZE_KEY_STEP_PX;
+        floatHeight = clamp(floatHeight + delta, minHeight, maxHeight());
+        handled = true;
+      }
+      if (handled) {
+        e.preventDefault();
+        persist();
+      }
+    };
+  }
+
+  // Bug #3 — Escape must not also reach an ancestor keydown handler (e.g.
+  // ComposedMapView's window-level Escape ascend/reset): without stopping
+  // propagation here, one Escape press both closed this window AND
+  // ascended/reset the map underneath it.
+  function handleKeydown(e: KeyboardEvent): void {
+    if (e.key === "Escape") {
+      e.preventDefault();
+      e.stopPropagation();
+      onClose?.();
+    }
+  }
+
+  onMount(() => {
+    loadPersisted();
+  });
+
+  $effect(() => {
+    if (typeof window === "undefined") return;
+    function onResize(): void {
+      viewportW = window.innerWidth;
+      viewportH = window.innerHeight;
+      // Bug #4 — clampFloating() below only ever touched floating
+      // geometry; a live shrink while docked left dockedWidth unclamped.
+      dockedWidth = clamp(dockedWidth, minWidth, maxWidth());
+      clampFloating();
+    }
+    window.addEventListener("resize", onResize);
+    return () => window.removeEventListener("resize", onResize);
+  });
+
+  $effect(() => {
+    if (typeof window === "undefined" || !window.matchMedia) return;
+    const mq = window.matchMedia("(prefers-reduced-motion: reduce)");
+    reducedMotion = mq.matches;
+    const onChange = (e: MediaQueryListEvent): void => {
+      reducedMotion = e.matches;
+    };
+    mq.addEventListener("change", onChange);
+    return () => mq.removeEventListener("change", onChange);
+  });
+
+  const controlsComp = Compartment.of(() =>
+    controls({
+      allow: ControlFrom.selector(".fw-header"),
+      block: ControlFrom.selector("button, a, input, textarea, select"),
+    }),
+  );
+  const boundsComp = Compartment.of(() => bounds(BoundsFrom.viewport()));
+  const posComp = Compartment.of(() => position({ current: { x, y } }));
+  const eventsComp = Compartment.of(() =>
+    events({
+      onDragStart: handleDragStart,
+      onDrag: handleDrag,
+      onDragEnd: handleDragEnd,
+    }),
+  );
+</script>
+
+<div
+  class="fw-root {mode} {className ?? ''}"
+  class:dragging={isDragging}
+  class:resizing={isResizing}
+  class:reduced-motion={reducedMotion}
+  style="width:{width}px; height:{height}px;"
+  role="dialog"
+  aria-label={ariaLabel}
+  tabindex="-1"
+  onkeydown={handleKeydown}
+  {@attach draggable(() => [controlsComp, boundsComp, posComp, eventsComp])}
+>
+  <div
+    class="fw-header"
+    tabindex="0"
+    role="toolbar"
+    aria-label={`${ariaLabel} header`}
+  >
+    <div class="fw-header-content">
+      {@render header?.()}
+    </div>
+    <div class="fw-header-controls">
+      <button
+        type="button"
+        class="fw-icon-btn"
+        aria-label={mode === "docked" ? "Undock (float)" : "Dock to edge"}
+        aria-pressed={mode === "floating"}
+        onclick={toggleDock}
+      >
+        {#if mode === "docked"}
+          <PinOff size={13} />
+        {:else}
+          <Pin size={13} />
+        {/if}
+      </button>
+      {#if onClose}
+        <button
+          type="button"
+          class="fw-icon-btn"
+          aria-label={closeAriaLabel}
+          onclick={onClose}
+        >
+          <X size={13} />
+        </button>
+      {/if}
+    </div>
+  </div>
+
+  <div class="fw-body">
+    {@render children?.()}
+  </div>
+
+  <!-- svelte-ignore a11y_no_noninteractive_tabindex -->
+  <!-- svelte-ignore a11y_no_noninteractive_element_interactions -->
+  <div
+    class="fw-resize fw-resize-left"
+    role="separator"
+    aria-orientation="vertical"
+    aria-label="Resize width"
+    aria-valuenow={Math.round(width)}
+    tabindex="0"
+    onpointerdown={startResize("left")}
+    onkeydown={resizeKeydown("left")}
+  ></div>
+  {#if mode === "floating"}
+    <!-- svelte-ignore a11y_no_noninteractive_tabindex -->
+    <!-- svelte-ignore a11y_no_noninteractive_element_interactions -->
+    <div
+      class="fw-resize fw-resize-right"
+      role="separator"
+      aria-orientation="vertical"
+      aria-label="Resize width"
+      aria-valuenow={Math.round(width)}
+      tabindex="0"
+      onpointerdown={startResize("right")}
+      onkeydown={resizeKeydown("right")}
+    ></div>
+    <!-- svelte-ignore a11y_no_noninteractive_tabindex -->
+    <!-- svelte-ignore a11y_no_noninteractive_element_interactions -->
+    <div
+      class="fw-resize fw-resize-top"
+      role="separator"
+      aria-orientation="horizontal"
+      aria-label="Resize height"
+      aria-valuenow={Math.round(height)}
+      tabindex="0"
+      onpointerdown={startResize("top")}
+      onkeydown={resizeKeydown("top")}
+    ></div>
+    <!-- svelte-ignore a11y_no_noninteractive_tabindex -->
+    <!-- svelte-ignore a11y_no_noninteractive_element_interactions -->
+    <div
+      class="fw-resize fw-resize-bottom"
+      role="separator"
+      aria-orientation="horizontal"
+      aria-label="Resize height"
+      aria-valuenow={Math.round(height)}
+      tabindex="0"
+      onpointerdown={startResize("bottom")}
+      onkeydown={resizeKeydown("bottom")}
+    ></div>
+    <!-- svelte-ignore a11y_no_noninteractive_tabindex -->
+    <!-- svelte-ignore a11y_no_noninteractive_element_interactions -->
+    <div
+      class="fw-resize fw-resize-top-left"
+      role="separator"
+      aria-label="Resize"
+      tabindex="0"
+      onpointerdown={startResize("top-left")}
+      onkeydown={resizeKeydown("top-left")}
+    ></div>
+    <!-- svelte-ignore a11y_no_noninteractive_tabindex -->
+    <!-- svelte-ignore a11y_no_noninteractive_element_interactions -->
+    <div
+      class="fw-resize fw-resize-top-right"
+      role="separator"
+      aria-label="Resize"
+      tabindex="0"
+      onpointerdown={startResize("top-right")}
+      onkeydown={resizeKeydown("top-right")}
+    ></div>
+    <!-- svelte-ignore a11y_no_noninteractive_tabindex -->
+    <!-- svelte-ignore a11y_no_noninteractive_element_interactions -->
+    <div
+      class="fw-resize fw-resize-bottom-left"
+      role="separator"
+      aria-label="Resize"
+      tabindex="0"
+      onpointerdown={startResize("bottom-left")}
+      onkeydown={resizeKeydown("bottom-left")}
+    ></div>
+    <!-- svelte-ignore a11y_no_noninteractive_tabindex -->
+    <!-- svelte-ignore a11y_no_noninteractive_element_interactions -->
+    <div
+      class="fw-resize fw-resize-bottom-right"
+      role="separator"
+      aria-label="Resize"
+      tabindex="0"
+      onpointerdown={startResize("bottom-right")}
+      onkeydown={resizeKeydown("bottom-right")}
+    ></div>
+  {/if}
+</div>
+
+<style>
+  /* Rule 24: this file OWNS its markup — no other layer may :global()
+     re-skin `.fw-*` class names (see rule 24's PRIMITIVE_CLASSES roster). */
+  :global(.fw-root) {
+    position: fixed;
+    top: 0;
+    left: 0;
+    z-index: 40;
+    display: flex;
+    flex-direction: column;
+    min-height: 0;
+    background: var(--bg-1);
+    border: 1px solid var(--line-2);
+    border-radius: 10px;
+    box-shadow: var(--shadow-card);
+    overflow: hidden;
+    touch-action: none;
+  }
+  :global(.fw-root:not(.dragging):not(.resizing)) {
+    transition:
+      transform 120ms ease,
+      width 120ms ease,
+      height 120ms ease;
+  }
+  :global(.fw-root.reduced-motion) {
+    transition: none;
+  }
+  :global(.fw-root:focus-visible) {
+    outline: none;
+  }
+
+  .fw-header {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    gap: 8px;
+    padding: 10px 12px;
+    border-bottom: 1px solid var(--line);
+    flex: none;
+    cursor: grab;
+    touch-action: none;
+  }
+  :global(.fw-root.dragging) .fw-header {
+    cursor: grabbing;
+  }
+  .fw-header:focus-visible {
+    outline: 2px solid var(--accent);
+    outline-offset: -2px;
+  }
+  .fw-header-content {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    min-width: 0;
+    flex: 1;
+  }
+  .fw-header-controls {
+    display: flex;
+    align-items: center;
+    gap: 2px;
+    flex: none;
+  }
+  .fw-icon-btn {
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    width: 24px;
+    height: 24px;
+    padding: 0;
+    border: none;
+    border-radius: 4px;
+    background: transparent;
+    color: var(--fg-3);
+    cursor: pointer;
+    transition:
+      background 120ms ease,
+      color 120ms ease;
+  }
+  .fw-icon-btn:hover {
+    background: var(--bg-2);
+    color: var(--fg-1);
+  }
+  .fw-icon-btn:focus-visible {
+    outline: 2px solid var(--accent);
+    outline-offset: -2px;
+  }
+
+  .fw-body {
+    position: relative;
+    flex: 1;
+    min-height: 0;
+    display: flex;
+    flex-direction: column;
+  }
+
+  .fw-resize {
+    position: absolute;
+    z-index: 5;
+    background: transparent;
+    transition: background 120ms;
+  }
+  :global(.fw-root.reduced-motion) .fw-resize {
+    transition: none;
+  }
+  .fw-resize:hover,
+  .fw-resize:focus-visible {
+    background: var(--accent-dim);
+    outline: none;
+  }
+  .fw-resize:active {
+    background: var(--accent);
+  }
+  .fw-resize-left {
+    top: 0;
+    bottom: 0;
+    left: -3px;
+    width: 6px;
+    cursor: ew-resize;
+  }
+  .fw-resize-right {
+    top: 0;
+    bottom: 0;
+    right: -3px;
+    width: 6px;
+    cursor: ew-resize;
+  }
+  .fw-resize-top {
+    left: 0;
+    right: 0;
+    top: -3px;
+    height: 6px;
+    cursor: ns-resize;
+  }
+  .fw-resize-bottom {
+    left: 0;
+    right: 0;
+    bottom: -3px;
+    height: 6px;
+    cursor: ns-resize;
+  }
+  /* Corners sit above the edge grips (later in DOM order, same z-index) so
+     they win pointer priority in the shared corner pixels. Diagonal cursor
+     matches the axis the corner travels along: nwse for the NW-SE diagonal
+     (top-left / bottom-right), nesw for the NE-SW diagonal (top-right /
+     bottom-left). */
+  .fw-resize-top-left {
+    left: -4px;
+    top: -4px;
+    width: 14px;
+    height: 14px;
+    border-radius: 3px;
+    cursor: nwse-resize;
+  }
+  .fw-resize-top-right {
+    right: -4px;
+    top: -4px;
+    width: 14px;
+    height: 14px;
+    border-radius: 3px;
+    cursor: nesw-resize;
+  }
+  .fw-resize-bottom-left {
+    left: -4px;
+    bottom: -4px;
+    width: 14px;
+    height: 14px;
+    border-radius: 3px;
+    cursor: nesw-resize;
+  }
+  .fw-resize-bottom-right {
+    right: -4px;
+    bottom: -4px;
+    width: 14px;
+    height: 14px;
+    border-radius: 3px;
+    cursor: nwse-resize;
+  }
+</style>
diff --git a/template/src/shared/ui/floating-window/index.ts b/template/src/shared/ui/floating-window/index.ts
new file mode 100644
index 0000000..7e31d3a
--- /dev/null
+++ b/template/src/shared/ui/floating-window/index.ts
@@ -0,0 +1,2 @@
+export { default as FloatingWindow } from "./FloatingWindow.svelte";
+export type { FloatingWindowMode } from "./FloatingWindow.svelte";
diff --git a/template/src/shared/ui/index.ts b/template/src/shared/ui/index.ts
index 2285a25..b9ea920 100644
--- a/template/src/shared/ui/index.ts
+++ b/template/src/shared/ui/index.ts
@@ -1,12 +1,21 @@
-export { Accordion, AccordionItem, AccordionTrigger, AccordionContent } from './accordion';
-export { Alert } from './alert';
-export { Badge } from './badge';
-export { Button } from './button';
-export { ButtonGroup } from './button-group';
-export { Card } from './card';
-export { Checkbox } from './checkbox';
-export { Code } from './code';
-export { Collapsible, CollapsibleTrigger, CollapsibleContent } from './collapsible';
+export {
+  Accordion,
+  AccordionItem,
+  AccordionTrigger,
+  AccordionContent,
+} from "./accordion";
+export { Alert } from "./alert";
+export { Badge } from "./badge";
+export { Button } from "./button";
+export { ButtonGroup } from "./button-group";
+export { Card } from "./card";
+export { Checkbox } from "./checkbox";
+export { Code } from "./code";
+export {
+  Collapsible,
+  CollapsibleTrigger,
+  CollapsibleContent,
+} from "./collapsible";
 export {
   Combobox,
   ComboboxTrigger,
@@ -15,7 +24,7 @@ export {
   ComboboxInput,
   type ComboboxVariant,
   type ComboboxSize,
-} from './combobox';
+} from "./combobox";
 export {
   Command,
   CommandInput,
@@ -24,23 +33,26 @@ export {
   CommandGroup,
   CommandSeparator,
   Item,
-} from './command';
-export { Dialog } from './dialog';
-export { Field } from './field';
-export { Input } from './input';
-export { InputGroup } from './input-group';
-export { Label } from './label';
-export { ModalRoot } from './modal';
-export { Popover, PopoverTrigger, PopoverContent } from './popover';
-export { Progress } from './progress';
-export { Radio, RadioGroup } from './radio-group';
-export { Select, type SelectItem } from './select';
-export { Separator } from './separator';
-export { Skeleton } from './skeleton';
-export { Slider } from './slider';
-export { Spinner } from './spinner';
-export { Switch } from './switch';
-export { Tabs, TabsList, TabsTrigger, TabsContent } from './tabs';
+} from "./command";
+export { Dialog } from "./dialog";
+export { Field } from "./field";
+export { FloatingWindow, type FloatingWindowMode } from "./floating-window";
+export { Input } from "./input";
+export { InputGroup } from "./input-group";
+export { Label } from "./label";
+export { MagicStar } from "./magic-star";
+export { ModalRoot } from "./modal";
+export { Popover, PopoverTrigger, PopoverContent } from "./popover";
+export { Progress } from "./progress";
+export { Radio, RadioGroup } from "./radio-group";
+export { ScrollArea } from "./scroll-area";
+export { Select, type SelectItem } from "./select";
+export { Separator } from "./separator";
+export { Skeleton } from "./skeleton";
+export { Slider } from "./slider";
+export { Spinner } from "./spinner";
+export { Switch } from "./switch";
+export { Tabs, TabsList, TabsTrigger, TabsContent } from "./tabs";
 export {
   Toaster,
   toast,
@@ -48,7 +60,7 @@ export {
   type Toast,
   type ToastInit,
   type ToastVariant,
-} from './toaster';
-export { Toggle } from './toggle';
-export { ToggleGroup, ToggleGroupItem } from './toggle-group';
-export { Tooltip, TooltipProvider } from './tooltip';
+} from "./toaster";
+export { Toggle } from "./toggle";
+export { ToggleGroup, ToggleGroupItem } from "./toggle-group";
+export { Tooltip, TooltipProvider } from "./tooltip";
diff --git a/template/src/shared/ui/magic-star/MagicStar.render.test.ts b/template/src/shared/ui/magic-star/MagicStar.render.test.ts
new file mode 100644
index 0000000..819a06f
--- /dev/null
+++ b/template/src/shared/ui/magic-star/MagicStar.render.test.ts
@@ -0,0 +1,87 @@
+// @vitest-environment happy-dom
+/**
+ * Coverage for the `MagicStar` primitive — the compact chat-launcher icon
+ * (extraboost.ai signature gradient stroke on a ✨ sparkles motif: one main
+ * four-pointed sparkle + two small accent sparkles). Harness: happy-dom +
+ * Svelte's built-in mount(), same pattern as the sibling
+ * FloatingWindow.render.test.ts.
+ */
+import { describe, it, expect, afterEach } from "vitest";
+import { mount, unmount, flushSync } from "svelte";
+import MagicStar from "./MagicStar.svelte";
+
+let host: HTMLElement | null = null;
+let instance: unknown = null;
+
+function mountStar(props: Record<string, unknown> = {}): HTMLElement {
+  host = document.createElement("div");
+  document.body.appendChild(host);
+  instance = mount(MagicStar, { target: host, props });
+  flushSync();
+  return host;
+}
+
+afterEach(() => {
+  if (instance) {
+    unmount(instance as object);
+    instance = null;
+  }
+  host?.remove();
+  host = null;
+});
+
+describe("MagicStar", () => {
+  it("renders a decorative svg with a gradient-stroked sparkles motif", () => {
+    const root = mountStar();
+
+    const svg = root.querySelector("svg.magic-star");
+    expect(svg).not.toBeNull();
+    expect(svg!.getAttribute("aria-hidden")).toBe("true");
+    expect(svg!.getAttribute("fill")).toBe("none");
+
+    const gradient = svg!.querySelector("linearGradient");
+    expect(gradient).not.toBeNull();
+    const gradientId = gradient!.getAttribute("id");
+    expect(gradientId).toMatch(/^magic-star-grad-/);
+
+    const stops = Array.from(gradient!.querySelectorAll("stop"));
+    expect(stops.length).toBe(6);
+    expect(stops[0]?.getAttribute("stop-color")).toBe("#5B8DEF");
+    expect(stops[5]?.getAttribute("stop-color")).toBe("#5B8DEF");
+
+    // The stroke lives on the wrapping <g> — main sparkle + accent sparkles
+    // all share the one animated gradient contour.
+    const group = svg!.querySelector("g");
+    expect(group).not.toBeNull();
+    expect(group!.getAttribute("stroke")).toBe(`url(#${gradientId})`);
+
+    // Main sparkle + two small accent sparkles = at least 3 path segments.
+    const paths = svg!.querySelectorAll("path");
+    expect(paths.length).toBeGreaterThanOrEqual(3);
+  });
+
+  it("defaults to a 20px box and honors an explicit size", () => {
+    const root = mountStar({ size: 32 });
+    const svg = root.querySelector("svg.magic-star")!;
+    expect(svg.getAttribute("width")).toBe("32");
+    expect(svg.getAttribute("height")).toBe("32");
+  });
+
+  it("gives each instance a distinct gradient id so multiple stars never collide", () => {
+    const rootA = mountStar();
+    const idA = rootA.querySelector("linearGradient")!.getAttribute("id");
+    unmount(instance as object);
+    instance = null;
+    host?.remove();
+
+    const rootB = mountStar();
+    const idB = rootB.querySelector("linearGradient")!.getAttribute("id");
+
+    expect(idA).not.toBe(idB);
+  });
+
+  it("renders animateTransform by default (motion allowed)", () => {
+    const root = mountStar();
+    expect(root.querySelector("animateTransform")).not.toBeNull();
+  });
+});
diff --git a/template/src/shared/ui/magic-star/MagicStar.svelte b/template/src/shared/ui/magic-star/MagicStar.svelte
new file mode 100644
index 0000000..4032492
--- /dev/null
+++ b/template/src/shared/ui/magic-star/MagicStar.svelte
@@ -0,0 +1,128 @@
+<script module lang="ts">
+  let magicStarInstanceCount = 0;
+</script>
+
+<script lang="ts">
+  interface Props {
+    size?: number;
+    class?: string;
+  }
+
+  let { size = 20, class: className }: Props = $props();
+
+  const gradientId = `magic-star-grad-${++magicStarInstanceCount}`;
+
+  let reducedMotion = $state(false);
+
+  $effect(() => {
+    if (typeof window === 'undefined' || !window.matchMedia) return;
+    const mq = window.matchMedia('(prefers-reduced-motion: reduce)');
+    reducedMotion = mq.matches;
+    const onChange = (e: MediaQueryListEvent) => {
+      reducedMotion = e.matches;
+    };
+    mq.addEventListener('change', onChange);
+    return () => mq.removeEventListener('change', onChange);
+  });
+</script>
+
+<svg
+  class="magic-star {className ?? ''}"
+  width={size}
+  height={size}
+  viewBox="-1 -1 26 26"
+  fill="none"
+  role="img"
+  aria-hidden="true"
+>
+  <defs>
+    <linearGradient
+      id={gradientId}
+      x1="0"
+      y1="0"
+      x2="1"
+      y2="1"
+      gradientUnits="objectBoundingBox"
+    >
+      <stop offset="0%" stop-color="#5B8DEF" />
+      <stop offset="20%" stop-color="#9D7BEA" />
+      <stop offset="40%" stop-color="#FB7185" />
+      <stop offset="60%" stop-color="#FBBF24" />
+      <stop offset="80%" stop-color="#34D399" />
+      <stop offset="100%" stop-color="#5B8DEF" />
+      {#if !reducedMotion}
+        <!-- Faster rotation (3s, was 6s) so the gradient's sweep across the
+             sparkle's arms reads as an obvious blue→violet→rose→amber→
+             emerald cycle rather than a near-static tint. -->
+        <animateTransform
+          attributeName="gradientTransform"
+          type="rotate"
+          from="0 0.5 0.5"
+          to="360 0.5 0.5"
+          dur="3s"
+          repeatCount="indefinite"
+        />
+      {/if}
+    </linearGradient>
+  </defs>
+  <!-- ✨ sparkles motif — one main four-pointed sparkle (concave-sided
+       "twinkle", N/E/S/W long points) plus two small accent sparkles
+       (top-right, bottom-left), all sharing the animated gradient stroke
+       via the group's `stroke`. Geometry mirrors the widely-used
+       Lucide "sparkles" icon shape. -->
+  <g
+    stroke="url(#{gradientId})"
+    stroke-width="1.75"
+    stroke-linejoin="round"
+    stroke-linecap="round"
+  >
+    <path
+      d="M9.937 15.5A2 2 0 0 0 8.5 14.063l-6.135-1.582a.5.5 0 0 1 0-.962L8.5 9.936A2 2 0 0 0 9.937 8.5l1.582-6.135a.5.5 0 0 1 .963 0L14.063 8.5A2 2 0 0 0 15.5 9.937l6.135 1.581a.5.5 0 0 1 0 .964L15.5 14.063a2 2 0 0 0-1.437 1.437l-1.582 6.135a.5.5 0 0 1-.963 0z"
+    />
+    <path d="M20 3v4M22 5h-4" />
+    <path d="M4 17v2M5 18H3" />
+  </g>
+</svg>
+
+<style>
+  /* The rotating gradientTransform (SMIL, above) sweeps color across the
+     sparkle's arms; layered on top, a gentle CSS hue-rotate makes the
+     color change unmistakable at a glance (belt-and-suspenders — the SMIL
+     rotation alone reads too subtly on a shape this small). Both freeze
+     under prefers-reduced-motion: the SMIL <animateTransform> is
+     conditionally omitted above, and the CSS animation is disabled below.
+     Tasteful pace (4s per hue cycle), not seizure-fast. */
+  .magic-star {
+    display: block;
+    flex-shrink: 0;
+    animation: magic-star-hue 4s linear infinite;
+    filter:
+      hue-rotate(0deg)
+      drop-shadow(0 0 3px rgba(157, 123, 234, 0.55))
+      drop-shadow(0 0 5px rgba(91, 141, 239, 0.3));
+  }
+
+  @keyframes magic-star-hue {
+    0% {
+      filter:
+        hue-rotate(0deg)
+        drop-shadow(0 0 3px rgba(157, 123, 234, 0.55))
+        drop-shadow(0 0 5px rgba(91, 141, 239, 0.3));
+    }
+    100% {
+      filter:
+        hue-rotate(360deg)
+        drop-shadow(0 0 3px rgba(157, 123, 234, 0.55))
+        drop-shadow(0 0 5px rgba(91, 141, 239, 0.3));
+    }
+  }
+
+  @media (prefers-reduced-motion: reduce) {
+    .magic-star {
+      animation: none;
+      filter:
+        drop-shadow(0 0 3px rgba(157, 123, 234, 0.55))
+        drop-shadow(0 0 5px rgba(91, 141, 239, 0.3));
+    }
+  }
+</style>
diff --git a/template/src/shared/ui/magic-star/index.ts b/template/src/shared/ui/magic-star/index.ts
new file mode 100644
index 0000000..793fb1a
--- /dev/null
+++ b/template/src/shared/ui/magic-star/index.ts
@@ -0,0 +1 @@
+export { default as MagicStar } from './MagicStar.svelte';
diff --git a/template/src/shared/ui/scroll-area/ScrollArea.svelte b/template/src/shared/ui/scroll-area/ScrollArea.svelte
new file mode 100644
index 0000000..0137eb8
--- /dev/null
+++ b/template/src/shared/ui/scroll-area/ScrollArea.svelte
@@ -0,0 +1,95 @@
+<script lang="ts">
+  /**
+   * ScrollArea — token-styled wrapper over bits-ui's ScrollArea (rule 24: a
+   * shared/ui-class primitive, not something upper layers hand-roll). Hides
+   * the native scrollbar and renders a custom vertical thumb using
+   * `--line-2`/`--line-3`/`--fg-3` so it stays correct in both themes for
+   * free, the same way every other primitive reads tokens instead of
+   * hardcoding colors. `viewportRef` is exposed so a caller (e.g. a chat
+   * message list) can read `scrollTop`/`scrollHeight` and call `scrollTo`
+   * directly on the real scrolling element.
+   */
+  import type { Snippet } from 'svelte';
+  import { ScrollArea as ScrollAreaPrimitive } from 'bits-ui';
+
+  interface Props {
+    class?: string;
+    viewportClass?: string;
+    /** `type="hover"` (bits-ui default) shows the scrollbar on hover/scroll
+     * only — matches the rest of the app's subtle-scrollbar convention. */
+    type?: 'hover' | 'scroll' | 'auto' | 'always';
+    viewportRef?: HTMLDivElement | null;
+    onViewportScroll?: (event: Event) => void;
+    children?: Snippet;
+  }
+
+  let {
+    class: className,
+    viewportClass,
+    type = 'hover',
+    viewportRef = $bindable(null),
+    onViewportScroll,
+    children,
+  }: Props = $props();
+</script>
+
+<ScrollAreaPrimitive.Root class="scroll-area {className ?? ''}" {type}>
+  <ScrollAreaPrimitive.Viewport
+    bind:ref={viewportRef}
+    class="scroll-area-viewport {viewportClass ?? ''}"
+    onscroll={onViewportScroll}
+  >
+    {@render children?.()}
+  </ScrollAreaPrimitive.Viewport>
+  <ScrollAreaPrimitive.Scrollbar orientation="vertical" class="scroll-area-scrollbar">
+    <ScrollAreaPrimitive.Thumb class="scroll-area-thumb" />
+  </ScrollAreaPrimitive.Scrollbar>
+  <ScrollAreaPrimitive.Corner />
+</ScrollAreaPrimitive.Root>
+
+<style>
+  :global(.scroll-area) {
+    position: relative;
+    overflow: hidden;
+    width: 100%;
+    height: 100%;
+  }
+
+  :global(.scroll-area-viewport) {
+    width: 100%;
+    height: 100%;
+  }
+
+  :global(.scroll-area-scrollbar) {
+    display: flex;
+    user-select: none;
+    touch-action: none;
+    padding: 2px;
+    width: 10px;
+    background: transparent;
+    transition: background 120ms ease;
+  }
+
+  :global(.scroll-area-scrollbar:hover) {
+    background: var(--bg-2);
+  }
+
+  :global(.scroll-area-thumb) {
+    flex: 1;
+    position: relative;
+    background: var(--line-3);
+    border-radius: 999px;
+  }
+
+  :global(.scroll-area-scrollbar:hover .scroll-area-thumb) {
+    background: var(--fg-3);
+  }
+
+  /* Larger invisible hit target than the visible thumb, same touch-target
+   * generosity as the rest of the catalogue's compact controls. */
+  :global(.scroll-area-thumb::before) {
+    content: '';
+    position: absolute;
+    inset: -6px;
+  }
+</style>
diff --git a/template/src/shared/ui/scroll-area/index.ts b/template/src/shared/ui/scroll-area/index.ts
new file mode 100644
index 0000000..10814c9
--- /dev/null
+++ b/template/src/shared/ui/scroll-area/index.ts
@@ -0,0 +1 @@
+export { default as ScrollArea } from "./ScrollArea.svelte";
diff --git a/template/src/widgets/composed-map/model/camera-bus.svelte.ts b/template/src/widgets/composed-map/model/camera-bus.svelte.ts
new file mode 100644
index 0000000..f22b4d4
--- /dev/null
+++ b/template/src/widgets/composed-map/model/camera-bus.svelte.ts
@@ -0,0 +1,39 @@
+// RFC-034 (Pillar C) — the ONE seam a chat (Tier 0 or Tier 1) uses to drive
+// ComposedMapView's existing camera (RFC-033 Invariant 2: fitToRect stays
+// the only camera-move primitive; this module never touches the DOM or the
+// zoom behaviour itself). Mirrors node-tabs.svelte.ts's plain module-level
+// $state store shape — no class, no context, one shared instance per page.
+
+export type CameraTarget = {
+  kind: "zone" | "node" | "flow";
+  id: string;
+};
+
+export interface CameraRequest {
+  target: CameraTarget | null;
+  /**
+   * Monotonically increasing per `showOnMap` call. The view keys its
+   * consuming $effect on this counter rather than on `target` identity, so
+   * asking to look at the SAME zone/node/flow twice in a row still re-fires
+   * the camera move (e.g. re-asking "where is X" recentres the view instead
+   * of being a silent no-op because the target object looks unchanged).
+   */
+  seq: number;
+}
+
+let request = $state<CameraRequest>({ target: null, seq: 0 });
+
+/** Chat writes: request the view's camera move to the given target. */
+export function showOnMap(target: CameraTarget): void {
+  request = { target, seq: request.seq + 1 };
+}
+
+/** View reads: the current camera request (target + seq to key off of). */
+export function currentCameraRequest(): CameraRequest {
+  return request;
+}
+
+/** Clears the current target without bumping `seq` (no new camera move). */
+export function clearCameraTarget(): void {
+  request = { target: null, seq: request.seq };
+}
diff --git a/template/src/widgets/composed-map/model/camera-bus.test.ts b/template/src/widgets/composed-map/model/camera-bus.test.ts
new file mode 100644
index 0000000..28c5da1
--- /dev/null
+++ b/template/src/widgets/composed-map/model/camera-bus.test.ts
@@ -0,0 +1,61 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import {
+  showOnMap,
+  currentCameraRequest,
+  clearCameraTarget,
+  type CameraTarget,
+} from "./camera-bus.svelte";
+
+// Module-level $state persists across tests in this file (same singleton
+// the real view consumes) — reset it before every test so cases don't leak
+// into each other, mirroring the isolation node-tabs.test.ts gets for free
+// from per-test-unique ids (a single current-target store has no such luxury).
+beforeEach(() => {
+  clearCameraTarget();
+});
+
+describe("camera-bus", () => {
+  it("starts with no target", () => {
+    expect(currentCameraRequest().target).toBeNull();
+  });
+
+  it("round-trips a target through showOnMap / currentCameraRequest", () => {
+    const target: CameraTarget = { kind: "zone", id: "zone-a" };
+    showOnMap(target);
+    expect(currentCameraRequest().target).toEqual(target);
+  });
+
+  it("increments seq on every showOnMap call", () => {
+    const before = currentCameraRequest().seq;
+    showOnMap({ kind: "node", id: "node-a" });
+    const afterFirst = currentCameraRequest().seq;
+    expect(afterFirst).toBe(before + 1);
+    showOnMap({ kind: "node", id: "node-a" });
+    const afterSecond = currentCameraRequest().seq;
+    expect(afterSecond).toBe(afterFirst + 1);
+  });
+
+  it("increments seq even when the SAME target is requested twice", () => {
+    const target: CameraTarget = { kind: "flow", id: "flow-a" };
+    showOnMap(target);
+    const firstSeq = currentCameraRequest().seq;
+    showOnMap(target);
+    const secondSeq = currentCameraRequest().seq;
+    expect(secondSeq).toBe(firstSeq + 1);
+    expect(currentCameraRequest().target).toEqual(target);
+  });
+
+  it("clearCameraTarget resets the target to null", () => {
+    showOnMap({ kind: "zone", id: "zone-b" });
+    expect(currentCameraRequest().target).not.toBeNull();
+    clearCameraTarget();
+    expect(currentCameraRequest().target).toBeNull();
+  });
+
+  it("clearCameraTarget does not bump seq", () => {
+    showOnMap({ kind: "zone", id: "zone-c" });
+    const seqAfterShow = currentCameraRequest().seq;
+    clearCameraTarget();
+    expect(currentCameraRequest().seq).toBe(seqAfterShow);
+  });
+});
diff --git a/template/src/widgets/composed-map/ui/ComposedMapView.svelte b/template/src/widgets/composed-map/ui/ComposedMapView.svelte
index 0738e7a..fbe606f 100644
--- a/template/src/widgets/composed-map/ui/ComposedMapView.svelte
+++ b/template/src/widgets/composed-map/ui/ComposedMapView.svelte
@@ -69,10 +69,14 @@
     type TourState,
     type TourStop,
   } from "@/widgets/composed-map/model/tour-state";
+  import {
+    currentCameraRequest,
+    type CameraTarget,
+  } from "@/widgets/composed-map/model/camera-bus.svelte";
   import type { ArtifactSummary } from "@/entities/artifact";
   import type { GraphEdge } from "@/entities/graph";
   import type { ScoreEntry } from "@/entities/score";
-  import { Alert, Badge, Button } from "@/shared/ui";
+  import { Alert, Badge, Button, MagicStar } from "@/shared/ui";
   import ZoneSlab from "./ZoneSlab.svelte";
   import NodeCard from "./NodeCard.svelte";
   import EdgeLayer from "./EdgeLayer.svelte";
@@ -80,6 +84,7 @@
   import LevelBreadcrumb from "./LevelBreadcrumb.svelte";
   import ZoneDetailCard from "./ZoneDetailCard.svelte";
   import OnboardTour from "./OnboardTour.svelte";
+  import MapChat from "@/widgets/map-chat/ui/MapChat.svelte";
 
   let {
     selectedId = null,
@@ -134,6 +139,12 @@
 
   let lastDoc = $state<MapDocument | null>(null);
   let activeFlow = $state<string | null>(null);
+  // RFC-034 (Pillar C, Phase 1b) — the chat drawer's open state. Now fully
+  // internal: the launcher lives in the FlowChips `leading` slot (left of
+  // "All") for every host, so no host needs to drive it externally anymore
+  // (superseded the earlier host-driven-launcher prop pair from the
+  // short-lived onboard-header launcher).
+  let chatOpen = $state(false);
 
   // Zone hover ring (ZoneSlab visual only). Driven by the same geometry
   // test as click-descend (hitTestZone), not DOM :hover — a node card
@@ -151,6 +162,25 @@
   // them.
   let detailZoneId = $state<string | null>(null);
 
+  // Dwell delay (bottom-left corner UX polish) — hoveredZoneId above keeps
+  // tracking the cursor immediately for the ring; detailZoneId only
+  // updates once the cursor rests on a *different* zone for ZONE_DWELL_MS
+  // with no intervening pointermove (handleCanvasPointerMove clears and
+  // restarts this timer on every qualifying move, so a moving cursor
+  // never lets it complete — only a genuine rest fires it). Cleared in
+  // closeZoneDetail, on every level change (descend/ascend/climbTo), when
+  // the map goes non-live, and on teardown so no stray timer fires after
+  // unmount/navigation.
+  let dwellTimer: ReturnType<typeof setTimeout> | null = null;
+  const ZONE_DWELL_MS = 350;
+
+  function clearDwellTimer() {
+    if (dwellTimer !== null) {
+      clearTimeout(dwellTimer);
+      dwellTimer = null;
+    }
+  }
+
   // RFC-031 Phase 3 — drill-down level stack. View state only, never
   // document state: level 0 (empty focusChain) folds to the root doc
   // verbatim (FR-008 zero-regression).
@@ -403,6 +433,13 @@
   let tour = $state<TourState>({ active: false, index: 0 });
   let reducedMotion = $state(false);
 
+  // RFC-034 (Pillar C, Phase 1b) — the Tier-0 chat drawer's open state.
+  // Internal open/close state; the transcript itself lives in
+  // chat-store.svelte.ts, surviving the panel being closed/reopened.
+  function toggleChat() {
+    chatOpen = !chatOpen;
+  }
+
   $effect(() => {
     if (typeof window === "undefined" || !window.matchMedia) return;
     const mq = window.matchMedia("(prefers-reduced-motion: reduce)");
@@ -453,6 +490,56 @@
     if (rect) fitToRect(rect, !reducedMotion);
   });
 
+  // RFC-034 (Pillar C, Phase 1a) — camera-bus consumption. The ONE seam a
+  // chat (Tier 0 today, Tier 1 later) uses to drive this view's existing
+  // camera; reuses fitToRect / onSelect / activeFlow verbatim (Invariant 2:
+  // no second camera controller). A target that doesn't resolve against the
+  // CURRENT level's document/layout (rect missing, node/flow not found) is a
+  // silent no-op — the chat's grounding is best-effort (RFC-034 OQ4).
+  function applyCameraTarget(target: CameraTarget): void {
+    if (!activeDoc || !layout) return;
+    if (target.kind === "zone") {
+      const rect = layout.zoneRects.get(target.id);
+      if (rect) fitToRect(rect, !reducedMotion);
+      return;
+    }
+    if (target.kind === "node") {
+      const node = activeDoc.nodes.find((n) => n.id === target.id);
+      if (!node) return;
+      // Mirrors handleNodeClick's non-descend branches: a real artifact
+      // selects by artifact_id, a plain code node opens its detail tab.
+      if (node.artifact_id) {
+        onSelect?.({ id: node.artifact_id });
+      } else {
+        setNodeTab(node.id, {
+          node,
+          connections: buildNodeConnections(activeDoc, node.id),
+        });
+        onSelect?.({ id: `node:${node.id}` });
+      }
+      const rect = layout.zoneRects.get(node.zone);
+      if (rect) fitToRect(rect, !reducedMotion);
+      return;
+    }
+    const flowExists =
+      activeDoc.flows?.some((f) => f.id === target.id) ?? false;
+    if (flowExists) activeFlow = target.id;
+  }
+
+  // Plain (non-reactive) bookkeeping, same idiom as prevRatio/cooldownUntil
+  // above — tracks the last-consumed request so a re-render that doesn't
+  // touch camera-bus (e.g. a layout recompute) never re-applies a stale
+  // target, while a genuinely new `showOnMap` (bumped `seq`) always does,
+  // even when it targets the same zone/node/flow as before.
+  let lastCameraSeq = 0;
+
+  $effect(() => {
+    const req = currentCameraRequest();
+    if (req.seq === lastCameraSeq) return;
+    lastCameraSeq = req.seq;
+    if (req.target) applyCameraTarget(req.target);
+  });
+
   // Zoom-to-fit only the FIRST non-empty layout (didFit latches); later
   // meta.version recomputes must not disturb the user's pan/zoom. The
   // queueMicrotask callback can outlive this effect (e.g. the view is
@@ -510,9 +597,11 @@
   // unclickable overlay under the frozen dimming.
   $effect(() => {
     if (!isLive) {
+      clearDwellTimer();
       hoveredZoneId = null;
       detailZoneId = null;
       tour = exitTour(tour);
+      chatOpen = false;
     }
   });
 
@@ -524,6 +613,12 @@
     return () => clearTimeout(timer);
   });
 
+  // Component teardown — a pending dwell timer must not fire after
+  // unmount (e.g. navigating away from the composed-map view mid-dwell).
+  $effect(() => {
+    return () => clearDwellTimer();
+  });
+
   // PRD-038 FR-002 (E3 seam) — fetches an emitted per-zone layer at most
   // once per zoneId and stores the validated result (or `null` on
   // absent/invalid) in layerCache. Fire-and-forget from descend(): the
@@ -575,7 +670,13 @@
     cooldownUntil = Date.now() + COOLDOWN_MS;
     prevRatio = 1;
     nothingDeeperLabel = null;
+    clearDwellTimer();
     detailZoneId = null;
+    // Bug #8 — deriveSubDocument zone ids are deterministic
+    // (`sub:<focusId>:<layerToken>`), so re-descending into the same zone
+    // without this would flash a stale hover ring until the next
+    // pointermove recomputes it.
+    hoveredZoneId = null;
     activeFlow = null;
     fitToView(true, childLayout);
   }
@@ -588,7 +689,9 @@
     levelStack = popLevel(levelStack);
     cooldownUntil = Date.now() + COOLDOWN_MS;
     prevRatio = target.kFit > 0 ? clamped.k / target.kFit : 1;
+    clearDwellTimer();
     detailZoneId = null;
+    hoveredZoneId = null; // Bug #8 — see descend()'s comment.
     activeFlow = null;
     applyTransform(clamped, true);
   }
@@ -601,7 +704,9 @@
     levelStack = climbToFrame(levelStack, index);
     cooldownUntil = Date.now() + COOLDOWN_MS;
     prevRatio = target.kFit > 0 ? clamped.k / target.kFit : 1;
+    clearDwellTimer();
     detailZoneId = null;
+    hoveredZoneId = null; // Bug #8 — see descend()'s comment.
     activeFlow = null;
     applyTransform(clamped, true);
   }
@@ -667,10 +772,12 @@
   // canvas via the same hitTestZone geometry test click-descend uses, so
   // a node card sitting on top of a zone still resolves to that zone.
   // hoveredZoneId (the ZoneSlab ring) tracks the cursor exactly and clears
-  // on empty canvas; detailZoneId (the sticky card) only ever advances to
-  // a newly-hovered zone and is left alone otherwise — moving the cursor
-  // onto the now-interactive card, or off the canvas entirely, must not
-  // clear it (see closeZoneDetail for the explicit dismissal path).
+  // on empty canvas; detailZoneId (the sticky card) only advances to a
+  // newly-hovered zone once the cursor has dwelt on it for ZONE_DWELL_MS
+  // (see the dwell-timer block below) and is left alone otherwise —
+  // moving the cursor onto the now-interactive card, or off the canvas
+  // entirely, must not clear it (see closeZoneDetail for the explicit
+  // dismissal path).
   function handleCanvasPointerMove(event: PointerEvent) {
     if (!svgEl || !activeDoc || !layout) return;
     const zoneId = hitTestZone(
@@ -684,10 +791,34 @@
       layout.zoneRects,
     );
     hoveredZoneId = zoneId;
-    if (zoneId) detailZoneId = zoneId;
+
+    // Cursor left every zone, or is already parked on the shown zone —
+    // nothing to (re-)arm. A null zoneId here deliberately does NOT clear
+    // an already-shown detailZoneId (sticky behaviour).
+    if (!zoneId || zoneId === detailZoneId) {
+      clearDwellTimer();
+      return;
+    }
+
+    // A new hover target: (re)start the dwell timer. Every qualifying
+    // pointermove clears+restarts it, so a cursor that keeps moving
+    // (even within the same still-not-shown zone) never lets it
+    // complete — only a genuine rest of ZONE_DWELL_MS with no
+    // intervening move fires it. capturedZoneId is fixed by closure; the
+    // hoveredZoneId check on fire guards against a stale timer applying
+    // after the cursor has moved on by the time it fires.
+    clearDwellTimer();
+    const capturedZoneId = zoneId;
+    dwellTimer = setTimeout(() => {
+      dwellTimer = null;
+      if (hoveredZoneId === capturedZoneId) {
+        detailZoneId = capturedZoneId;
+      }
+    }, ZONE_DWELL_MS);
   }
 
   function closeZoneDetail() {
+    clearDwellTimer();
     detailZoneId = null;
   }
 
@@ -805,6 +936,12 @@
       }
       return;
     }
+    // RFC-034 (Pillar C, Phase 1b) — the chat drawer owns Escape while open,
+    // same "topmost overlay first" ordering as the tour branch above.
+    if (chatOpen && event.key === "Escape") {
+      chatOpen = false;
+      return;
+    }
     if (event.key !== "Escape") return;
     if (levelStack.length > 1) {
       ascend();
@@ -1045,7 +1182,29 @@
         flows={activeDoc.flows ?? []}
         activeFlowId={activeFlow}
         onToggle={(id) => (activeFlow = id)}
-      />
+      >
+        {#snippet leading()}
+          <!-- RFC-034/RFC-035 — the star launcher now lives left of "All" in
+               the top chips toolbar (not the bottom-right canvas footer),
+               for both hosts (dashboard + /onboard). -->
+          <Button
+            variant="ghost"
+            size="icon"
+            disabled={!isLive}
+            aria-label={chatOpen ? "Close chat" : "Ask the map"}
+            aria-expanded={chatOpen}
+            aria-controls="map-chat-panel"
+            onclick={toggleChat}
+          >
+            <MagicStar />
+          </Button>
+        {/snippet}
+      </FlowChips>
+      {#if chatOpen && okDoc}
+        <div id="map-chat-panel">
+          <MapChat doc={okDoc} onClose={() => (chatOpen = false)} />
+        </div>
+      {/if}
       {#if detailZone}
         {@const zone = detailZone}
         <ZoneDetailCard
@@ -1200,6 +1359,20 @@
     z-index: 3;
   }
 
+  /* The MapChat mount point (`#map-chat-panel` above) used to be a sized
+     position:absolute box matching a pre-RFC-035 fixed drawer. MapChat's own
+     FloatingWindow root is `position: fixed` and owns 100% of its geometry
+     (drag/resize/dock/viewport-clamp), so this mount point now carries NO
+     layout/positioning of its own — it exists purely as the DOM anchor for
+     `id="map-chat-panel"` (the launcher's `aria-controls` target). Giving it
+     `position` + a numeric `z-index` would establish a stacking context that
+     traps FloatingWindow's fixed-positioned root inside it (a `position:
+     fixed` descendant of a stacking-context-establishing ancestor is still
+     painted within that ancestor's local stacking order), defeating the
+     "escapes to the viewport" behaviour MapChat.svelte's own header comment
+     describes — so this box is deliberately un-styled (default `display:
+     block`, no position, no z-index). */
+
   .node-hit {
     cursor: pointer;
   }
diff --git a/template/src/widgets/composed-map/ui/FlowChips.render.test.ts b/template/src/widgets/composed-map/ui/FlowChips.render.test.ts
new file mode 100644
index 0000000..b3cf338
--- /dev/null
+++ b/template/src/widgets/composed-map/ui/FlowChips.render.test.ts
@@ -0,0 +1,93 @@
+// @vitest-environment happy-dom
+/**
+ * Coverage for FlowChips's `leading` snippet slot (RFC-035) — the compact
+ * chat-star launcher renders BEFORE the "All" chip, and the guard change
+ * (`flows.length > 0 || leading`) means a `leading` snippet still renders
+ * `.flow-chips` even when there are zero flows (only the launcher shows;
+ * no "All" / per-flow chips).
+ */
+import { describe, it, expect, afterEach } from "vitest";
+import { mount, unmount, flushSync, createRawSnippet } from "svelte";
+import FlowChips from "./FlowChips.svelte";
+import type { MapFlow } from "@/entities/map";
+
+const FLOWS: MapFlow[] = [
+  { id: "flow-a", name: "Flow A", node_ids: ["n1", "n2"] },
+  { id: "flow-b", name: "Flow B", node_ids: ["n3"] },
+];
+
+let host: HTMLElement | null = null;
+let instance: unknown = null;
+
+function launcherSnippet() {
+  return createRawSnippet(() => ({
+    render: () =>
+      `<button class="test-launcher" aria-label="Ask the map">star</button>`,
+  }));
+}
+
+function mountChips(
+  props: {
+    flows: ReadonlyArray<MapFlow>;
+    leading?: ReturnType<typeof createRawSnippet>;
+  },
+): HTMLElement {
+  host = document.createElement("div");
+  document.body.appendChild(host);
+  instance = mount(FlowChips, { target: host, props });
+  flushSync();
+  return host;
+}
+
+afterEach(() => {
+  if (instance) {
+    unmount(instance as object);
+    instance = null;
+  }
+  host?.remove();
+  host = null;
+});
+
+describe("FlowChips leading slot", () => {
+  it("renders the leading snippet as the first child, before the All chip", () => {
+    const root = mountChips({ flows: FLOWS, leading: launcherSnippet() });
+
+    const chips = root.querySelector(".flow-chips");
+    expect(chips).not.toBeNull();
+
+    const firstChild = chips!.firstElementChild;
+    expect(firstChild?.classList.contains("test-launcher")).toBe(true);
+
+    const buttons = Array.from(chips!.querySelectorAll("button"));
+    expect(buttons[0]!.classList.contains("test-launcher")).toBe(true);
+    expect(buttons[1]!.textContent?.trim()).toBe("All");
+  });
+
+  it("renders only the leading launcher when there are zero flows", () => {
+    const root = mountChips({ flows: [], leading: launcherSnippet() });
+
+    const chips = root.querySelector(".flow-chips");
+    expect(chips).not.toBeNull();
+
+    const buttons = Array.from(chips!.querySelectorAll("button"));
+    expect(buttons.length).toBe(1);
+    expect(buttons[0]!.classList.contains("test-launcher")).toBe(true);
+    expect(chips!.textContent).not.toContain("All");
+  });
+
+  it("renders nothing when there are zero flows and no leading snippet (unchanged default behaviour)", () => {
+    const root = mountChips({ flows: [] });
+
+    expect(root.querySelector(".flow-chips")).toBeNull();
+  });
+
+  it("renders All + per-flow chips with no leading slot (unchanged default behaviour)", () => {
+    const root = mountChips({ flows: FLOWS });
+
+    const chips = root.querySelector(".flow-chips");
+    expect(chips).not.toBeNull();
+    const buttons = Array.from(chips!.querySelectorAll("button"));
+    expect(buttons.length).toBe(3); // All + 2 flows
+    expect(buttons[0]!.textContent?.trim()).toBe("All");
+  });
+});
diff --git a/template/src/widgets/composed-map/ui/FlowChips.svelte b/template/src/widgets/composed-map/ui/FlowChips.svelte
index 2f3d352..7742b00 100644
--- a/template/src/widgets/composed-map/ui/FlowChips.svelte
+++ b/template/src/widgets/composed-map/ui/FlowChips.svelte
@@ -1,4 +1,5 @@
 <script lang="ts">
+  import type { Snippet } from "svelte";
   import type { MapFlow } from "@/entities/map";
   import { Button } from "@/shared/ui";
 
@@ -14,32 +15,41 @@
     flows,
     activeFlowId = null,
     onToggle,
+    leading,
   }: {
     flows: ReadonlyArray<MapFlow>;
     activeFlowId?: string | null;
     onToggle?: (id: string | null) => void;
+    /** Optional leading slot rendered BEFORE the "All" chip (e.g. the
+     * compact star chat launcher). Renders even when `flows.length === 0`
+     * — see the guard below — so a caller's launcher is never hidden on a
+     * flow-less map/level. */
+    leading?: Snippet;
   } = $props();
 </script>
 
-{#if flows.length > 0}
+{#if flows.length > 0 || leading}
   <div class="flow-chips">
-    <Button
-      variant={activeFlowId === null ? "primary" : "secondary"}
-      size="sm"
-      aria-pressed={activeFlowId === null}
-      onclick={() => onToggle?.(null)}>All</Button
-    >
-    {#each flows as flow (flow.id)}
+    {@render leading?.()}
+    {#if flows.length > 0}
       <Button
-        variant={flow.id === activeFlowId ? "primary" : "secondary"}
+        variant={activeFlowId === null ? "primary" : "secondary"}
         size="sm"
-        aria-pressed={flow.id === activeFlowId}
-        title={flow.name}
-        onclick={() => onToggle?.(flow.id === activeFlowId ? null : flow.id)}
+        aria-pressed={activeFlowId === null}
+        onclick={() => onToggle?.(null)}>All</Button
       >
-        {truncateLabel(flow.name)}
-      </Button>
-    {/each}
+      {#each flows as flow (flow.id)}
+        <Button
+          variant={flow.id === activeFlowId ? "primary" : "secondary"}
+          size="sm"
+          aria-pressed={flow.id === activeFlowId}
+          title={flow.name}
+          onclick={() => onToggle?.(flow.id === activeFlowId ? null : flow.id)}
+        >
+          {truncateLabel(flow.name)}
+        </Button>
+      {/each}
+    {/if}
   </div>
 {/if}
 
diff --git a/template/src/widgets/composed-map/ui/ZoneDetailCard.svelte b/template/src/widgets/composed-map/ui/ZoneDetailCard.svelte
index 406eeb3..8f286ce 100644
--- a/template/src/widgets/composed-map/ui/ZoneDetailCard.svelte
+++ b/template/src/widgets/composed-map/ui/ZoneDetailCard.svelte
@@ -1,11 +1,13 @@
 <script lang="ts">
   /**
    * ZoneDetailCard — sticky detail panel for a zone (floating card,
-   * top-right, anchored below the FlowChips row). Opens on hover of a
-   * zone's empty area or title and STAYS OPEN once the cursor leaves —
-   * ComposedMapView tracks the pinned zone separately from the transient
-   * ZoneSlab hover ring, so this card only ever changes when a different
-   * zone is hovered or the user dismisses it explicitly (× button).
+   * fixed bottom-left corner). Opens after the cursor DWELLS on a zone's
+   * empty area or title (ComposedMapView gates detailZoneId behind a
+   * ~350ms dwell timer so a fast pass across zones doesn't flicker the
+   * card) and STAYS OPEN once the cursor leaves — ComposedMapView tracks
+   * the pinned zone separately from the transient ZoneSlab hover ring, so
+   * this card only ever changes when a different zone is dwelt on or the
+   * user dismisses it explicitly (× button).
    *
    * Interactive: the "What's inside" list is mouse-scrollable, node rows
    * with an `artifact_id` open that artifact via `onNodeSelect`, and
@@ -87,9 +89,9 @@
 <style>
   .zone-detail-card {
     position: absolute;
-    top: 52px;
-    right: 16px;
-    max-width: 320px;
+    bottom: 16px;
+    left: 16px;
+    max-width: 300px;
     max-height: calc(100vh - 84px);
     overflow-y: auto;
     background: var(--bg-1);
diff --git a/template/src/widgets/composed-map/ui/chat-launcher.render.test.ts b/template/src/widgets/composed-map/ui/chat-launcher.render.test.ts
new file mode 100644
index 0000000..1e49c32
--- /dev/null
+++ b/template/src/widgets/composed-map/ui/chat-launcher.render.test.ts
@@ -0,0 +1,109 @@
+// @vitest-environment happy-dom
+/**
+ * Coverage for ComposedMapView's chat launcher. RFC-035 moved it out of a
+ * standalone bottom-right `.ask-chat-pos` box (and, briefly, an
+ * onboard-header-only variant) into `FlowChips`'s `leading` slot — so it
+ * now renders inside `.flow-chips`, to the LEFT of the "All" chip, for
+ * EVERY host (no more `showChatLauncher`/bindable `chatOpen` prop pair;
+ * `chatOpen` is fully internal to ComposedMapView now).
+ *
+ * The launcher itself is a compact `Button variant="ghost" size="icon"`
+ * carrying only a `MagicStar` child (no text). State is conveyed via
+ * `aria-label`/`aria-expanded`, not text.
+ *
+ * Harness: happy-dom + Svelte's built-in mount() — same pattern as the
+ * sibling nav-contract render-proof suite.
+ */
+import { describe, it, expect, vi, afterEach } from "vitest";
+import { mount, unmount, flushSync } from "svelte";
+
+vi.mock("@/shared/api", () => {
+  return {
+    createPoller: () => ({
+      state: {
+        data: null,
+        loading: false,
+        error: null,
+        lastFetched: null,
+        cmd: null,
+      },
+      refresh: async () => {},
+      start: () => {},
+      stop: () => {},
+    }),
+  };
+});
+
+// Same defensive mock as MapChat.render.test.ts — a probe/opening the chat
+// panel below must not depend on a real daemon socket/fetch being reachable.
+vi.mock("@/widgets/map-chat/model/agent-client", () => ({
+  probeDaemon: vi.fn(() => Promise.resolve({ up: false })),
+  connectAgent: vi.fn(),
+}));
+
+import ComposedMapView from "./ComposedMapView.svelte";
+import { mapPoller } from "@/entities/map";
+import fixture from "@/entities/map/lib/fixtures/checkpoint-map.json";
+
+let host: HTMLElement | null = null;
+let instance: unknown = null;
+
+function mountView(extraProps: Record<string, unknown> = {}): HTMLElement {
+  mapPoller.state.data = fixture as never;
+  mapPoller.state.error = null;
+  mapPoller.state.lastFetched = Date.now();
+  host = document.createElement("div");
+  document.body.appendChild(host);
+  instance = mount(ComposedMapView, { target: host, props: { ...extraProps } });
+  flushSync();
+  return host;
+}
+
+afterEach(() => {
+  if (instance) {
+    unmount(instance as object);
+    instance = null;
+  }
+  host?.remove();
+  host = null;
+  vi.restoreAllMocks();
+});
+
+describe("chat launcher (FlowChips leading slot)", () => {
+  it("renders the compact star launcher as the first child of .flow-chips, left of All", () => {
+    const root = mountView();
+
+    const chips = root.querySelector(".flow-chips");
+    expect(chips).not.toBeNull();
+
+    const buttons = Array.from(chips!.querySelectorAll("button"));
+    expect(buttons.length).toBeGreaterThan(1); // launcher + All + flow chips
+
+    const launcher = buttons[0]!;
+    expect(launcher.className).toContain("variant-ghost");
+    expect(launcher.className).toContain("size-icon");
+    expect(launcher.getAttribute("aria-controls")).toBe("map-chat-panel");
+    expect(launcher.getAttribute("aria-expanded")).toBe("false");
+    expect(launcher.getAttribute("aria-label")).toBe("Ask the map");
+    expect(launcher.textContent?.trim()).toBe("");
+    expect(launcher.querySelector("svg.magic-star")).not.toBeNull();
+
+    // "All" is the very next button, immediately to the launcher's right.
+    const allButton = buttons[1]!;
+    expect(allButton.textContent?.trim()).toBe("All");
+  });
+
+  it("clicking the launcher toggles chatOpen and mounts the chat panel", () => {
+    const root = mountView();
+
+    expect(root.querySelector("#map-chat-panel")).toBeNull();
+
+    const launcher = root.querySelector<HTMLButtonElement>(".flow-chips button")!;
+    launcher.dispatchEvent(new MouseEvent("click", { bubbles: true, cancelable: true }));
+    flushSync();
+
+    expect(launcher.getAttribute("aria-expanded")).toBe("true");
+    expect(launcher.getAttribute("aria-label")).toBe("Close chat");
+    expect(root.querySelector("#map-chat-panel")).not.toBeNull();
+  });
+});
diff --git a/template/src/widgets/map-chat/model/agent-client.test.ts b/template/src/widgets/map-chat/model/agent-client.test.ts
new file mode 100644
index 0000000..27d8d1d
--- /dev/null
+++ b/template/src/widgets/map-chat/model/agent-client.test.ts
@@ -0,0 +1,500 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { probeDaemon, connectAgent, type AgentHandlers } from "./agent-client";
+import type { OtherAgentInstance, UsageDelta } from "./agent-client";
+import type { CameraTarget } from "@/widgets/composed-map/model/camera-bus.svelte";
+
+// RFC-034 Test Strategy Hooks — probe up/down; token stream assembles;
+// `show_on_map` frame -> `onShowOnMap`; close -> `onClose`. A hand-rolled
+// mock WebSocket stands in for the real thing: it records what was sent
+// and lets a test fire `message`/`error`/`close` events on demand.
+
+const OPEN = 1;
+const CLOSED = 3;
+
+class MockSocket {
+  static CONNECTING = 0;
+  static OPEN = OPEN;
+  static CLOSING = 2;
+  static CLOSED = CLOSED;
+
+  readyState = MockSocket.CONNECTING;
+  url: string;
+  sent: string[] = [];
+  closed = false;
+  private listeners = new Map<string, Set<(event: unknown) => void>>();
+
+  constructor(url: string) {
+    this.url = url;
+    instances.push(this);
+  }
+
+  addEventListener(type: string, cb: (event: unknown) => void): void {
+    if (!this.listeners.has(type)) this.listeners.set(type, new Set());
+    this.listeners.get(type)!.add(cb);
+  }
+
+  removeEventListener(type: string, cb: (event: unknown) => void): void {
+    this.listeners.get(type)?.delete(cb);
+  }
+
+  send(data: string): void {
+    if (this.readyState !== OPEN) throw new Error("socket not open");
+    this.sent.push(data);
+  }
+
+  close(): void {
+    this.closed = true;
+    this.readyState = CLOSED;
+  }
+
+  /** Test helper: simulate the socket reaching OPEN. */
+  open(): void {
+    this.readyState = OPEN;
+  }
+
+  /** Test helper: fire a listener as the real WebSocket would. */
+  emit(type: string, event: unknown = {}): void {
+    for (const cb of this.listeners.get(type) ?? []) cb(event);
+  }
+
+  emitMessage(payload: unknown): void {
+    this.emit("message", { data: JSON.stringify(payload) });
+  }
+}
+
+let instances: MockSocket[] = [];
+
+function lastSocket(): MockSocket {
+  const socket = instances[instances.length - 1];
+  expect(socket).toBeDefined();
+  return socket!;
+}
+
+beforeEach(() => {
+  instances = [];
+  vi.stubGlobal("WebSocket", MockSocket);
+  vi.useFakeTimers();
+});
+
+afterEach(() => {
+  vi.useRealTimers();
+  vi.unstubAllGlobals();
+});
+
+// RFC-034 bugfix — probeDaemon reverted from a WebSocket-per-tick probe
+// (which spawned a `claude` subprocess on the daemon for every liveness
+// check) to a plain `fetch` against `GET /health`, now that the daemon
+// serves that endpoint with an `access-control-allow-origin: *` header
+// (safe: the daemon binds 127.0.0.1 ONLY, ADR-010). These tests mock
+// global `fetch` directly rather than the WebSocket mock above.
+function mockFetchOnce(
+  impl: () => Promise<{ ok: boolean; json: () => Promise<unknown> }>,
+): void {
+  vi.stubGlobal("fetch", vi.fn(impl));
+}
+
+describe("probeDaemon", () => {
+  it("resolves up:true with the model when /health responds ok", async () => {
+    mockFetchOnce(() =>
+      Promise.resolve({
+        ok: true,
+        json: () =>
+          Promise.resolve({ ok: true, protocolVersion: 1, model: "claude-x" }),
+      }),
+    );
+    await expect(probeDaemon(7431)).resolves.toEqual({
+      up: true,
+      model: "claude-x",
+      capabilities: [],
+      otherInstances: [],
+    });
+  });
+
+  // RFC-035 (Wave 2 follow-up) — /health now mirrors the ready frame's
+  // capabilities/otherInstances so the Info tab populates on chat open,
+  // before any WebSocket connects.
+  it("parses capabilities and otherInstances from a well-formed /health payload", async () => {
+    const otherInstances: OtherAgentInstance[] = [
+      { projectName: "sibling-project", port: 7432, kind: "web" },
+    ];
+    mockFetchOnce(() =>
+      Promise.resolve({
+        ok: true,
+        json: () =>
+          Promise.resolve({
+            ok: true,
+            protocolVersion: 2,
+            model: "claude-x",
+            capabilities: ["usage", "instances"],
+            otherInstances,
+          }),
+      }),
+    );
+    await expect(probeDaemon(7431)).resolves.toEqual({
+      up: true,
+      model: "claude-x",
+      capabilities: ["usage", "instances"],
+      otherInstances,
+    });
+  });
+
+  it("defaults capabilities/otherInstances to [] when absent from /health (pre-follow-up daemon)", async () => {
+    mockFetchOnce(() =>
+      Promise.resolve({
+        ok: true,
+        json: () =>
+          Promise.resolve({ ok: true, protocolVersion: 1, model: "claude-x" }),
+      }),
+    );
+    const result = await probeDaemon(7431);
+    expect(result.capabilities).toEqual([]);
+    expect(result.otherInstances).toEqual([]);
+  });
+
+  it("drops malformed capabilities/otherInstances entries but keeps the well-formed ones", async () => {
+    mockFetchOnce(() =>
+      Promise.resolve({
+        ok: true,
+        json: () =>
+          Promise.resolve({
+            ok: true,
+            protocolVersion: 2,
+            model: "claude-x",
+            capabilities: ["usage", 123, null],
+            otherInstances: [
+              { projectName: "ok-project", port: 7432, kind: "agent" },
+              { projectName: 123, port: "nope" },
+            ],
+          }),
+      }),
+    );
+    await expect(probeDaemon(7431)).resolves.toEqual({
+      up: true,
+      model: "claude-x",
+      capabilities: ["usage"],
+      otherInstances: [
+        { projectName: "ok-project", port: 7432, kind: "agent" },
+      ],
+    });
+  });
+
+  it("resolves up:false when the fetch rejects", async () => {
+    vi.stubGlobal(
+      "fetch",
+      vi.fn(() => Promise.reject(new Error("network down"))),
+    );
+    await expect(probeDaemon(7431)).resolves.toEqual({ up: false });
+  });
+
+  it("resolves up:false on a non-2xx response", async () => {
+    mockFetchOnce(() =>
+      Promise.resolve({ ok: false, json: () => Promise.resolve({}) }),
+    );
+    await expect(probeDaemon(7431)).resolves.toEqual({ up: false });
+  });
+
+  it("resolves up:false on unparsable JSON", async () => {
+    mockFetchOnce(() =>
+      Promise.resolve({
+        ok: true,
+        json: () => Promise.reject(new Error("bad json")),
+      }),
+    );
+    await expect(probeDaemon(7431)).resolves.toEqual({ up: false });
+  });
+
+  it("resolves up:false immediately with no global fetch (SSR)", async () => {
+    vi.stubGlobal("fetch", undefined);
+    await expect(probeDaemon(7431)).resolves.toEqual({ up: false });
+  });
+});
+
+function handlers(): AgentHandlers &
+  Record<keyof AgentHandlers, ReturnType<typeof vi.fn>> {
+  return {
+    onToken: vi.fn<(delta: string) => void>(),
+    onShowOnMap: vi.fn<(target: CameraTarget) => void>(),
+    onDone: vi.fn<() => void>(),
+    onError: vi.fn<(message: string) => void>(),
+    onClose: vi.fn<() => void>(),
+    onSession: vi.fn<(sessionId: string) => void>(),
+    onUsage: vi.fn<(usage: UsageDelta) => void>(),
+    onReadyMeta:
+      vi.fn<
+        (meta: {
+          capabilities: string[];
+          otherInstances: OtherAgentInstance[];
+        }) => void
+      >(),
+  };
+}
+
+describe("connectAgent", () => {
+  it("assembles a token stream by forwarding each delta in order", () => {
+    const h = handlers();
+    connectAgent(7431, h);
+    const socket = lastSocket();
+    socket.emitMessage({ type: "token", delta: "Hel" });
+    socket.emitMessage({ type: "token", delta: "lo" });
+    expect(h.onToken.mock.calls).toEqual([
+      ["Hel", null],
+      ["lo", null],
+    ]);
+  });
+
+  // Bugfix #1 — every per-turn frame echoes the turnId it belongs to;
+  // `null` when the daemon supplied none (older build, or omitted).
+  it("forwards a token frame's turnId to onToken", () => {
+    const h = handlers();
+    connectAgent(7431, h);
+    lastSocket().emitMessage({ type: "token", delta: "Hi", turnId: "t-1" });
+    expect(h.onToken).toHaveBeenCalledWith("Hi", "t-1");
+  });
+
+  it("routes a show_on_map frame to onShowOnMap", () => {
+    const h = handlers();
+    connectAgent(7431, h);
+    const socket = lastSocket();
+    const target = { kind: "zone" as const, id: "z.a" };
+    socket.emitMessage({ type: "show_on_map", target });
+    expect(h.onShowOnMap).toHaveBeenCalledWith(target, null);
+  });
+
+  it("forwards a show_on_map frame's turnId to onShowOnMap", () => {
+    const h = handlers();
+    connectAgent(7431, h);
+    const target = { kind: "zone" as const, id: "z.a" };
+    lastSocket().emitMessage({ type: "show_on_map", target, turnId: "t-2" });
+    expect(h.onShowOnMap).toHaveBeenCalledWith(target, "t-2");
+  });
+
+  it("routes a done frame to onDone", () => {
+    const h = handlers();
+    connectAgent(7431, h);
+    lastSocket().emitMessage({ type: "done" });
+    expect(h.onDone).toHaveBeenCalledWith(null);
+  });
+
+  it("forwards a done frame's turnId to onDone", () => {
+    const h = handlers();
+    connectAgent(7431, h);
+    lastSocket().emitMessage({ type: "done", turnId: "t-3" });
+    expect(h.onDone).toHaveBeenCalledWith("t-3");
+  });
+
+  it("routes an error frame to onError with the message, defaulting fatal to true and turnId to null", () => {
+    const h = handlers();
+    connectAgent(7431, h);
+    lastSocket().emitMessage({ type: "error", message: "boom" });
+    expect(h.onError).toHaveBeenCalledWith("boom", true, null);
+  });
+
+  // Bugfix #6 — the daemon's `fatal: false` (a recoverable per-turn
+  // failure) must reach onError intact, not be coerced to the true
+  // default reserved for frames that omit the field entirely.
+  it("forwards a non-fatal error frame's fatal:false and turnId to onError", () => {
+    const h = handlers();
+    connectAgent(7431, h);
+    lastSocket().emitMessage({
+      type: "error",
+      message: "turn failed",
+      fatal: false,
+      turnId: "t-4",
+    });
+    expect(h.onError).toHaveBeenCalledWith("turn failed", false, "t-4");
+  });
+
+  it("routes an unsolicited close to onClose", () => {
+    const h = handlers();
+    connectAgent(7431, h);
+    lastSocket().emit("close");
+    expect(h.onClose).toHaveBeenCalledTimes(1);
+  });
+
+  it("does not call onClose again when the caller itself closes the connection", () => {
+    const h = handlers();
+    const conn = connectAgent(7431, h);
+    const socket = lastSocket();
+    conn.close();
+    // The real WebSocket fires its own close event once the underlying
+    // socket actually terminates -- simulate that arriving after close().
+    socket.emit("close");
+    expect(h.onClose).not.toHaveBeenCalled();
+  });
+
+  it("sends a user_message frame (with its turnId) only once the socket is open", () => {
+    const h = handlers();
+    const conn = connectAgent(7431, h);
+    const socket = lastSocket();
+    conn.send("hello", "t-a");
+    expect(socket.sent).toEqual([]);
+    socket.open();
+    conn.send("hello again", "t-b");
+    expect(socket.sent).toEqual([
+      JSON.stringify({
+        type: "user_message",
+        text: "hello again",
+        turnId: "t-b",
+      }),
+    ]);
+  });
+
+  it("buffers sends issued before the socket opens and flushes them, in order, once open fires", () => {
+    const h = handlers();
+    const conn = connectAgent(7431, h);
+    const socket = lastSocket();
+    // Simulates chat-store's Tier-1 send: connectAgent() + conn.send()
+    // called synchronously, before the socket has left CONNECTING.
+    conn.send("first", "t-1");
+    conn.send("second", "t-2");
+    expect(socket.sent).toEqual([]);
+    socket.open();
+    socket.emit("open");
+    expect(socket.sent).toEqual([
+      JSON.stringify({ type: "user_message", text: "first", turnId: "t-1" }),
+      JSON.stringify({ type: "user_message", text: "second", turnId: "t-2" }),
+    ]);
+  });
+
+  it("still delivers a send issued after the socket is already open immediately", () => {
+    const h = handlers();
+    const conn = connectAgent(7431, h);
+    const socket = lastSocket();
+    socket.open();
+    socket.emit("open");
+    conn.send("hello", "t-1");
+    expect(socket.sent).toEqual([
+      JSON.stringify({ type: "user_message", text: "hello", turnId: "t-1" }),
+    ]);
+  });
+
+  it("sends a cancel frame", () => {
+    const h = handlers();
+    const conn = connectAgent(7431, h);
+    const socket = lastSocket();
+    socket.open();
+    conn.cancel();
+    expect(socket.sent).toEqual([JSON.stringify({ type: "cancel" })]);
+  });
+
+  it("ignores malformed frames instead of throwing", () => {
+    const h = handlers();
+    connectAgent(7431, h);
+    const socket = lastSocket();
+    expect(() => socket.emit("message", { data: "{not json" })).not.toThrow();
+    expect(h.onToken).not.toHaveBeenCalled();
+  });
+
+  it("degrades to a no-op connection plus an async onClose with no global WebSocket", async () => {
+    vi.stubGlobal("WebSocket", undefined);
+    const h = handlers();
+    const conn = connectAgent(7431, h);
+    expect(() => conn.send("x", "t-1")).not.toThrow();
+    expect(() => conn.cancel()).not.toThrow();
+    expect(() => conn.close()).not.toThrow();
+    // The degraded connection reports via a queued microtask, not a timer
+    // -- flush microtasks directly rather than reaching for a real-timer
+    // poll (vi.waitFor) while fake timers are active in this suite.
+    await Promise.resolve();
+    await Promise.resolve();
+    expect(h.onClose).toHaveBeenCalledTimes(1);
+  });
+
+  // RFC-035 (Wave 2, FR-5) — the daemon's `usage` frame forwards one
+  // completed turn's token/cost delta; routes to onUsage, drops if malformed.
+  it("routes a usage frame to onUsage with its numeric fields intact", () => {
+    const h = handlers();
+    connectAgent(7431, h);
+    const socket = lastSocket();
+    const usage: UsageDelta = {
+      inputTokens: 120,
+      outputTokens: 45,
+      costUsd: 0.0123,
+    };
+    socket.emitMessage({ type: "usage", ...usage });
+    expect(h.onUsage).toHaveBeenCalledWith(usage, null);
+  });
+
+  // Bugfix #1 — a usage frame is per-turn too; its turnId reaches onUsage.
+  it("forwards a usage frame's turnId to onUsage", () => {
+    const h = handlers();
+    connectAgent(7431, h);
+    const socket = lastSocket();
+    const usage: UsageDelta = { inputTokens: 10, outputTokens: 5, costUsd: 0 };
+    socket.emitMessage({ type: "usage", ...usage, turnId: "t-5" });
+    expect(h.onUsage).toHaveBeenCalledWith(usage, "t-5");
+  });
+
+  it("drops a malformed usage frame (a non-numeric field) instead of calling onUsage", () => {
+    const h = handlers();
+    connectAgent(7431, h);
+    const socket = lastSocket();
+    socket.emitMessage({
+      type: "usage",
+      inputTokens: "oops",
+      outputTokens: 45,
+      costUsd: 0.01,
+    });
+    expect(h.onUsage).not.toHaveBeenCalled();
+  });
+
+  // RFC-035 (Wave 2, FR-6) — the `ready` frame's additive capabilities/
+  // otherInstances fields route to onReadyMeta, defaulting to [] when
+  // absent (a pre-Wave-2 daemon) and dropping malformed entries.
+  it("routes a ready frame's capabilities/otherInstances to onReadyMeta", () => {
+    const h = handlers();
+    connectAgent(7431, h);
+    const socket = lastSocket();
+    const otherInstances: OtherAgentInstance[] = [
+      { projectName: "sibling-project", port: 7432, kind: "web" },
+    ];
+    socket.emitMessage({
+      type: "ready",
+      protocolVersion: 2,
+      model: "claude-x",
+      capabilities: ["usage", "instances"],
+      otherInstances,
+    });
+    expect(h.onReadyMeta).toHaveBeenCalledWith({
+      capabilities: ["usage", "instances"],
+      otherInstances,
+    });
+  });
+
+  it("defaults ready's capabilities/otherInstances to [] when absent (pre-Wave-2 daemon)", () => {
+    const h = handlers();
+    connectAgent(7431, h);
+    const socket = lastSocket();
+    socket.emitMessage({
+      type: "ready",
+      protocolVersion: 1,
+      model: "claude-x",
+    });
+    expect(h.onReadyMeta).toHaveBeenCalledWith({
+      capabilities: [],
+      otherInstances: [],
+    });
+  });
+
+  it("drops malformed otherInstances entries but keeps the well-formed ones", () => {
+    const h = handlers();
+    connectAgent(7431, h);
+    const socket = lastSocket();
+    socket.emitMessage({
+      type: "ready",
+      protocolVersion: 2,
+      model: "claude-x",
+      capabilities: ["usage"],
+      otherInstances: [
+        { projectName: "ok-project", port: 7432, kind: "agent" },
+        { projectName: 123, port: "nope" },
+      ],
+    });
+    expect(h.onReadyMeta).toHaveBeenCalledWith({
+      capabilities: ["usage"],
+      otherInstances: [
+        { projectName: "ok-project", port: 7432, kind: "agent" },
+      ],
+    });
+  });
+});
diff --git a/template/src/widgets/map-chat/model/agent-client.ts b/template/src/widgets/map-chat/model/agent-client.ts
new file mode 100644
index 0000000..f1a5844
--- /dev/null
+++ b/template/src/widgets/map-chat/model/agent-client.ts
@@ -0,0 +1,437 @@
+// RFC-034 (Pillar C, Phase 3b) — read-only WebSocket client for the
+// onboarding daemon (@forgeplan/web-agent). The browser talks to
+// ws://127.0.0.1:<port> DIRECTLY — never through /api/* (rule 22: the
+// SvelteKit server is a read-only mirror and structurally cannot proxy
+// this). Every export here is defensive by contract: a missing daemon, a
+// dropped connection, or an unparseable frame degrades to a callback (or
+// a resolved `{ up: false }`), never a thrown exception — chat-store's
+// Tier 1 must be able to fail silently back to Tier 0.
+
+import type { CameraTarget } from "@/widgets/composed-map/model/camera-bus.svelte";
+
+const PROBE_TIMEOUT_MS = 1500;
+
+/** RFC-035 (Wave 2, FR-6) — one entry in the `ready` frame's
+ * instance-discovery snapshot (agent/lib/registry.mjs#readOtherLiveInstances).
+ * `kind` stays a plain `string` (not a union) so a future registry row kind
+ * decodes without a web-side release — same forward-compat stance as the
+ * rest of this file's frame parsing. */
+export interface OtherAgentInstance {
+  projectName: string;
+  port: number;
+  kind: string;
+}
+
+/** RFC-035 (Wave 2, FR-5) — one turn's token/cost delta, forwarded verbatim
+ * from the Agent SDK's own `result.usage` + `result.total_cost_usd` via the
+ * daemon's `usage` frame. Callers accumulate across turns themselves. */
+export interface UsageDelta {
+  inputTokens: number;
+  outputTokens: number;
+  costUsd: number;
+}
+
+// Mirrors the daemon's lib/protocol.mjs wire schema (RFC-034 Function
+// Signatures/Contracts) — one source of truth split across two packages.
+// RFC-035 (Wave 2) added `usage` and the `ready` frame's `capabilities`/
+// `otherInstances` fields, additively (PROTOCOL_VERSION 1 -> 2).
+//
+// Bugfix #1 (cross-turn frame race, PROTOCOL_VERSION 2 -> 3) — every
+// per-turn frame (`token`/`show_on_map`/`usage`/`done`/`error`) now echoes
+// the `turnId` of the `user_message` that started it; `null` means "no
+// correlation available" (older daemon, or a `cancel`-triggered synthetic
+// `done`) and callers must accept it as-is per agent/lib/protocol.mjs's
+// header. Bugfix #6 — `error` also carries `fatal: boolean`, discriminating
+// a recoverable per-turn failure from one that ends the connection/session.
+type ServerMsg =
+  | {
+      type: "ready";
+      protocolVersion?: number;
+      model?: string;
+      capabilities: string[];
+      otherInstances: OtherAgentInstance[];
+    }
+  | { type: "session"; sessionId: string }
+  | { type: "token"; delta: string; turnId: string | null }
+  | { type: "show_on_map"; target: CameraTarget; turnId: string | null }
+  | {
+      type: "usage";
+      inputTokens: number;
+      outputTokens: number;
+      costUsd: number;
+      turnId: string | null;
+    }
+  | { type: "done"; turnId: string | null }
+  | { type: "error"; message: string; fatal: boolean; turnId: string | null };
+
+/** Bugfix #1 — the client always tags its `user_message` with the turnId
+ * the caller (chat-store) generated for this turn, so the daemon can echo
+ * it back on every frame that turn produces. */
+type ClientMsg =
+  | { type: "user_message"; text: string; turnId: string }
+  | { type: "cancel" };
+
+/** RFC-035 (Wave 2 follow-up) — `/health` now mirrors the same
+ * `capabilities`/`otherInstances` the `ready` frame advertises (see
+ * agent/bin/agent.mjs's `GET /health` handler), so the Info tab's "Other
+ * projects" row (and model) can populate from the probe alone — before any
+ * WebSocket connects. Both optional so a pre-follow-up daemon's `/health`
+ * (still just `{ ok, protocolVersion, model }`) keeps parsing unchanged. */
+export interface ProbeResult {
+  up: boolean;
+  model?: string;
+  capabilities?: string[];
+  otherInstances?: OtherAgentInstance[];
+}
+
+export interface AgentHandlers {
+  /** Bugfix #1 — `turnId` echoes the `user_message.turnId` that started the
+   * turn this frame belongs to; `null` when the daemon supplied none
+   * (older build, or a cancel-triggered synthetic frame). The caller
+   * (chat-store) is responsible for dropping frames whose `turnId` no
+   * longer matches the turn it is currently rendering — this client
+   * forwards every frame uninterpreted. */
+  onToken(delta: string, turnId: string | null): void;
+  onShowOnMap(target: CameraTarget, turnId: string | null): void;
+  onDone(turnId: string | null): void;
+  /** Bugfix #6 — `fatal` discriminates a recoverable per-turn failure
+   * (connection/session still usable) from one that ends the connection/
+   * session (the caller should fall back to Tier 0). */
+  onError(message: string, fatal: boolean, turnId: string | null): void;
+  onClose(): void;
+  /** RFC-034 Phase 4c (live-continue) — fires once the daemon captures the
+   * Agent SDK's own session id for this connection (from its `system`/
+   * `init` message). Optional so existing callers/mocks built before this
+   * phase keep compiling unchanged. */
+  onSession?(sessionId: string): void;
+  /** RFC-035 (Wave 2, FR-5) — fires on each daemon `usage` frame (one per
+   * completed turn) with that turn's own delta; the caller accumulates
+   * across turns (chat-store keeps session + cumulative totals). Optional
+   * so pre-Wave-2 callers/mocks keep compiling unchanged. */
+  onUsage?(usage: UsageDelta, turnId: string | null): void;
+  /** RFC-035 (Wave 2, FR-6) — fires once per connection with the `ready`
+   * frame's additive fields: which optional frame types this daemon build
+   * emits, and the instance-discovery snapshot taken at connect time.
+   * Optional, same reasoning as onUsage/onSession. */
+  onReadyMeta?(meta: {
+    capabilities: string[];
+    otherInstances: OtherAgentInstance[];
+  }): void;
+}
+
+export interface ConnectOptions {
+  /** RFC-034 Phase 4c (live-continue) — when set, asks the daemon to
+   * `resume` this Agent SDK session id instead of starting a fresh one.
+   * Threaded onto the WS URL as `?resume=<id>` (read at connect time by
+   * agent/bin/agent.mjs) rather than a WS frame — see lib/protocol.mjs's
+   * header for why. */
+  resumeSessionId?: string;
+}
+
+export interface AgentConnection {
+  /** Bugfix #1 — `turnId` is threaded onto the outgoing `user_message` so
+   * every frame the daemon emits for this turn echoes it back, letting the
+   * caller correlate/drop stale-turn frames. */
+  send(text: string, turnId: string): void;
+  cancel(): void;
+  close(): void;
+}
+
+function daemonUrl(port: number, resumeSessionId?: string): string {
+  const base = `ws://127.0.0.1:${port}`;
+  return resumeSessionId
+    ? `${base}/?resume=${encodeURIComponent(resumeSessionId)}`
+    : base;
+}
+
+function isServerMsgShape(value: unknown): value is { type: string } {
+  return (
+    typeof value === "object" &&
+    value !== null &&
+    typeof (value as { type?: unknown }).type === "string"
+  );
+}
+
+/** RFC-035 (Wave 2, FR-6) — narrows one `otherInstances` array entry; a
+ * malformed entry is dropped rather than failing the whole `ready` frame
+ * (mirrors agent/lib/protocol.mjs#decodeServerMessage's own leniency). */
+function isOtherAgentInstance(value: unknown): value is OtherAgentInstance {
+  if (typeof value !== "object" || value === null) return false;
+  const v = value as Record<string, unknown>;
+  return (
+    typeof v.projectName === "string" &&
+    typeof v.port === "number" &&
+    typeof v.kind === "string"
+  );
+}
+
+/** RFC-035 (Wave 2, FR-6) — normalizes a `ready` frame's additive fields.
+ * Absent (a pre-Wave-2 daemon) defaults to `[]` so the frame still decodes;
+ * present-but-malformed entries are dropped rather than failing the whole
+ * frame — same contract as agent/lib/protocol.mjs's own `decodeServerMessage`. */
+function normalizeReady(parsed: Record<string, unknown>): ServerMsg {
+  const capabilities = Array.isArray(parsed.capabilities)
+    ? parsed.capabilities.filter((c): c is string => typeof c === "string")
+    : [];
+  const otherInstances = Array.isArray(parsed.otherInstances)
+    ? parsed.otherInstances.filter(isOtherAgentInstance)
+    : [];
+  return {
+    type: "ready",
+    protocolVersion:
+      typeof parsed.protocolVersion === "number"
+        ? parsed.protocolVersion
+        : undefined,
+    model: typeof parsed.model === "string" ? parsed.model : undefined,
+    capabilities,
+    otherInstances,
+  };
+}
+
+/** Bugfix #1 — extracts a frame's `turnId`, defaulting to `null` when
+ * absent/malformed (older daemon, or a cancel-triggered synthetic frame) —
+ * mirrors agent/lib/protocol.mjs#decodeServerMessage's own leniency. */
+function turnIdOf(p: Record<string, unknown>): string | null {
+  return typeof p.turnId === "string" ? p.turnId : null;
+}
+
+/** Parses one WS text frame as a `ServerMsg`. Unknown `type`s and
+ * malformed JSON both degrade to `null` rather than throwing — a future
+ * daemon protocol bump must not crash an older web build. */
+function parseServerMsg(raw: unknown): ServerMsg | null {
+  if (typeof raw !== "string") return null;
+  try {
+    const parsed: unknown = JSON.parse(raw);
+    if (!isServerMsgShape(parsed)) return null;
+    const p = parsed as Record<string, unknown>;
+    const turnId = turnIdOf(p);
+    switch (parsed.type) {
+      case "ready":
+        return normalizeReady(p);
+      case "session":
+        return parsed as ServerMsg;
+      case "token":
+        return { ...(parsed as { type: "token"; delta: string }), turnId };
+      case "show_on_map":
+        return {
+          ...(parsed as { type: "show_on_map"; target: CameraTarget }),
+          turnId,
+        };
+      case "done":
+        return { type: "done", turnId };
+      case "error":
+        // Bugfix #6 — `fatal` defaults to `true` when absent: an older
+        // daemon's error frame predates the discriminant, and treating it
+        // as fatal preserves the exact behaviour the web already had
+        // before this field existed (full tier0 fallback on any error).
+        // `message` is read off `p` (already `Record<string, unknown>`)
+        // rather than cast through `parsed` — `{ type: string }` and
+        // `{ message: string }` share no property, so TS correctly flags
+        // that cast as an unsound conversion (neither type overlaps the
+        // other); validating the field's runtime type instead avoids the
+        // cast entirely.
+        return {
+          type: "error",
+          message: typeof p.message === "string" ? p.message : "",
+          fatal: typeof p.fatal === "boolean" ? p.fatal : true,
+          turnId,
+        };
+      case "usage":
+        if (
+          typeof p.inputTokens !== "number" ||
+          typeof p.outputTokens !== "number" ||
+          typeof p.costUsd !== "number"
+        ) {
+          return null;
+        }
+        return {
+          type: "usage",
+          inputTokens: p.inputTokens,
+          outputTokens: p.outputTokens,
+          costUsd: p.costUsd,
+          turnId,
+        };
+      default:
+        return null;
+    }
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Probes the daemon's `GET /health` endpoint with a short-timeout `fetch`.
+ * A plain fetch has no socket lifecycle to manage, so it is safe to poll on
+ * `chat-store`'s `PROBE_INTERVAL_MS` interval (unlike opening a fresh
+ * WebSocket per tick, which used to spawn a `claude` subprocess on the
+ * daemon for every probe — see agent/bin/agent.mjs's file header for the
+ * daemon-side rationale for exposing both `/health` and the per-connection
+ * `{type:"ready"}` frame). Resolves `{ up: false }` on ANY failure — a
+ * missing global `fetch`/`AbortController` (e.g. SSR), a network-level
+ * rejection, a non-2xx response, or unparsable JSON — never throws.
+ */
+export function probeDaemon(port: number): Promise<ProbeResult> {
+  if (typeof fetch === "undefined" || typeof AbortController === "undefined") {
+    return Promise.resolve({ up: false });
+  }
+
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), PROBE_TIMEOUT_MS);
+
+  return fetch(`http://127.0.0.1:${port}/health`, {
+    signal: controller.signal,
+    headers: { accept: "application/json" },
+  })
+    .then(async (res) => {
+      if (!res.ok) return { up: false };
+      const json = (await res.json()) as {
+        ok?: unknown;
+        model?: unknown;
+        capabilities?: unknown;
+        otherInstances?: unknown;
+      };
+      // RFC-035 (Wave 2 follow-up) — same leniency as normalizeReady: a
+      // malformed/absent field never fails the whole probe, it just drops
+      // to an empty list so the Info tab shows "just this one" instead of
+      // throwing.
+      const capabilities = Array.isArray(json.capabilities)
+        ? json.capabilities.filter((c): c is string => typeof c === "string")
+        : [];
+      const otherInstances = Array.isArray(json.otherInstances)
+        ? json.otherInstances.filter(isOtherAgentInstance)
+        : [];
+      return {
+        up: json.ok === true,
+        model: typeof json.model === "string" ? json.model : undefined,
+        capabilities,
+        otherInstances,
+      };
+    })
+    .catch((): ProbeResult => ({ up: false }))
+    .finally(() => clearTimeout(timer));
+}
+
+/**
+ * Opens a persistent WebSocket session to the daemon and routes every
+ * frame to `handlers`. Returns immediately without waiting for `ready` —
+ * a daemon that never answers surfaces through `onError`/`onClose`, the
+ * same path a daemon that answers and later drops takes. Any `send`/
+ * `cancel` issued before the socket reaches `OPEN` is buffered and
+ * flushed, in order, once the `open` event fires, so a caller that calls
+ * `send` synchronously right after `connectAgent` returns never loses the
+ * frame. Never throws; a missing global `WebSocket` degrades to a no-op
+ * connection plus an async `onClose` so the caller's fallback path runs
+ * uniformly either way.
+ */
+export function connectAgent(
+  port: number,
+  handlers: AgentHandlers,
+  options?: ConnectOptions,
+): AgentConnection {
+  const noop = (): void => {};
+
+  if (typeof WebSocket === "undefined") {
+    queueMicrotask(() => handlers.onClose());
+    return { send: noop, cancel: noop, close: noop };
+  }
+
+  let socket: WebSocket;
+  try {
+    socket = new WebSocket(daemonUrl(port, options?.resumeSessionId));
+  } catch {
+    queueMicrotask(() => handlers.onClose());
+    return { send: noop, cancel: noop, close: noop };
+  }
+
+  let closedByCaller = false;
+  const pending: ClientMsg[] = [];
+  const dispatch = (payload: ClientMsg): void => {
+    if (socket.readyState !== WebSocket.OPEN) {
+      pending.push(payload);
+      return;
+    }
+    try {
+      socket.send(JSON.stringify(payload));
+    } catch {
+      // Dropped between the readyState check and send — the close/error
+      // event already in flight will notify the caller.
+    }
+  };
+
+  socket.addEventListener("message", (event: MessageEvent) => {
+    const msg = parseServerMsg(event.data);
+    if (!msg) return;
+    switch (msg.type) {
+      case "ready":
+        handlers.onReadyMeta?.({
+          capabilities: msg.capabilities,
+          otherInstances: msg.otherInstances,
+        });
+        return;
+      case "session":
+        handlers.onSession?.(msg.sessionId);
+        return;
+      case "token":
+        handlers.onToken(msg.delta, msg.turnId);
+        return;
+      case "show_on_map":
+        handlers.onShowOnMap(msg.target, msg.turnId);
+        return;
+      case "usage":
+        handlers.onUsage?.(
+          {
+            inputTokens: msg.inputTokens,
+            outputTokens: msg.outputTokens,
+            costUsd: msg.costUsd,
+          },
+          msg.turnId,
+        );
+        return;
+      case "done":
+        handlers.onDone(msg.turnId);
+        return;
+      case "error":
+        handlers.onError(msg.message, msg.fatal, msg.turnId);
+        return;
+    }
+  });
+  socket.addEventListener("error", () => {
+    if (!closedByCaller) {
+      // Connection-level failure, not a per-turn daemon frame — always
+      // fatal (the socket itself is gone) and has no turn to correlate.
+      handlers.onError("Connection to the live agent failed.", true, null);
+    }
+  });
+  socket.addEventListener("close", () => {
+    if (!closedByCaller) handlers.onClose();
+  });
+  socket.addEventListener("open", () => {
+    if (closedByCaller) return;
+    const queued = pending.splice(0, pending.length);
+    for (const payload of queued) {
+      try {
+        socket.send(JSON.stringify(payload));
+      } catch {
+        // Dropped mid-flush — the close/error event already in flight
+        // will notify the caller.
+      }
+    }
+  });
+
+  return {
+    send(text: string, turnId: string): void {
+      dispatch({ type: "user_message", text, turnId });
+    },
+    cancel(): void {
+      dispatch({ type: "cancel" });
+    },
+    close(): void {
+      closedByCaller = true;
+      try {
+        socket.close();
+      } catch {
+        // Already closed/closing.
+      }
+    },
+  };
+}
diff --git a/template/src/widgets/map-chat/model/chat-store.svelte.ts b/template/src/widgets/map-chat/model/chat-store.svelte.ts
new file mode 100644
index 0000000..265c486
--- /dev/null
+++ b/template/src/widgets/map-chat/model/chat-store.svelte.ts
@@ -0,0 +1,634 @@
+// RFC-034 (Pillar C, Phase 3b) — the chat's message/tier/live-connection
+// store. Mirrors node-tabs.svelte.ts / camera-bus.svelte.ts's plain
+// module-level `$state` shape: no class, no context, one shared instance
+// per page; state stays module-private and is only ever read/written
+// through the exported functions below.
+//
+// AI-only (onboard-agent phase 1): the live daemon (Tier 1,
+// @forgeplan/web-agent) is the ONLY source of answers — there is no
+// client-side, model-free fallback answerer. `checkDaemon` probes the
+// daemon and upgrades the tier on success; a live connection that errors
+// or closes degrades back to "tier0", which now means "offline, no daemon
+// detected" rather than a fallback answering mode. `send()` is a no-op
+// while offline — MapChat's offline call-to-action keeps the input/Send
+// disabled too, so this is the belt to that view-level suspenders.
+
+import { showOnMap } from "@/widgets/composed-map/model/camera-bus.svelte";
+import { probeDaemon, connectAgent } from "./agent-client";
+import type {
+  AgentConnection,
+  OtherAgentInstance,
+  UsageDelta,
+} from "./agent-client";
+import type { CameraTarget } from "@/widgets/composed-map/model/camera-bus.svelte";
+
+export interface ChatMessage {
+  role: "user" | "assistant";
+  text: string;
+  /** Set when this message's answer drove camera-bus — lets the view render
+   * a "→ moved to <label>" chip. Omitted (never `undefined`-valued) so the
+   * plain `{ role, text }` shape existing callers assert on is unaffected. */
+  target?: CameraTarget;
+}
+
+export type ChatTier = "tier0" | "tier1";
+
+/** RFC-035 (chat panel v2) — which of the two panel tabs is active. Lives
+ * here (not local component state) so it's the store's single source of
+ * truth for anything the Info tab needs, matching how tier/model already
+ * work; window geometry stays entirely inside the `FloatingWindow`
+ * primitive (rule 24 — the store never duplicates that). */
+export type ChatTab = "chat" | "info";
+
+/** RFC-035 (Wave 2, FR-5) — accumulated token/cost totals for the Info tab.
+ * `session` resets on `newChat()`; `cumulative` persists for the lifetime
+ * of this page load. */
+export interface TokenUsage {
+  inputTokens: number;
+  outputTokens: number;
+  costUsd: number;
+}
+
+export interface UsageSnapshot {
+  session: TokenUsage;
+  cumulative: TokenUsage;
+}
+
+const ZERO_USAGE: TokenUsage = { inputTokens: 0, outputTokens: 0, costUsd: 0 };
+
+/** RFC-034 (Pillar C, chat UI upgrade) — a session is the archived shape of
+ * one chat transcript. The LIVE transcript (`messages` below) is not itself
+ * a `ChatSession` — it is archived into one by `newChat()`. */
+export interface ChatSession {
+  id: string;
+  title: string;
+  messages: ChatMessage[];
+  createdAt: number;
+  /** RFC-034 (Pillar C, Phase 4c — live-continue) — the Agent SDK's own
+   * session id for this transcript's daemon connection, if one was ever
+   * captured (the daemon's `{type:"session"}` frame). Absent for sessions
+   * archived before this feature shipped, or if the daemon never reported
+   * one (e.g. the connection dropped before the SDK's `system`/`init`
+   * message arrived). `continueSession` falls back to a fresh (non-resume)
+   * reconnect when this is missing — see its own doc comment. */
+  agentSessionId?: string;
+}
+
+/** RFC-034 ADI cycle A (A1) — fixed default port + probe for the MVP. */
+export const DEFAULT_AGENT_PORT = 7431;
+const PROBE_INTERVAL_MS = 15_000;
+const SESSION_HISTORY_STORAGE_KEY = "forgeplan-web:map-chat:sessions";
+const SESSION_HISTORY_CAP = 20;
+const SESSION_TITLE_MAX = 64;
+
+let messages = $state<ChatMessage[]>([]);
+let tier = $state<ChatTier>("tier0");
+let model = $state<string | null>(null);
+let pending = $state(false);
+let activeTab = $state<ChatTab>("chat");
+let sessionId = $state(createSessionId());
+let sessionHistory = $state<ChatSession[]>(loadSessionHistory());
+/** Non-null while the view is revisiting a past session read-only (MVP —
+ * see `viewSession`'s TODO for the live-continue graduation path). */
+let viewingSessionId = $state<string | null>(null);
+/** RFC-035 (Wave 2, FR-5) — resets on `newChat()`. */
+let sessionUsage = $state<TokenUsage>({ ...ZERO_USAGE });
+/** RFC-035 (Wave 2, FR-5) — persists across `newChat()`, for the page's
+ * lifetime. */
+let cumulativeUsage = $state<TokenUsage>({ ...ZERO_USAGE });
+/** RFC-035 (Wave 2, FR-6) — the other live instances reported by the most
+ * recent `ready` frame; empty until the first one arrives (or if genuinely
+ * alone on the machine). */
+let otherInstances = $state<OtherAgentInstance[]>([]);
+
+let connection: AgentConnection | null = null;
+let activeAssistantIndex: number | null = null;
+let probeTimer: ReturnType<typeof setInterval> | null = null;
+let agentPort = DEFAULT_AGENT_PORT;
+/** Bugfix #1 (cross-turn frame race) — the turnId of the turn currently
+ * being rendered, generated fresh per `send()` and threaded onto
+ * `connection.send`/`user_message`. Every per-turn server frame echoes a
+ * `turnId`; frames whose `turnId` doesn't match this are stale (from a
+ * cancelled or otherwise superseded turn) and are dropped — see
+ * `isCurrentTurn`. */
+let currentTurnId: string | null = null;
+/** Bugfix #9 (stale probe race) — bumped on every `startAgentProbe`/
+ * `stopAgentProbe` call; a `checkDaemon` result only applies while its
+ * captured generation is still current, so a fast close→reopen can't let
+ * an older in-flight probe overwrite a newer result. */
+let probeGeneration = 0;
+
+function createSessionId(): string {
+  return `s-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+}
+
+function createTurnId(): string {
+  return `t-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+}
+
+/** Bugfix #1 — `turnId === null` means "no correlation available" (older
+ * daemon, or a cancel-triggered synthetic frame) and per
+ * agent/lib/protocol.mjs's contract must be accepted as-is; otherwise the
+ * frame only applies if it matches the turn currently being rendered. */
+function isCurrentTurn(turnId: string | null): boolean {
+  return turnId === null || turnId === currentTurnId;
+}
+
+function isValidChatMessage(value: unknown): value is ChatMessage {
+  if (typeof value !== "object" || value === null) return false;
+  const m = value as Record<string, unknown>;
+  return (
+    (m.role === "user" || m.role === "assistant") && typeof m.text === "string"
+  );
+}
+
+function isValidSession(value: unknown): value is ChatSession {
+  if (typeof value !== "object" || value === null) return false;
+  const s = value as Record<string, unknown>;
+  return (
+    typeof s.id === "string" &&
+    typeof s.title === "string" &&
+    typeof s.createdAt === "number" &&
+    Array.isArray(s.messages) &&
+    s.messages.every(isValidChatMessage)
+  );
+}
+
+/** Reads the archived-session history from `localStorage`. Never throws —
+ * a missing/unavailable storage (SSR, private mode, corrupted JSON)
+ * degrades to an empty history rather than breaking chat startup. */
+function loadSessionHistory(): ChatSession[] {
+  if (typeof localStorage === "undefined") return [];
+  try {
+    const raw = localStorage.getItem(SESSION_HISTORY_STORAGE_KEY);
+    if (!raw) return [];
+    const parsed: unknown = JSON.parse(raw);
+    return Array.isArray(parsed) ? parsed.filter(isValidSession) : [];
+  } catch {
+    return [];
+  }
+}
+
+/** Best-effort persistence — a full/blocked `localStorage` (private
+ * browsing) must not break the chat, so failures are silently ignored. */
+function persistSessionHistory(): void {
+  if (typeof localStorage === "undefined") return;
+  try {
+    localStorage.setItem(
+      SESSION_HISTORY_STORAGE_KEY,
+      JSON.stringify(sessionHistory),
+    );
+  } catch {
+    // Storage unavailable/full — the in-memory history still works for
+    // the rest of this page session.
+  }
+}
+
+function clearSessionHistoryStorage(): void {
+  if (typeof localStorage === "undefined") return;
+  try {
+    localStorage.removeItem(SESSION_HISTORY_STORAGE_KEY);
+  } catch {
+    // Best-effort, same as persistSessionHistory.
+  }
+}
+
+/** Session menu title: the first user question, truncated. Falls back to
+ * "New chat" for a (theoretically archived) transcript with no user turn. */
+function sessionTitle(msgs: readonly ChatMessage[]): string {
+  const firstUser = msgs.find((m) => m.role === "user");
+  const text = firstUser?.text.trim();
+  if (!text) return "New chat";
+  return text.length > SESSION_TITLE_MAX
+    ? `${text.slice(0, SESSION_TITLE_MAX)}…`
+    : text;
+}
+
+/** View reads: the current transcript, oldest first. */
+export function getMessages(): ChatMessage[] {
+  return messages;
+}
+
+/** View reads: which tier is currently answering. */
+export function getTier(): ChatTier {
+  return tier;
+}
+
+/** View reads: the live daemon's advertised model name (Tier 1 only). */
+export function getModel(): string | null {
+  return model;
+}
+
+/** View reads: true while a Tier-1 answer is still streaming in. */
+export function isPending(): boolean {
+  return pending;
+}
+
+/** View reads: which panel tab (Chat | Info) is active. */
+export function getActiveTab(): ChatTab {
+  return activeTab;
+}
+
+/** View writes: switches the active panel tab. Never touches `messages`/
+ * `connection` — switching tabs must never interrupt a streaming answer or
+ * reset scroll/in-flight state (RFC-035 FR-3), which is why the Chat
+ * subtree stays mounted in the view (bits-ui's `Tabs.Content` hides
+ * inactive panels via the `hidden` attribute, not by unmounting). */
+export function setActiveTab(tab: ChatTab): void {
+  activeTab = tab;
+}
+
+/** View reads (Info tab, RFC-035 Wave 2 FR-5): accumulated token/cost
+ * totals — `session` since the current transcript started, `cumulative`
+ * for the lifetime of this page load. Both stay all-zero (rendered as "—"
+ * by the view) until the first `usage` frame arrives. */
+export function getUsage(): UsageSnapshot {
+  return { session: sessionUsage, cumulative: cumulativeUsage };
+}
+
+/** View reads (Info tab, RFC-035 Wave 2 FR-6): the other live
+ * forgeplan-web/agent instances discovered via the daemon's `ready` frame.
+ * Empty until the first `ready` frame arrives (or if genuinely alone). */
+export function getOtherInstances(): OtherAgentInstance[] {
+  return otherInstances;
+}
+
+function appendMessage(
+  role: ChatMessage["role"],
+  text: string,
+  target?: CameraTarget,
+): number {
+  const msg: ChatMessage = target ? { role, text, target } : { role, text };
+  messages = [...messages, msg];
+  return messages.length - 1;
+}
+
+/** Records the camera target the streaming assistant message drove, so the
+ * view can render its "→ moved to <label>" chip once the answer settles. */
+function setMessageTarget(index: number, target: CameraTarget): void {
+  const existing = messages[index];
+  if (!existing) return;
+  const next = messages.slice();
+  next[index] = { ...existing, target };
+  messages = next;
+}
+
+function appendDelta(index: number, delta: string): void {
+  const existing = messages[index];
+  if (!existing) return;
+  const next = messages.slice();
+  next[index] = { ...existing, text: existing.text + delta };
+  messages = next;
+}
+
+/** Tears down any live connection and reverts to the offline tier. A
+ * still-empty placeholder assistant bubble (no tokens ever arrived) is
+ * dropped rather than left dangling; a partial answer is kept as-is. */
+function fallBackToTier0(): void {
+  if (
+    activeAssistantIndex !== null &&
+    messages[activeAssistantIndex]?.text === ""
+  ) {
+    const dropIndex = activeAssistantIndex;
+    messages = messages.filter((_, i) => i !== dropIndex);
+  }
+  connection?.close();
+  connection = null;
+  tier = "tier0";
+  model = null;
+  pending = false;
+  activeAssistantIndex = null;
+  currentTurnId = null;
+}
+
+/** Bugfix #6 — `fatal` (echoed from the daemon's `error` frame) decides
+ * whether this is a connection-ending failure or a recoverable per-turn
+ * one. `fatal: true` tears the whole Tier-1 session down via
+ * `fallBackToTier0`, same as before this fix. `fatal: false` means the
+ * connection/session is still usable: the error text is appended to the
+ * in-flight assistant bubble same as always, but `pending`/
+ * `activeAssistantIndex` are simply cleared so the user can try another
+ * question on the SAME live connection. */
+function handleError(message: string, fatal: boolean): void {
+  if (activeAssistantIndex !== null) {
+    const existing = messages[activeAssistantIndex]?.text ?? "";
+    appendDelta(
+      activeAssistantIndex,
+      existing.length > 0 ? `\n\n${message}` : message,
+    );
+  }
+  if (fatal) {
+    fallBackToTier0();
+    return;
+  }
+  pending = false;
+  activeAssistantIndex = null;
+}
+
+function handleDone(): void {
+  pending = false;
+  activeAssistantIndex = null;
+}
+
+function handleShowOnMap(target: CameraTarget): void {
+  if (activeAssistantIndex !== null)
+    setMessageTarget(activeAssistantIndex, target);
+  showOnMap(target);
+}
+
+function addUsage(total: TokenUsage, delta: UsageDelta): TokenUsage {
+  return {
+    inputTokens: total.inputTokens + delta.inputTokens,
+    outputTokens: total.outputTokens + delta.outputTokens,
+    costUsd: total.costUsd + delta.costUsd,
+  };
+}
+
+/** RFC-035 (Wave 2, FR-5) — one daemon `usage` frame (one per completed
+ * turn); folded into both the current-session and page-lifetime totals. */
+function handleUsage(delta: UsageDelta): void {
+  sessionUsage = addUsage(sessionUsage, delta);
+  cumulativeUsage = addUsage(cumulativeUsage, delta);
+}
+
+/** RFC-035 (Wave 2, FR-6) — the `ready` frame's instance-discovery
+ * snapshot; `capabilities` isn't surfaced by the Info tab yet, so only
+ * `otherInstances` is retained. */
+function handleReadyMeta(meta: {
+  capabilities: string[];
+  otherInstances: OtherAgentInstance[];
+}): void {
+  otherInstances = meta.otherInstances;
+}
+
+function ensureConnection(): AgentConnection {
+  if (connection) return connection;
+  connection = connectAgent(agentPort, {
+    // Bugfix #1 — every per-turn handler below drops a frame whose
+    // `turnId` no longer matches the turn currently being rendered (a
+    // cancelled-then-superseded turn's late frames land here too since the
+    // daemon runs one persistent Query per connection). `onClose`/
+    // `onReadyMeta` stay unguarded — they are connection-level, not
+    // per-turn.
+    onToken: (delta, turnId) => {
+      if (!isCurrentTurn(turnId)) return;
+      if (activeAssistantIndex !== null)
+        appendDelta(activeAssistantIndex, delta);
+    },
+    onShowOnMap: (target, turnId) => {
+      if (!isCurrentTurn(turnId)) return;
+      handleShowOnMap(target);
+    },
+    onDone: (turnId) => {
+      if (!isCurrentTurn(turnId)) return;
+      handleDone();
+    },
+    onError: (message, fatal, turnId) => {
+      if (!isCurrentTurn(turnId)) return;
+      handleError(message, fatal);
+    },
+    onClose: fallBackToTier0,
+    onUsage: (usage, turnId) => {
+      if (!isCurrentTurn(turnId)) return;
+      handleUsage(usage);
+    },
+    onReadyMeta: handleReadyMeta,
+  });
+  return connection;
+}
+
+function sendTier1(question: string): void {
+  pending = true;
+  currentTurnId = createTurnId();
+  activeAssistantIndex = appendMessage("assistant", "");
+  ensureConnection().send(question, currentTurnId);
+}
+
+/**
+ * Sends a user question to the live agent (Tier 1). Pushes an empty
+ * assistant message and streams the live agent's answer into it, relaying
+ * any `show_on_map` call to the camera. A no-op while offline (`tier !==
+ * "tier1"`) — this app is AI-only, there is no client-side fallback
+ * answerer (the Tier 0 keyword matcher was removed, onboard-agent
+ * phase 1). MapChat's offline call-to-action already keeps Send disabled
+ * while offline; this guard covers any other caller.
+ */
+export function send(question: string): void {
+  const trimmed = question.trim();
+  if (!trimmed) return;
+  if (tier !== "tier1") return; // offline — no client-side fallback answerer
+  if (pending) return; // one in-flight Tier-1 answer at a time
+
+  messages = [...messages, { role: "user", text: trimmed }];
+  sendTier1(trimmed);
+}
+
+const STOPPED_MARKER = "_(stopped)_";
+
+/** Appends a subtle stopped marker to a message's existing text, used only
+ * by `cancelCurrent()`. Keeps whatever partial text already streamed in; a
+ * still-empty bubble (cancelled before any token arrived) gets just the
+ * marker rather than being left blank. */
+function appendStoppedMarker(index: number): void {
+  const existing = messages[index];
+  if (!existing) return;
+  const next = messages.slice();
+  next[index] = {
+    ...existing,
+    text:
+      existing.text.length > 0
+        ? `${existing.text}\n\n${STOPPED_MARKER}`
+        : STOPPED_MARKER,
+  };
+  messages = next;
+}
+
+/**
+ * Stops the in-flight Tier-1 answer immediately (the view's Stop button).
+ * Tells the daemon to cancel — `AgentConnection#cancel` never throws, even
+ * with no live connection (the optional chaining below covers that case
+ * too) — then, without waiting for any daemon response, marks the
+ * in-progress assistant bubble as stopped (keeping whatever partial text
+ * already streamed in) and clears `pending` so the input/Send re-enable
+ * immediately. The connection itself is left open — RFC-034 Phase 4a: "the
+ * session stays open for the next question" — only `newChat()` closes it.
+ * A no-op when nothing is pending.
+ *
+ * Bugfix #1 — also invalidates `currentTurnId`, so any frame from the
+ * cancelled turn that arrives after this point (the daemon's `cancel`
+ * interrupts the turn but doesn't guarantee no frames are already in
+ * flight) no longer matches `isCurrentTurn` and is dropped rather than
+ * corrupting whatever the user sends next.
+ */
+export function cancelCurrent(): void {
+  if (!pending) return;
+  connection?.cancel();
+  if (activeAssistantIndex !== null) {
+    appendStoppedMarker(activeAssistantIndex);
+  }
+  pending = false;
+  activeAssistantIndex = null;
+  currentTurnId = null;
+}
+
+/** View reads: past chat transcripts, most recent first (capped at
+ * `SESSION_HISTORY_CAP`). */
+export function getSessionHistory(): ChatSession[] {
+  return sessionHistory;
+}
+
+/** View reads: non-null while revisiting a past session — the id into
+ * `sessionHistory` currently shown instead of the live transcript. */
+export function getViewingSessionId(): string | null {
+  return viewingSessionId;
+}
+
+/** View reads: the full archived session currently being revisited, or
+ * `null` when there isn't one (viewing the live transcript). */
+export function getViewedSession(): ChatSession | null {
+  if (!viewingSessionId) return null;
+  return sessionHistory.find((s) => s.id === viewingSessionId) ?? null;
+}
+
+/**
+ * Selects a past session for read-only revisit — the view swaps its
+ * transcript to `getViewedSession()` and disables sending. The live
+ * session keeps running in the background (a Tier-1 answer already
+ * in flight is unaffected); `viewCurrentSession` switches back to it.
+ *
+ * // TODO(rfc-034-live-continue): reconnecting THIS archived session's own
+ * daemon context (rather than only viewing its transcript) is a
+ * nice-to-have graduation path — MVP ships read-only revisit only.
+ */
+export function viewSession(id: string): void {
+  viewingSessionId = id;
+}
+
+/** Switches the view back to the live transcript. */
+export function viewCurrentSession(): void {
+  viewingSessionId = null;
+}
+
+/**
+ * Archives the current transcript (if non-empty) into session history and
+ * starts a fresh one. Closes any live Tier-1 connection so the next
+ * question opens a brand-new daemon session — RFC-034's "New chat gets a
+ * fresh agent context" contract — rather than continuing the old one's
+ * accrued context. A no-op while a Tier-1 answer is still streaming in,
+ * so an in-flight message is never discarded (call again once it settles).
+ */
+export function newChat(): void {
+  if (pending) return;
+  if (messages.length > 0) {
+    const archived: ChatSession = {
+      id: sessionId,
+      title: sessionTitle(messages),
+      messages,
+      createdAt: Date.now(),
+    };
+    sessionHistory = [archived, ...sessionHistory].slice(
+      0,
+      SESSION_HISTORY_CAP,
+    );
+    persistSessionHistory();
+  }
+  connection?.close();
+  connection = null;
+  activeAssistantIndex = null;
+  currentTurnId = null;
+  messages = [];
+  sessionId = createSessionId();
+  viewingSessionId = null;
+  sessionUsage = { ...ZERO_USAGE };
+}
+
+/**
+ * Probes the daemon once and updates tier/model on success. Exposed
+ * directly (not just via the interval) so callers — including tests —
+ * can await a single check without waiting on `PROBE_INTERVAL_MS`. A
+ * down result only reverts to Tier 0 when there's no live connection
+ * already open — an established Tier-1 session's own onError/onClose is
+ * the source of truth for *that* session dropping, not a parallel probe.
+ *
+ * Bugfix #9 — captures `probeGeneration` before awaiting the (~1.5s
+ * timeout) probe and re-checks it on resolve: a fast close→reopen bumps
+ * the generation via `stopAgentProbe`/`startAgentProbe`, so an
+ * older in-flight probe's result is discarded instead of overwriting a
+ * newer one that already landed.
+ */
+export async function checkDaemon(
+  port: number = DEFAULT_AGENT_PORT,
+): Promise<void> {
+  agentPort = port;
+  const generation = probeGeneration;
+  const result = await probeDaemon(port);
+  if (generation !== probeGeneration) return; // superseded by a newer probe
+  if (result.up) {
+    tier = "tier1";
+    model = result.model ?? null;
+    // RFC-035 (Wave 2 follow-up) — the probe now carries the same
+    // otherInstances snapshot the `ready` frame does, so the Info tab's
+    // "Other projects" row populates on chat open, before any WebSocket
+    // connects. Whichever of the probe (every PROBE_INTERVAL_MS) or a live
+    // `ready` frame (handleReadyMeta) fired most recently wins — both write
+    // the same store field.
+    otherInstances = result.otherInstances ?? [];
+  } else if (!connection) {
+    tier = "tier0";
+    model = null;
+  }
+}
+
+/** View lifecycle (MapChat onMount): start probing for the daemon.
+ * Idempotent — a second call while a timer is already running is a
+ * no-op. Bugfix #9 — bumps `probeGeneration` so a probe left in flight
+ * from a just-stopped probe cycle (see `stopAgentProbe`) can never
+ * overwrite the state this fresh cycle establishes. */
+export function startAgentProbe(port: number = DEFAULT_AGENT_PORT): void {
+  if (probeTimer) return;
+  probeGeneration++;
+  void checkDaemon(port);
+  probeTimer = setInterval(() => void checkDaemon(port), PROBE_INTERVAL_MS);
+}
+
+/** View lifecycle (MapChat onDestroy): stop probing and tear down any
+ * live connection/pending state.
+ *
+ * Bugfix #2 — closing the connection directly here (the old behaviour)
+ * left `pending`/`activeAssistantIndex` stuck if a Tier-1 answer was mid
+ * stream when the panel closed: `newChat()` no-ops while `pending`, so a
+ * later remount with a fresh probe couldn't clear the orphaned
+ * "● thinking…" bubble. Routing through `fallBackToTier0` clears that
+ * state the same way any other connection teardown does.
+ *
+ * Bugfix #9 — bumps `probeGeneration` so a probe already in flight when
+ * the panel closes can't land after this call and resurrect tier1 state
+ * for a connection that no longer exists.
+ */
+export function stopAgentProbe(): void {
+  if (probeTimer) {
+    clearInterval(probeTimer);
+    probeTimer = null;
+  }
+  probeGeneration++;
+  fallBackToTier0();
+}
+
+/** Test/dev helper: resets the shared store to its initial state, including
+ * session history (in-memory + persisted) so tests stay isolated. */
+export function resetChat(): void {
+  stopAgentProbe();
+  messages = [];
+  tier = "tier0";
+  model = null;
+  pending = false;
+  activeAssistantIndex = null;
+  currentTurnId = null;
+  sessionId = createSessionId();
+  sessionHistory = [];
+  viewingSessionId = null;
+  sessionUsage = { ...ZERO_USAGE };
+  cumulativeUsage = { ...ZERO_USAGE };
+  otherInstances = [];
+  clearSessionHistoryStorage();
+}
diff --git a/template/src/widgets/map-chat/model/chat-store.test.ts b/template/src/widgets/map-chat/model/chat-store.test.ts
new file mode 100644
index 0000000..b632bdf
--- /dev/null
+++ b/template/src/widgets/map-chat/model/chat-store.test.ts
@@ -0,0 +1,524 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import {
+  send,
+  cancelCurrent,
+  getMessages,
+  getModel,
+  getOtherInstances,
+  getTier,
+  getUsage,
+  isPending,
+  checkDaemon,
+  newChat,
+  resetChat,
+} from "./chat-store.svelte";
+import {
+  currentCameraRequest,
+  clearCameraTarget,
+} from "@/widgets/composed-map/model/camera-bus.svelte";
+import { probeDaemon, connectAgent, type AgentHandlers } from "./agent-client";
+
+// onboard-agent phase 1 (AI-only) — send() answers ONLY through the live
+// daemon (Tier 1); there is no client-side fallback answerer any more.
+// Module-level state (messages/tier here, the camera request in
+// camera-bus) persists across tests in this file — reset both before
+// every test, mirroring camera-bus.test.ts's own isolation.
+//
+// agent-client is mocked file-wide: the offline describe block below never
+// calls checkDaemon, so the mock is inert for it; the "tier1" block
+// reassigns probeDaemon/connectAgent per test to drive the store's
+// live-agent branch deterministically, without a real socket.
+vi.mock("./agent-client", () => ({
+  probeDaemon: vi.fn(),
+  connectAgent: vi.fn(),
+}));
+
+beforeEach(() => {
+  resetChat();
+  clearCameraTarget();
+  vi.mocked(probeDaemon).mockReset();
+  vi.mocked(connectAgent).mockReset();
+});
+
+describe("chat-store — send (offline)", () => {
+  it("is a no-op while offline (tier0) — no messages are pushed", () => {
+    send("Tell me about CLI Surfaces");
+    expect(getMessages()).toEqual([]);
+  });
+
+  it("does not move the camera while offline", () => {
+    const before = currentCameraRequest().seq;
+    send("Tell me about CLI Surfaces");
+    expect(currentCameraRequest().seq).toBe(before);
+  });
+
+  it("ignores a blank/whitespace-only question while offline too", () => {
+    send("   ");
+    expect(getMessages()).toEqual([]);
+  });
+});
+
+describe("chat-store — tier", () => {
+  it("defaults to tier0", () => {
+    expect(getTier()).toBe("tier0");
+  });
+});
+
+describe("chat-store — resetChat", () => {
+  it("clears the transcript and restores the default tier", async () => {
+    vi.mocked(probeDaemon).mockResolvedValue({
+      up: true,
+      model: "claude-mock",
+    });
+    await checkDaemon(7431);
+    vi.mocked(connectAgent).mockReturnValue({
+      send: vi.fn(),
+      cancel: vi.fn(),
+      close: vi.fn(),
+    });
+
+    send("Tell me about CLI Surfaces");
+    expect(getMessages().length).toBeGreaterThan(0);
+    resetChat();
+    expect(getMessages()).toEqual([]);
+    expect(getTier()).toBe("tier0");
+  });
+});
+
+// onboard-agent phase 1 Test Strategy Hooks — checkDaemon upgrades the tier
+// on a successful probe; send() in tier1 streams tokens into the assistant
+// message via a mocked agent-client and drives camera-bus via
+// onShowOnMap; onError/onClose fall back to tier0 (offline) gracefully.
+describe("chat-store — tier1", () => {
+  function mockConnection() {
+    const conn = { send: vi.fn(), cancel: vi.fn(), close: vi.fn() };
+    let handlers: AgentHandlers | undefined;
+    vi.mocked(connectAgent).mockImplementation((_port, h) => {
+      handlers = h;
+      return conn;
+    });
+    return {
+      conn,
+      handlers: () => {
+        expect(handlers).toBeDefined();
+        return handlers!;
+      },
+    };
+  }
+
+  it("upgrades to tier1 and records the model once the daemon probe succeeds", async () => {
+    vi.mocked(probeDaemon).mockResolvedValue({
+      up: true,
+      model: "claude-mock",
+    });
+    await checkDaemon(7431);
+    expect(getTier()).toBe("tier1");
+    expect(getModel()).toBe("claude-mock");
+  });
+
+  it("stays on tier0 when the probe reports the daemon down", async () => {
+    vi.mocked(probeDaemon).mockResolvedValue({ up: false });
+    await checkDaemon(7431);
+    expect(getTier()).toBe("tier0");
+    expect(getModel()).toBeNull();
+  });
+
+  it("pushes a user message and streams tokens into a progressively-updated assistant message", async () => {
+    vi.mocked(probeDaemon).mockResolvedValue({
+      up: true,
+      model: "claude-mock",
+    });
+    await checkDaemon(7431);
+    const { handlers } = mockConnection();
+
+    send("Where does artifact recording live?");
+    expect(getMessages()).toEqual([
+      { role: "user", text: "Where does artifact recording live?" },
+      { role: "assistant", text: "" },
+    ]);
+    expect(isPending()).toBe(true);
+
+    handlers().onToken("Arti", null);
+    handlers().onToken("facts live in .forgeplan/", null);
+    expect(getMessages()[1]).toEqual({
+      role: "assistant",
+      text: "Artifacts live in .forgeplan/",
+    });
+
+    handlers().onDone(null);
+    expect(isPending()).toBe(false);
+  });
+
+  it("relays a show_on_map call to camera-bus during a tier1 answer", async () => {
+    vi.mocked(probeDaemon).mockResolvedValue({
+      up: true,
+      model: "claude-mock",
+    });
+    await checkDaemon(7431);
+    const { handlers } = mockConnection();
+
+    const before = currentCameraRequest().seq;
+    send("Where does artifact recording live?");
+    handlers().onShowOnMap({ kind: "zone", id: "z.a" }, null);
+
+    const after = currentCameraRequest();
+    expect(after.seq).toBe(before + 1);
+    expect(after.target).toEqual({ kind: "zone", id: "z.a" });
+  });
+
+  it("ignores a second send while a tier1 answer is still pending", async () => {
+    vi.mocked(probeDaemon).mockResolvedValue({
+      up: true,
+      model: "claude-mock",
+    });
+    await checkDaemon(7431);
+    const { conn } = mockConnection();
+
+    send("First question");
+    send("Second question");
+    expect(conn.send).toHaveBeenCalledTimes(1);
+    expect(getMessages()).toHaveLength(2);
+  });
+
+  it("falls back to tier0 and surfaces the message on a fatal onError", async () => {
+    vi.mocked(probeDaemon).mockResolvedValue({
+      up: true,
+      model: "claude-mock",
+    });
+    await checkDaemon(7431);
+    const { handlers } = mockConnection();
+
+    send("Where does artifact recording live?");
+    handlers().onError("daemon crashed", true, null);
+
+    expect(getTier()).toBe("tier0");
+    expect(getModel()).toBeNull();
+    expect(isPending()).toBe(false);
+    expect(getMessages()[1]).toEqual({
+      role: "assistant",
+      text: "daemon crashed",
+    });
+  });
+
+  it("falls back to tier0 and drops the empty placeholder on an unsolicited close", async () => {
+    vi.mocked(probeDaemon).mockResolvedValue({
+      up: true,
+      model: "claude-mock",
+    });
+    await checkDaemon(7431);
+    const { handlers } = mockConnection();
+
+    send("Where does artifact recording live?");
+    handlers().onClose();
+
+    expect(getTier()).toBe("tier0");
+    // No tokens ever arrived — the dangling empty assistant bubble is
+    // dropped rather than left in the transcript.
+    expect(getMessages()).toEqual([
+      { role: "user", text: "Where does artifact recording live?" },
+    ]);
+  });
+
+  it("keeps a partial answer intact when the connection drops mid-stream", async () => {
+    vi.mocked(probeDaemon).mockResolvedValue({
+      up: true,
+      model: "claude-mock",
+    });
+    await checkDaemon(7431);
+    const { handlers } = mockConnection();
+
+    send("Where does artifact recording live?");
+    handlers().onToken("Partial answer", null);
+    handlers().onClose();
+
+    expect(getTier()).toBe("tier0");
+    expect(getMessages()[1]).toEqual({
+      role: "assistant",
+      text: "Partial answer",
+    });
+  });
+});
+
+// Phase 4a — cancel/stop: cancelCurrent() lets the user stop a streaming
+// Tier-1 answer mid-flight. It must relay the cancel to the daemon (via
+// AgentConnection#cancel), clear pending immediately (no waiting on any
+// daemon response), keep whatever partial text already streamed in, and
+// leave the connection/tier untouched so the next question reuses the
+// same live session.
+describe("chat-store — cancelCurrent", () => {
+  function mockConnection() {
+    const conn = { send: vi.fn(), cancel: vi.fn(), close: vi.fn() };
+    let handlers: AgentHandlers | undefined;
+    vi.mocked(connectAgent).mockImplementation((_port, h) => {
+      handlers = h;
+      return conn;
+    });
+    return {
+      conn,
+      handlers: () => {
+        expect(handlers).toBeDefined();
+        return handlers!;
+      },
+    };
+  }
+
+  it("is a no-op when nothing is pending — never throws with no active connection", () => {
+    expect(() => cancelCurrent()).not.toThrow();
+    expect(getMessages()).toEqual([]);
+    expect(isPending()).toBe(false);
+  });
+
+  it("calls connection.cancel() and clears pending so Send re-enables", async () => {
+    vi.mocked(probeDaemon).mockResolvedValue({
+      up: true,
+      model: "claude-mock",
+    });
+    await checkDaemon(7431);
+    const { conn } = mockConnection();
+
+    send("Where does artifact recording live?");
+    expect(isPending()).toBe(true);
+
+    cancelCurrent();
+
+    expect(conn.cancel).toHaveBeenCalledTimes(1);
+    expect(isPending()).toBe(false);
+  });
+
+  it("keeps the partial assistant text and appends a stopped marker", async () => {
+    vi.mocked(probeDaemon).mockResolvedValue({
+      up: true,
+      model: "claude-mock",
+    });
+    await checkDaemon(7431);
+    const { handlers } = mockConnection();
+
+    send("Where does artifact recording live?");
+    handlers().onToken("Partial answer", null);
+    cancelCurrent();
+
+    expect(getMessages()[1]).toEqual({
+      role: "assistant",
+      text: "Partial answer\n\n_(stopped)_",
+    });
+  });
+
+  it("marks a still-empty assistant bubble as stopped rather than dropping it", async () => {
+    vi.mocked(probeDaemon).mockResolvedValue({
+      up: true,
+      model: "claude-mock",
+    });
+    await checkDaemon(7431);
+    mockConnection();
+
+    send("Where does artifact recording live?");
+    cancelCurrent();
+
+    expect(getMessages()[1]).toEqual({
+      role: "assistant",
+      text: "_(stopped)_",
+    });
+  });
+
+  it("does not close the connection or revert to tier0 — the session stays open for the next question", async () => {
+    vi.mocked(probeDaemon).mockResolvedValue({
+      up: true,
+      model: "claude-mock",
+    });
+    await checkDaemon(7431);
+    const { conn } = mockConnection();
+
+    send("Where does artifact recording live?");
+    cancelCurrent();
+
+    expect(conn.close).not.toHaveBeenCalled();
+    expect(getTier()).toBe("tier1");
+  });
+
+  it("allows sending a new question immediately after cancelling", async () => {
+    vi.mocked(probeDaemon).mockResolvedValue({
+      up: true,
+      model: "claude-mock",
+    });
+    await checkDaemon(7431);
+    const { conn } = mockConnection();
+
+    send("First question");
+    cancelCurrent();
+    send("Second question");
+
+    expect(conn.send).toHaveBeenCalledTimes(2);
+    expect(isPending()).toBe(true);
+  });
+
+  it("is a no-op if called a second time once already cancelled", async () => {
+    vi.mocked(probeDaemon).mockResolvedValue({
+      up: true,
+      model: "claude-mock",
+    });
+    await checkDaemon(7431);
+    const { conn } = mockConnection();
+
+    send("Where does artifact recording live?");
+    cancelCurrent();
+    cancelCurrent();
+
+    expect(conn.cancel).toHaveBeenCalledTimes(1);
+  });
+});
+
+// RFC-035 Wave 2 (FR-5/FR-6) — Info tab live data: token usage accumulates
+// per-session AND cumulatively (session resets on newChat, cumulative
+// doesn't); otherInstances mirrors the daemon's ready-frame snapshot.
+describe("chat-store — usage + other instances (RFC-035 Wave 2)", () => {
+  function mockConnection() {
+    const conn = { send: vi.fn(), cancel: vi.fn(), close: vi.fn() };
+    let handlers: AgentHandlers | undefined;
+    vi.mocked(connectAgent).mockImplementation((_port, h) => {
+      handlers = h;
+      return conn;
+    });
+    return {
+      conn,
+      handlers: () => {
+        expect(handlers).toBeDefined();
+        return handlers!;
+      },
+    };
+  }
+
+  it("starts at zero usage and no other instances", () => {
+    expect(getUsage()).toEqual({
+      session: { inputTokens: 0, outputTokens: 0, costUsd: 0 },
+      cumulative: { inputTokens: 0, outputTokens: 0, costUsd: 0 },
+    });
+    expect(getOtherInstances()).toEqual([]);
+  });
+
+  // RFC-035 (Wave 2 follow-up) — the /health probe now carries the same
+  // otherInstances snapshot the ready frame does, so checkDaemon alone (no
+  // WebSocket connection, no message ever sent) populates the Info tab's
+  // "Other projects" row on chat open.
+  it("populates otherInstances from the probe result alone, with no WS connection", async () => {
+    vi.mocked(probeDaemon).mockResolvedValue({
+      up: true,
+      model: "claude-mock",
+      capabilities: ["usage", "instances"],
+      otherInstances: [
+        { projectName: "sibling-project", port: 7432, kind: "web" },
+      ],
+    });
+
+    await checkDaemon(7431);
+
+    expect(connectAgent).not.toHaveBeenCalled();
+    expect(getOtherInstances()).toEqual([
+      { projectName: "sibling-project", port: 7432, kind: "web" },
+    ]);
+  });
+
+  it("defaults otherInstances to [] when the probe result omits it", async () => {
+    vi.mocked(probeDaemon).mockResolvedValue({
+      up: true,
+      model: "claude-mock",
+    });
+
+    await checkDaemon(7431);
+
+    expect(getOtherInstances()).toEqual([]);
+  });
+
+  it("accumulates usage frames into both session and cumulative totals", async () => {
+    vi.mocked(probeDaemon).mockResolvedValue({
+      up: true,
+      model: "claude-mock",
+    });
+    await checkDaemon(7431);
+    const { handlers } = mockConnection();
+
+    send("Where does artifact recording live?");
+    handlers().onUsage?.(
+      { inputTokens: 100, outputTokens: 40, costUsd: 0.01 },
+      null,
+    );
+    handlers().onUsage?.(
+      { inputTokens: 50, outputTokens: 20, costUsd: 0.005 },
+      null,
+    );
+
+    expect(getUsage()).toEqual({
+      session: { inputTokens: 150, outputTokens: 60, costUsd: 0.015 },
+      cumulative: { inputTokens: 150, outputTokens: 60, costUsd: 0.015 },
+    });
+  });
+
+  it("resets session usage but keeps cumulative usage across newChat", async () => {
+    vi.mocked(probeDaemon).mockResolvedValue({
+      up: true,
+      model: "claude-mock",
+    });
+    await checkDaemon(7431);
+    const { handlers } = mockConnection();
+
+    send("Where does artifact recording live?");
+    handlers().onUsage?.(
+      { inputTokens: 100, outputTokens: 40, costUsd: 0.01 },
+      null,
+    );
+    handlers().onDone(null);
+    newChat();
+
+    expect(getUsage()).toEqual({
+      session: { inputTokens: 0, outputTokens: 0, costUsd: 0 },
+      cumulative: { inputTokens: 100, outputTokens: 40, costUsd: 0.01 },
+    });
+  });
+
+  it("captures otherInstances from the ready frame's onReadyMeta callback", async () => {
+    vi.mocked(probeDaemon).mockResolvedValue({
+      up: true,
+      model: "claude-mock",
+    });
+    await checkDaemon(7431);
+    const { handlers } = mockConnection();
+
+    send("Where does artifact recording live?");
+    handlers().onReadyMeta?.({
+      capabilities: ["usage", "instances"],
+      otherInstances: [
+        { projectName: "sibling-project", port: 7432, kind: "web" },
+      ],
+    });
+
+    expect(getOtherInstances()).toEqual([
+      { projectName: "sibling-project", port: 7432, kind: "web" },
+    ]);
+  });
+
+  it("resetChat clears usage totals and other-instance state", async () => {
+    vi.mocked(probeDaemon).mockResolvedValue({
+      up: true,
+      model: "claude-mock",
+    });
+    await checkDaemon(7431);
+    const { handlers } = mockConnection();
+
+    send("Where does artifact recording live?");
+    handlers().onUsage?.(
+      { inputTokens: 100, outputTokens: 40, costUsd: 0.01 },
+      null,
+    );
+    handlers().onReadyMeta?.({
+      capabilities: ["usage"],
+      otherInstances: [{ projectName: "other", port: 1, kind: "web" }],
+    });
+
+    resetChat();
+
+    expect(getUsage()).toEqual({
+      session: { inputTokens: 0, outputTokens: 0, costUsd: 0 },
+      cumulative: { inputTokens: 0, outputTokens: 0, costUsd: 0 },
+    });
+    expect(getOtherInstances()).toEqual([]);
+  });
+});
diff --git a/template/src/widgets/map-chat/ui/ChatMarkdown.svelte b/template/src/widgets/map-chat/ui/ChatMarkdown.svelte
new file mode 100644
index 0000000..d3d8736
--- /dev/null
+++ b/template/src/widgets/map-chat/ui/ChatMarkdown.svelte
@@ -0,0 +1,236 @@
+<script lang="ts">
+  /**
+   * ChatMarkdown — RFC-034 (Pillar C) chat UI upgrade, Phase A. Renders an
+   * assistant message's markdown properly instead of the raw `**`/`##`
+   * text MapChat showed before this component existed. Built on
+   * svelte-exmarkdown (Svelte-5-native, reactive: `<Markdown md={text}>`
+   * re-parses as `text` grows, so a Tier-1 answer streaming token-by-token
+   * renders progressively without re-mounting) + its `gfmPlugin` (tables,
+   * task lists, strikethrough) + rehype-highlight (lowlight) for
+   * fenced-code syntax highlighting.
+   *
+   * Styling is TOKEN-ONLY: highlighted-code `.hljs-*` classes below are
+   * mapped straight to our existing --fg/--accent/--good/--bad tokens
+   * (no vendored highlight.js theme CSS, no hardcoded hex) — this makes
+   * syntax highlighting dual-theme-correct for free, the same way every
+   * other token already flips on `data-theme`. `<a>` gets a dedicated
+   * renderer component (MdLink) for target=_blank+rel — the one piece
+   * that needs real behaviour, not just CSS. Everything else
+   * (headings/lists/paragraphs/tables/blockquote/code) is styled via
+   * `:global()` selectors scoped under `.chat-md`, over this component's
+   * own rendered subtree — the same pattern already used by
+   * ArtifactPanel's `{@html}` markdown body (rule 24's documented
+   * own-subtree exception; this file reaches into nothing outside itself).
+   *
+   * `denylist(["script", "iframe"])` is a defence-in-depth backstop:
+   * svelte-exmarkdown never uses `{@html}` (raw HTML embedded in markdown
+   * parses to an inert hast "raw" text node and is rendered via a plain
+   * Svelte text interpolation, never executed), so this mainly guards
+   * against a future rehype plugin reintroducing raw HTML elements.
+   *
+   * `<svelte:boundary>` is the safety net for the "never throws on a
+   * growing/partial string" contract: CommonMark itself can't fail to
+   * parse (any string is a valid document) and `ignoreMissing: true`
+   * stops rehype-highlight from throwing on an unrecognised fence
+   * language, but a render-time surprise still falls back to the raw
+   * text rather than blanking the message bubble.
+   */
+  import Markdown, { denylist } from "svelte-exmarkdown";
+  import { gfmPlugin } from "svelte-exmarkdown/gfm";
+  import rehypeHighlight from "rehype-highlight";
+  import type { Plugin } from "svelte-exmarkdown";
+  import MdLink from "./MdLink.svelte";
+
+  let { text }: { text: string } = $props();
+
+  const plugins: Plugin[] = [
+    gfmPlugin(),
+    { rehypePlugin: [rehypeHighlight, { ignoreMissing: true }] },
+    denylist(["script", "iframe"]),
+    { renderer: { a: MdLink } },
+  ];
+</script>
+
+<div class="chat-md">
+  <svelte:boundary>
+    <Markdown md={text} {plugins} />
+    {#snippet failed()}
+      <p class="chat-md-fallback">{text}</p>
+    {/snippet}
+  </svelte:boundary>
+</div>
+
+<style>
+  .chat-md {
+    font-family: var(--font-sans);
+    font-size: 12px;
+    line-height: 1.5;
+    color: var(--fg-1);
+  }
+  .chat-md-fallback {
+    margin: 0;
+    white-space: pre-wrap;
+    color: var(--fg-1);
+  }
+
+  /* Block spacing — sensible for a chat bubble (tighter than a full
+     document panel): first/last child collapse their outer margin so a
+     one-line answer doesn't add extra air above/below. */
+  .chat-md :global(> :first-child) {
+    margin-top: 0;
+  }
+  .chat-md :global(> :last-child) {
+    margin-bottom: 0;
+  }
+
+  .chat-md :global(p) {
+    margin: 6px 0;
+  }
+  .chat-md :global(h1),
+  .chat-md :global(h2),
+  .chat-md :global(h3),
+  .chat-md :global(h4),
+  .chat-md :global(h5),
+  .chat-md :global(h6) {
+    margin: 10px 0 4px;
+    color: var(--fg);
+    font-weight: 600;
+    line-height: 1.3;
+  }
+  .chat-md :global(h1) {
+    font-size: 14px;
+  }
+  .chat-md :global(h2) {
+    font-size: 13.5px;
+  }
+  .chat-md :global(h3),
+  .chat-md :global(h4),
+  .chat-md :global(h5),
+  .chat-md :global(h6) {
+    font-size: 12.5px;
+  }
+
+  .chat-md :global(ul),
+  .chat-md :global(ol) {
+    margin: 6px 0;
+    padding-left: 20px;
+  }
+  .chat-md :global(li) {
+    margin: 2px 0;
+  }
+  .chat-md :global(li > p) {
+    margin: 0;
+  }
+
+  .chat-md :global(blockquote) {
+    margin: 6px 0;
+    padding-left: 10px;
+    border-left: 2px solid var(--accent);
+    color: var(--fg-2);
+  }
+
+  .chat-md :global(hr) {
+    margin: 10px 0;
+    border: none;
+    border-top: 1px solid var(--line);
+  }
+
+  .chat-md :global(table) {
+    margin: 6px 0;
+    border-collapse: collapse;
+    font-size: 11.5px;
+    max-width: 100%;
+  }
+  .chat-md :global(th),
+  .chat-md :global(td) {
+    border: 1px solid var(--line);
+    padding: 3px 6px;
+    text-align: left;
+  }
+  .chat-md :global(th) {
+    background: var(--bg-2);
+    font-weight: 600;
+    color: var(--fg);
+  }
+
+  .chat-md :global(img) {
+    max-width: 100%;
+    border-radius: 4px;
+  }
+
+  /* Inline code — a small chip, matching shared/ui/code's `.inline` look. */
+  .chat-md :global(code) {
+    background: var(--bg-2);
+    border-radius: 2px;
+    padding: 1px 4px;
+    font-family: var(--font-mono);
+    font-size: 11.5px;
+  }
+
+  /* Fenced code blocks — rehype-highlight wraps these in
+     <pre><code class="hljs language-xxx">, so `pre code` resets the
+     inline chip styling and the block itself carries the bg/border. */
+  .chat-md :global(pre) {
+    margin: 6px 0;
+    background: var(--bg-2);
+    border: 1px solid var(--line-2);
+    border-radius: 3px;
+    padding: 8px 10px;
+    overflow-x: auto;
+    max-width: 100%;
+  }
+  .chat-md :global(pre code) {
+    background: transparent;
+    padding: 0;
+    font-size: 11.5px;
+    white-space: pre;
+  }
+
+  /* Syntax-highlighting tokens (rehype-highlight / lowlight's `.hljs-*`
+     classes) — mapped straight to design tokens, no vendored theme CSS,
+     so highlighting stays correct in both themes automatically. */
+  .chat-md :global(.hljs-comment),
+  .chat-md :global(.hljs-quote) {
+    color: var(--fg-3);
+    font-style: italic;
+  }
+  .chat-md :global(.hljs-keyword),
+  .chat-md :global(.hljs-selector-tag),
+  .chat-md :global(.hljs-literal),
+  .chat-md :global(.hljs-section),
+  .chat-md :global(.hljs-link) {
+    color: var(--accent);
+  }
+  .chat-md :global(.hljs-string),
+  .chat-md :global(.hljs-addition),
+  .chat-md :global(.hljs-attr),
+  .chat-md :global(.hljs-meta .hljs-string) {
+    color: var(--good);
+  }
+  .chat-md :global(.hljs-number),
+  .chat-md :global(.hljs-symbol),
+  .chat-md :global(.hljs-bullet) {
+    color: var(--accent-soft);
+  }
+  .chat-md :global(.hljs-title),
+  .chat-md :global(.hljs-name),
+  .chat-md :global(.hljs-selector-id),
+  .chat-md :global(.hljs-selector-class) {
+    color: var(--fg);
+  }
+  .chat-md :global(.hljs-type),
+  .chat-md :global(.hljs-built_in),
+  .chat-md :global(.hljs-builtin-name),
+  .chat-md :global(.hljs-attribute) {
+    color: var(--fg-2);
+  }
+  .chat-md :global(.hljs-deletion) {
+    color: var(--bad);
+  }
+  .chat-md :global(.hljs-emphasis) {
+    font-style: italic;
+  }
+  .chat-md :global(.hljs-strong) {
+    font-weight: 600;
+  }
+</style>
diff --git a/template/src/widgets/map-chat/ui/MapChat.render.test.ts b/template/src/widgets/map-chat/ui/MapChat.render.test.ts
new file mode 100644
index 0000000..9f76ef8
--- /dev/null
+++ b/template/src/widgets/map-chat/ui/MapChat.render.test.ts
@@ -0,0 +1,795 @@
+// @vitest-environment happy-dom
+/**
+ * onboard-agent phase 1 (AI-only) render-proof for MapChat.svelte. Harness:
+ * happy-dom + Svelte's built-in mount() — same pattern as
+ * OnboardTour.render.test.ts / nav-contract.render.test.ts.
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { mount, unmount, flushSync } from "svelte";
+import MapChat from "./MapChat.svelte";
+import { checkDaemon, resetChat } from "../model/chat-store.svelte";
+import {
+  clearCameraTarget,
+  currentCameraRequest,
+} from "@/widgets/composed-map/model/camera-bus.svelte";
+import type { MapDocument, MapZone } from "@/entities/map";
+import {
+  probeDaemon,
+  connectAgent,
+  type AgentHandlers,
+} from "../model/agent-client";
+
+// agent-client is mocked so the offline assertions below stay deterministic
+// (no real socket, no real daemon on the test host) and so Tier-1
+// rendering can be driven explicitly per test.
+vi.mock("../model/agent-client", () => ({
+  probeDaemon: vi.fn(),
+  connectAgent: vi.fn(),
+}));
+
+let host: HTMLElement | null = null;
+let instance: unknown = null;
+
+function zone(overrides: Partial<MapZone> = {}): MapZone {
+  return {
+    id: "z.a",
+    label: "Zone A",
+    kind: "surface",
+    accent: "--map-accent-cyan",
+    treatment: "neutral-dashed",
+    rule_edge: "off",
+    layout_rule: "grid",
+    cols: 2,
+    ...overrides,
+  };
+}
+
+function fixtureDoc(): MapDocument {
+  return {
+    schema: "forgeplan.map/v1",
+    meta: {
+      map_id: "test",
+      status: "confirmed",
+      project_type: "generic",
+      composition_id: "c1",
+      source_fingerprint: "fp",
+      version: 1,
+    },
+    canvas: {
+      grid: { cols: 1, rows: 1 },
+      gap: { x: 88, y: 70 },
+      margin: 40,
+      cell: {
+        card_w: 190,
+        card_h: 60,
+        card_gap: 36,
+        zpad: { top: 50, side: 24, bottom: 24 },
+      },
+    },
+    composition: {
+      template: "generic",
+      arrangement: "stack-ttb",
+      entry_zone: "z.a",
+      placements: [{ zone: "z.a", cell: { row: 0, col: 0 } }],
+      zone_connectors: [],
+    },
+    zones: [zone({ id: "z.a", label: "CLI Surfaces" })],
+    nodes: [],
+    edges: [],
+  };
+}
+
+function mountChat(props: {
+  doc: MapDocument;
+  onClose?: () => void;
+}): HTMLElement {
+  host = document.createElement("div");
+  document.body.appendChild(host);
+  instance = mount(MapChat, { target: host, props });
+  flushSync();
+  return host;
+}
+
+function getInput(root: HTMLElement): HTMLTextAreaElement {
+  const input = root.querySelector<HTMLTextAreaElement>(
+    '[aria-label="Ask the map a question"]',
+  );
+  expect(input).not.toBeNull();
+  return input!;
+}
+
+function getSendButton(root: HTMLElement): HTMLButtonElement {
+  const btn = Array.from(root.querySelectorAll("button")).find((b) =>
+    b.textContent?.includes("Send"),
+  );
+  expect(btn).toBeDefined();
+  return btn as HTMLButtonElement;
+}
+
+function getNewChatButton(root: HTMLElement): HTMLButtonElement {
+  const btn = Array.from(root.querySelectorAll("button")).find((b) =>
+    b.textContent?.includes("New chat"),
+  );
+  expect(btn).toBeDefined();
+  return btn as HTMLButtonElement;
+}
+
+function findStopButton(root: HTMLElement): HTMLButtonElement | null {
+  return (
+    (Array.from(root.querySelectorAll("button")).find((b) =>
+      b.textContent?.includes("Stop"),
+    ) as HTMLButtonElement | undefined) ?? null
+  );
+}
+
+function findSendButton(root: HTMLElement): HTMLButtonElement | null {
+  return (
+    (Array.from(root.querySelectorAll("button")).find((b) =>
+      b.textContent?.includes("Send"),
+    ) as HTMLButtonElement | undefined) ?? null
+  );
+}
+
+function typeInto(input: HTMLTextAreaElement, text: string): void {
+  input.value = text;
+  input.dispatchEvent(new Event("input", { bubbles: true }));
+  flushSync();
+}
+
+beforeEach(() => {
+  resetChat();
+  clearCameraTarget();
+  vi.mocked(probeDaemon).mockReset().mockResolvedValue({ up: false });
+  vi.mocked(connectAgent).mockReset();
+});
+
+afterEach(() => {
+  if (instance) {
+    unmount(instance as object);
+    instance = null;
+  }
+  host?.remove();
+  host = null;
+  vi.restoreAllMocks();
+});
+
+// onboard-agent phase 1 — with no daemon detected (the default in
+// beforeEach: probeDaemon resolves { up: false }), the chat is AI-only and
+// has nothing to answer with, so the body shows an offline call-to-action
+// instead of a message list + input. No sending, no fake answers.
+describe("MapChat — offline (no daemon)", () => {
+  it("shows the offline call-to-action instead of a message list and input", () => {
+    const root = mountChat({ doc: fixtureDoc() });
+    expect(root.textContent).toContain("The live assistant isn't running.");
+    expect(root.textContent).toContain("Start it in your project to chat:");
+    expect(root.textContent).toContain(
+      "The chat connects automatically once the agent is running.",
+    );
+  });
+
+  it("shows the offline status", () => {
+    // RFC-035 FR-2 — the header's old verbose "offline · Tier 0" Badge was
+    // replaced by a compact red-dot + "offline" word; the model/tier string
+    // moved to the Info tab (FR-4) instead of disappearing.
+    const root = mountChat({ doc: fixtureDoc() });
+    expect(root.textContent).toContain("offline");
+  });
+
+  it("renders the onboard-agent command as a copyable code block", () => {
+    const root = mountChat({ doc: fixtureDoc() });
+    expect(root.textContent).toContain("npx @forgeplan/web onboard-agent");
+    expect(
+      root.querySelector('[aria-label="Copy to clipboard"]'),
+    ).not.toBeNull();
+  });
+
+  it("renders no text input or Send button while offline", () => {
+    const root = mountChat({ doc: fixtureDoc() });
+    expect(
+      root.querySelector('[aria-label="Ask the map a question"]'),
+    ).toBeNull();
+    expect(
+      Array.from(root.querySelectorAll("button")).some((b) =>
+        b.textContent?.includes("Send"),
+      ),
+    ).toBe(false);
+  });
+
+  it("does nothing when send() is called directly while offline", async () => {
+    const { send, getMessages } = await import("../model/chat-store.svelte");
+    mountChat({ doc: fixtureDoc() });
+    send("Tell me about CLI Surfaces");
+    expect(getMessages()).toEqual([]);
+  });
+
+  it("renders a close button and fires onClose when clicked", () => {
+    const onClose = vi.fn();
+    const root = mountChat({ doc: fixtureDoc(), onClose });
+    const closeBtn = root.querySelector<HTMLButtonElement>(
+      '[aria-label="Close chat"]',
+    );
+    expect(closeBtn).not.toBeNull();
+    closeBtn!.dispatchEvent(new MouseEvent("click", { bubbles: true }));
+    flushSync();
+    expect(onClose).toHaveBeenCalledTimes(1);
+  });
+
+  it("omits the close button when onClose is not provided", () => {
+    const root = mountChat({ doc: fixtureDoc() });
+    expect(root.querySelector('[aria-label="Close chat"]')).toBeNull();
+  });
+});
+
+// onboard-agent phase 1 — Tier 1: the daemon probe (mocked) reports up
+// before mount, so the store is already in "tier1" by the time MapChat
+// reads it; a mocked agent-client connection drives the streaming/relay
+// behaviour explicitly. This is the ONLY state in which the chat can send
+// or answer anything (AI-only) — the offline call-to-action from the
+// describe block above disappears once the probe flips to tier1.
+describe("MapChat — tier1 (live)", () => {
+  function mockConnection() {
+    const conn = { send: vi.fn(), cancel: vi.fn(), close: vi.fn() };
+    let handlers: AgentHandlers | undefined;
+    vi.mocked(connectAgent).mockImplementation((_port, h) => {
+      handlers = h;
+      return conn;
+    });
+    return {
+      conn,
+      handlers: () => {
+        expect(handlers).toBeDefined();
+        return handlers!;
+      },
+    };
+  }
+
+  async function mountOnline(doc: MapDocument = fixtureDoc()) {
+    vi.mocked(probeDaemon).mockResolvedValue({
+      up: true,
+      model: "claude-mock",
+    });
+    await checkDaemon(7431);
+    const { handlers, conn } = mockConnection();
+    const root = mountChat({ doc });
+    return { root, handlers, conn };
+  }
+
+  it("shows the live badge with the daemon's model once the probe succeeds", async () => {
+    vi.mocked(probeDaemon).mockResolvedValue({
+      up: true,
+      model: "claude-mock",
+    });
+    await checkDaemon(7431);
+    const root = mountChat({ doc: fixtureDoc() });
+    expect(root.textContent).toContain("live");
+    expect(root.textContent).toContain("claude-mock");
+  });
+
+  it("renders the empty-transcript hint, an input, and a disabled Send button", async () => {
+    const { root } = await mountOnline();
+    expect(root.textContent).toContain("Ask anything about this project");
+    getInput(root);
+    expect(getSendButton(root).disabled).toBe(true);
+  });
+
+  it("enables Send once the input has non-whitespace text", async () => {
+    const { root } = await mountOnline();
+    const input = getInput(root);
+    typeInto(input, "   ");
+    expect(getSendButton(root).disabled).toBe(true);
+    typeInto(input, "hello");
+    expect(getSendButton(root).disabled).toBe(false);
+  });
+
+  it("pressing Enter in the input sends the message and clears it", async () => {
+    const { root } = await mountOnline();
+    const input = getInput(root);
+    typeInto(input, "Tell me about CLI Surfaces");
+    input.dispatchEvent(
+      new KeyboardEvent("keydown", { key: "Enter", bubbles: true }),
+    );
+    flushSync();
+    expect(root.textContent).toContain("CLI Surfaces");
+    expect(input.value).toBe("");
+  });
+
+  it("Shift+Enter does not send (only a plain Enter does)", async () => {
+    const { root } = await mountOnline();
+    const input = getInput(root);
+    typeInto(input, "Tell me about CLI Surfaces");
+    input.dispatchEvent(
+      new KeyboardEvent("keydown", {
+        key: "Enter",
+        shiftKey: true,
+        bubbles: true,
+      }),
+    );
+    flushSync();
+    // No message sent — the empty-transcript hint is still showing.
+    expect(root.textContent).toContain("Ask anything about this project");
+  });
+
+  it("clicking Send sends the message and clears the input", async () => {
+    const { root } = await mountOnline();
+    const input = getInput(root);
+    typeInto(input, "Tell me about CLI Surfaces");
+    getSendButton(root).dispatchEvent(
+      new MouseEvent("click", { bubbles: true }),
+    );
+    flushSync();
+    expect(root.textContent).toContain("CLI Surfaces");
+    expect(input.value).toBe("");
+  });
+
+  it("streams a live answer into the chat progressively", async () => {
+    const { root, handlers } = await mountOnline();
+    const input = getInput(root);
+    typeInto(input, "Where does artifact recording live?");
+    getSendButton(root).dispatchEvent(
+      new MouseEvent("click", { bubbles: true }),
+    );
+    flushSync();
+    expect(input.value).toBe("");
+
+    handlers().onToken("Arti", null);
+    flushSync();
+    expect(root.textContent).toContain("Arti");
+
+    handlers().onToken("facts live in .forgeplan/", null);
+    flushSync();
+    expect(root.textContent).toContain("Artifacts live in .forgeplan/");
+
+    handlers().onDone(null);
+    flushSync();
+    expect(root.textContent).toContain("Artifacts live in .forgeplan/");
+  });
+
+  it("renders a streamed assistant answer's markdown as real elements, not literal ** / ##", async () => {
+    const { root, handlers } = await mountOnline();
+    typeInto(getInput(root), "## Bold Heading");
+    getSendButton(root).dispatchEvent(
+      new MouseEvent("click", { bubbles: true }),
+    );
+    flushSync();
+
+    handlers().onToken("## Bold Heading — **bold** text", null);
+    handlers().onDone(null);
+    flushSync();
+
+    const assistantMarkdown = root.querySelector(".chat-md");
+    expect(assistantMarkdown).not.toBeNull();
+    expect(assistantMarkdown!.querySelector("h2")).not.toBeNull();
+    expect(assistantMarkdown!.querySelector("strong")).not.toBeNull();
+    expect(assistantMarkdown!.textContent).not.toContain("##");
+    expect(assistantMarkdown!.textContent).not.toContain("**");
+  });
+
+  it("shows Stop instead of Send while pending, then Send (disabled when empty) once the answer completes", async () => {
+    const { root, handlers } = await mountOnline();
+    const input = getInput(root);
+    typeInto(input, "Where does artifact recording live?");
+    getSendButton(root).dispatchEvent(
+      new MouseEvent("click", { bubbles: true }),
+    );
+    flushSync();
+
+    // Sending cleared the input and swapped Send for Stop while the
+    // answer streams -- Send is not the active control during a pending
+    // turn (Phase 4a: cancel/stop).
+    expect(input.value).toBe("");
+    expect(findStopButton(root)).not.toBeNull();
+    expect(findSendButton(root)).toBeNull();
+
+    handlers().onDone(null);
+    flushSync();
+
+    // Once the answer completes, Stop swaps back to Send -- disabled
+    // again because the input is still empty, enabled once text is typed.
+    expect(findStopButton(root)).toBeNull();
+    expect(findSendButton(root)).not.toBeNull();
+    expect(findSendButton(root)!.disabled).toBe(true);
+
+    typeInto(input, "another question");
+    expect(findSendButton(root)!.disabled).toBe(false);
+  });
+
+  it("relays a show_on_map call to camera-bus during a tier1 answer", async () => {
+    const { root, handlers } = await mountOnline();
+    typeInto(getInput(root), "Where does artifact recording live?");
+    getSendButton(root).dispatchEvent(
+      new MouseEvent("click", { bubbles: true }),
+    );
+    flushSync();
+
+    const before = currentCameraRequest().seq;
+    handlers().onShowOnMap({ kind: "zone", id: "z.a" }, null);
+    expect(currentCameraRequest().seq).toBe(before + 1);
+    expect(currentCameraRequest().target).toEqual({ kind: "zone", id: "z.a" });
+  });
+
+  // Bugfix #5 — a connection drop used to yank a non-empty transcript
+  // off-screen in favour of the offline CTA (isOffline used to ignore
+  // `messages.length`); the corrected behaviour keeps any existing
+  // transcript (partial answer included) visible, and reserves the CTA
+  // for the genuinely-empty case.
+  it("keeps the transcript visible (not the offline CTA) when the connection drops with a message already in flight", async () => {
+    const { root, handlers } = await mountOnline();
+    expect(root.textContent).toContain("claude-mock");
+
+    typeInto(getInput(root), "Where does artifact recording live?");
+    getSendButton(root).dispatchEvent(
+      new MouseEvent("click", { bubbles: true }),
+    );
+    flushSync();
+    handlers().onToken("Partial answer", null);
+    flushSync();
+
+    handlers().onClose();
+    flushSync();
+
+    // The header status flips to offline, but the transcript (including
+    // the partial answer already streamed in) stays on screen instead of
+    // being replaced by the offline call-to-action.
+    expect(root.textContent).toContain("offline");
+    expect(root.textContent).toContain("Partial answer");
+    expect(root.textContent).not.toContain(
+      "The live assistant isn't running.",
+    );
+  });
+
+  it('the "New chat" control clears the transcript via newChat', async () => {
+    const { root, handlers } = await mountOnline();
+    typeInto(getInput(root), "Tell me about CLI Surfaces");
+    getSendButton(root).dispatchEvent(
+      new MouseEvent("click", { bubbles: true }),
+    );
+    flushSync();
+    handlers().onDone(null);
+    flushSync();
+    expect(root.textContent).toContain("CLI Surfaces");
+
+    getNewChatButton(root).dispatchEvent(
+      new MouseEvent("click", { bubbles: true }),
+    );
+    flushSync();
+    expect(root.textContent).toContain("Ask anything about this project");
+  });
+
+  // Phase 4a — cancel/stop: the Send button becomes a Stop button while a
+  // Tier-1 answer is streaming, and swaps back once it settles (onDone) or
+  // is cancelled by the user.
+  describe("Stop button", () => {
+    it("shows Stop (not Send) while an answer is streaming, and Send once it completes", async () => {
+      const { root, handlers } = await mountOnline();
+      typeInto(getInput(root), "Where does artifact recording live?");
+      getSendButton(root).dispatchEvent(
+        new MouseEvent("click", { bubbles: true }),
+      );
+      flushSync();
+
+      expect(findStopButton(root)).not.toBeNull();
+      expect(findSendButton(root)).toBeNull();
+
+      handlers().onDone(null);
+      flushSync();
+
+      expect(findStopButton(root)).toBeNull();
+      expect(findSendButton(root)).not.toBeNull();
+    });
+
+    it("clicking Stop cancels the connection, keeps the partial answer with a stopped marker, and swaps back to Send", async () => {
+      const { root, conn, handlers } = await mountOnline();
+      typeInto(getInput(root), "Where does artifact recording live?");
+      getSendButton(root).dispatchEvent(
+        new MouseEvent("click", { bubbles: true }),
+      );
+      flushSync();
+
+      handlers().onToken("Partial answer", null);
+      flushSync();
+      expect(root.textContent).toContain("Partial answer");
+
+      findStopButton(root)!.dispatchEvent(
+        new MouseEvent("click", { bubbles: true }),
+      );
+      flushSync();
+
+      expect(conn.cancel).toHaveBeenCalledTimes(1);
+      expect(root.textContent).toContain("Partial answer");
+      expect(root.textContent).toContain("stopped");
+      expect(findStopButton(root)).toBeNull();
+      expect(findSendButton(root)).not.toBeNull();
+    });
+
+    it("does not fall back to offline after Stop — the live badge stays up for the next question", async () => {
+      const { root, handlers } = await mountOnline();
+      typeInto(getInput(root), "Where does artifact recording live?");
+      getSendButton(root).dispatchEvent(
+        new MouseEvent("click", { bubbles: true }),
+      );
+      flushSync();
+
+      findStopButton(root)!.dispatchEvent(
+        new MouseEvent("click", { bubbles: true }),
+      );
+      flushSync();
+
+      expect(root.textContent).toContain("live");
+      expect(root.textContent).toContain("claude-mock");
+      void handlers; // no further daemon frames needed for this assertion
+    });
+  });
+});
+
+// RFC-035 FR-3 — the Chat|Info Tabs split. Both panels stay MOUNTED (bits-ui
+// toggles the inactive one via the native `hidden` attribute) so a streaming
+// answer survives a tab switch — but that means a regression can make BOTH
+// panels visible at once. A live-browser check caught exactly this: the
+// `.mc-tab-chat`/`.mc-tab-info` layout overrides in MapChat.svelte's
+// `<style>` were unconditional CSS, which wins over the browser's own
+// `[hidden] -> display:none` UA rule regardless of selector specificity, so
+// the inactive panel kept its `display: flex`/`block` and rendered stacked
+// under the active one (fixed by scoping both to `:not([hidden])`).
+//
+// NOTE: this vitest `dom` project's `mount()` harness does NOT inject
+// component `<style>` blocks into `document.head` at all (verified —
+// `document.head.querySelectorAll("style")` is empty after mount), so
+// `getComputedStyle` here can never reflect the CSS fix either way — it
+// would report browser defaults regardless of whether the bug is present or
+// fixed. The CSS-cascade behaviour itself can only be proven by a real
+// browser (which is how it was found). What IS reliably testable here is
+// the DOM-structural half of the contract bits-ui drives independently of
+// CSS: exactly one panel's `hidden` attribute is absent at a time, and any
+// element that must be inaccessible on the inactive tab has a `[hidden]`
+// ancestor. These tests assert that half; they would have caught a
+// regression in the *attribute* wiring, not the CSS override — see rule-24
+// grep / manual browser check for the latter.
+describe("MapChat — Chat/Info tab switch shows exactly one panel (RFC-035 FR-3)", () => {
+  function getTabButton(
+    root: HTMLElement,
+    value: "chat" | "info",
+  ): HTMLButtonElement {
+    const btn = root.querySelector<HTMLButtonElement>(
+      `[role="tab"][data-value="${value}"]`,
+    );
+    expect(btn).not.toBeNull();
+    return btn!;
+  }
+
+  function getPanel(
+    root: HTMLElement,
+    cls: "mc-tab-chat" | "mc-tab-info",
+  ): HTMLElement {
+    const el = root.querySelector<HTMLElement>(`.${cls}`);
+    expect(el).not.toBeNull();
+    return el!;
+  }
+
+  async function mountOnlineForTabs() {
+    vi.mocked(probeDaemon).mockResolvedValue({
+      up: true,
+      model: "claude-mock",
+    });
+    await checkDaemon(7431);
+    vi.mocked(connectAgent).mockImplementation(() => ({
+      send: vi.fn(),
+      cancel: vi.fn(),
+      close: vi.fn(),
+    }));
+    const root = mountChat({ doc: fixtureDoc() });
+    return root;
+  }
+
+  it("Chat is the active tab by default: chat panel visible, Info panel hidden", async () => {
+    const root = await mountOnlineForTabs();
+    const chatPanel = getPanel(root, "mc-tab-chat");
+    const infoPanel = getPanel(root, "mc-tab-info");
+
+    expect(chatPanel.hasAttribute("hidden")).toBe(false);
+    expect(infoPanel.hasAttribute("hidden")).toBe(true);
+  });
+
+  it("clicking the Info tab hides the Chat panel (transcript + input) and shows only the Info diagnostics", async () => {
+    const root = await mountOnlineForTabs();
+    getTabButton(root, "info").dispatchEvent(
+      new MouseEvent("click", { bubbles: true }),
+    );
+    flushSync();
+
+    const chatPanel = getPanel(root, "mc-tab-chat");
+    const infoPanel = getPanel(root, "mc-tab-info");
+
+    expect(infoPanel.hasAttribute("hidden")).toBe(false);
+    expect(chatPanel.hasAttribute("hidden")).toBe(true);
+
+    // The input row (textarea + Send) belongs to the Chat panel only — it
+    // must live inside the now-hidden panel, not float outside the Tabs
+    // content boundary where it would always render regardless of tab.
+    const textarea = root.querySelector(
+      '[aria-label="Ask the map a question"]',
+    );
+    expect(textarea).not.toBeNull();
+    expect(chatPanel.contains(textarea)).toBe(true);
+    expect(textarea!.closest("[hidden]")).not.toBeNull();
+    expect(
+      Array.from(root.querySelectorAll("button")).some((b) =>
+        b.textContent?.includes("Send"),
+      ),
+    ).toBe(true);
+
+    // The Info diagnostics are visible, not nested under any hidden ancestor.
+    expect(infoPanel.textContent).toContain("Model");
+    expect(infoPanel.closest("[hidden]")).toBeNull();
+  });
+
+  it("clicking back to the Chat tab restores the transcript/input view and hides Info again", async () => {
+    const root = await mountOnlineForTabs();
+    getTabButton(root, "info").dispatchEvent(
+      new MouseEvent("click", { bubbles: true }),
+    );
+    flushSync();
+    getTabButton(root, "chat").dispatchEvent(
+      new MouseEvent("click", { bubbles: true }),
+    );
+    flushSync();
+
+    const chatPanel = getPanel(root, "mc-tab-chat");
+    const infoPanel = getPanel(root, "mc-tab-info");
+    expect(chatPanel.hasAttribute("hidden")).toBe(false);
+    expect(infoPanel.hasAttribute("hidden")).toBe(true);
+  });
+
+  it("switching to Info and back preserves an in-flight streaming answer (the Chat subtree stays mounted, never destroyed)", async () => {
+    const root = await mountOnlineForTabs();
+    const input = getInput(root);
+    typeInto(input, "Where does artifact recording persist?");
+    getSendButton(root).dispatchEvent(
+      new MouseEvent("click", { bubbles: true }),
+    );
+    flushSync();
+
+    getTabButton(root, "info").dispatchEvent(
+      new MouseEvent("click", { bubbles: true }),
+    );
+    flushSync();
+    // The Info tab is visible now, but the Chat panel (with its in-flight
+    // assistant bubble) must still be present in the DOM, merely hidden —
+    // never unmounted — so switching back shows it exactly as left.
+    const chatPanel = getPanel(root, "mc-tab-chat");
+    expect(chatPanel.textContent).toContain(
+      "Where does artifact recording persist?",
+    );
+
+    getTabButton(root, "chat").dispatchEvent(
+      new MouseEvent("click", { bubbles: true }),
+    );
+    flushSync();
+    expect(root.textContent).toContain(
+      "Where does artifact recording persist?",
+    );
+    expect(getInput(root).value).toBe("");
+  });
+});
+
+// RFC-035 Wave 2 (FR-5/FR-6) — Info tab fills in from live daemon frames:
+// token usage stays "—" until the first `usage` frame, then renders
+// thousands-separated counts (+ cost); "other projects" reports the
+// ready-frame instance-discovery snapshot.
+describe("MapChat — Info tab token usage + other projects (RFC-035 Wave 2)", () => {
+  function mockConnection() {
+    const conn = { send: vi.fn(), cancel: vi.fn(), close: vi.fn() };
+    let handlers: AgentHandlers | undefined;
+    vi.mocked(connectAgent).mockImplementation((_port, h) => {
+      handlers = h;
+      return conn;
+    });
+    return {
+      conn,
+      handlers: () => {
+        expect(handlers).toBeDefined();
+        return handlers!;
+      },
+    };
+  }
+
+  function getInfoPanel(root: HTMLElement): HTMLElement {
+    const el = root.querySelector<HTMLElement>(".mc-tab-info");
+    expect(el).not.toBeNull();
+    return el!;
+  }
+
+  function openInfoTab(root: HTMLElement): void {
+    const btn = root.querySelector<HTMLButtonElement>(
+      '[role="tab"][data-value="info"]',
+    );
+    expect(btn).not.toBeNull();
+    btn!.dispatchEvent(new MouseEvent("click", { bubbles: true }));
+    flushSync();
+  }
+
+  // A live connection only opens once a question is actually sent
+  // (chat-store's `ensureConnection` is lazy) — send one turn so
+  // `connectAgent` fires and captures its handlers, mirroring the "tier1
+  // (live)" describe block above.
+  async function mountOnlineForInfo() {
+    vi.mocked(probeDaemon).mockResolvedValue({
+      up: true,
+      model: "claude-mock",
+    });
+    await checkDaemon(7431);
+    const { handlers, conn } = mockConnection();
+    const root = mountChat({ doc: fixtureDoc() });
+    typeInto(getInput(root), "Where does artifact recording live?");
+    getSendButton(root).dispatchEvent(
+      new MouseEvent("click", { bubbles: true }),
+    );
+    flushSync();
+    // Bugfix #1 — the turnId chat-store generated for this send is the
+    // second argument threaded onto the mocked connection's `send()`;
+    // reading it back here (rather than passing `null`) proves the usage
+    // frame's real turnId-correlation path, not just the "no correlation
+    // available" bypass.
+    const turnId = conn.send.mock.calls[0]?.[1] as string;
+    expect(typeof turnId).toBe("string");
+    return { root, handlers, turnId };
+  }
+
+  it("shows — for token usage until the first usage frame arrives", async () => {
+    const { root } = await mountOnlineForInfo();
+    openInfoTab(root);
+    expect(getInfoPanel(root).textContent).toContain("—");
+  });
+
+  it("renders session token counts with thousands separators and cost after a usage frame fires", async () => {
+    const { root, handlers, turnId } = await mountOnlineForInfo();
+    handlers().onUsage?.(
+      { inputTokens: 1234, outputTokens: 567, costUsd: 0.0123 },
+      turnId,
+    );
+    flushSync();
+    openInfoTab(root);
+    const text = getInfoPanel(root).textContent ?? "";
+    expect(text).toContain("1,234");
+    expect(text).toContain("567");
+    expect(text).toContain("$0.0123");
+  });
+
+  it("accumulates a second usage frame into both session and cumulative totals shown in the Info tab", async () => {
+    const { root, handlers, turnId } = await mountOnlineForInfo();
+    handlers().onUsage?.(
+      { inputTokens: 100, outputTokens: 40, costUsd: 0.01 },
+      turnId,
+    );
+    handlers().onUsage?.(
+      { inputTokens: 50, outputTokens: 10, costUsd: 0.005 },
+      turnId,
+    );
+    flushSync();
+    openInfoTab(root);
+    const text = getInfoPanel(root).textContent ?? "";
+    expect(text).toContain("150");
+    expect(text).toContain("50");
+    expect(text).toContain("cumulative");
+  });
+
+  it("shows 'just this one' when there are no other live instances", async () => {
+    const { root } = await mountOnlineForInfo();
+    openInfoTab(root);
+    expect(getInfoPanel(root).textContent).toContain("just this one");
+  });
+
+  it("renders the other-instance count and project list once the ready frame reports one", async () => {
+    const { root, handlers } = await mountOnlineForInfo();
+    handlers().onReadyMeta?.({
+      capabilities: ["usage", "instances"],
+      otherInstances: [
+        { projectName: "sibling-project", port: 7432, kind: "web" },
+      ],
+    });
+    flushSync();
+    openInfoTab(root);
+    const text = getInfoPanel(root).textContent ?? "";
+    expect(text).toContain("sees 1 other");
+    expect(text).toContain("sibling-project:7432");
+  });
+});
diff --git a/template/src/widgets/map-chat/ui/MapChat.svelte b/template/src/widgets/map-chat/ui/MapChat.svelte
new file mode 100644
index 0000000..8f36e04
--- /dev/null
+++ b/template/src/widgets/map-chat/ui/MapChat.svelte
@@ -0,0 +1,875 @@
+<script lang="ts">
+  /**
+   * MapChat — RFC-034 (Pillar C) chat panel; RFC-035 Wave 1 upgraded the
+   * shell from a fixed right-docked drawer into a floatable/dockable/
+   * resizable `FloatingWindow` with a Chat|Info `Tabs` split. Composes:
+   * `ChatMarkdown` for assistant answers (real markdown — headings, bold,
+   * lists, code, links — instead of raw `**`/`##`), `shared/ui`'s
+   * `ScrollArea` for the message list, `shared/ui`'s `Code` for the offline
+   * call-to-action's copyable command, and `chat-store.svelte.ts`'s session
+   * history (New chat / past-session revisit) on top of the daemon-only
+   * (Tier 1, live `@forgeplan/web-agent`, streamed) answering path. There is
+   * no client-side fallback answerer any more — when the daemon isn't
+   * detected (`tier !== "tier1"`) and we aren't revisiting an archived
+   * session, the body shows an offline call-to-action instead of the
+   * message list + input, so the chat never fabricates an answer; the
+   * probe (`startAgentProbe`) keeps polling in the background and the
+   * normal chat appears automatically once it flips to "tier1". Both the
+   * live chat and archived sessions drive the map's existing camera through
+   * camera-bus when an answer names a zone/node/flow — rendered here as a
+   * small "→ <label>" chip under the message that triggered it.
+   *
+   * Pure presentation + local input/scroll state here; composes
+   * `shared/ui` primitives only (rule 24) — no primitive re-skinning. The
+   * `FloatingWindow` primitive owns all positioning (fixed root, docked/
+   * floating mode, drag, resize, viewport-clamp, localStorage persistence);
+   * this file only supplies its header chrome (status, New chat, sessions,
+   * the Chat|Info tab triggers) and body (the two `TabsContent` panes). The
+   * mounting wrapper in ComposedMapView.svelte is a bare, unstyled `<div
+   * id="map-chat-panel">` (no position/z-index of its own — that CSS was
+   * deliberately removed, since it would establish a stacking context that
+   * traps this file's `position: fixed` root inside it); the div exists
+   * only as the launcher button's `aria-controls` anchor. `FloatingWindow`'s
+   * own root escapes to the viewport the same way the old `.map-chat` root
+   * did (no ancestor between here and the viewport sets a
+   * `transform`/`filter`/`contain`, and now none sets `position`+`z-index`
+   * either).
+   */
+  import { onDestroy, onMount } from "svelte";
+  import type { MapDocument } from "@/entities/map";
+  import {
+    cancelCurrent,
+    getActiveTab,
+    getMessages,
+    getModel,
+    getOtherInstances,
+    getSessionHistory,
+    getTier,
+    getUsage,
+    getViewedSession,
+    getViewingSessionId,
+    isPending,
+    newChat,
+    send,
+    setActiveTab,
+    startAgentProbe,
+    stopAgentProbe,
+    viewCurrentSession,
+    viewSession,
+  } from "../model/chat-store.svelte";
+  import type { ChatTab } from "../model/chat-store.svelte";
+  import type { CameraTarget } from "@/widgets/composed-map/model/camera-bus.svelte";
+  import {
+    Button,
+    Code,
+    FloatingWindow,
+    Popover,
+    PopoverTrigger,
+    PopoverContent,
+    ScrollArea,
+    Separator,
+    Tabs,
+    TabsContent,
+    TabsList,
+    TabsTrigger,
+  } from "@/shared/ui";
+  import ChatMarkdown from "./ChatMarkdown.svelte";
+  import History from "@lucide/svelte/icons/history";
+  import SquarePen from "@lucide/svelte/icons/square-pen";
+  import ArrowDown from "@lucide/svelte/icons/arrow-down";
+
+  let { doc, onClose }: { doc: MapDocument; onClose?: () => void } = $props();
+
+  const TEXTAREA_LINE_HEIGHT_PX = 18;
+  const TEXTAREA_MAX_LINES = 4;
+  const TEXTAREA_VERTICAL_PADDING_PX = 16;
+  const NEAR_BOTTOM_THRESHOLD_PX = 48;
+  const ONBOARD_AGENT_COMMAND = "npx @forgeplan/web onboard-agent";
+
+  // RFC-035 Wave 1 — static, read-only agent profile (agent/lib/profile.mjs).
+  // Surfaced verbatim in the Info tab; there is no runtime introspection of
+  // the daemon's actual tool grants yet (Wave 2), so this mirrors the
+  // daemon's own known constants rather than deriving them.
+  const ALLOWED_TOOLS = "Read, Glob, Grep, show_on_map";
+  const DISALLOWED_TOOLS = "Write, Edit, Bash";
+
+  let question = $state("");
+  let textareaEl = $state<HTMLTextAreaElement | undefined>();
+  let viewportEl = $state<HTMLDivElement | null>(null);
+  let sessionsOpen = $state(false);
+  let isNearBottom = $state(true);
+  let reducedMotion = $state(false);
+
+  const tier = $derived(getTier());
+  const model = $derived(getModel());
+  const pending = $derived(isPending());
+  const sessionHistory = $derived(getSessionHistory());
+  const viewingSessionId = $derived(getViewingSessionId());
+  const viewedSession = $derived(getViewedSession());
+  const isViewingPast = $derived(viewingSessionId !== null);
+  const messages = $derived(
+    isViewingPast ? (viewedSession?.messages ?? []) : getMessages(),
+  );
+  /** True when there is no live daemon to answer, we aren't passively
+   * revisiting an already-answered archived session, AND the transcript is
+   * genuinely empty — the one state in which the chat body must show the
+   * offline call-to-action instead of a message list + input (AI-only: no
+   * client-side fallback answerer).
+   *
+   * Bugfix #5 — this used to ignore `messages.length`, so the instant
+   * `handleError` appended the daemon's error text and synchronously fell
+   * back to tier0 (chat-store's `fallBackToTier0`), the transcript
+   * (including that error) was yanked off-screen in favour of a blank
+   * "isn't running" CTA. Gating on `messages.length === 0` keeps any
+   * existing transcript — error text included — visible; the offline CTA
+   * is reserved for the case where there is truly nothing to show yet. */
+  const isOffline = $derived(
+    !isViewingPast && tier !== "tier1" && messages.length === 0,
+  );
+  const canSend = $derived(
+    question.trim().length > 0 &&
+      !pending &&
+      !isViewingPast &&
+      tier === "tier1",
+  );
+  /** True while a Tier-1 answer is streaming — the form's Send button
+   * swaps to Stop in this state (Phase 4a: cancel a streaming answer). */
+  const showStop = $derived(pending && !isViewingPast);
+  /** RFC-035 FR-2 — the compact header/Info-tab status word; the old
+   * verbose "● live — {model}" string is gone, the model itself moved to
+   * the Info tab (FR-4). */
+  const statusWord = $derived(tier === "tier1" ? "online" : "offline");
+  /** RFC-035 FR-3 — which panel tab is active, driven by the store so the
+   * Info tab (FR-4) can read the same source of truth. */
+  const activeTab = $derived(getActiveTab());
+  const isStreamingLast = $derived(
+    !isViewingPast && pending && messages[messages.length - 1]?.role === "assistant",
+  );
+  // RFC-035 Wave 2 (FR-5/FR-6) — Info tab live data.
+  const usage = $derived(getUsage());
+  const otherInstances = $derived(getOtherInstances());
+  const hasUsage = $derived(
+    usage.cumulative.inputTokens > 0 || usage.cumulative.outputTokens > 0,
+  );
+
+  /** Thousands-separated token count, locale-pinned so the format doesn't
+   * drift with the host's `Intl` default. */
+  function formatTokenCount(n: number): string {
+    return n.toLocaleString("en-US");
+  }
+
+  function formatCostUsd(costUsd: number): string {
+    return `$${costUsd.toFixed(4)}`;
+  }
+
+  function otherInstanceLabel(instance: { projectName: string; port: number }): string {
+    return `${instance.projectName}:${instance.port}`;
+  }
+
+  /** Human label for a camera-bus target, read straight from the loaded
+   * `MapDocument` — never fabricated (falls back to the raw id only if the
+   * zone/node/flow can no longer be found, e.g. a stale target after the map
+   * reloaded). */
+  function targetLabel(target: CameraTarget): string {
+    if (target.kind === "zone") {
+      return doc.zones.find((z) => z.id === target.id)?.label ?? target.id;
+    }
+    if (target.kind === "node") {
+      return doc.nodes.find((n) => n.id === target.id)?.label ?? target.id;
+    }
+    return (doc.flows ?? []).find((f) => f.id === target.id)?.name ?? target.id;
+  }
+
+  onMount(() => {
+    startAgentProbe();
+    textareaEl?.focus();
+  });
+  onDestroy(() => {
+    stopAgentProbe();
+  });
+
+  function handleSend(): void {
+    if (!canSend) return;
+    send(question);
+    question = "";
+  }
+
+  function handleStop(): void {
+    cancelCurrent();
+  }
+
+  function handleKeydown(event: KeyboardEvent): void {
+    if (event.key !== "Enter" || event.shiftKey) return;
+    event.preventDefault();
+    handleSend();
+  }
+
+  function resizeTextarea(): void {
+    const el = textareaEl;
+    if (!el) return;
+    el.style.height = "auto";
+    const maxHeight =
+      TEXTAREA_LINE_HEIGHT_PX * TEXTAREA_MAX_LINES + TEXTAREA_VERTICAL_PADDING_PX;
+    const next = Math.min(el.scrollHeight, maxHeight);
+    el.style.height = `${next}px`;
+    el.style.overflowY = el.scrollHeight > maxHeight ? "auto" : "hidden";
+  }
+
+  // Re-measure on every change to `question` — covers both user typing
+  // (bind:value) and the programmatic clear in handleSend, so the textarea
+  // shrinks back to one line after sending without a separate code path.
+  $effect(() => {
+    question;
+    resizeTextarea();
+  });
+
+  function handleViewportScroll(event: Event): void {
+    const el = event.currentTarget as HTMLDivElement;
+    isNearBottom =
+      el.scrollHeight - el.scrollTop - el.clientHeight <= NEAR_BOTTOM_THRESHOLD_PX;
+  }
+
+  function scrollToBottom(smooth: boolean): void {
+    viewportEl?.scrollTo({
+      top: viewportEl.scrollHeight,
+      behavior: smooth ? "smooth" : "auto",
+    });
+  }
+
+  function jumpToLatest(): void {
+    isNearBottom = true;
+    scrollToBottom(!reducedMotion);
+  }
+
+  // Auto-stick to the newest message ONLY while already near the bottom —
+  // a user who scrolled up to reread something earlier is never yanked back
+  // down; they get the "Jump to latest" affordance instead.
+  $effect(() => {
+    if (messages.length === 0 || !isNearBottom) return;
+    requestAnimationFrame(() => scrollToBottom(!reducedMotion));
+  });
+
+  $effect(() => {
+    if (typeof window === "undefined" || !window.matchMedia) return;
+    const mq = window.matchMedia("(prefers-reduced-motion: reduce)");
+    reducedMotion = mq.matches;
+    const onChange = (e: MediaQueryListEvent) => {
+      reducedMotion = e.matches;
+    };
+    mq.addEventListener("change", onChange);
+    return () => mq.removeEventListener("change", onChange);
+  });
+
+  function openCurrentSession(): void {
+    viewCurrentSession();
+    sessionsOpen = false;
+  }
+
+  function openSession(id: string): void {
+    viewSession(id);
+    sessionsOpen = false;
+  }
+
+  /** RFC-035 FR-3 — `Tabs`'s `onValueChange` hands back a plain `string`
+   * (bits-ui's contract); narrow it to `ChatTab` before writing the store,
+   * since the only values that can ever reach here are the two
+   * `TabsTrigger` values below ("chat" / "info"). */
+  function handleTabChange(next: string): void {
+    setActiveTab(next as ChatTab);
+  }
+</script>
+
+{#snippet statusIndicator()}
+  <span class="mc-status" class:online={tier === "tier1"}>
+    <span class="mc-status-dot" aria-hidden="true"></span>
+    {statusWord}
+  </span>
+{/snippet}
+
+<Tabs value={activeTab} onValueChange={handleTabChange}>
+  <FloatingWindow
+    storageKey="map-chat"
+    ariaLabel="Map assistant chat"
+    closeAriaLabel="Close chat"
+    onClose={onClose}
+  >
+    {#snippet header()}
+      <div class="mc-header-block">
+        <div class="mc-header-row">
+          <div class="mc-header-titles">
+            <span class="mc-title">Ask the map</span>
+            {@render statusIndicator()}
+          </div>
+          <div class="mc-header-actions">
+            <Button variant="ghost" size="sm" disabled={pending} onclick={() => newChat()}>
+              <SquarePen size={13} />
+              New chat
+            </Button>
+            <Popover bind:open={sessionsOpen}>
+              <PopoverTrigger class="mc-sessions-trigger">
+                <Button variant="ghost" size="icon" aria-label="Chat sessions">
+                  <History size={14} />
+                </Button>
+              </PopoverTrigger>
+              <PopoverContent side="bottom" align="end" class="mc-sessions-menu">
+                <div class="mc-sessions-list" role="menu" aria-label="Chat sessions">
+                  <Button
+                    variant="ghost"
+                    size="sm"
+                    class="mc-session-item"
+                    aria-current={!isViewingPast ? "true" : undefined}
+                    onclick={openCurrentSession}
+                  >
+                    Current chat
+                  </Button>
+                  {#if sessionHistory.length > 0}
+                    <Separator />
+                    {#each sessionHistory as session (session.id)}
+                      <Button
+                        variant="ghost"
+                        size="sm"
+                        class="mc-session-item"
+                        aria-current={viewingSessionId === session.id ? "true" : undefined}
+                        onclick={() => openSession(session.id)}
+                      >
+                        {session.title}
+                      </Button>
+                    {/each}
+                  {:else}
+                    <p class="mc-sessions-empty">No past sessions yet.</p>
+                  {/if}
+                </div>
+              </PopoverContent>
+            </Popover>
+          </div>
+        </div>
+        <TabsList class="mc-tabs-list" ariaLabel="Chat panel sections">
+          <TabsTrigger value="chat">Chat</TabsTrigger>
+          <TabsTrigger value="info">Info</TabsTrigger>
+        </TabsList>
+      </div>
+    {/snippet}
+
+    <TabsContent value="chat" class="mc-tab-chat">
+      <div class="mc-body">
+        {#if isOffline}
+          <div class="mc-offline" role="status">
+            <p class="mc-offline-msg">The live assistant isn't running.</p>
+            <p class="mc-offline-label">Start it in your project to chat:</p>
+            <Code code={ONBOARD_AGENT_COMMAND} ariaLabel="onboard-agent command" />
+            <p class="mc-offline-hint">
+              The chat connects automatically once the agent is running.
+            </p>
+          </div>
+        {:else}
+          <ScrollArea
+            class="mc-scroll"
+            viewportClass="mc-messages"
+            bind:viewportRef={viewportEl}
+            onViewportScroll={handleViewportScroll}
+          >
+            <div
+              class="mc-messages-inner"
+              role="log"
+              aria-live="polite"
+              aria-label="Chat transcript"
+            >
+              {#if messages.length === 0}
+                <p class="mc-empty">
+                  Ask anything about this project — the live assistant reads your
+                  code, .forgeplan/, and the map to answer, and moves the map as
+                  it explains.
+                </p>
+              {/if}
+              {#each messages as msg, i (i)}
+                {@const streamingThis = isStreamingLast && i === messages.length - 1}
+                <div class="mc-msg mc-msg-{msg.role}">
+                  <span class="mc-role">{msg.role === "user" ? "You" : "Map"}</span>
+                  {#if msg.role === "assistant"}
+                    <div class="mc-assistant-body">
+                      <ChatMarkdown text={msg.text} />
+                      {#if streamingThis}
+                        {#if msg.text.length === 0}
+                          <span class="mc-thinking">● thinking…</span>
+                        {:else}
+                          <span class="mc-caret" aria-hidden="true"></span>
+                        {/if}
+                      {/if}
+                    </div>
+                  {:else}
+                    <p class="mc-text">{msg.text}</p>
+                  {/if}
+                  {#if msg.target}
+                    <span class="mc-target-chip">→ {targetLabel(msg.target)}</span>
+                  {/if}
+                </div>
+              {/each}
+            </div>
+          </ScrollArea>
+          {#if !isNearBottom && messages.length > 0}
+            <div class="mc-jump-wrap">
+              <Button variant="secondary" size="sm" onclick={jumpToLatest}>
+                <ArrowDown size={12} />
+                Jump to latest
+              </Button>
+            </div>
+          {/if}
+        {/if}
+      </div>
+
+      {#if !isOffline}
+        <div class="mc-form">
+          {#if isViewingPast}
+            <p class="mc-viewing-hint" role="status">
+              Viewing a past chat.
+              <Button variant="ghost" size="sm" onclick={openCurrentSession}>
+                Return to current chat
+              </Button>
+            </p>
+          {/if}
+          <div class="mc-input-row">
+            <textarea
+              bind:this={textareaEl}
+              bind:value={question}
+              class="mc-textarea"
+              rows="1"
+              placeholder="Ask where something lives…"
+              aria-label="Ask the map a question"
+              disabled={isViewingPast}
+              onkeydown={handleKeydown}
+            ></textarea>
+            {#if showStop}
+              <Button type="button" variant="secondary" size="sm" onclick={handleStop}>
+                Stop
+              </Button>
+            {:else}
+              <Button
+                type="button"
+                variant="primary"
+                size="sm"
+                disabled={!canSend}
+                onclick={handleSend}
+              >
+                Send
+              </Button>
+            {/if}
+          </div>
+        </div>
+      {/if}
+    </TabsContent>
+
+    <TabsContent value="info" class="mc-tab-info">
+      <dl class="mc-info-dl">
+        <div class="mc-info-row">
+          <dt>Status</dt>
+          <dd>{@render statusIndicator()}</dd>
+        </div>
+        <div class="mc-info-row">
+          <dt>Model</dt>
+          <dd>{model ?? "—"}</dd>
+        </div>
+        <div class="mc-info-row">
+          <dt>Allowed tools</dt>
+          <dd>{ALLOWED_TOOLS}</dd>
+        </div>
+        <div class="mc-info-row">
+          <dt>Disallowed tools</dt>
+          <dd>{DISALLOWED_TOOLS}</dd>
+        </div>
+        <div class="mc-info-row">
+          <dt>Notes</dt>
+          <dd>Read-only agent.</dd>
+        </div>
+        <div class="mc-info-row">
+          <dt>Token usage</dt>
+          <dd>
+            {#if !hasUsage}
+              —
+            {:else}
+              <div class="mc-usage-line">
+                input {formatTokenCount(usage.session.inputTokens)} · output {formatTokenCount(
+                  usage.session.outputTokens,
+                )}
+                {#if usage.session.costUsd > 0}
+                  · {formatCostUsd(usage.session.costUsd)}
+                {/if}
+              </div>
+              <div class="mc-usage-line mc-usage-cumulative">
+                cumulative: input {formatTokenCount(
+                  usage.cumulative.inputTokens,
+                )} · output {formatTokenCount(usage.cumulative.outputTokens)}
+                {#if usage.cumulative.costUsd > 0}
+                  · {formatCostUsd(usage.cumulative.costUsd)}
+                {/if}
+              </div>
+            {/if}
+          </dd>
+        </div>
+        <div class="mc-info-row">
+          <dt>Other projects</dt>
+          <dd>
+            {#if otherInstances.length === 0}
+              just this one
+            {:else}
+              sees {otherInstances.length} other · {otherInstances
+                .map(otherInstanceLabel)
+                .join(", ")}
+            {/if}
+          </dd>
+        </div>
+      </dl>
+    </TabsContent>
+  </FloatingWindow>
+</Tabs>
+
+<style>
+  /* Rule 24: Button/Code/Popover/ScrollArea/Separator/Tabs* below are
+     shared/ui primitives, unmodified — this file only lays out its own
+     markup (header/body/form chrome, message rows, offline CTA copy, Info
+     tab rows) and never reaches into a primitive's internals. `FloatingWindow`
+     owns the window shell (docked/floating/resize/position) entirely — this
+     file supplies only its `header` snippet + body content. `.mc-tab-chat` /
+     `.mc-tab-info` / `.mc-tabs-list` below are consumer-supplied classes
+     forwarded onto `TabsContent`/`TabsList` roots for layout only (flex
+     sizing, spacing) — not chrome — the sanctioned rule-24 extension point,
+     same shape as this file's own pre-existing `.mc-jump-wrap :global(.btn)`. */
+
+  .mc-header-block {
+    display: flex;
+    flex-direction: column;
+    gap: 6px;
+    width: 100%;
+    min-width: 0;
+  }
+  .mc-header-row {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    gap: 8px;
+    min-width: 0;
+  }
+  .mc-header-titles {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    min-width: 0;
+  }
+  .mc-title {
+    font-family: var(--font-sans);
+    font-weight: 500;
+    font-size: 12.5px;
+    color: var(--fg-1);
+    white-space: nowrap;
+  }
+  .mc-header-actions {
+    display: flex;
+    align-items: center;
+    gap: 4px;
+    flex: none;
+  }
+
+  /* RFC-035 FR-2 — compact status dot replacing the old verbose Badge. */
+  .mc-status {
+    display: inline-flex;
+    align-items: center;
+    gap: 5px;
+    font-family: var(--font-mono);
+    font-size: 10.5px;
+    letter-spacing: 0.03em;
+    color: var(--fg-3);
+    white-space: nowrap;
+  }
+  .mc-status-dot {
+    width: 7px;
+    height: 7px;
+    border-radius: 50%;
+    background: var(--danger);
+    flex: none;
+  }
+  .mc-status.online {
+    color: var(--fg-2);
+  }
+  .mc-status.online .mc-status-dot {
+    background: var(--ok);
+  }
+
+  :global(.mc-tabs-list) {
+    margin-top: 2px;
+  }
+
+  /* Layout-only overrides on the forwarded TabsContent class — see rule-24
+     note at the top of this style block. `:not([hidden])` matters here:
+     bits-ui toggles the inactive panel via the native `hidden` attribute
+     (kept mounted, never unmounted — RFC-035 FR-3), which the browser's own
+     UA stylesheet hides via `[hidden] { display: none }`. Author CSS wins
+     over that UA rule regardless of selector specificity (origin beats
+     specificity in the cascade), so an unconditional `display: flex` here
+     would defeat `hidden` and show BOTH panels stacked at once — scoping
+     every layout declaration to `:not([hidden])` lets the attribute govern
+     visibility while this class only supplies layout for the active pane. */
+  :global(.mc-tab-chat:not([hidden])) {
+    display: flex;
+    flex-direction: column;
+    flex: 1;
+    min-height: 0;
+    padding: 0;
+  }
+  :global(.mc-tab-info:not([hidden])) {
+    display: block;
+    flex: 1;
+    min-height: 0;
+    overflow-y: auto;
+    padding: 14px 16px;
+  }
+
+  .mc-info-dl {
+    margin: 0;
+    display: flex;
+    flex-direction: column;
+    gap: 12px;
+  }
+  .mc-info-row {
+    display: flex;
+    flex-direction: column;
+    gap: 2px;
+  }
+  .mc-info-row dt {
+    font-family: var(--font-mono);
+    font-size: 9.5px;
+    letter-spacing: 0.08em;
+    text-transform: uppercase;
+    color: var(--fg-3);
+  }
+  .mc-info-row dd {
+    margin: 0;
+    font-size: 12px;
+    line-height: 1.5;
+    color: var(--fg-1);
+  }
+  .mc-info-hint {
+    margin-left: 4px;
+    color: var(--fg-3);
+    font-size: 10.5px;
+    font-style: italic;
+  }
+  /* RFC-035 Wave 2 — token usage's two lines (this-session + cumulative). */
+  .mc-usage-line {
+    display: block;
+  }
+  .mc-usage-cumulative {
+    margin-top: 2px;
+    color: var(--fg-3);
+    font-size: 10.5px;
+  }
+
+  .mc-sessions-list {
+    display: flex;
+    flex-direction: column;
+    gap: 2px;
+    min-width: 200px;
+  }
+  :global(.mc-session-item) {
+    justify-content: flex-start;
+    text-align: left;
+    width: 100%;
+    overflow: hidden;
+    text-overflow: ellipsis;
+  }
+  .mc-sessions-empty {
+    margin: 4px 6px;
+    color: var(--fg-3);
+    font-size: 11px;
+  }
+
+  .mc-body {
+    position: relative;
+    flex: 1;
+    min-height: 0;
+    display: flex;
+    flex-direction: column;
+  }
+  :global(.mc-scroll) {
+    flex: 1;
+    min-height: 0;
+  }
+  :global(.mc-messages) {
+    padding: 10px 14px;
+  }
+  .mc-messages-inner {
+    display: flex;
+    flex-direction: column;
+    gap: 12px;
+  }
+  .mc-empty {
+    margin: 0;
+    color: var(--fg-3);
+    font-size: 11.5px;
+    line-height: 1.5;
+  }
+
+  .mc-offline {
+    flex: 1;
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    justify-content: center;
+    gap: 8px;
+    padding: 20px 22px;
+    text-align: center;
+  }
+  .mc-offline-msg {
+    margin: 0;
+    color: var(--fg-1);
+    font-size: 12.5px;
+    line-height: 1.5;
+  }
+  .mc-offline-label {
+    margin: 4px 0 0;
+    color: var(--fg-3);
+    font-size: 11px;
+  }
+  .mc-offline-hint {
+    margin: 4px 0 0;
+    max-width: 280px;
+    color: var(--fg-3);
+    font-size: 10.5px;
+    line-height: 1.5;
+  }
+
+  .mc-jump-wrap {
+    position: absolute;
+    left: 0;
+    right: 0;
+    bottom: 10px;
+    display: flex;
+    justify-content: center;
+    pointer-events: none;
+  }
+  .mc-jump-wrap :global(.btn) {
+    pointer-events: auto;
+    box-shadow: var(--shadow-mini);
+  }
+
+  .mc-msg {
+    display: flex;
+    flex-direction: column;
+    gap: 2px;
+    align-items: flex-start;
+  }
+  .mc-role {
+    font-family: var(--font-mono);
+    font-size: 9.5px;
+    letter-spacing: 0.08em;
+    text-transform: uppercase;
+    color: var(--fg-3);
+  }
+  .mc-text {
+    margin: 0;
+    font-size: 12px;
+    line-height: 1.5;
+    color: var(--fg-1);
+    white-space: pre-wrap;
+  }
+  .mc-msg-user .mc-role {
+    color: var(--accent);
+  }
+  .mc-assistant-body {
+    width: 100%;
+  }
+
+  .mc-thinking {
+    display: inline-flex;
+    color: var(--fg-3);
+    font-family: var(--font-mono);
+    font-size: 11px;
+  }
+  .mc-caret {
+    display: inline-block;
+    width: 2px;
+    height: 12px;
+    margin-left: 2px;
+    vertical-align: text-bottom;
+    background: var(--accent);
+    animation: mc-caret-blink 1s step-end infinite;
+  }
+  @media (prefers-reduced-motion: reduce) {
+    .mc-caret {
+      animation: none;
+      opacity: 0.6;
+    }
+  }
+  @keyframes mc-caret-blink {
+    0%,
+    100% {
+      opacity: 1;
+    }
+    50% {
+      opacity: 0;
+    }
+  }
+
+  .mc-target-chip {
+    display: inline-flex;
+    align-items: center;
+    margin-top: 2px;
+    padding: 1px 7px;
+    border-radius: 999px;
+    background: var(--accent-dim);
+    border: 1px solid var(--accent);
+    color: var(--accent);
+    font-family: var(--font-mono);
+    font-size: 10px;
+  }
+
+  .mc-form {
+    flex: none;
+    display: flex;
+    flex-direction: column;
+    gap: 6px;
+    padding: 10px 12px;
+    border-top: 1px solid var(--line);
+  }
+  .mc-viewing-hint {
+    margin: 0;
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    flex-wrap: wrap;
+    color: var(--fg-3);
+    font-size: 11px;
+  }
+  .mc-input-row {
+    display: flex;
+    align-items: flex-end;
+    gap: 8px;
+  }
+  .mc-textarea {
+    flex: 1;
+    min-width: 0;
+    min-height: 30px;
+    max-height: 88px;
+    resize: none;
+    box-sizing: border-box;
+    background: var(--bg-1);
+    color: var(--fg-1);
+    border: 1px solid var(--line-2);
+    border-radius: 4px;
+    padding: 6px 10px;
+    font-family: var(--font-sans);
+    font-size: 12px;
+    line-height: 1.5;
+    outline: none;
+    transition: border-color 120ms ease;
+  }
+  .mc-textarea:focus-visible {
+    border-color: var(--accent);
+  }
+  .mc-textarea:disabled {
+    opacity: 0.5;
+    cursor: not-allowed;
+  }
+  /* TODO(shared-ui-textarea): no shared/ui multi-line text primitive exists
+     yet (Input is single-line only) — this is the one hand-styled control
+     in the file. Promote to shared/ui/textarea (rule 24) if a second
+     caller needs a growing textarea. */
+</style>
diff --git a/template/src/widgets/map-chat/ui/MdLink.svelte b/template/src/widgets/map-chat/ui/MdLink.svelte
new file mode 100644
index 0000000..5b5fd27
--- /dev/null
+++ b/template/src/widgets/map-chat/ui/MdLink.svelte
@@ -0,0 +1,38 @@
+<script lang="ts">
+  /**
+   * MdLink — ChatMarkdown's custom renderer for markdown `<a>` (RFC-034
+   * Pillar C, chat UI upgrade Phase A). svelte-exmarkdown's `Plugin.renderer`
+   * maps the `a` tag to this component instead of a bare element so every
+   * link in an assistant answer opens in a new tab without leaving the
+   * chat, per the standard `noopener noreferrer` safe-external-link
+   * contract. Receives the parsed hast node's properties as props
+   * (`href`, plus anything else the markdown carried, e.g. `title`).
+   */
+  import type { Snippet } from "svelte";
+  import type { HTMLAttributes } from "svelte/elements";
+
+  interface Props extends Omit<HTMLAttributes<HTMLAnchorElement>, "children"> {
+    href?: string;
+    children?: Snippet;
+  }
+
+  let { href, class: className, children, ...rest }: Props = $props();
+</script>
+
+<a {href} target="_blank" rel="noopener noreferrer" class="chat-md-link {className ?? ''}" {...rest}>
+  {@render children?.()}
+</a>
+
+<style>
+  .chat-md-link {
+    color: var(--accent);
+    text-decoration: none;
+  }
+  .chat-md-link:hover {
+    text-decoration: underline;
+  }
+  .chat-md-link:focus-visible {
+    outline: 2px solid var(--accent);
+    outline-offset: 2px;
+  }
+</style>