diff --git a/TESTING_AND_MODIFICATION_GUIDE.md b/TESTING_AND_MODIFICATION_GUIDE.md
new file mode 100644
index 000000000..f0957c3fb
--- /dev/null
+++ b/TESTING_AND_MODIFICATION_GUIDE.md
@@ -0,0 +1,239 @@
+# Workspaces stack: testing and modification guide
+
+For an agent picking up the Workspaces work. Read `AGENTS.md` first (worktree rules,
+spec conventions); this guide covers only what is specific to the stack.
+
+## 1. Where the code is
+
+The work is a stack of ten branches, each a draft PR based on the one before it.
+Every branch has its own worktree as a sibling of the repo:
+
+| # | PR | Branch | Worktree | What it adds |
+|---|---|---|---|---|
+| 1 | #614 | `workspaces-window` | `dormouse.workspaces-2/.claude/worktrees/workspaces-window` | Workspace strip, one Wall per Workspace, hidden-Workspace minimize |
+| 2 | #615 | `workspaces-persist` | `dormouse.workspaces-2/.claude/worktrees/workspaces-persist` | Per-Workspace persistence, agent recovery |
+| 3 | #616 | `workspaces-multiwindow` | `dormouse.workspaces-2/.claude/worktrees/workspaces-multiwindow` | Several windows, routing, quit voting, transfer, drag |
+| 4 | #617 | `workspaces-dor` | `dormouse.workspaces-2/.claude/worktrees/workspaces-dor` | `dor workspace` verbs |
+| 5 | #618 | `workspaces-harden` | `dormouse.workspaces-harden` | Held events in the transfer gap, drift cleanup |
+| 6 | #619 | `workspaces-registry` | `dormouse.workspaces-registry` | Rust registry, stable `workspace:<n>` refs, cross-window routing |
+| 7 | #620 | `workspaces-durability` | `dormouse.workspaces-durability` | Transfer moves the snapshot between files on disk |
+| 8 | #621 | `workspaces-fidelity` | `dormouse.workspaces-fidelity` | Marks, serialized xterm buffers, pins across a move |
+| 9 | #622 | `workspaces-move-verb` | `dormouse.workspaces-move-verb` | `dor workspace move`, `dor list --window`, iframe move gate |
+| 10 | #623 | `workspaces-harness` | `dormouse.workspaces-harness` | Harness alert stores through the sidecar |
+
+**Work on the tip** (`dormouse.workspaces-harness`) for testing and for any tweak,
+unless the tweak clearly belongs to an earlier stage and you want it reviewed
+there. If you commit on an earlier stage, merge it forward through every later
+branch (`git merge --no-ff <previous>` in each worktree, in order), or the PRs
+diverge. Push with `git push origin <branch>`; the PRs update themselves.
+
+Never `git switch -c` inside an existing worktree. New branches:
+`wt switch --create <name> --base @` from the worktree you are stacking on.
+
+## 1a. Changing the stack, and landing it
+
+**Default: put changes in new PRs on top of the tip.** A change to an early
+stage has to be merged forward through every later branch; a new PR at the tip
+touches nothing behind it, and testing findings usually cut across stages anyway.
+Edit an existing PR only when (a) the bug would make that PR wrong to merge on
+its own, (b) it answers review feedback on that PR, or (c) the stage's spec text
+is untrue. After editing an earlier stage, merge it forward at once, stage by
+stage, and run the tip's suites once at the end.
+
+**Land with merge commits, in order, never squash.** The stack is built on merge
+commits, so merging PR N with a merge commit leaves PR N+1's diff exactly its own
+and GitHub retargets it to `main` when PR N's branch is deleted; nothing else is
+needed. If a PR is squash-merged by mistake, PR N+1 will show PR N's changes
+again until `main` is merged into its branch (that merge resolves cleanly, since
+both sides carry identical content). The repo's default is a merge commit; keep it.
+
+Keep every PR a draft until it is actually up for review (Chromatic bills on
+ready-for-review).
+
+## 2. Setup in a worktree
+
+```
+pnpm install
+pnpm --filter dor-lib-common build      # dor tests import its dist
+pnpm --filter remote-lib-common build   # vscode-ext tests import its dist
+pnpm --filter dor build                 # dor CLI tests and help snapshots
+```
+
+For `cargo test`, the build script needs a self-contained Node 24.18.0 binary and
+rejects Homebrew's. Copy the bundled one from the main checkout and point the env
+var at that source path, **never at the worktree's own `binaries/` path** (the
+build script copies source onto destination and truncates the file to 0 bytes):
+
+```
+mkdir -p standalone/src-tauri/binaries
+cp /Users/ntwigg/projects/dormouse/standalone/src-tauri/binaries/node-aarch64-apple-darwin standalone/src-tauri/binaries/
+cd standalone/src-tauri
+DORMOUSE_NODE_BINARY=/Users/ntwigg/projects/dormouse/standalone/src-tauri/binaries/node-aarch64-apple-darwin cargo test
+```
+
+## 3. Running the app
+
+- **Tauri (real thing, several windows):** `pnpm dev:standalone` from the repo
+  root of the worktree. Dev builds use a separate state root
+  (`<app_data_dir>/dev`), so dev and installed app never share snapshots.
+- **Browser harness (one window only):** inside Dormouse,
+  `dor ensure -- pnpm innerdogfood`; outside, `pnpm innerdogfood`. It prints the
+  URL and an `agent-browser` command. The skill
+  `.claude/skills/debug-standalone-agent-browser/SKILL.md` covers driving it.
+  The harness simulates **one** window: transfer, tear-out, quit voting, and
+  cross-window `dor` routing only run in Tauri.
+
+Opening a second window: drag a Workspace tab out of the strip and release it
+outside the window, or from a Dormouse terminal run
+`dor workspace move <ref> --window new`.
+
+## 4. Automated tests
+
+Per package, from the worktree root:
+
+```
+(cd lib && npx tsc --noEmit -p . && npx vitest run)          # ~3000 tests
+(cd standalone && npx tsc --noEmit -p . && npx vitest run && node --test scripts/*.test.mjs)
+(cd standalone/sidecar && node --test)
+(cd dor && node --test)                                        # help snapshots
+(cd vscode-ext && npx vitest run)
+pnpm lint:specs && node scripts/xterm-lint.mjs
+cargo test                                                     # see §2
+```
+
+Help snapshots: after changing any `dor` help text, rebuild and refresh with
+`cd dor && pnpm build && UPDATE_SNAPSHOTS=1 node --test`, then run `node --test`
+again and commit `dor/test/snapshots/`.
+
+Tests that pin the stack's non-obvious rules, by concern:
+
+| Concern | Tests |
+|---|---|
+| Hidden-Workspace minimize | `lib/src/components/TerminalPane.test.tsx` ("a hidden Workspace minimizes its terminals") |
+| Composition, switching, close race | `lib/src/components/WorkspaceWindow.test.tsx`, `Wall.test.tsx` |
+| Strip | `lib/src/components/WorkspaceStrip.test.tsx`, `workspace-strip-drag.test.ts` |
+| Quit / close arbitration | `standalone/src/quit.test.ts`, `teardown-arbiter.test.ts`, `window-close.test.ts`; Rust `quit_state` |
+| Routing table, arrivals, marking, held events | Rust `routing::tests` |
+| Transfer, content, tear-out boot | `standalone/src/workspace-move.test.ts` |
+| Cross-window drag and iframe gate | `standalone/src/workspace-drag.test.ts` |
+| Registry, stable refs | Rust `workspaces::tests`, `standalone/src/workspace-registry.test.ts`, `lib/src/lib/workspace-store.test.ts` |
+| Sidecar marks and since-mark replay | `standalone/sidecar/pty-core.test.js` |
+| Pins across a move | `lib/src/lib/notepad/source-link.test.ts`, `notepad-store.test.ts` |
+| `dor workspace` verbs, move gate | `lib/src/components/wall/workspace-control.test.ts`, `dor-control-router.test.ts` |
+| Disk staging of a transfer | Rust `tests::a_staged_arrival_is_in_the_target_snapshot_until_it_is_handed_back` |
+
+## 5. Manual test checklist
+
+Nothing below has been run in the Tauri app yet. Items marked **WKWebView** are
+the ones the design depends on and that were validated only in Chromium.
+
+**Hidden-Workspace minimize (WKWebView)**
+- Two Workspaces, three terminals each. Switch away; in Safari Web Inspector the
+  hidden Workspace's canvases should have lost their WebGL contexts and the
+  visible one's should be live.
+- Switch back: zero PTY resizes at an unchanged grid (watch `pty:resize` in the
+  sidecar log). Resize the window while hidden: exactly one resize on return.
+- 30+ switches with more than 16 terminals total: every pane still shows
+  `data-renderer="webgl"`, no "too many active WebGL contexts" in the console.
+- A full-screen TUI (`btop`) on switch-back: look for a one-frame blank. If seen,
+  keep the outgoing Wall painted one extra frame; do not abandon detaching.
+- Switch into an 8-pane Workspace: watch for jank from N context creations.
+
+**Transfer and tear-out**
+- Move a Workspace with a long-running TUI and 10k+ lines of scrollback to a
+  second window: scrollback, cursor, and colors intact; output continues with
+  nothing repeated or lost at the seam.
+- A note pinned to scrollback survives the move (click the pin in the target).
+- Kill the app mid-drag (after the drop, before the target finishes): on
+  relaunch the Workspace is in the target window with fresh shells, and not in
+  the source.
+- Tear out a Workspace whose terminals are idle (no output): the new window
+  appears within a second (the mark round trip is the only wait).
+- Drop onto a target and close that target before it adopts: the Workspace
+  stays in the source, its terminals keep receiving output.
+
+**Iframe gate**
+- A Workspace holding a `dor iframe` Surface: dragging it to another window
+  raises the typed-letter dialog naming the count; Escape leaves everything as
+  it was; the letter moves it and the iframe reloads at its URL.
+- Same Workspace with only agent-browser Surfaces: no dialog.
+- `dor workspace move workspace:<n> --window <label>` refuses and names the
+  Surfaces; `--dangerously-destroy-iframe-page-state` moves it.
+
+**Registry and refs**
+- `dor list --workspaces` in two windows: refs never collide and never renumber
+  after a reorder or a move.
+- From window A, `dor list --workspace <ref in B>` and
+  `dor list --window ws-2` answer from B.
+- `dor workspace move --index 0` reorders without changing the ref.
+
+**Quit**
+- Two windows, one with a running command. Cmd+Q, then Cmd+Q again while the
+  dialog is up, then confirm: the app quits (this was the wedge).
+- Relaunch: both windows and their Workspaces come back; the interrupted agent
+  is offered its resume command.
+
+**Harness alert stores**
+- In `innerdogfood`, toggle a watched command and change alarm settings: they
+  survive a page reload (they now live in the sidecar).
+
+## 6. Where to change what
+
+Each row names the code and the spec section that must change with it. Spec
+lint enforces word budgets: after editing a spec, run `pnpm lint:specs`; if it
+reports a budget, `node scripts/spec-lint.mjs --ratchet docs/specs/<name>.md`
+in the same commit. The "why" of a rule goes in `<name>.rationale.md`, keyed by
+the heading, and the rule gets a `(rationale)` marker.
+
+| Concern | Code | Spec |
+|---|---|---|
+| Strip look, tabs, menus, rename, indicators | `lib/src/components/WorkspaceStrip.tsx`, `workspace-strip-drag.ts`, stories in `lib/src/stories/` | `docs/specs/layout.md` → Workspaces; `standalone.md` → AppBar; `alert.md` → Workspace union |
+| Close confirmation, move confirmation dialogs | `WorkspaceStrip.tsx` (renders `KillConfirmModal` for `pendingClose` / `pendingMove`), `lib/src/lib/workspace-ui-store.ts`, `lib/src/components/KillConfirm.tsx` (`title`, `detail` props) | `layout.md` → Workspaces |
+| Command-mode keys (`c n p l 1-9 W & !` etc.) | `lib/src/components/wall/keyboard/handle-workspace-shortcuts.ts` | `layout.md` → Workspaces, `shortcuts.md` |
+| Composition, active/hidden Wall, input gating | `lib/src/components/WorkspaceWindow.tsx`, `Wall.tsx` (`WorkspaceActiveContext`) | `layout.md` → Workspaces |
+| Hidden-Workspace terminal minimize | `lib/src/components/TerminalPane.tsx` mount effect (gated on `workspaceActive`), `lib/src/lib/terminal-lifecycle.ts` (`mountElement`/`unmountElement`), `terminal-webgl.ts` | `layout.md` → Workspaces, Renderer; `layout.rationale.md` → Workspaces |
+| Workspace store, ids, refs | `lib/src/lib/workspace-store.ts` (`installWorkspaceIdPool`, `workspaceRefFor`, `resolveWorkspaceRef`) | `dor-cli.md` → Handle Model; `standalone.md` → Workspace registry |
+| Registry (Rust) | `standalone/src-tauri/src/workspaces.rs`; commands `workspace_reserve_ids` / `workspace_report` / `workspace_registry` in `lib.rs`; `standalone/src/workspace-registry.ts` (`useWorkspaceRegistry` for UI that needs other windows' Workspaces) | `standalone.md` → Workspace registry |
+| Sidecar event routing | `standalone/src-tauri/src/routing.rs` (`route`, pure) and `dispatch_sidecar_event` in `lib.rs` | `standalone.md` → Routing (the table) |
+| Transfer protocol | Source and target halves in `standalone/src/workspace-move.ts`; lib half in `lib/src/components/wall/workspace-transfer.ts` (`prepareWorkspaceTransfer`, `captureTransferContent`); Rust `begin_arrival` / `transfer_workspace_content` / `adopt_ready` / `adopt_done` / `hand_back_arrival` in `lib.rs`, `Arrival` in `routing.rs` | `standalone.md` → Transfer, Tear-out, Arrival queue; `transport.md` → Transferring a Workspace |
+| Marks and since-mark replay | `mark` / `list` in `standalone/sidecar/pty-core.js`; `pty:marked` routing and bookkeeping in `routing.rs` / `lib.rs`; `serializeTerminal` / `flushTerminal` in `terminal-lifecycle.ts` | `transport.md` → Transferring a Workspace; `standalone.rationale.md` → Arrival queue |
+| Pins across a move | `lib/src/lib/notepad/source-link.ts` (`transferredPinOf`, `registerTerminalSourceAtLines`), `notepad-store.ts` (`snapshotTerminalPins`, `restoreTerminalPins`) | `transport.md`, `notepad.md` |
+| Disk staging of a transfer | `stage_arrival_on_disk` / `unstage_arrival_on_disk` in `lib.rs` | `standalone.md` → Arrival queue |
+| Arrival deadline, held events | `ARRIVAL_MAX`, `expire_arrival`, `hold_event` / `take_held` in `routing.rs`; `spawn_arrival_watchdog` in `lib.rs` | `standalone.md` → Arrival queue, Routing |
+| Cross-window drag | `standalone/src/workspace-drag.ts` (release gate in `onDropOnOtherWindow`), `window_at_cursor` in Rust | `standalone.md` → Dragging a Workspace between windows |
+| Quit and per-window close | `standalone/src/quit.ts`, `teardown-flow.ts`, `window-close.ts`; Rust `quit_state.rs`, `macos_terminate.rs` | `standalone.md` → Quit flow, Per-window close |
+| Persistence and restore | `lib/src/lib/window-session-aggregator.ts`, `standalone/src/window-restore.ts`, Rust `save_session` etc. | `standalone.md` → Persistence; `transport.md` |
+| `dor workspace` verbs, `dor list` | `dor/src/commands/workspace.ts`, `list.ts`, `dor/src/protocol.ts`, `dor/src/control-client.ts`, `dor/src/commands/types.ts`; window handler `lib/src/components/wall/workspace-control.ts`; router `dor-control-router.ts` | `dor-cli.md` → dor workspace, Standalone, Handle Model |
+| Platform hooks the stack added | `onPtyMarked`, `transferWorkspace` on `PlatformAdapter` (`lib/src/lib/platform/types.ts`), implemented in `standalone/src/tauri-adapter.ts` and `browser-sidecar-adapter.ts` | `transport.md` |
+| Browser harness | `standalone/scripts/dev-agent-browser.mjs` (`invokeMap`, `fireAndForget`), `browser-sidecar-adapter.ts` | `transport.md` → Standalone browser-dev harness |
+
+## 7. Rules that bite
+
+- **Every Tauri `listen` must be `listenToWindow`** (`standalone/src/window-label.ts`).
+  A bare `listen` receives every window's traffic; `scripts/window-listeners.test.mjs`
+  fails the build otherwise. Broadcasts (`app.emit`) still reach scoped listeners.
+- **Ids are minted only by Rust** in standalone. `createWorkspace()` draws from the
+  pool `installWorkspaceIdPool` fills at adapter init; do not hand-roll ids.
+- **Never release a Session from an unmount.** `releaseSession` is reachable only
+  from a transfer's `commit`; `Wall.test.tsx` pins it.
+- **`take_arrivals` does not consume**, and an arrival without content is not
+  drainable. If you change the transfer sequence, keep: source invokes → Rust marks
+  → source serializes → `transfer_workspace_content` → target nudged/built.
+- **The routing lock is never held across an emit**, and the registry lock is taken
+  only for `dor:controlRequest`. Read the comment above `dispatch_sidecar_event`.
+- **Spec lint** rejects a bare file name in a `Source of truth:` line; use full
+  repo paths. Each rationale `## Heading` must exist in the spec.
+- **`DORMOUSE_NODE_BINARY`** must not point at the worktree's own `binaries/` file
+  (see §2).
+
+## 8. Known gaps
+
+- The browser harness simulates one window; multi-window behavior is Tauri-only.
+- `dor list --all` still lists the answering window only (`dor-cli.md` → Future).
+- A mark can fall inside an escape sequence the sidecar's parser is holding; the
+  target's parser resynchronizes on the next ground byte, the same class of cut
+  the old bounded replay made. Documented in `standalone.rationale.md` → Arrival queue.
+- The alert stores in the sidecar are memory-only; a sidecar respawn loses them
+  until a window re-seeds.
+- The one-frame blank on switch-back and WKWebView context release are unverified
+  (§5).
diff --git a/docs/specs/transport.md b/docs/specs/transport.md
index d6415131b..756637fa0 100644
--- a/docs/specs/transport.md
+++ b/docs/specs/transport.md
@@ -46,7 +46,7 @@ The bridge is a transport shim over the same sidecar protocol, not a second PTY
 
 **An unauthorized caller gets the same `404 not found` as an unknown path**, so the port does not identify itself. The harness prints the token and a ready-made `curl` on startup.
 
-The harness **may omit** native-only desktop chrome (window controls, update checks) but **must preserve** every `PlatformAdapter` contract the app uses — PTY, control-request, clipboard, iframe-proxy, Burrow, agent-browser. It **must mirror** standalone's Session-persistence answer ("The governing rule"): the same `persistsSession`, one `PersistedWindow` per window (in `localStorage` rather than the Rust file store), and the same agent-recovery *claim* against a per-run temp state directory. **The harness must never capture**: a reload there is a live resume over PTYs that survive it, and capture is a quit-only step (`docs/specs/standalone.md` → "Agent recovery"). **Tauri APIs must not be required at static module-evaluation time** when `VITE_DORMOUSE_BROWSER_DEV_HOST` is set — a normal browser loads the page, not the Tauri WebView.
+The harness **may omit** native-only desktop chrome (window controls, update checks) but **must preserve** every `PlatformAdapter` contract the app uses — PTY, control-request, clipboard, iframe-proxy, Burrow, agent-browser, and the sidecar-hosted alert stores (`alert_command` in, their broadcasts back; `docs/specs/alert.md`) — so a rule that only holds across the host boundary is exercised rather than answered by a private copy. **`BrowserSidecarHost.init()` resolves on the SSE stream being open, not on its construction**, so a seed cannot precede the stream that carries its reply; **must let retryable connection failures reconnect within the open timeout and display fatal startup errors with a reload action**; after a reconnect the adapter re-sends its last seeds so the stores republish (`standalone/src/browser-sidecar-host.test.ts`). It **must mirror** standalone's Session-persistence answer ("The governing rule"): the same `persistsSession`, one `PersistedWindow` per window (in `localStorage` rather than the Rust file store), and the same agent-recovery *claim* against a per-run temp state directory. **The harness must never capture**: a reload there is a live resume over PTYs that survive it, and capture is a quit-only step (`docs/specs/standalone.md` → "Agent recovery"). **Tauri APIs must not be required at static module-evaluation time** when `VITE_DORMOUSE_BROWSER_DEV_HOST` is set — a normal browser loads the page, not the Tauri WebView.
 
 Source of truth: `standalone/scripts/dev-agent-browser.mjs`, `standalone/scripts/dev-run.mjs`, `standalone/scripts/dev-host-guard.mjs`, `standalone/src/browser-sidecar-host.ts`, `standalone/src/browser-sidecar-adapter.ts`; `stepBurrow` in `scripts/pairing-walkthrough/steps.mjs`; `sessionForKey` in `dor-lib-common/src/agent-browser.ts`.
 
diff --git a/scripts/spec-word-budgets.json b/scripts/spec-word-budgets.json
index 524d97944..9e3a852cd 100644
--- a/scripts/spec-word-budgets.json
+++ b/scripts/spec-word-budgets.json
@@ -30,7 +30,7 @@
   "docs/specs/terminal-state.md": 2350,
   "docs/specs/theme.md": 2150,
   "docs/specs/tiling-engine.md": 4500,
-  "docs/specs/transport.md": 5750,
+  "docs/specs/transport.md": 5850,
   "docs/specs/tutorial.md": 1900,
   "docs/specs/vscode.md": 7500,
   "docs/specs/webgl-text.md": 1200,
diff --git a/standalone/scripts/dev-agent-browser.mjs b/standalone/scripts/dev-agent-browser.mjs
index 87739af9d..bbc80cc18 100644
--- a/standalone/scripts/dev-agent-browser.mjs
+++ b/standalone/scripts/dev-agent-browser.mjs
@@ -111,6 +111,10 @@ const fireAndForget = {
   // The Burrow's whole bridge rides one passthrough, exactly as it does
   // through Rust (`burrow_command` in src-tauri/src/lib.rs).
   burrow_command: ({ payload }) => writeSidecar('burrow:command', payload),
+  // The app-global alert stores live in the sidecar; their broadcasts come back
+  // over the event stream like every other sidecar line (`alert_command` in
+  // src-tauri/src/lib.rs).
+  alert_command: ({ payload }) => writeSidecar('alert:command', payload),
   kill_sidecar_now: () => shutdown(),
 };
 
@@ -174,7 +178,7 @@ let registryRevision = 0;
 function registrySnapshot() {
   const workspaces = JSON.parse(registryEntries).map((entry) => ({
     id: entry.id,
-    ref: /^workspace-(\d+)$/.test(entry.id) ? `workspace:${entry.id.slice('workspace-'.length)}` : null,
+    ref: /^workspace-(\d+)$/.test(entry.id) ? `workspace:${entry.id.slice('workspace-'.length)}` : `workspace:${entry.id}`,
     name: entry.name,
     active: Boolean(entry.active),
   }));
diff --git a/standalone/src/browser-sidecar-adapter.test.ts b/standalone/src/browser-sidecar-adapter.test.ts
index ec2b75a0d..1a1a024b5 100644
--- a/standalone/src/browser-sidecar-adapter.test.ts
+++ b/standalone/src/browser-sidecar-adapter.test.ts
@@ -13,6 +13,9 @@ vi.mock("@tauri-apps/plugin-shell", () => ({ open: vi.fn(async () => {}) }));
 import { BrowserSidecarAdapter } from "./browser-sidecar-adapter";
 import { BrowserSidecarHost } from "./browser-sidecar-host";
 import { TauriAdapter } from "./tauri-adapter";
+import type { AlertManager } from "dormouse-lib/lib/alert-manager";
+import type { AlertSettings } from "dormouse-lib/lib/alert-settings";
+import { DEFAULT_ALERT_SETTINGS } from "dormouse-lib/lib/alert-settings-model";
 
 // Both adapters are viewed as `PlatformAdapter` here on purpose: `onFilesDropped`
 // is optional precisely so consumers can probe for it
@@ -104,11 +107,16 @@ describe("BrowserSidecarAdapter terminal stream", () => {
   async function listening() {
     const host = new BrowserSidecarHost("http://localhost:1234");
     let emit: (event: { event: string; data: unknown }) => void = () => {};
+    let reconnect: () => void = () => {};
     vi.spyOn(host, "init").mockResolvedValue(undefined);
     vi.spyOn(host, "onEvent").mockImplementation((listener) => {
       emit = listener;
       return () => {};
     });
+    vi.spyOn(host, "onReconnect").mockImplementation((listener) => {
+      reconnect = listener;
+      return () => {};
+    });
     const send = vi.spyOn(host, "send").mockImplementation(() => {});
     (window as typeof window & { __DORMOUSE_BROWSER_CONSOLE_PATCHED__?: boolean })
       .__DORMOUSE_BROWSER_CONSOLE_PATCHED__ = true;
@@ -116,7 +124,16 @@ describe("BrowserSidecarAdapter terminal stream", () => {
     const adapter = new BrowserSidecarAdapter(host);
     await adapter.init();
     send.mockClear();
-    return { adapter, send, deliver: (event: string, data: unknown) => emit({ event, data }) };
+    // The manager is where a broadcast has to land for the rule to bite; the
+    // handler fan-out alone would pass with a private copy of the store.
+    const manager = (adapter as unknown as { alertManager: AlertManager }).alertManager;
+    const alertCommands = () =>
+      send.mock.calls.filter(([cmd]) => cmd === "alert_command").map(([, args]) => args);
+    return {
+      adapter, send, manager, alertCommands,
+      reconnect: () => reconnect(),
+      deliver: (event: string, data: unknown) => emit({ event, data }),
+    };
   }
 
   it("forwards the projection pair it was handed, parsing nothing again", async () => {
@@ -130,13 +147,69 @@ describe("BrowserSidecarAdapter terminal stream", () => {
     expect(send.mock.calls.filter(([cmd]) => cmd === "pty_write")).toEqual([]);
   });
 
+  it("routes the alert stores through the sidecar and applies their broadcasts", async () => {
+    const { adapter, manager, alertCommands, deliver } = await listening();
+    const quiet: AlertSettings = { ...DEFAULT_ALERT_SETTINGS, speakEnabled: false };
+    adapter.alertSetCommandWatched("cargo", true);
+    adapter.alertPublishSettings(quiet, { seed: true });
+    expect(alertCommands()).toEqual([
+      { payload: { op: "setCommandWatched", name: "cargo", watched: true } },
+      { payload: { op: "initializeSettings", settings: quiet } },
+    ]);
+
+    const setWatched = vi.spyOn(manager, "setWatchedCommands");
+    const applySettings = vi.spyOn(manager, "applySettings");
+    const names: string[][] = [];
+    const settings: AlertSettings[] = [];
+    adapter.onWatchedCommands((next) => void names.push(next));
+    adapter.onAlertSettings((next) => void settings.push(next));
+
+    deliver("alert:watchedCommands", { names: ["cargo", "make"] });
+    expect(setWatched).toHaveBeenCalledWith(["cargo", "make"]);
+    expect(names).toEqual([["cargo", "make"]]);
+
+    const canonical: AlertSettings = { ...DEFAULT_ALERT_SETTINGS, deferAlertsUntilQuiet: true };
+    deliver("alert:settings", { settings: canonical });
+    expect(applySettings).toHaveBeenCalledWith(canonical);
+    expect(settings).toEqual([canonical]);
+
+    // A broadcast with no blob is dropped, not applied as "no settings".
+    deliver("alert:settings", {});
+    expect(applySettings).toHaveBeenCalledTimes(1);
+    expect(settings).toEqual([canonical]);
+  });
+
+  // The stream is the only path a store's snapshot takes back, and a dropped
+  // stream loses the bridge's fan-out entry with it. Re-offering the seeds is
+  // what makes the sidecar republish; a repeat seed is refused as a seed but
+  // still answered (lib/src/lib/watched-command-host.ts `initialize`).
+  it("re-sends its last seeds when the event stream reconnects", async () => {
+    const { adapter, alertCommands, reconnect, send } = await listening();
+    const quiet: AlertSettings = { ...DEFAULT_ALERT_SETTINGS, speakEnabled: false };
+    adapter.alertSetWatchedCommands(["cargo"]);
+    adapter.alertPublishSettings(quiet, { seed: true });
+    // Neither a mutation nor a non-seed publish is a seed; neither is replayed.
+    adapter.alertSetCommandWatched("make", true);
+    adapter.alertPublishSettings({ ...quiet, pushEnabled: true }, { seed: false });
+    send.mockClear();
+
+    reconnect();
+    expect(alertCommands()).toEqual([
+      { payload: { op: "initializeWatchedCommands", names: ["cargo"] } },
+      { payload: { op: "initializeSettings", settings: quiet } },
+    ]);
+  });
+
   // Same contract as TauriAdapter: the replay is all a transferred pane's new
   // window sees, so it rebuilds the AlertManager's half too.
   it("rebuilds alert state from a replay, not only pane state", async () => {
     const { adapter, deliver } = await listening();
     const alerts: AlertStateDetail[] = [];
     adapter.onAlertState((detail) => void alerts.push(detail));
+    // The rule set lives in the sidecar here: the seed goes out, its snapshot
+    // comes back, and only then does this manager watch anything.
     adapter.alertSetWatchedCommands(["sleep"]);
+    deliver("alert:watchedCommands", { names: ["sleep"] });
 
     deliver("pty:replay", { id: "replay-b", data: "\x1b]633;E;sleep 5\x07\x1b]633;C\x07" });
 
diff --git a/standalone/src/browser-sidecar-adapter.ts b/standalone/src/browser-sidecar-adapter.ts
index c87c7ee52..ae8cacd68 100644
--- a/standalone/src/browser-sidecar-adapter.ts
+++ b/standalone/src/browser-sidecar-adapter.ts
@@ -72,9 +72,18 @@ export class BrowserSidecarAdapter implements PlatformAdapter {
   private replayHandlers = new Set<(detail: PtyReplayDetail) => void>();
   private markedHandlers = new Set<(detail: PtyMarkedDetail) => void>();
   private alertStateHandlers = new Set<(detail: AlertStateDetail) => void>();
+  private watchedCommandHandlers = new Set<(names: string[]) => void>();
+  private alertSettingsHandlers = new Set<(settings: AlertSettings) => void>();
   private alertManager = new AlertManager();
   private unlistenHost: (() => void) | null = null;
+  private unlistenReconnect: (() => void) | null = null;
   private unlistenRegistry: (() => void) | null = null;
+  // The seeds this renderer last offered, keyed by op. The SSE stream is the
+  // only way a store's snapshot reaches this adapter, and a dropped stream
+  // takes the bridge's fan-out entry with it; re-offering the seeds after a
+  // reconnect makes the sidecar republish both stores (a repeat seed is
+  // ignored as a seed but still answered with the canonical snapshot).
+  private readonly alertSeeds = new Map<string, Record<string, unknown>>();
   private onRegistrySnapshot: ((snapshot: WorkspaceRegistrySnapshot) => void) | null = null;
   private static STATE_KEY = 'dormouse.browser-sidecar.session';
   private windowSlot = windowStateSlot(localStorage, BrowserSidecarAdapter.STATE_KEY, 'browser-sidecar');
@@ -114,6 +123,9 @@ export class BrowserSidecarAdapter implements PlatformAdapter {
   async init(): Promise<void> {
     await this.host.init();
     this.unlistenHost = this.host.onEvent(({ event, data }) => this.handleHostEvent(event, data));
+    this.unlistenReconnect = this.host.onReconnect(() => {
+      for (const payload of this.alertSeeds.values()) this.host.send("alert_command", { payload });
+    });
     this.installConsoleForwarder();
     this.unlistenRegistry = await installWorkspaceRegistry({
       invoke: (cmd, args) => this.host.invoke(cmd, args),
@@ -135,6 +147,8 @@ export class BrowserSidecarAdapter implements PlatformAdapter {
     this.alertManager.dispose();
     this.unlistenHost?.();
     this.unlistenHost = null;
+    this.unlistenReconnect?.();
+    this.unlistenReconnect = null;
     this.unlistenRegistry?.();
     this.unlistenRegistry = null;
     this.burrowClient.dispose();
@@ -319,9 +333,23 @@ export class BrowserSidecarAdapter implements PlatformAdapter {
   notifySessionFlushComplete(_requestId: string): void {}
 
   alertRemove(id: string): void { this.alertManager.remove(id); }
-  alertSetWatchedCommands(names: string[]): void { this.alertManager.setWatchedCommands(names); }
-  alertSetCommandWatched(name: string, watched: boolean): void { this.alertManager.setCommandWatched(name, watched); }
-  alertPublishSettings(settings: AlertSettings): void { this.alertManager.applySettings(settings); }
+  // Through the sidecar's app-global stores and back as their broadcasts, the
+  // path the shipped app takes (see TauriAdapter), so the harness exercises
+  // the seed-once and delta rules rather than a private copy of the state.
+  alertSetWatchedCommands(names: string[]): void {
+    this.sendAlertSeed({ op: "initializeWatchedCommands", names });
+  }
+  alertSetCommandWatched(name: string, watched: boolean): void {
+    this.host.send("alert_command", { payload: { op: "setCommandWatched", name, watched } });
+  }
+  alertPublishSettings(settings: AlertSettings, opts: { seed: boolean }): void {
+    if (opts.seed) this.sendAlertSeed({ op: "initializeSettings", settings });
+    else this.host.send("alert_command", { payload: { op: "updateSettings", settings } });
+  }
+  private sendAlertSeed(payload: { op: string } & Record<string, unknown>): void {
+    this.alertSeeds.set(payload.op, payload);
+    this.host.send("alert_command", { payload });
+  }
   alertDismiss(id: string): void { this.alertManager.dismissAlert(id); }
   alertAttend(id: string): void { this.alertManager.attend(id); }
   alertResize(id: string): void { this.alertManager.onResize(id); }
@@ -331,9 +359,8 @@ export class BrowserSidecarAdapter implements PlatformAdapter {
   alertClearTodo(id: string): void { this.alertManager.clearTodo(id); }
   alertAwait(id: string, options: AwaitOptions): AwaitHandle { return this.alertManager.awaitCompletion(id, options); }
   onAlertState(handler: (detail: AlertStateDetail) => void): void { this.alertStateHandlers.add(handler); }
-  // See TauriAdapter: single webview, so nothing is broadcast back.
-  onWatchedCommands(_handler: (names: string[]) => void): void {}
-  onAlertSettings(_handler: (settings: AlertSettings) => void): void {}
+  onWatchedCommands(handler: (names: string[]) => void): void { this.watchedCommandHandlers.add(handler); }
+  onAlertSettings(handler: (settings: AlertSettings) => void): void { this.alertSettingsHandlers.add(handler); }
 
   // The harness mirrors the shipped persistence answer, so a reload here
   // exercises what the app does (docs/specs/transport.md -> "The governing rule").
@@ -369,6 +396,19 @@ export class BrowserSidecarAdapter implements PlatformAdapter {
       this.onRegistrySnapshot?.(data as WorkspaceRegistrySnapshot);
       return;
     }
+    if (event === "alert:watchedCommands") {
+      const names = (data as { names?: string[] } | undefined)?.names ?? [];
+      this.alertManager.setWatchedCommands(names);
+      for (const handler of this.watchedCommandHandlers) handler(names);
+      return;
+    }
+    if (event === "alert:settings") {
+      const settings = (data as { settings?: AlertSettings } | undefined)?.settings;
+      if (!settings) return;
+      this.alertManager.applySettings(settings);
+      for (const handler of this.alertSettingsHandlers) handler(settings);
+      return;
+    }
     if (event === "pty:data") {
       // Already parsed by the sidecar, which owns the PTY; its events arrive as
       // the two messages below (docs/specs/terminal-escapes.md).
diff --git a/standalone/src/browser-sidecar-host.test.ts b/standalone/src/browser-sidecar-host.test.ts
index 4f2c0f8cd..c593aa8d1 100644
--- a/standalone/src/browser-sidecar-host.test.ts
+++ b/standalone/src/browser-sidecar-host.test.ts
@@ -1,4 +1,4 @@
-import { describe, expect, it } from "vitest";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { BrowserSidecarHost } from "./browser-sidecar-host";
 
 // The dev bridge is an authenticated loopback control plane — `pty_spawn`
@@ -28,3 +28,103 @@ describe("BrowserSidecarHost.url", () => {
     expect(url.pathname).toBe("/__dormouse_dev_host/send");
   });
 });
+
+// jsdom ships no `EventSource`; this one is driven by hand. `EventTarget`
+// gives it the `addEventListener` surface the host subscribes through.
+class FakeEventSource extends EventTarget {
+  static instances: FakeEventSource[] = [];
+  static readonly CLOSED = 2;
+  readyState = 0;
+  closed = false;
+  constructor(readonly url: string | URL) {
+    super();
+    FakeEventSource.instances.push(this);
+  }
+  close(): void { this.closed = true; this.readyState = FakeEventSource.CLOSED; }
+  open(): void { this.readyState = 1; this.dispatchEvent(new Event("open")); }
+  fail(fatal = false): void { this.readyState = fatal ? FakeEventSource.CLOSED : 0; this.dispatchEvent(new Event("error")); }
+}
+
+// The bridge only fans a broadcast out to streams it has already registered,
+// and the app POSTs its two alert seeds the moment `init()` resolves — replies
+// that ride the stream. So `init()` settles on the stream being *open*, never
+// on the `EventSource` merely existing (docs/specs/transport.md ->
+// "Standalone browser-dev harness").
+describe("BrowserSidecarHost.init", () => {
+  beforeEach(() => {
+    FakeEventSource.instances = [];
+    vi.stubGlobal("EventSource", FakeEventSource);
+    vi.spyOn(console, "error").mockImplementation(() => {});
+  });
+  afterEach(() => {
+    vi.unstubAllGlobals();
+    vi.restoreAllMocks();
+    vi.useRealTimers();
+  });
+
+  const stream = () => FakeEventSource.instances[0]!;
+  async function settled(promise: Promise<unknown>): Promise<"pending" | "resolved" | "rejected"> {
+    let state: "pending" | "resolved" | "rejected" = "pending";
+    promise.then(() => { state = "resolved"; }, () => { state = "rejected"; });
+    await Promise.resolve();
+    await Promise.resolve();
+    return state;
+  }
+
+  it("resolves on the stream's open event, not on construction", async () => {
+    const host = new BrowserSidecarHost("http://127.0.0.1:1422/?t=deadbeef");
+    const ready = host.init();
+    expect(await settled(ready)).toBe("pending");
+    stream().open();
+    expect(await settled(ready)).toBe("resolved");
+    // A second call while connected is the same connection, not a second stream.
+    await host.init();
+    expect(FakeEventSource.instances).toHaveLength(1);
+  });
+
+  it("rejects, and stops the stream, when it errors before opening", async () => {
+    const host = new BrowserSidecarHost("http://127.0.0.1:1422/?t=deadbeef");
+    const ready = host.init();
+    stream().fail(true);
+    await expect(ready).rejects.toThrow("failed before it opened");
+    expect(stream().closed).toBe(true);
+  });
+
+  it("allows retryable pre-open failures to reconnect within the deadline", async () => {
+    const host = new BrowserSidecarHost("http://127.0.0.1:1422");
+    const ready = host.init();
+    stream().fail();
+    expect(await settled(ready)).toBe("pending");
+    expect(stream().closed).toBe(false);
+    stream().open();
+    await expect(ready).resolves.toBeUndefined();
+  });
+
+  it("gives up after a bounded wait when neither event arrives", async () => {
+    vi.useFakeTimers();
+    const host = new BrowserSidecarHost("http://127.0.0.1:1422/?t=deadbeef");
+    const ready = host.init();
+    vi.advanceTimersByTime(BrowserSidecarHost.OPEN_TIMEOUT_MS);
+    await expect(ready).rejects.toThrow("did not open");
+    expect(stream().closed).toBe(true);
+  });
+
+  // The browser re-establishes a dropped stream by itself, but the bridge's
+  // fan-out set forgot this client in between: whatever it broadcast is gone.
+  // The reconnect hook is how subscribers learn to re-ask; the first open is
+  // not a reconnect, `init()` already reports that one.
+  it("reports every open after the first as a reconnect", async () => {
+    const host = new BrowserSidecarHost("http://127.0.0.1:1422/?t=deadbeef");
+    const reconnects = vi.fn();
+    host.onReconnect(reconnects);
+    const ready = host.init();
+    stream().open();
+    await ready;
+    expect(reconnects).not.toHaveBeenCalled();
+    stream().fail();
+    expect(await settled(ready)).toBe("resolved");
+    expect(reconnects).not.toHaveBeenCalled();
+    stream().open();
+    expect(reconnects).toHaveBeenCalledTimes(1);
+  });
+});
diff --git a/standalone/src/browser-sidecar-host.ts b/standalone/src/browser-sidecar-host.ts
index b2027c61e..15e5cd22f 100644
--- a/standalone/src/browser-sidecar-host.ts
+++ b/standalone/src/browser-sidecar-host.ts
@@ -1,8 +1,13 @@
 export type BrowserSidecarEvent = { event: string; data: unknown };
 
 export class BrowserSidecarHost {
+  /** How long `init()` waits for the stream to open before giving up. */
+  static readonly OPEN_TIMEOUT_MS = 10_000;
+
   private events: EventSource | null = null;
+  private ready: Promise<void> | null = null;
   private readonly eventHandlers = new Set<(event: BrowserSidecarEvent) => void>();
+  private readonly reconnectHandlers = new Set<() => void>();
   private nextId = 1;
 
   constructor(private readonly baseUrl: string) {}
@@ -24,22 +29,63 @@ export class BrowserSidecarHost {
     return url;
   }
 
-  async init(): Promise<void> {
-    if (this.events) return;
+  /**
+   * Resolves once the SSE stream is *open*, not once the `EventSource` is
+   * constructed. The bridge registers a stream in `sseClients` when the GET
+   * arrives, and the app's first act after `init()` is to POST the two alert
+   * seeds whose replies come back only over that stream — a POST that beat
+   * the GET would be answered to nobody (docs/specs/transport.md ->
+   * "Standalone browser-dev harness"). Tauri awaits its listener
+   * registration for the same reason.
+   */
+  init(): Promise<void> {
+    if (this.ready) return this.ready;
     const url = this.url('/__dormouse_dev_host/events');
-    this.events = new EventSource(url);
-    this.events.addEventListener('sidecar', (event) => {
+    const events = new EventSource(url);
+    this.events = events;
+    events.addEventListener('sidecar', (event) => {
       const parsed = JSON.parse((event as MessageEvent).data) as BrowserSidecarEvent;
       this.deliver(parsed);
     });
-    this.events.onerror = () => {
-      console.error('[browser-sidecar] event stream disconnected');
-    };
+    this.ready = new Promise<void>((resolve, reject) => {
+      let opened = false;
+      const giveUp = (why: string) => {
+        clearTimeout(timer);
+        events.close();
+        reject(new Error(`[browser-sidecar] event stream ${why}`));
+      };
+      const timer = setTimeout(
+        () => giveUp(`did not open within ${BrowserSidecarHost.OPEN_TIMEOUT_MS}ms`),
+        BrowserSidecarHost.OPEN_TIMEOUT_MS,
+      );
+      events.addEventListener('open', () => {
+        if (!opened) {
+          opened = true;
+          clearTimeout(timer);
+          resolve();
+          return;
+        }
+        // The browser reconnected on its own after a drop. The bridge's
+        // fan-out set forgot this client in between, so anything it would
+        // have broadcast is gone; subscribers re-ask for what they need.
+        for (const handler of this.reconnectHandlers) handler();
+      });
+      events.addEventListener('error', () => {
+        if (!opened) {
+          // CONNECTING is retryable; EventSource retries within the open budget.
+          if (events.readyState === EventSource.CLOSED) giveUp('failed before it opened');
+          return;
+        }
+        console.error('[browser-sidecar] event stream disconnected');
+      });
+    });
+    return this.ready;
   }
 
   close(): void {
     this.events?.close();
     this.events = null;
+    this.ready = null;
   }
 
   onEvent(handler: (event: BrowserSidecarEvent) => void): () => void {
@@ -47,6 +93,13 @@ export class BrowserSidecarHost {
     return () => this.eventHandlers.delete(handler);
   }
 
+  /** Fires on every `open` after the first — the stream was dropped and the
+   *  browser re-established it. Not on the initial open; `init()` covers that. */
+  onReconnect(handler: () => void): () => void {
+    this.reconnectHandlers.add(handler);
+    return () => this.reconnectHandlers.delete(handler);
+  }
+
   send(cmd: string, args?: Record<string, unknown>): void {
     fetch(this.url('/__dormouse_dev_host/send'), {
       method: 'POST',
diff --git a/standalone/src/main.tsx b/standalone/src/main.tsx
index 9f54d0b2e..f37375f41 100644
--- a/standalone/src/main.tsx
+++ b/standalone/src/main.tsx
@@ -174,4 +174,14 @@ async function bootstrap() {
   );
 }
 
-bootstrap();
+void bootstrap().catch((error: unknown) => {
+  console.error("[dormouse] startup failed", error);
+  const root = document.getElementById("root");
+  if (!root) return;
+  const message = document.createElement("p");
+  message.textContent = `Dormouse could not start: ${error instanceof Error ? error.message : String(error)}`;
+  const retry = document.createElement("button");
+  retry.textContent = "Reload";
+  retry.addEventListener("click", () => window.location.reload());
+  root.replaceChildren(message, retry);
+});