diff --git a/.github/audit/application-security.md b/.github/audit/application-security.md
index bc137e89..71a69abc 100644
--- a/.github/audit/application-security.md
+++ b/.github/audit/application-security.md
@@ -46,10 +46,14 @@ today's tree, not the scope.
 For the rest of `docs/specs/security-local.md`, read each section's owner first
 — `docs/specs/terminal-escapes.md`, `docs/specs/dor-browser.md`,
 `docs/specs/dor-cli.md`, `docs/specs/vscode.md` -> "Webview message
-authentication", `docs/specs/standalone.md` -> "Persistence" — then the parser,
-the iframe shim, the control-socket code, and the persistence path they point
-at. The attacker there is a program printing to the terminal, a page in a
-browser pane, or another local account, never the network.
+authentication", `docs/specs/standalone.md` -> "Persistence",
+`docs/specs/notepad.md` -> "Archive" — then the parser, the iframe shim, the
+control-socket code, and the persistence paths they point at. `## Persisted
+state` now covers two stores that hold user text on purpose: the session
+snapshot and the notepad archive, both written through
+`write_file_atomically` on standalone, the archive in `globalState` on VS Code.
+The attacker there is a program printing to the terminal, a page in a browser
+pane, or another local account, never the network.
 
 ## Qualitative pass
 
diff --git a/AGENTS.md b/AGENTS.md
index 6ef9066e..51f339e0 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -47,6 +47,7 @@ A spec is the accurate reference for the current code: it states the invariants
 - **`docs/specs/terminal-escapes.md`** — Registry of every escape sequence parsed, answered, or ignored, each row pointing at its owning spec. Read before touching OSC/CSI parsing.
 - **`docs/specs/transport.md`** — Adapter-agnostic webview ↔ host protocol: PTY lifecycle and buffering, reconnection, message contracts, persisted-session types, the invariants every adapter honors.
 - **`docs/specs/mouse-and-clipboard.md`** — Terminal-owned selection, copy (Raw / Rewrapped), paste tiers, smart URL/path extension, the mouse-ownership state matrix.
+- **`docs/specs/notepad.md`** — The per-Surface notepad: the note model and host archive port, capture from a terminal selection, source pins back to scrollback, the panel/Door/Archive UI, and every closure path that archives notes.
 - **`docs/specs/theme.md`** — The two-layer CSS variable strategy, consumed-token resolver, terminal color contract, theme debugger.
 - **`docs/specs/dor-cli.md`** — The `dor` CLI on every Dormouse terminal's `PATH`: bundling and env contract, `spawnAndCapture` rules, control-socket plumbing, the Surface handle model, the command set.
 - **`docs/specs/dor-browser.md`** — The browser surface: `BrowserPanel` with swappable `renderMode`, browser chrome, the agent-browser stack, the iframe proxy and CSP boundaries.
diff --git a/docs/specs/dor-cli.md b/docs/specs/dor-cli.md
index 42b2cd8e..8590e70a 100644
--- a/docs/specs/dor-cli.md
+++ b/docs/specs/dor-cli.md
@@ -229,9 +229,11 @@ late response for a reaped id is a silent no-op on the server.
 
 **Must cancel `ensure`'s polling when the client disconnects.** Cancellation
 before an interrupted command returns to its prompt prevents relaunch;
-cancellation during initial integration detection removes the throwaway split.
+cancellation during initial integration detection closes the temporary Surface per `docs/specs/notepad.md` → "Closure".
 `lib/src/components/Wall.test.tsx` pins both paths.
 
+**Must exclude Surfaces with a Wall closure in progress from reuse.** An unrelated notes freeze permits reuse.
+
 Source of truth: `standalone/sidecar/dor-control-server.js`,
 `dor/src/control-client.ts`, `dor/src/protocol.ts`, `peerDirIsSafe` in
 `vscode-ext/src/peer-link.ts`, `lib/src/lib/platform/dor-control-dispatch.ts`,
@@ -353,7 +355,7 @@ The spec keeps the behavior help cannot express:
 | Command | Behavioral contract |
 |---|---|
 | `split` | **Only a bare split focuses the new Surface.** A `--` marker or command tail leaves the caller focused; pre-parse preserves the marker stricli discards. |
-| `ensure` | **Must have a `--` command tail.** Matching uses the exact OSC 633 command plus resolved CWD; `cmd.exe` without integration fails immediately, other unintegrated shells time out after 8s and lose their throwaway split. `--restart` drives the live PTY in place, preserving layout and minimized/visible state, so it works on Doors too. |
+| `ensure` | **Must have a `--` command tail.** Matching uses the exact OSC 633 command plus resolved CWD; `cmd.exe` without integration fails immediately, other unintegrated shells time out after 8s and close through the notepad coordinator. `--restart` drives the live PTY in place, preserving layout and minimized/visible state, so it works on Doors too. |
 | `send` | **Must select exactly one input mode.** Text then key is the only mixed order; duplicate flags require the explicit sequence form. |
 | `read` | Clean, ANSI-free rendered lines; line limits count rendered lines. |
 | `await` | **Must name `--until quiet\|exit`; never infer it.** Timeout 1–86400 whole seconds, default 600; `alert.md` owns wake semantics. |
diff --git a/docs/specs/layout.md b/docs/specs/layout.md
index c2685202..2f658996 100644
--- a/docs/specs/layout.md
+++ b/docs/specs/layout.md
@@ -48,7 +48,7 @@ Panes are separated by a 7px gap (`PANE_GUTTER_PX`), odd so the 1px selection ri
 
 A 30px header doubling as a drag handle: **a `pointerdown` past a 5px threshold begins a Lath pane drag**; below the threshold the header's own click behavior stands. It uses `cursor-grab` / `active:cursor-grabbing`, `select-none`, the shared terminal top radius from `lib/src/components/design.tsx`, and the `--color-header-active-*` / `--color-header-inactive-*` token pairs (VSCode file-tree list colors).
 
-Elements left to right: derived label; alert bell; TODO pill (compact+); flexible gap; mouse-reporting override icon (compact+, only while the inside program requests mouse reporting); split left/right, split top/bottom, zoom/unzoom (full only); minimize; kill (hover turns error-red).
+Elements left to right: derived label; alert bell; TODO pill (compact+); flexible gap; mouse-reporting override icon (compact+, only while the inside program requests mouse reporting); notepad icon (`docs/specs/notepad.md` → "Notepad UI"); split left/right, split top/bottom, zoom/unzoom (full only); minimize; kill (hover turns error-red).
 
 The label is the `DerivedHeader` from `deriveHeader(...)`; `docs/specs/terminal-state.md` owns the priority chain and disambiguator. Layout renders it: primary truncates with ellipsis, secondary muted beside it, a failed last command appends an error-colored glyph. Click renames/pins; right-click — or `>` in command mode — opens the header context menu.
 
@@ -72,6 +72,8 @@ The label is the `DerivedHeader` from `deriveHeader(...)`; `docs/specs/terminal-
 
 **Must focus context controls on opening.** Explicit entry into helper xterm gives it terminal keys; Escape there belongs to its program. Escape from controls closes the innermost disclosure, then context. Terminal clipboard routing uses the focused helper rather than the selected source. Actions use subdued link color and shared compact `OnOffSwitch` controls.
 
+**Must place the shared notepad button beside Promote in the Helper status row**, opening the parent's panel over the context; `docs/specs/notepad.md` → "Helper terminals" owns its behavior.
+
 **Must tint the copyable Surface ref as an action and confirm each successful context copy in its button** with a checkmark and “Copied” for 1.4 seconds, preserving button width and keeping the context open. Failed copies show the action error without success feedback.
 
 **Must suppress context action hover and focus highlights while the window is unfocused**, including after opening a native explorer or system browser. **Must also withhold hover from an in-flight action, which stays focusable and `aria-disabled` rather than `disabled`** so the innermost disclosure keeps a focused descendant for Escape and Tab.
@@ -103,7 +105,7 @@ A ResizeObserver picks one of three tiers by header width:
 
 - **Full** (>280px): everything.
 - **Compact** (>160px): split, zoom, and unzoom hidden.
-- **Minimal** (≤160px): also hides the TODO pill and the mouse-override icon, leaving alert, minimize, and kill. The label truncates with ellipsis.
+- **Minimal** (≤160px): also hides the TODO pill and the mouse-override icon, leaving alert, minimize, and kill. **The notepad icon survives this tier only while the Surface has notes** (`docs/specs/notepad.md` → "Notepad UI"). The label truncates with ellipsis.
 
 ## Baseboard
 
@@ -121,6 +123,7 @@ A minimized session becomes a **door**, showing its label plus the alert/TODO/sp
 - **m** / **d** (command mode): restore into a pane but stay in command mode — the inverse of `m`/`d` on a pane, making them toggles.
 - **x** / **k** (command mode): restore into a pane, then show the kill confirmation (an untouched Surface is killed outright — [Kill confirmation](#kill-confirmation)).
 - **Arrow keys** navigate to and between doors ([Spatial navigation](#spatial-navigation)).
+- **A Door holding notes carries a second button**, the notepad, which neither reattaches nor drags (`docs/specs/notepad.md` → "Notepad UI").
 
 **A reattach that stays in command mode defers its follow-up** (focus, kill, replace) to `requestAnimationFrame` and skips it if the pane vanished in between.
 
@@ -179,6 +182,8 @@ All keys are handled in one capture-phase `keydown` listener on `window` (`use-w
 
 That order is load-bearing twice: a rename input suppresses the pane shortcuts but **not** the mode-exit gesture or the field's own clipboard chords; and a staged kill confirmation hijacks each key reaching it before the dialog gate, so the confirm letter works even though the modal is open.
 
+**Every open dialog holds its own reference-counted lease on that gate**, and command-mode dispatch resumes only once the last lease is released — so a dialog closing over another cannot lift the survivor's suppression (`createDialogKeyboardCoordinator` in `lib/src/components/wall/wall-context.tsx`).
+
 ### Split cwd inheritance
 
 A split from an existing pane (`|`/`%`/`-`/`"` or the header split buttons) spawns the new pane with its source pane's last-known cwd, then selects it and enters passthrough; host New Terminal actions share that focus tail (rationale). Focus-neutral control-plane creation (`dor split -- …`, `dor ensure`, `dor iframe`, `dor ab`) keeps its documented background behavior.
@@ -191,9 +196,11 @@ The source cwd is read from `getTerminalPaneState(sourceId).cwd`. **Never inheri
 
 **Confirmation must be staged in a ref synchronously, not only in React state** — a second confirm keydown arriving before React flushes would otherwise pass the guard and kill twice (`lath.isDying` is the second line of defense).
 
+**Every kill routes through the notepad close coordinator**, confirmed and untouched-fast-path alike, which archives the Surface's notes before teardown and can refuse the close (`docs/specs/notepad.md` → "Closure"; that spec also names who may still tear a Surface down immediately).
+
 **Untouched sessions skip this confirmation.** A newly spawned shell starts `untouched: true`; the first user-originated PTY input flips it to false. Counted: printable keys, Enter, control keys, keyboard CSI such as arrows/history, paste, file-drop path insertion. Not counted: replay-shaped terminal reports and stripped mouse-report-only input — **the gate checks `inputIsReplayTerminalReport`**, the broader synthetic-report check gating input recording and alert attention, not this flag. Killing an untouched pane runs the normal kill animation/dispose path immediately; killing an untouched door first reattaches it only far enough to reuse that removal path, then kills it with no overlay.
 
-Source of truth: `acceptKill` in `lib/src/components/Wall.tsx`, `lib/src/components/KillConfirm.tsx`.
+Source of truth: `requestKill` (every kill gesture: Door reattach, untouched fast path, or staging the overlay) and `acceptKill` in `lib/src/components/Wall.tsx`, `lib/src/components/KillConfirm.tsx`.
 
 ## Selection overlay
 
@@ -303,7 +310,7 @@ Source of truth: `lib/src/components/wall/IllegalRenameWarning.tsx`, `lib/src/co
 | **Swap** | `Cmd/Ctrl+Arrow` trades two leaf identities via a Lath `swap`; registry entries follow the ids ([Spatial navigation](#spatial-navigation)). |
 
 - **Untouched**: new `getOrCreateTerminal` sessions start untouched; `isUntouched(id)` exposes the flag, user-originated PTY input clears it, and resume/restore seed the persisted one. **Missing legacy snapshot data defaults to touched (`false`)**, keeping close confirmation conservative.
-- **Shell selection replacement**: the standalone Settings dialog's Shell row and the VS Code shell picker send `dormouse:new-terminal` with `replaceUntouched` when the selected shell type changes. **A shell is identified by executable path plus ordered arguments**, so WSL distributions and Windows Developer shells sharing an executable stay distinct. **`Wall` always mints a new session id and a fresh `surface:N` ref.** An untouched selected pane or door has the new terminal take over its leaf via a Lath `replace` op (an atomic identity swap; doors reattach through the normal restore path first), the old session disposed and its ref retired; a touched selection, or none, spawns a new pane beside it. Announced spawns show a transient pane-anchored notice (`Switched to zsh`, `Opened bash`).
+- **Shell selection replacement**: the standalone Settings dialog's Shell row and the VS Code shell picker send `dormouse:new-terminal` with `replaceUntouched` when the selected shell type changes. **A shell is identified by executable path plus ordered arguments**, so WSL distributions and Windows Developer shells sharing an executable stay distinct. **`Wall` always mints a new session id and a fresh `surface:N` ref.** An untouched selected pane or door has the new terminal take over its leaf via a Lath `replace` op (an atomic identity swap; doors reattach through the normal restore path first), the old session disposed and its ref retired; a touched selection, or none, spawns a new pane beside it. Announced spawns show a transient pane-anchored notice (`Switched to zsh`, `Opened bash`). **A replacement migrates the Surface's notepad to the new id rather than archiving it** (`docs/specs/notepad.md` → "Closure").
 - **Replay-time terminal reports must be dropped; user input must not be** — during **resume** replay the registry drops the replies xterm.js emits to queries embedded in buffered output, before they reach the retained PTY (`docs/specs/terminal-escapes.md` → "Report filtering on the input side").
 
 Source of truth: `lib/src/lib/terminal-store.ts` (registry maps and pending shell opts, imported directly, including by `lib/src/remote/burrow/`), `lib/src/lib/terminal-lifecycle.ts` (the ops), `lib/src/lib/terminal-registry.ts` (the facade).
@@ -398,7 +405,7 @@ A store commit that empties the tree (last pane killed or minimized) triggers th
 3. **Stable hitboxes across moves**: a leaf measured after a move reports its new rect ([Position tracking](#position-tracking)), and Lath never re-parents a leaf div, so its node identity — and any embedded `<iframe>` — survives every op.
 4. **Asymmetric back-navigation**: the breadcrumb ([Spatial navigation](#spatial-navigation)) makes every arrow move reversible even where no spatial query would return you.
 5. **Door keeps selection through the auto-spawn refill** ([Auto-spawn refill](#auto-spawn-refill)). Explicit user selection of a pane — a click, a drag, or an embed focusing itself — still moves selection off a door.
-6. **Focus-neutral surface creation (`dor ensure` / `dor iframe` / `dor ab`)**: unlike `dor split`, these open in the background without moving focus off the caller (`docs/specs/dor-cli.md`, `docs/specs/dor-browser.md`). An add never re-parents the caller's subtree or steals activation, and the create does not call `selectPane` (`settleAddSelection` returns false for a focus-neutral, non-selection-replacing add). **The one exception**: `dor iframe` / `dor ab` replacing the pane the user is *currently selected on* moves selection to the replacement, else it would dangle on the removed leaf; any other pane, or a door selection, is left untouched. A throwaway that never reports OSC 633 integration is torn down with `killPaneImmediately`, whose live selection check leaves the caller's selection intact (a `--minimize` throwaway is already a door, disposed directly).
+6. **Focus-neutral surface creation (`dor ensure` / `dor iframe` / `dor ab`)**: unlike `dor split`, these open in the background without moving focus off the caller (`docs/specs/dor-cli.md`, `docs/specs/dor-browser.md`). An add never re-parents the caller's subtree or steals activation, and the create does not call `selectPane` (`settleAddSelection` returns false for a focus-neutral, non-selection-replacing add). **The one exception**: `dor iframe` / `dor ab` replacing the pane the user is *currently selected on* moves selection to the replacement, else it would dangle on the removed leaf; any other pane, or a door selection, is left untouched. Cleanup of a `dor ensure` temporary Surface follows `docs/specs/notepad.md` → "Closure"; any completed teardown preserves the caller's live selection.
 
 ## Future
 
diff --git a/docs/specs/mouse-and-clipboard.md b/docs/specs/mouse-and-clipboard.md
index 3d8e9127..1e296070 100644
--- a/docs/specs/mouse-and-clipboard.md
+++ b/docs/specs/mouse-and-clipboard.md
@@ -115,6 +115,8 @@ A finalized selection gets a popup of action buttons adjacent to it, on the side
 
 Source of truth: `lib/src/components/SelectionPopup.tsx` (Copy Raw, Copy Rewrapped, platform-dependent shortcut labels).
 
+A third button, **Add to notepad**, follows the two copies on every host that has a notepad; it captures the selection, flashes in place, and dismisses the popup without opening the notepad (`docs/specs/notepad.md` → "Capture").
+
 #### 4.1.1 Copy Raw
 
 **Must preserve displayed row breaks and decorative characters**, trimming trailing whitespace on each selected row; soft-wrapped rows also get `\n`. Source of truth: `extractSelectionText` in `lib/src/lib/selection-text.ts`.
@@ -132,6 +134,8 @@ Copies with two transformations applied (`lib/src/lib/rewrap.ts`):
 
 With an active, finalized terminal selection, popup focused or not: **Cmd+C** (Ctrl+C on non-macOS) triggers Copy Raw, **Cmd+Shift+C** (Ctrl+Shift+C) triggers Copy Rewrapped.
 
+**Cmd+N** (Ctrl+N on non-macOS) adds the selection to the notepad, **gated exactly like Ctrl+C** — intercepted only with a finalized selection, otherwise reaching the program as readline's next-history — and shown only where the host binds it (`docs/specs/notepad.md` → "Notepad UI").
+
 **Intercept Ctrl+C as Copy Raw only while a terminal selection is active.** With none it is forwarded to the inside program as usual (SIGINT for shells, app-defined for TUIs). An in-program selection a TUI maintains itself (vim visual mode, less search highlight) is **not** a terminal selection and does not change that routing.
 
 ### 4.3 Dismissing the Popup
diff --git a/docs/specs/notepad.md b/docs/specs/notepad.md
new file mode 100644
index 00000000..7dd44063
--- /dev/null
+++ b/docs/specs/notepad.md
@@ -0,0 +1,180 @@
+# Surface Notepad
+
+> See `docs/specs/glossary.md` for Surface / Session / Pane / Door / Wall vocabulary. This spec uses it throughout.
+>
+> Owns the per-Surface notepad: its model, the host archive port, capture, source pins, the notepad UI, the Archive view, and every path that turns live notes into archived ones.
+> **Defers:** header element order and density tiers to `docs/specs/layout.md`; the selection popup and its chords to `docs/specs/mouse-and-clipboard.md`; CWD semantics to `docs/specs/terminal-state.md`.
+> Read [Closure](#closure) first for anything about a Surface ending.
+
+## Model
+
+A notepad is one ordered list of notes per Surface, held in renderer memory for that Surface's life and opened from its header or its Door.
+
+- **A note is plain text or a captured terminal excerpt** (`NoteContent`), and nothing else.
+- **A run keeps bold, italic, foreground, and background, and nothing else.** Colors are normalized lowercase `#rrggbb`; a missing color means the theme default, so an excerpt stays theme-adaptive. **Underline, dim, blink, strike-through, and hyperlinks are dropped at capture**, never later.
+- **A note's source pin is runtime-only.** `RuntimeTerminalSource` holds live xterm markers, so `ArchivedNote` is `LiveNote` minus that field and no marker ever reaches a store.
+- **A closure appends one `ArchiveBatch` per Surface** — `id`, `closedAt`, `surfaceTitle`, `surfaceKind`, `cwd`, and the notes in creation order.
+- **`ArchiveBatch.cwd` is required and nullable.** It is the whole canonical `CwdState` snapshotted before teardown — path, URI, host, path kind, source, observation time — or `null` for a browser Surface and a terminal that never reported one. **Never persist a preformatted CWD label beside it**; the Archive renders path and remote host through `cwdDisplay`.
+- **A batch id is remembered per Surface across its closure attempts and forgotten once one lands**, and **every attempt deletes and re-appends that id in one mutation**, so an attempt that landed and *then* reported failure is replaced by the next, carrying the edits, additions, and deletions made in between. **`closedAt` is minted per attempt.**
+- **A mutation applies its deletes before its appends**, which is what makes that pair a replacement. Appends stay idempotent by batch and note id — an already-stored note is dropped from an appended batch and a batch left empty is skipped — and deleting something already gone is a no-op.
+
+Source of truth: `lib/src/lib/notepad/types.ts`; `applyArchiveMutation`, `buildArchiveBatch`, `readNotepadArchive` and `toArchivedNote` in `lib/src/lib/notepad/archive-model.ts`; `pendingBatchId` in `lib/src/lib/notepad/notepad-store.ts`.
+
+## Helper terminals
+
+- **Must share the parent Surface's notepad while a terminal is a Helper**, capturing into the parent's ordered list and editing that same list from the Helper's notepad button.
+- **Never create source pins for Helper captures or show pin actions in the Helper's notepad view**, including for notes captured by the parent. Parent pins remain usable from the parent's ordinary notepad view.
+- **Must retain shared notes on Helper hide, refresh, Reset, and promotion.** Promotion leaves existing notes with the parent; the promoted Session starts with an empty independent notepad and ordinary capture behavior.
+- **Must archive shared notes once under the parent on parent closure**, using the parent's metadata and closing freeze. Helper disposal creates no archive batch.
+
+Source of truth: `addSelectionToNotepad` in `lib/src/lib/notepad/capture.ts`; `TerminalContext` in `lib/src/components/wall/TerminalContext.tsx`; `NotepadPanel` in `lib/src/components/NotepadPanel.tsx`. Tests: `lib/src/lib/notepad/capture.test.ts`, `lib/src/components/NotepadPanel.test.tsx`, `lib/src/components/Wall.test.tsx`.
+
+## The archive port
+
+`PlatformAdapter.notepadArchive` is the whole host surface of the archive.
+
+- **A host stores bytes and names their version; the shared layer owns the shape.** `load()` returns `{ raw, revision }` or `null` (nothing ever archived); `save(archive, baseRevision)` replaces the stored archive only while it is still at that revision, answering `'conflict'` otherwise.
+- **Every mutation is a compare-and-swap, retried on conflict** — load, validate, apply, save against the revision just read — bounded at `MAX_SAVE_ATTEMPTS` before it reports the archive busy (rationale).
+- **One mutation queue per webview.** Two Surfaces closing together would otherwise read one revision and lose a batch to the other's conflict.
+- **A host with no notepad omits the port.** Pocket does, and the header icon, Door button, selection-popup action, and Settings entry are hidden with it.
+- **One store per host, never shared.** The standalone and VS Code archives must never discover, import, or synchronize each other's data.
+- **A failed archive rejects; it never resolves as if the write landed.** Closure paths turn that rejection into their failure UI rather than dropping notes.
+
+Standalone stores a file ([Standalone quit](#standalone-quit)), VS Code a shared file ([VS Code lifecycle](#vs-code-lifecycle)), the demo hosts plain memory cleared by a page reload.
+
+Source of truth: `NotepadArchivePort` in `lib/src/lib/notepad/types.ts`; `mutateArchive` and `resetUnreadableArchive` in `lib/src/lib/notepad/archive-service.ts`; `createMemoryNotepadArchivePort` in `lib/src/lib/notepad/memory-archive-port.ts`.
+
+## Capture
+
+"Add to notepad" captures a finalized Dormouse selection as a rich note on the Surface holding it.
+
+- **Join soft-wrapped rows and keep every hard break.** A row is soft-wrapped when the row *following* it reports xterm's `isWrapped`; a block selection is a rectangular slab, so every one of its rows ends hard. **Trailing whitespace is trimmed only on a row that ends hard** — a soft-wrapped row is full by definition.
+- **Capture is not Copy Rewrapped**: no paragraph joining and no box-drawing stripping (`docs/specs/mouse-and-clipboard.md` §4.1.2; rationale).
+- **Retain the raw selected text separately.** `extractSelectionText` over the same selection is the pin's validation key, read from the buffer rather than rebuilt from the runs.
+- **Colors record what xterm drew.** Walk buffer cells over the normalized selection, skip width-zero continuation cells, emit a wide character once, resolve palette and RGB colors, swap inverse ones to explicit values, and merge adjacent runs of identical styling. **Bold text on palette entries 0–7 resolves to the bright entry while `drawBoldTextInBrightColors` is on.** Entries 0–15 come from the live theme, 16–255 from xterm's computed table.
+- **An alternate-buffer capture gets no pin.** A full-screen program rewrites its grid in place, so there is nothing stable to point at.
+- **A capture flashes in place and dismisses the selection; it never opens the notepad.**
+
+Source of truth: `extractRichRuns` and `captureRichSelection` in `lib/src/lib/notepad/rich-extract.ts`; `addSelectionToNotepad` in `lib/src/lib/notepad/capture.ts`.
+
+## Source links
+
+A pin is the runtime link from a captured note back to the scrollback it came from.
+
+- **Pin an ordinary Session's normal-buffer capture with two xterm markers plus the normalized endpoint columns and the raw text.** Markers ride the buffer as it scrolls; the columns and text rebuild and prove the range.
+- Clicking a pin runs five steps: close the notepad; reattach a minimized Surface; resolve both markers and rebuild the range from their current lines and the stored columns; read it back and compare **exactly** with the captured raw text; on success scroll it into view and restore the Dormouse selection, outline and finalized popup included, plus the selection baseline a drag would leave — render-tick invalidation applies to a restored selection as to a dragged one.
+- **Column restoration after a resize is best effort**; the raw-text equality is what prevents navigating to the wrong output. Trimmed scrollback is discovered only when a pin is used.
+- **While the alternate buffer is active a pin is temporarily unavailable and kept** — the markers belong to the normal buffer and resolve again once the program exits; the notepad says to exit it.
+- **Every other pin failure removes the pin and keeps the note.** Disposed markers, rows out of range, and a text mismatch all report that the source is no longer available, the notepad kept or reopened to say so.
+- **Disposing or replacing a terminal instance drops its pins immediately**, notes untouched — a marker belongs to one xterm instance.
+- **Pins never affect ordering and are not user-controlled favorites.**
+
+Source of truth: `registerTerminalSource`, `resolveTerminalSource` and `revealResolvedSource` in `lib/src/lib/notepad/source-link.ts`; `revealNoteSource` in `lib/src/lib/notepad/pin.ts`; `setTerminalSelectionBaseline` in `lib/src/lib/terminal-store.ts`; `dropSourcesForTerminal` in `lib/src/lib/notepad/notepad-store.ts`, called from `disposeSession` in `lib/src/lib/terminal-lifecycle.ts`.
+
+## Notepad UI
+
+**The header notepad icon sits after the mouse-override icon and before the split controls** (`docs/specs/layout.md` → "Pane header"), filled while the Surface has notes and regular otherwise. **At the minimal tier an empty notepad yields its space to the title; one with notes stays**, so notes are never invisible.
+
+- **The attached notepad is a panel in the top-right of the Surface body, three quarters of it wide and tall.** It closes on its close control, Escape, or an outside click.
+- **Only one Surface notepad is open per Wall.** The store holds a single open id, and opening a Door's popover closes the attached panel.
+- **An open notepad owns the keyboard.** It is a `role="dialog"` with a focus trap, takes a lease on the Wall's dialog keyboard so command-mode dispatch stands down, and stops key and mouse events from reaching the Surface under it — a live browser pane's key forwarder included.
+- **A Door is a wrapper carrying `data-door-id` with one or two buttons.** The wrapper is what the selection ring and the baseboard fitting measure; the title button keeps click-to-reattach and the drag press, the notepad button does neither. **A minimized Surface with no notes gets no notepad button.**
+- **The Door popover opens above its Door, edge-clamped, capped at 30rem wide and 75% of the Wall height. Opening it never reattaches the Surface** — only following a pin from it does.
+
+Editing and copying:
+
+- **Notes stay in creation order, never re-sorted.** Add New appends an empty plain note at the bottom and focuses it; **an untouched empty note is pruned on blur or on panel close**.
+- **Moving the caret through a rich note never converts it.** Conversion hangs off the one event that names the edit: **the first content mutation — typing, deletion, cut, or paste — converts the whole note to plain text and applies the edit atomically.** **Paste inserts the plain flavor only.**
+- **An IME composition converts on `compositionend`, with the composed text** — `insertCompositionText` is not cancelable, so it is the one edit the browser writes into the rich DOM first.
+- **Rich runs render as escaped spans in a whitespace-preserving container**, never as injected HTML.
+- **Copy always writes `text/plain`.** A terminal note adds a `text/html` flavor built only from escaped text and the four supported attributes — never by serializing rendered DOM. **Anything the rich clipboard refuses falls back to the plain-text write**, best effort by contract.
+
+Source of truth: `NotepadBody` in `lib/src/components/NotepadBody.tsx`, placed by `lib/src/components/NotepadPanel.tsx` and `lib/src/components/DoorNotepadPopover.tsx`; `applyPlainEdit` in `lib/src/components/NoteList.tsx`; `lib/src/components/Door.tsx`; `noteToHtml` and `copyNoteToClipboard` in `lib/src/lib/notepad/rich-clipboard.ts`.
+
+The popup's third action and the `⌘N` / `Ctrl+N` chord belong to `docs/specs/mouse-and-clipboard.md` §4.1 and §4.2. Two rules are the notepad's own: **intercept the chord only while that terminal has a finalized Dormouse selection**, so with none it reaches the program unchanged; and **a host whose browser reserves the chord shows no shortcut and binds none**, gated by `browserReservesNotepadChord`, which the website demo and the standalone browser-dev harness set (rationale). Source of truth: `isNotepadChordBound` in `lib/src/lib/notepad/capture.ts`, `lib/src/components/SelectionPopup.tsx`.
+
+## Archive
+
+A **Notepad archive** entry in Settings replaces that dialog's content with a roomier Archive view carrying a Back to Settings action. **The entry is hidden where the host has no archive port.**
+
+- **Must re-read storage on every Archive opening**, ordering reads with mutations; tested in `lib/src/lib/notepad/archive-service.test.ts`.
+- **Batches show newest first, notes in their original order within each batch.** A batch header carries its Surface title, kind, closure time, and CWD when present.
+- **An archived note offers Copy and Delete only** — no editing and no pin, through the same clipboard exporter live notes use.
+- **Deletions are staged while the view is open.** A delete hides its target with no confirmation, a batch left with nothing visible goes with it, and the first deletion raises "Deletion is irreversible once this window closes." with an **Undo** restoring everything staged since the view opened.
+- **Back, Escape, and the close control commit the staged set as one mutation before leaving. A failed commit keeps the view open with its staged set intact and shows the error**; pressing the same control again is the retry.
+- **Stored data that fails validation is reported as unreadable and never silently replaced.** Every append fails meanwhile, and closures take the failure path in [Closure](#closure). **Exactly one user-initiated recovery moves the stored data aside — never deletes it — and starts an empty archive** (rationale).
+- **Must revalidate a VS Code recovery inside the storage transaction**; a now-valid or absent archive stays untouched (`vscode-ext/test/notepad-archive-store.test.ts`).
+- **An unknown field anywhere in stored data fails validation**, because every mutation rewrites the whole archive, so a field this build does not know would be erased on the next save (rationale).
+- **Archived entries stay until explicitly deleted.** No age limit and no count limit.
+
+Source of truth: `lib/src/components/NotepadArchiveView.tsx`; the Settings entry in `lib/src/components/SettingsDialog.tsx`.
+
+## Closure
+
+**Every user-visible permanent Surface closure routes through the close coordinator**, which builds stable-id batches from whatever notes exist and appends them in one mutation *before* teardown. Routed: the header kill button, keyboard kills both confirmed and on the untouched fast path, `dor kill`, the Door-restore kill path, and controlled application quit. **A multi-Surface closure appends every batch in one mutation**, and a closure with no notes writes nothing — **unless an earlier attempt of that Surface landed a batch, which the same mutation then deletes**, its notes having been deleted after the user was told none were stored.
+
+**A Surface's notes are frozen from the moment its closure snapshots them until the write settles** — adds, edits, and deletes are refused, a refused capture releases its own markers, and the panel renders read-only behind an "Archiving notes…" line — so nothing taken during the write can be archived stale or dropped unarchived by the forget step (rationale). The freeze is counted, so overlapping closures of one Surface thaw it once. **Empty plain notes are never archived**: an untouched Add New still on screen when the kill lands is not a note, and a Surface holding only those closes as if it held none.
+
+**A terminal Surface's process CWD is refreshed immediately before its batch is built** — every such Surface at once, bounded as one batch at `PROCESS_CWD_REFRESH_MS`, a timeout, refusal, or synchronous lookup error keeping whatever the Session last reported, and **never overriding, or even asking about, a CWD the shell integration reported** — so a shell with no CWD escapes still archives where it was, and no Surface pays for an answer that would be discarded.
+
+**Must route `dor ensure` cancellation and integration-timeout cleanup through `closeSurface`**, archiving notes entered in the temporary pane or retaining it if closure fails. **Must call the immediate-teardown primitive only after the archive question is settled.**
+
+**Must check Helper work before archiving and again before teardown.** If work begins during the write, retain the live notes and pending batch for replacement on retry. The parent's notes stay frozen through both checks. Close anyway discards notes only after the same Helper guard accepts closure.
+
+On a failed archive:
+
+- **A blockable closure keeps the Surface open** behind a pane-anchored error offering **Keep open** (default) and **Close anyway**, which discards that Surface's notes; without the escape an unwritable archive would make every Surface unclosable. **Must perform no new archive write for Close anyway or Quit anyway**: a batch an earlier attempt landed before reporting failure stays in the Archive rather than risking a second refused write.
+- **Refused closures queue, oldest first, one prompt on screen**, so a second refusal cannot orphan the Surface waiting on the first; a Surface already queued has its message replaced.
+- **`dor kill` returns an error, raises no prompt, and the Surface stays** — the caller is a command, not someone looking at the Wall.
+- **An aborted `AbortSignal` suppresses the forget step.** The mutation still finishes, but the live notes stay, so a caller that stopped waiting cannot empty a notepad behind the user; a later close re-archives them once.
+
+**An in-place replacement keeps the notepad instead of archiving it.** Renderer swaps, browser/terminal mode changes, and shell replacement each mint a new Surface id, so the notes migrate with the ref wherever `transferSurfaceRef` runs; pins into the disposed terminal are dropped on the way.
+
+Reserved: Workspace and Window closure has no live code path today (`closeWorkspace` has only test callers and the workspaces flag is dormant), so nothing is wired to it; routing it through the coordinator belongs to the **workspaces-rollout** scope.
+
+Source of truth: `archiveSurfaceNotes` in `lib/src/lib/notepad/close-coordinator.ts`; `closeSurface` and `killPaneImmediately` in `lib/src/components/Wall.tsx`; `NotepadArchiveFailureModal` in `lib/src/components/NotepadArchiveFailure.tsx`; `beginClosing` and `transferNotepad` in `lib/src/lib/notepad/notepad-store.ts`; `useSurfaceClosing` in `lib/src/components/use-notepad.ts`.
+
+## Standalone quit
+
+**Archiving is a gate step before teardown**: after the running-work confirmation, or immediately on an all-idle quit, and **before the first `quit_progress`** (`docs/specs/standalone.md` → "Quit flow"; rationale). **It is bounded at 3 s.**
+
+- **A failure or timeout leaves the quit pending in Rust**, whose phase-2 wait is unbounded for exactly this (`docs/specs/standalone.md` → "Quit flow"), and the dialog shows the error with **Cancel** (default) and **Quit anyway**, which discards the notes. **Only Cancel calls `quit_cancel`**: Quit anyway must reach teardown with the watchdog still armed.
+- **A timeout aborts the archive it stopped waiting for** ([Closure](#closure)).
+- **Must include Surfaces with pending batch IDs even after their last note is deleted**, both when archiving and discarding on Quit anyway; pinned by `standalone/src/quit-notepad.test.ts`.
+- **Teardown's own rule is untouched**: once teardown begins, no failing step prevents exit.
+
+The store is `<app_data_dir>/notepad-archive-v1.json`, **a sibling of `sessions/`, never inside it** — a Surface's notes outlive the window whose closure archived them, so they must not ride the per-window session blob or be swept by `clear_session`. **It is written owner-only and atomically through the same `write_file_atomically` the session snapshot uses** (`docs/specs/security-local.md` → "Persisted state"). **The revision is a hash of the stored bytes, and every load, save and reset holds an exclusive lock on the sidecar `notepad-archive-v1.lock`** — a second Dormouse sharing `app_data_dir()`, a dev build beside the installed app, then conflicts instead of overwriting batches it never read. **Recovery renames it to `notepad-archive-v1.unreadable-<unix-millis>.json` beside the original**, disambiguating rather than overwriting an earlier quarantine; only a temp file a crash left behind is dropped.
+
+Source of truth: `archiveNotesBeforeQuit` in `standalone/src/quit.ts`, the `'archive-failed'` phase in `standalone/src/quit-confirm-store.ts`; `write_notepad_archive_to`, `lock_notepad_archive` and `reset_notepad_archive_at` in `standalone/src-tauri/src/lib.rs`; the port in `standalone/src/tauri-adapter.ts`.
+
+## VS Code lifecycle
+
+**Must store the archive in `<globalStorageUri>/notepad-archive.json`**, atomically replaced with mode `0600` (Windows inherits VS Code's directory ACL). **Must serialize reads, saves, recovery, and teardown mutations across extension hosts**, checking the shared revision under the filesystem lock; pinned by `vscode-ext/test/notepad-archive-file.test.ts`. **Must migrate `globalState` key `dormouse.notepadArchive.v1` only when the file is absent**, retaining a tombstone after recovery so stale caches cannot resurrect it. **Never register the legacy key for Settings Sync.** Recovery preserves the file in a unique sibling quarantine. (rationale)
+
+VS Code can destroy a webview without asking, so the close coordinator may never run. **Every webview therefore mirrors its live notes into extension-host memory**, and a teardown archives from that mirror instead.
+
+- **The mirror holds what a close would archive minus the markers** — notes, Surface title, kind and CWD, plus its pending batch id, each terminal Surface's PTY id, and any archive deletions an open Archive view has staged. **The PTY id is mirror-only and never reaches a batch.**
+- **Must mirror pending batch identity before saving and retain it after the last note is deleted.** Teardown deletes and re-appends that batch; live resume restores its identity. Pinned by `vscode-ext/test/notepad-archive-store.test.ts` and `lib/src/lib/notepad/notepad-store.test.ts`.
+- **A teardown refreshes the mirror's process CWDs while the PTYs are alive** — bounded, and never overriding an integration-reported one — which on an editor-panel disposal is what makes the kill wait for the archive write, and in `deactivate()` puts it ahead of the session flush.
+- **The mirror is memory only, never written to disk, and cleared by an extension restart.** It is a bridge across one disposal, not a draft store.
+- **The mirror is sanitized on the way in**, round-tripped through the archive validator, because a teardown writes it verbatim with no webview left to ask.
+- **Editor-panel disposal (`killOnDispose: true`) and `deactivate()` archive their mirrored notes, best effort**, draining what they take so `deactivate()` cannot write a panel's notes again under a fresh batch id. In `deactivate()` the step sits between the recovery capture and the session flush, bounded (`docs/specs/vscode.md` → "Serialization and restore").
+- **Every router disposal commits and drains that router's staged archive deletions, best effort** — they were promised irreversible once this window closed, and the webview *is* the window. **A live resume is therefore never handed a pending deletion**; `hydrateNotepadFromVolatile` ignores the field.
+- **A `WebviewView` disposal is not a closure.** Its PTYs stay alive, so only its *notes* stay in the mirror for the next resolve.
+- **External tab or window destruction cannot reliably be blocked**, so a storage failure or a forced termination may lose those notes. **Never add a persistent draft mirror to address it.**
+
+Source of truth: `withArchiveFile` in `vscode-ext/src/notepad-archive-file.ts`; `vscode-ext/src/notepad-archive-store.ts` and `vscode-ext/src/notepad-volatile.ts`; the `notepad:*` handlers and the `killOnDispose` archive in `vscode-ext/src/message-router.ts`; the archive step in `deactivate` in `vscode-ext/src/extension.ts`.
+
+## Live resume
+
+**The mirror hydrates exactly one path, a live resume** — a webview re-resolved in the same extension host, including browser-only views with no PTYs. It rides the boot payload beside the recovery commands, claimed by the same pane ids, and **is consumed exactly once**: a second read would be a cold restore's, and **a cold restore must never hydrate live notes** (rationale). An editor panel and an extension restart supply `null`. **Must hydrate browser-only layouts from a present same-host mirror even when the PTY list is empty**, pinned by `lib/src/lib/reconnect.test.ts`.
+
+**Hydration fills only live Surfaces holding no notes yet**, and restores no pins — the markers died with the previous webview's xterm instances.
+
+**Live notes must never enter a restoration path**: not a session snapshot, not Lath persistence, not `localStorage`, not VS Code webview or workspace state. The volatile mirror is the single exception, and only here.
+
+Source of truth: `hydrateNotepadFromVolatile` in `lib/src/lib/notepad/notepad-store.ts`, called from the live-resume branch of `lib/src/lib/reconnect.ts`; `snapshotForLiveResume` in `vscode-ext/src/notepad-volatile.ts`; `readInjectedVolatileNotepad` in `lib/src/lib/vscode-notepad-global.ts`.
+
+## Security
+
+**Captured terminal excerpts, their style data, the Surface title and kind, and the CWD persist in the archive; ordinary scrollback still persists nowhere** (`docs/specs/security-local.md` → "Persisted state"). An excerpt reaches disk only because the user added it to a notepad and then closed that Surface.
diff --git a/docs/specs/notepad.rationale.md b/docs/specs/notepad.rationale.md
new file mode 100644
index 00000000..603af843
--- /dev/null
+++ b/docs/specs/notepad.rationale.md
@@ -0,0 +1,299 @@
+# Surface Notepad — rationale
+
+Evidence for `docs/specs/notepad.md`, keyed by its headings.
+
+## The archive port
+
+The port could have been "hand the host a mutation and let it apply it". It is a
+compare-and-swap instead because the three hosts have nothing in common except
+"store a string": the standalone store is a file behind a Rust command, VS Code's
+is `globalState` behind a message round trip, and the demo's is a variable. Putting
+validation and the mutation in one shared module means one implementation of the
+schema, one of the merge, and hosts that cannot drift from each other — the VS Code
+extension host imports the very same `applyArchiveMutation` for the teardown case
+where no webview is left to ask.
+
+That choice forces the revision token: without one, two webviews (a VS Code window
+with the panel and an editor tab both open) each read, apply, and write, and the
+later write silently drops the earlier one's batch. A token plus a retry costs one
+extra read on the rare collision and loses nothing. The retry is only safe because
+mutations are idempotent: the `'conflict'` loop re-applies the same mutation object,
+so batch id alone covers it.
+
+A closure attempt that reaches the host, lands, and *then* reports failure (the VS
+Code adapter's request timeout does exactly this) leaves the user looking at a
+Surface that is still open, so they keep working in it. A fresh batch id per
+attempt with dedupe by note id kept the notes added since, but not an edit to one
+already stored: the second batch's copy was recognized by id and dropped, so the
+archive kept the pre-edit text and `removeSurface` then discarded the edit.
+Remembering the id and deleting it in the very mutation that re-appends it replaces
+the batch wholesale instead, so edits, additions, and the user's own deletions all
+survive. That is why deletes apply before appends, and why the note-id dedupe is
+computed after them — otherwise the batch being replaced would still count as
+storing its own notes. The dedupe stays because the VS Code mirror path mints a
+fresh id per teardown and has nothing to address an earlier write by; a note id is
+a UUID, so "already stored" is an exact test there rather than a heuristic.
+
+`MAX_SAVE_ATTEMPTS` is 5. An unbounded retry against an archive somebody else is
+rewriting in a loop would spin instead of telling the user, and the closure paths
+need a decision — "keep this Surface open" — rather than a hang.
+
+## Capture
+
+Copy Rewrapped exists to make terminal output paste well into a chat window: it
+drops frame-only lines, strips box-drawing runs, and joins paragraphs. That is the
+wrong transform for a note. A captured excerpt is kept to be looked at again later,
+often next to the terminal it came from, and often *because* of its shape — a table,
+a tree, a diff. Rewrapping would destroy exactly what made it worth keeping. So the
+capture joins soft-wrapped rows (undoing display wrapping, which is not content)
+and does nothing else.
+
+Trailing whitespace is trimmed only on rows that end hard for the same reason
+`extractSelectionText` does it: a soft-wrapped row is full by definition, so its
+trailing spaces are content that the next row continues from, while a hard-ended
+row's trailing spaces are just the rest of the terminal grid.
+
+Colors record what xterm *drew* rather than what the program *said*. The alternative
+— record palette index 1 and re-resolve it at render time — sounds more faithful
+but produces a note that does not match the screenshot in the user's memory: with
+`drawBoldTextInBrightColors` on (xterm's default) bold red is drawn as bright red,
+and a note showing plain red beside a terminal showing bright red reads as a bug.
+The same argument settles inverse: the swap is baked in, with the defaulted side
+made explicit, because a note that inverts at render time against a *different*
+theme inverts to different colors.
+
+Palette entries 0–15 are read from the live theme and 16–255 computed, because the
+first sixteen are the user's and the rest are a fixed formula xterm itself applies.
+
+## Source links
+
+The pin could have stored a scrollback line number. It stores two xterm markers
+because a marker is the only handle xterm keeps correct as the buffer scrolls, and
+scrolling is the normal case — a capture is usually of something that has already
+moved up the screen.
+
+Markers alone are not enough, though: they track lines, not columns, and a resize
+reflows the buffer under them. Rather than reimplement reflow tracking, the pin
+carries the raw text it captured and refuses to navigate unless the rebuilt range
+reads back byte for byte. That turns every failure mode — reflow, trimmed
+scrollback, a program that overwrote the rows — into one honest outcome instead of
+scrolling the user to plausible-looking wrong output. It is why column restoration
+is allowed to be best effort at all.
+
+Failure removes the pin rather than leaving it to fail again. A pin the user can
+see is one that resolved the last time it was asked, which is a more useful promise
+than a button that sometimes apologizes.
+
+The alternate buffer is the one failure that is not about the capture. A
+full-screen program covers the normal buffer rather than rewriting it, so the
+markers stay live and the range is still there underneath; the earlier code let
+the out-of-range rows fall through to the same removal as a dead pin, which meant
+opening a note while `less` was up destroyed the link for good. Checking the
+buffer type first separates "hidden right now" from "gone", and only the second
+is worth spending the pin on.
+
+## Notepad UI
+
+`beforeinput` is the whole mechanism behind "the first content mutation converts".
+It is the one event that names *what* the edit is (`inputType`) for typing,
+deletion, cut, and paste alike, and it fires before the DOM changes, so the handler
+can cancel it, apply the same edit to the note's plain text, and hand that to the
+store — one transition instead of a converted note plus a lost keystroke. React's
+synthetic `onBeforeInput` cannot be used: it is built from composition and
+`textInput` events, carries no `inputType`, and never fires for a deletion.
+
+Caret movement and selection deliberately do not convert, because reading a rich
+note is the common case and losing its colors to a stray arrow key would be a
+surprise the user cannot undo.
+
+### The chord on hosts that do not own their keyboard
+
+Cmd/Ctrl+N in an ordinary browser tab opens a new window before any listener runs;
+`preventDefault` does not stop it. A demo that showed `Cmd+N` next to "Add to
+notepad" would therefore advertise a shortcut that spawns a window and (sometimes)
+also adds a note. `browserReservesNotepadChord` lets the adapter say "this build
+runs in a browser I do not own", in the style of `hostOwnsTheme`, so the button
+stays and the shortcut label and binding both disappear. The shipped Tauri and VS
+Code builds own their keyboards and leave it unset.
+
+The chord is gated on a finalized selection for the same reason Ctrl+C is: with no
+selection, Ctrl+N is readline's next-history and must reach the program.
+
+## Archive
+
+An unreadable archive is the one place the app could destroy user data by being
+helpful. Starting fresh over a file that failed to parse is what most stores do,
+and it is unrecoverable — the bytes may be a JSON syntax error one character wide
+with a hundred notes behind it. So validation failure is a *state*, not a repair:
+every append fails, closures take their failure path, and the Archive view says
+plainly that nothing was replaced. Recovery is a single explicit button, and it
+moves the data aside rather than deleting it, because only a human can judge
+whether what is in there is worth salvaging.
+
+Rejecting unknown fields rather than projecting them away is the same instinct
+once more. A reader that keeps the fields it knows and drops the rest looks
+forgiving, but every mutation loads, applies, and writes the *whole* archive
+back, so the first save after a downgrade would quietly delete whatever a newer
+build had stored — notes included, if the newer shape carried them in a field
+this one does not have. `version` cannot cover it: it guards breaking changes,
+and additive fields are exactly the ones a newer build ships without bumping it.
+Refusing turns that into the unreadable state above — visible, and with the data
+still on disk — instead of silent loss.
+
+Staged deletion, rather than immediate, follows from the same instinct in the
+opposite direction: the archive is where things go to be found weeks later, so a
+misclick must be cheap. Holding the set in view state costs nothing, makes Undo
+free, and means a failed write leaves the view exactly as it was — the retry is
+pressing Back again.
+
+## Closure
+
+Refused closures queue rather than sharing one slot because a Surface with an
+unanswered prompt is a Surface the user cannot close. With one slot, killing a
+second Surface while the first prompt was up replaced it, and the first Surface was
+left holding its notes with nothing on screen left to answer for it.
+
+`dor kill` takes the error and raises no prompt because its caller is an agent or a
+script, not someone looking at the Wall: a modal there blocks a window nobody is
+watching, and the command already answers with the reason.
+
+The freeze exists because the coordinator snapshots the notes, awaits the host, and
+*then* forgets them, and the panel stayed interactive across that await. A note
+added in between was deleted having never been archived. An edit was worse: the
+batch already held the pre-edit text, so the archive kept a stale copy and the
+forget step took the edit with it. Refusing the mutations is what makes the
+snapshot and the forget describe the same notes; a counted freeze rather than a
+flag is because two closures of one Surface can overlap (a kill retried while the
+quit gate is closing everything), and the first to finish must not thaw notes the
+second is still writing.
+
+The process CWD is asked for at closure rather than tracked continuously because
+it is only knowable while the PTY is alive and only *needed* when a batch is about
+to be written. Without it a shell that emits no CWD escape — `cmd.exe`, a bare
+`sh`, anything without shell integration — archived `cwd: null` while the host
+could have inspected the live process, which is the same fallback the VS Code
+session-save path already uses per pane. It is bounded because the refresh sits
+between a kill keystroke and the teardown it triggers: a host that never answers
+must not hold a Surface open, and what it returns is metadata, so a timeout just
+keeps whatever the Session last reported.
+
+## Standalone quit
+
+The gate sits before the first `quit_progress` rather than inside the teardown
+because teardown has a standing rule that no failing step prevents exit — that rule
+is what keeps a wedged flush from stranding the app. Archiving needs the opposite:
+a failure has to be able to stop the quit and ask. Before `quit_progress` the flow
+is still in the phase Rust's watchdog does not bound (a human may be looking at the
+confirmation dialog), so the dialog can offer Cancel / Quit anyway. Once teardown
+starts, nothing may ask a question again.
+
+The failure path leaves the pending quit alone rather than cancelling it, because
+`quit_cancel` bumps `seq` and retires the live watchdog: cancelling before the
+dialog went up meant a later Quit anyway ran the whole teardown unwatched, with
+nothing left to force the exit if the webview wedged. Phase 2's wait is unbounded
+precisely so it can sit through a human's decision, so the quit stays pending and
+only Cancel — the branch that really does abandon the quit — invokes it.
+
+The deadline aborts the archive it stopped waiting for because `withDeadline` only
+stops the *waiting*. The write keeps going, and a success arriving minutes later
+called `removeSurface` on every Surface — emptying every notepad in front of a user
+who had just been told the notes were not stored and had chosen Cancel.
+
+3 s is the bound because the write is one small file and the user is waiting on a
+quit they already asked for; a slower answer is a failure worth surfacing.
+
+The file is a sibling of `sessions/` rather than a member of it because the two have
+different lifetimes: session snapshots are per window and swept by `clear_session`,
+while archived notes outlive the window that produced them and must survive that
+sweep. They share `write_file_atomically` because both carry user text and both
+must survive a crash mid-write; that is one implementation, not two.
+
+The revision was a process-local counter until it turned out two processes can hold
+this file: `app_data_dir()` is keyed by the Tauri identifier, which `pnpm
+dev:standalone` shares with the installed app, and a counter tracks only its own
+process's writes — so the loser of an overlapping load→save reported no conflict and
+dropped the winner's batches. A content hash is what two processes agree on without
+talking, where an mtime is coarse on some filesystems and moves for reasons that are
+not a content change; `DefaultHasher` is used because it is fixed-key rather than
+randomly seeded, so a second process and a second run derive the same token from the
+same bytes. The lock is a separate file rather than the archive's own inode because
+every save replaces the archive by rename, leaving a holder locking an inode nobody
+will open again. The exposure it closes is the load→save window rather than a torn
+write — `write_file_atomically` already ruled that out — since both processes re-read
+the file on every mutation, and without an exclusive holder the compare and the
+rename interleave.
+
+## VS Code lifecycle
+
+VS Code destroys a webview whenever it likes — an editor tab closed, a window gone,
+a panel dragged between containers — and gives the extension no veto and no
+reliable "about to be destroyed with these notes" hook. The close coordinator
+therefore cannot be the only path. The mirror is the smallest thing that closes the
+gap: the webview pushes what a close *would* archive after every change, and the
+two endings the extension host *does* see (a `killOnDispose` router disposal, and
+`deactivate()`) archive from it.
+
+It is memory only, and that is the point rather than a limitation. A file-backed
+draft store would be a second archive with its own staleness, its own recovery
+story, and its own disclosure — captured terminal excerpts on disk that no closure
+ever wrote. Module state cleared by an extension restart is exactly the lifetime
+the mirror needs: one disposal wide.
+
+The snapshot is round-tripped through `readNotepadArchive` on the way in because a
+teardown writes it verbatim into the archive with no webview left to validate it,
+and one malformed note would make the whole archive unreadable on the next load.
+
+Staged archive deletions leave on *every* disposal, not only a killing one, because
+the promise the Archive view makes when it stages them is "irreversible once this
+window closes" — and for the user the webview *is* the window. A `WebviewView`
+dragged between containers is disposed and re-resolved, and keeping the staged set
+meant the new view showed a batch the user had already deleted, still offering
+Undo, which `deactivate()` would then delete for real hours later. Committing at
+the disposal makes the promise true and leaves nothing pending to hand a resume.
+
+The mirror carries a PTY id purely so a teardown can ask where each process is: the
+extension host knows nothing of Surface ids, and `ptyManager.getCwd` answers for the
+Session id the webview spawned under. On an editor-panel disposal the kills moved
+*after* the archive write for that one reason — the loop used to run first, so by
+the time the refresh asked, the PTY it was asking about was already dead. Every
+other bookkeeping step in that disposal stayed synchronous and where it was; only
+the kills wait, and they run in a `finally`, so a failed write still kills them.
+
+The original `globalState` store was workspace-independent but cached separately
+in every extension host. A process-local queue and revision counter therefore
+accepted a stale save from another window, dropping the first window's batch
+(reproduced 2026-09). The shared file supplies authoritative bytes and revision;
+the filesystem lock covers migration, comparison, and replacement. Its envelope
+keeps an explicit absent value after recovery so another host's legacy cache
+cannot re-import the quarantined data. A unique revision on every write also
+recognizes writes that restore identical content.
+
+The lock publishes a nonempty directory atomically. Its unique owner filename
+lets a reaper remove only a dead owner's entry; a delayed reaper cannot remove a
+new owner's nonempty directory. A live process is never evicted by age, since a
+paused extension host could finish its write after another owner acquired the
+lock. Contention fails after two seconds. PID reuse may delay reaping until that
+process exits, preserving exclusion.
+
+## Live resume
+
+The mirror hydrates a live resume and nothing else because a live resume is the one
+case where the notes and the Surfaces they belong to are both still real: any PTYs
+never died, the pane ids are the same, and the webview that vanished was a
+rendering detail. A cold restore is the opposite — the PTYs are gone, the Surfaces
+are rebuilt from a saved snapshot, and any notes still in memory belong to a
+previous life of the application. Hydrating there would resurrect notes for
+Surfaces the user already ended, which is worse than losing them.
+
+`loadVolatile()` is consumed exactly once for that reason: a second read could only
+be a later, colder boot's.
+
+The mirror is served non-destructively (the resuming webview re-reports the notes
+under its own router, re-establishing ownership) so that a webview which boots and
+then crashes before its first sync still has its notes archived by `deactivate()`.
+
+A browser-only view has no PTY to mark its resume as live. Its volatile mirror is
+still evidence of the same extension-host lifetime: a restart clears that module
+state and supplies no mirror. Rebuilding the browser layout before hydration
+preserves both visible and minimized browser notes, while terminal cold restores
+still never consume the mirror.
diff --git a/docs/specs/security-local.md b/docs/specs/security-local.md
index 4b5690a0..58407e0b 100644
--- a/docs/specs/security-local.md
+++ b/docs/specs/security-local.md
@@ -146,11 +146,18 @@ persisted"): `normalizeSessionV3` strips it on read, and the standalone store is
 switched off today, clearing any legacy snapshot at boot. Snapshots older
 versions left behind do carry transcripts (rationale).
 
+**The notepad archive is the one store holding terminal text on purpose** —
+excerpts the user explicitly captured, their colors, the Surface title and kind,
+and the CWD at closure, appended only by a Surface closing
+(`docs/specs/notepad.md` -> "Archive"). Standalone keeps it as
+`<app_data_dir>/notepad-archive-v1.json`, owner-only; VS Code keeps it in
+`<globalStorageUri>/notepad-archive.json`, mode `0600` on Unix and inheriting VS Code's directory ACL on Windows. Migration and Settings Sync follow `docs/specs/notepad.md` -> "VS Code lifecycle". Its live half never reaches disk.
+
 **VS Code persists pane structure in VS Code's own storage** — `workspaceState`
 under `dormouse.session`, and `vscode.setState()`, a WebviewPanel's only store —
 so the modes there are VS Code's, not ours, and no transcript reaches either
-(`docs/specs/vscode.md` -> "Serialization and restore"). Dormouse writes one file
-of its own there, `recovery.json`, at the umask: one rebuilt agent-resume
+(`docs/specs/vscode.md` -> "Serialization and restore"). Dormouse also writes
+`recovery.json` there, at the umask: one rebuilt agent-resume
 invocation per Surface, no buffer, unlinked as it is read
 (`docs/specs/vscode.md` -> "Capturing agent recovery").
 
@@ -166,7 +173,8 @@ lands at the umask — readable by another local account wherever `<tmpdir>` is
 shared (rationale). No log call carries PTY bytes; the `dor` control socket path
 does. A gap, not an accepted risk.
 
-- **FAIL IF** `write_session_to` in `standalone/src-tauri/src/lib.rs` stops restricting the `sessions/` directory and the snapshot to the owning user on **every** platform `restrict_to_owner` has an arm for — `0700`/`0600` on unix, and on Windows a DACL protected from inheritance carrying exactly one ACE for the current user, asserted by `restrict_to_owner_leaves_one_owner_only_ace`. `session_write_tightens_directory_and_existing_temp_file` pins unix modes; `session_permission_failures_preserve_previous_snapshot_without_writing_bytes` pins both failure gates. The mode reaches the temp file *before* any bytes are written (rationale).
+- **FAIL IF** `write_file_atomically` in `standalone/src-tauri/src/lib.rs` stops restricting the directory and the file it writes to the owning user on **every** platform `restrict_to_owner` has an arm for — `0700`/`0600` on unix, and on Windows a DACL protected from inheritance carrying exactly one ACE for the current user, asserted by `restrict_to_owner_leaves_one_owner_only_ace` — or if either of its two callers, `write_session_to` (the session snapshot) and `write_notepad_archive_to` (the notepad archive), stops going through it. `session_write_tightens_directory_and_existing_temp_file` pins unix modes; `session_permission_failures_preserve_previous_snapshot_without_writing_bytes` pins both failure gates. The mode reaches the temp file *before* any bytes are written (rationale).
+- **FAIL IF** the VS Code notepad archive key — `NOTEPAD_ARCHIVE_KEY` in `vscode-ext/src/notepad-archive-store.ts` — is passed to `context.globalState.setKeysForSync`, directly or as part of any list. It holds captured terminal excerpts, their CWDs, and their Surface titles, and Settings Sync would copy them to every machine the account signs into. Nothing in the extension calls that API today, so the rule is kept by that call not existing; a call added for anything else must exclude this key.
 
 Source of truth: `SESSION_STATE_KEY` in `vscode-ext/src/session-state.ts`,
 `ensureToken` in `vscode-ext/src/peer-link.ts`, `default_log_path` in
diff --git a/docs/specs/security.md b/docs/specs/security.md
index 06a8545d..c2937753 100644
--- a/docs/specs/security.md
+++ b/docs/specs/security.md
@@ -35,7 +35,7 @@ last column means nothing cheaper does.
 | **A page in a browser pane cannot forge a host message.** In VS Code every host message carries a per-boot token it cannot read, and the standalone adapters have no inbox for it to post to. | [Browser panes](./security-local.md#browser-panes) | `lib/src/lib/platform/vscode-adapter.test.ts` |
 | **Only your own account can drive your terminals through `dor`.** The socket sits in a directory only you can open, and its token never crosses the wire. | [The dor control socket](./security-local.md#the-dor-control-socket) | `standalone/sidecar/dor-control-server.test.js` |
 | **A loopback listener grants a stranger nothing it could not get from the upstream directly.** | [Loopback Listeners](./security-local.md#loopback-listeners) | `scripts/loopback-lint.mjs` |
-| **Current persistence writers never save terminal scrollback.** Standalone snapshots are owner-only; VS Code controls access to its own storage. Older snapshots may contain transcripts. | [Persisted state](./security-local.md#persisted-state) | audit |
+| **Current persistence writers never save terminal scrollback.** Standalone snapshots are owner-only; VS Code controls access to its own storage. Older snapshots may contain transcripts. Explicitly captured notepad excerpts, titles, and working directories are archived on Surface closure. | [Persisted state](./security-local.md#persisted-state) | audit |
 | **Nothing but a human at the laptop can authorize a phone.** The only path into a Burrow's ACL is typing, on that Burrow, the two digits the phone shows, and the Burrow makes every access decision. | [Pairing](./remote-security-model.md#pairing), [Burrow Authorization](./remote-security-model.md#burrow-authorization) | `remote-lib-common/test/security-guarantees.test.mjs` |
 | **The Relay cannot read ceremony or terminal content or grant terminal access.** One end-to-end channel per ceremony carries content under keys the Relay never holds; account data and routing metadata remain visible. | [Trust Model](./remote-security-model.md#trust-model), [Residual metadata](./remote-security-model.md#residual-metadata) | `scripts/e2e-lint.mjs` |
 | **Push notifications are opt-in, and a push is sealed to the one phone that receives it.** | [Push sealing](./remote-security-model.md#push-sealing) | `remote-lib-common/test/push-seal.test.mjs` |
diff --git a/docs/specs/shortcuts.md b/docs/specs/shortcuts.md
index 9285ebc4..b820bc66 100644
--- a/docs/specs/shortcuts.md
+++ b/docs/specs/shortcuts.md
@@ -47,6 +47,7 @@ Both modes, ahead of the passthrough gate, and only on a terminal **selected** S
 | *(any other key)* | — | Swallowed during a terminal-handled drag, never reaching the inside program (`docs/specs/mouse-and-clipboard.md` §3.6). |
 | `⌘C` (macOS) / `Ctrl+C` (others) | Copy raw | Copy the selection as-is; requires a finalized selection. |
 | `⌘⇧C` (macOS) / `Ctrl+Shift+C` (others) | Copy rewrapped | Copy the selection rewrapped for single-line display. |
+| `⌘N` (macOS) / `Ctrl+N` (others) | Add to notepad | Capture the finalized selection as a note on that Surface; unbound where the browser reserves the chord (`docs/specs/notepad.md`). |
 | `⌘V` / `⌘⇧V` / `Ctrl+V` / `Ctrl+Shift+V` | Paste | Paste into the terminal; the `Ctrl` variants are intercepted on every platform, macOS included. |
 
 On macOS `Ctrl+C` still reaches the running program; a literal `0x16` needs the shell's `quoted-insert` (`Ctrl+Q`) (`docs/specs/mouse-and-clipboard.md` §8.3).
diff --git a/docs/specs/standalone.md b/docs/specs/standalone.md
index 3082634a..6ea82383 100644
--- a/docs/specs/standalone.md
+++ b/docs/specs/standalone.md
@@ -339,6 +339,12 @@ window, `<app_data_dir>/sessions/<label>.json`:
 - No WAL to grow, and rewriting the same path bounds the on-disk size to one
   blob (rationale).
 
+**The notepad archive is a sibling of `sessions/`, not a member of it** —
+`<app_data_dir>/notepad-archive-v1.json`, its own compare-and-swap commands and
+its own lifetime, so `clear_session` never sweeps it
+(`docs/specs/notepad.md` -> "Standalone quit"). Both stores write through the one
+`write_file_atomically`.
+
 **Must restrict the session store to the owner before any bytes are written**
 (`docs/specs/security-local.md` -> "Persisted state"; rationale).
 `restrict_to_owner` sets `0700` on the directory and `0600` on the temp file
@@ -399,13 +405,20 @@ Tauri-only) responds:
 
 1. **Always `quit_ack`** first (fire-and-catch), so phase 1 stands down even if
    the orchestrator then dedupes the event out.
-2. **`quit_progress`** when teardown begins — immediately on an all-idle quit, or
-   after the user confirms — setting `tearing_down` and bumping a `progress`
-   counter. Sent again at the install phase boundary.
-3. The teardown (below), then **`quit_proceed`** — sets `approved` and calls
+2. **Archive the notepads**, bounded at 3 s, *before* the first `quit_progress` —
+   the last point at which a failure may still ask a question, since teardown may
+   not (`docs/specs/notepad.md` -> "Standalone quit"). Failure or timeout leaves
+   the quit **pending**: its dialog is another human decision, which phase 2 is
+   unbounded for.
+3. **`quit_progress`** when teardown begins — immediately on an all-idle quit, or
+   after the user confirms and the archive gate passes — setting `tearing_down`
+   and bumping a `progress` counter. Sent again at the install phase boundary.
+4. The teardown (below), then **`quit_proceed`** — sets `approved` and calls
    `app.exit(0)`.
-4. A confirmation-dialog cancel (below) calls **`quit_cancel`** — bumps `seq`,
-   invalidating the live watchdog, and leaves the app running.
+5. A confirmation-dialog cancel (below), or a **Cancel** on the archive-failure
+   dialog, calls **`quit_cancel`** — bumps `seq`, invalidating the live watchdog,
+   and leaves the app running. **Nothing else cancels**: a Quit anyway must reach
+   teardown with the watchdog still armed.
 
 A cloned-`AppHandle` **watchdog** thread keeps quit bounded against a dead or
 wedged webview, in three phases:
@@ -453,7 +466,10 @@ Source of truth: `standalone/src/quit-confirm-store.ts` (the module store + gate
 `standalone/src/QuitConfirmModal.tsx` (the modal).
 
 **Teardown ordering (`runQuitTeardown`), and why.** Wrapped in an 8 s ceiling, with
-**every step individually bounded** so a stall cannot wedge quit:
+**every step individually bounded** so a stall cannot wedge quit. The notepad
+archive is **not** a step here: it runs ahead of `quit_progress` precisely because
+teardown's rule below holds — no failing step prevents exit — and archiving must be
+able to stop the quit (`docs/specs/notepad.md` -> "Standalone quit"):
 
 1. `requestSessionFlush` — save while PTYs are alive, so CWDs are fresh.
 2. `gracefulKillAllPtys` — SIGTERM every PTY, resolving early once all exit and
diff --git a/docs/specs/terminal-context.md b/docs/specs/terminal-context.md
index d0bee812..a39d6393 100644
--- a/docs/specs/terminal-context.md
+++ b/docs/specs/terminal-context.md
@@ -7,7 +7,7 @@
 
 ## Helper lifecycle
 
-- **Must create at most one helper per source, lazily on first context opening.** Concurrent openings share the same pending creation. Closing the source during startup cancels creation. Helpers cannot have helpers.
+- **Must create at most one helper per source, lazily on first context opening.** Concurrent openings share the same pending creation. Closing the source during startup cancels creation, including while its registry entry remains for the exit animation. Helpers cannot have helpers.
 - **Must start with the configured shell in the source's local directory**, using the ordinary split fallback when unavailable. Shell exports and virtual environments are not inherited. SSH integration is outside this feature.
 - **Must inject autorun only after integrated shell readiness**, accepting prompt-start and prompt-end/editing states with no current command. User input before injection cancels it. After eight seconds without readiness, show an unsupported state and never write a timeout fallback.
 - **Must treat typing, paste, accepted drops, and application mouse input as user work**, disarming automatic refresh until Reset or Promote. Selection, copying, resize, and terminal protocol replies do not count. Returning to idle does not rearm autorun.
@@ -29,13 +29,15 @@
 
 **Must make Reset an explicit discard**, confirming loss of scrollback, unfinished input, running programs, and unsaved edits. Cancellation changes nothing; confirmation disposes the old helper and launches a fresh one using the source's current directory and current global setting. Stale timers cannot write to the replacement.
 
-Source of truth: `openHelper` / `helperHasWork` / `disposeHelper` in `lib/src/lib/helper-terminal.ts`; `markSessionTouched` / `unmountElement` in `lib/src/lib/terminal-lifecycle.ts`; `TerminalContextView` in `lib/src/components/wall/TerminalContextView.tsx`. Tests: `lib/src/lib/helper-terminal.test.ts`.
+Source of truth: `openHelper` / `helperHasWork` / `disposeHelper` / `closeHelperParent` in `lib/src/lib/helper-terminal.ts`; `markSessionTouched` / `parkElement` in `lib/src/lib/terminal-lifecycle.ts`; `TerminalContextView` in `lib/src/components/wall/TerminalContextView.tsx`. Tests: `lib/src/lib/helper-terminal.test.ts`.
+
+Notepad sharing and pin restrictions follow `docs/specs/notepad.md` → "Helper terminals".
 
 ## Promotion and source closure
 
 **Must promote the actual Session into a regular split beside its source**, preserving the PTY, xterm, scrollback, directory, partial input, and identity. Cancel pending autorun, close context, assign the public Surface ref, and focus the promoted terminal. Failed placement restores auxiliary host ownership. The source's next opening creates a new helper.
 
-**Must reject Reset and duplicate Promote during ownership transfer**, including from a reopened context. A failed transfer or rollback reports its error and resumes inspection so promotion can be retried.
+**Must reject Reset, source retirement, and duplicate Promote during ownership transfer**, including from a reopened context. A failed transfer or rollback reports its error and resumes inspection so promotion can be retried.
 
 **Must close an idle helper with its source**, even when it has user input or scrollback. The idle shell itself is not running work. Existing source-work confirmation remains applicable.
 
@@ -43,7 +45,7 @@ Source of truth: `openHelper` / `helperHasWork` / `disposeHelper` in `lib/src/li
 
 **Must include hidden helper work in shutdown checks.** The helper's host inspection also detects background descendants; unresolved inspection, including a process table missing the live PTY process, counts conservatively as work. Minimizing the source hides its context and retains the helper.
 
-Source of truth: `beginPromotion` / `cancelPromotion` / `finishPromotion` / `helperHasWork` in `lib/src/lib/helper-terminal.ts`; `helperBlocksClose` / `contextActions` in `lib/src/components/Wall.tsx`; `countRunningSessions` in `lib/src/lib/terminal-state-store.ts`.
+Source of truth: `beginPromotion` / `cancelPromotion` / `finishPromotion` / `helperHasWork` in `lib/src/lib/helper-terminal.ts`; `closeSurface` / `requestKill` / `contextActions` in `lib/src/components/Wall.tsx`; `countRunningSessions` in `lib/src/lib/terminal-state-store.ts`.
 
 ## Global autorun setting
 
diff --git a/docs/specs/transport.md b/docs/specs/transport.md
index 4e80740a..bb00c2b3 100644
--- a/docs/specs/transport.md
+++ b/docs/specs/transport.md
@@ -92,7 +92,9 @@ VS Code's `pty-manager` keeps two buffers plus one counter per PTY. **Must cap e
 
 **Seeded titles reject the sentinels.** Saved pane and door titles come back through `setTerminalUserTitle()`, which rejects the reserved `<idle>` prefix (`docs/specs/terminal-state.md` → Supported OSC Inputs), and the seed callers in `terminal-lifecycle.ts` additionally skip `<unnamed>`, the default panel placeholder (rationale).
 
-**Cold restore** (no live PTYs) falls back to saved session state: new PTYs in the saved CWDs under the currently selected Dormouse shell, plus the saved Lath layout. No transcript is replayed ("What is persisted"), and any pane carrying a recovery command auto-runs it. `reconnect.ts` waits 500 ms for the PTY list.
+**Must follow `docs/specs/notepad.md` → "Live resume" for browser-only resumes.**
+
+**Cold restore** (neither live PTYs nor a browser-only resume) falls back to saved session state: new PTYs in the saved CWDs under the currently selected Dormouse shell, plus the saved Lath layout. No transcript is replayed ("What is persisted"), and any pane carrying a recovery command auto-runs it. `reconnect.ts` waits 500 ms for the PTY list.
 
 ## Message protocol
 
@@ -171,7 +173,7 @@ Source of truth: `PersistedSession` in `lib/src/lib/session-types.ts`; `surfaceR
 
 ### What is persisted
 
-Structure only: panes (id, cwd, title, `untouched`, `surfaceType`, TODO/alert blob), doors and their Lath restore tokens, the Lath layout, and the Workspace's `dor` surface refs. **Scrollback is never persisted by any writer**, and neither is the recovery command (above).
+Structure only: panes (id, cwd, title, `untouched`, `surfaceType`, TODO/alert blob), doors and their Lath restore tokens, the Lath layout, and the Workspace's `dor` surface refs. **Scrollback is never persisted by any writer**, and neither is the recovery command (above). **Live notepad notes are never persisted here either** — the notepad archive is a separate per-host store written only by a closure (`docs/specs/notepad.md` → "Live resume").
 
 ### Retiring the transcripts already on disk
 
@@ -196,6 +198,8 @@ something ends it:
 | VS Code editor-tab close (`killOnDispose: true`) | Yes | Fresh for that panel |
 | VS Code extension-host crash | No, but `deactivate()` never ran | Fresh |
 
+Ending something deliberately is also what *keeps* its notes: **a deliberate closure archives the Surface's notepad before teardown** (`docs/specs/notepad.md` → "Closure"), so the one thing a user asked to hold on to survives the boundary that discards everything else.
+
 **Standalone therefore persists no Session state at all**, and the write path itself
 is removed rather than written-then-ignored (rationale). Sessions still survive a
 reload — resume reads the sidecar's live PTY list, not disk — but the layout does
diff --git a/docs/specs/vscode.md b/docs/specs/vscode.md
index 272a96c1..6797f7ae 100644
--- a/docs/specs/vscode.md
+++ b/docs/specs/vscode.md
@@ -31,6 +31,7 @@ The webview is the shared `lib/` frontend, unmodified for this host (`docs/specs
 - **WATCHING rules are host-authoritative.** The first webview after extension-host startup seeds the shared host rule set and **no later webview may replace it**.
 - **Never let a resuming router steal another webview's PTYs.** Each router tracks its PTYs in `ownedPtyIds`; a module-level `globalOwnedPtyIds` set enforces it.
 - **Every save path must merge current alert states through the shared persistence projection.** The frontend periodic save (`onSaveState`) and the backend deactivate refresh (`refreshSavedSessionStateFromPtys`) both narrow alerts with `toPersistedAlertState`; missing the merge reverts alert state on restore, while passing live state through persists transient fields.
+- **Must reserve a closing router's PTYs until its deferred kills finish**, so another router cannot claim them during archive/CWD work; pinned by `vscode-ext/test/message-router.test.ts`.
 - **retainContextWhenHidden.** Set on both `WebviewPanel` and `WebviewView` so xterm.js DOM, scrollback, and PTY subscriptions survive panel hide/show without a resume.
 - **Two save sources must produce consistent state**: the frontend's periodic `dormouse:saveState` and the backend's deactivate flush-then-refresh.
 - **Every host → webview send carries the message token**, and **never add a `message` listener that skips `isHostMessage`**.
@@ -65,9 +66,11 @@ Consequences:
 - Hiding or toggling the Dormouse panel neither kills its PTYs nor destroys sessions.
 - **Closing an editor-tab `WebviewPanel` is not hiding it.** `setupPanel` attaches
   its router with `killOnDispose: true`, so disposal kills that panel's owned PTYs
-  and VS Code discards the tab's per-panel state. **The `WebviewView` router is
-  attached without that flag**: its `onDidDispose` releases the router and leaves
-  the PTYs alive.
+  and VS Code discards the tab's per-panel state — and archives that router's
+  mirrored notepad notes, since no close coordinator will run
+  (`docs/specs/notepad.md` → "VS Code lifecycle"). **The `WebviewView` router is
+  attached without that flag**: its `onDidDispose` releases the router, leaves the
+  PTYs alive, and **leaves its mirrored notes in place for the next resolve**.
 - Each VS Code window gets its own extension host, and therefore its own pty-host child process.
 
 ### Workspaces
@@ -123,9 +126,13 @@ A `WebviewPanelSerializer` registered under the `dormouse` view type restores ed
    external-process time overlaps the capture. **Its rejections are absorbed:** a
    throw out of the join would skip the flush, the refresh, and both kills.
 2. `captureAgentRecoveryCommands(context, 1200)`.
-3. `flushAllSessions(1000)` — ask every webview to save now, bounded.
-4. `refreshSavedSessionStateFromPtys()` — re-read CWD while the processes are alive.
-5. `gracefulKillAll(2000)` (SIGTERM, wait), then `killAll()` (force).
+3. Refresh the mirror's process CWDs against the still-live PTYs, then archive
+   the volatile notepad mirror, both bounded — the last chance for notes no
+   close coordinator will ever reach (`docs/specs/notepad.md` → "VS Code
+   lifecycle").
+4. `flushAllSessions(1000)` — ask every webview to save now, bounded.
+5. `refreshSavedSessionStateFromPtys()` — re-read CWD while the processes are alive.
+6. `gracefulKillAll(2000)` (SIGTERM, wait), then `killAll()` (force).
 
 **Recovery must go first** — the resume hint exists only between the interrupt and
 the kill, and the shutdown budget is not ours (rationale), so the one step whose
@@ -135,11 +142,17 @@ live PTY, waits bounded, scans those buffers, and records the invocation to
 `recovery.json` under `context.storageUri`, **written synchronously and replaced
 temp-then-rename**. **Never `workspaceState`**, whose SQLite flush is already
 tearing down (rationale), and **never `PersistedPane.resumeCommand`**, which the
-step-3 flush would overwrite with the webview's stale copy. **The record is
+step-4 flush would overwrite with the webview's stale copy. **The record is
 rewritten the moment each command is found and every wait is bounded**, so being
 killed mid-poll costs at most a late agent's command and a timeout loses a
 recovery command rather than delaying shutdown.
 
+**Live notepad notes are never in any of this.** They ride a volatile in-memory
+mirror the extension host keeps per webview, archived by the disposals above and
+handed back on a live resume through its own boot global beside the recovery
+commands — **a `WebviewView` re-resolve only, never a deserialized panel and never
+a cold restore** (`docs/specs/notepad.md` → "Live resume").
+
 **On activate**, saved state loads through `readPersistedSession()`
 (`docs/specs/transport.md` → "Persisted session types") and is passed to routers
 for cold-start restore. The WebviewView and each deserialized WebviewPanel then
@@ -389,7 +402,7 @@ Source of truth: `vscode-ext/src/peer-link.ts` (sockets, arbitration); `vscode-e
 
 `pnpm --filter dormouse test` typechecks and runs the suites under `vscode-ext/test/`; the socket tests use real local sockets, and `vitest.config.mts` supplies only the minimal `vscode` stub required outside an editor. **Never widen that stub to make an editor-dependent test pass** — command registration, webview hosting, and the theme observer require a real Extension Development Host.
 
-`webview-boot.smoketest.ts` is separate: `pnpm --filter dormouse test:smoke` runs the shipped webview under Chromium against a prebuilt `media/`, in its own CI job. **It must stub `acquireVsCodeApi`** so the VS Code-only lazy import executes.
+`webview-boot.smoketest.ts` is separate: `pnpm --filter dormouse test:smoke` runs the shipped webview under Chromium against a prebuilt `media/`, in its own CI job. **It must stub `acquireVsCodeApi`** so the VS Code-only lazy import executes. **Must share the unit config's resolver aliases**, including the shared notepad schema's CLI imports.
 
 ### Build and development
 
diff --git a/lib/src/components/AgentBrowserScreenModalHost.tsx b/lib/src/components/AgentBrowserScreenModalHost.tsx
index 8ca7291f..18b7e2c0 100644
--- a/lib/src/components/AgentBrowserScreenModalHost.tsx
+++ b/lib/src/components/AgentBrowserScreenModalHost.tsx
@@ -5,6 +5,7 @@ import {
   useAgentBrowserScreenController,
   useOpenAgentBrowserScreenModalId,
 } from './wall/agent-browser-screen';
+import { useDialogKeyboardOwner } from './wall/wall-context';
 
 /**
  * Mounts the agent-browser screen modal when a surface requests it, mirroring
@@ -12,20 +13,15 @@ import {
  * (e.g. `surface:3`) for the title.
  */
 export function AgentBrowserScreenModalHost({
-  onKeyboardActiveChange,
   resolveLabel,
 }: {
-  onKeyboardActiveChange: (active: boolean) => void;
   resolveLabel: (surfaceId: string) => string;
 }) {
   const id = useOpenAgentBrowserScreenModalId();
   const controller = useAgentBrowserScreenController(id ?? '');
   const open = id !== null && controller !== null;
 
-  useEffect(() => {
-    onKeyboardActiveChange(open);
-    return () => onKeyboardActiveChange(false);
-  }, [onKeyboardActiveChange, open]);
+  useDialogKeyboardOwner(open);
 
   // The surface was killed (or detached) while its modal was open — drop it.
   useEffect(() => {
diff --git a/lib/src/components/Baseboard.test.tsx b/lib/src/components/Baseboard.test.tsx
index b5f5ebf6..d95771ec 100644
--- a/lib/src/components/Baseboard.test.tsx
+++ b/lib/src/components/Baseboard.test.tsx
@@ -7,7 +7,10 @@ import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
 vi.mock('../lib/platform', () => ({
   IS_MAC: false,
-  getPlatform: () => ({ alertPublishSettings: vi.fn() }),
+  // An archive port present ⇒ this host has a notepad, which is what puts the
+  // button on a Door that has notes.
+  getPlatform: () => ({ alertPublishSettings: vi.fn(), notepadArchive: {} }),
+  getPlatformOrNull: () => ({ alertPublishSettings: vi.fn(), notepadArchive: {} }),
 }));
 
 import { Baseboard } from './Baseboard';
@@ -22,6 +25,7 @@ import {
   type DormouseTheme,
 } from '../lib/themes';
 import { resetShellStore, seedShellStore } from '../lib/shell-store';
+import { addPlainNote, clearAllNotepads } from '../lib/notepad/notepad-store';
 import { resetPushDevices, setPushDevices, setPushDevicesRefresher } from '../lib/push-devices';
 
 globalThis.IS_REACT_ACT_ENVIRONMENT = true;
@@ -329,3 +333,39 @@ describe('Baseboard browser Doors', () => {
     );
   });
 });
+
+describe('Baseboard Door notepad', () => {
+  afterEach(() => {
+    act(() => clearAllNotepads());
+  });
+
+  it('opens the popover on the Door with notes without reattaching it', () => {
+    addPlainNote('pane-a', 'from the door');
+    const onReattach = vi.fn();
+    act(() => root.render(
+      <Baseboard
+        items={[
+          { id: 'pane-a', kind: 'terminal', title: 'noted' },
+          { id: 'pane-b', kind: 'terminal', title: 'quiet' },
+        ]}
+        onReattach={onReattach}
+      />,
+    ));
+
+    // Only the Door holding notes grows the button.
+    expect(container.querySelectorAll('[data-door-notepad-for]')).toHaveLength(1);
+
+    const notepad = container.querySelector<HTMLButtonElement>('[data-door-notepad-for="pane-a"]')!;
+    act(() => { notepad.dispatchEvent(new MouseEvent('click', { bubbles: true })); });
+
+    const popover = document.querySelector('[data-notepad-popover-for="pane-a"]');
+    expect(popover).not.toBeNull();
+    expect(popover?.querySelector('textarea')?.value).toBe('from the door');
+    expect(onReattach).not.toHaveBeenCalled();
+
+    // Escape dismisses it, and still nothing reattached.
+    act(() => { window.dispatchEvent(new KeyboardEvent('keydown', { key: 'Escape', bubbles: true })); });
+    expect(document.querySelector('[data-notepad-popover-for="pane-a"]')).toBeNull();
+    expect(onReattach).not.toHaveBeenCalled();
+  });
+});
diff --git a/lib/src/components/Baseboard.tsx b/lib/src/components/Baseboard.tsx
index 8b49b246..7ee07346 100644
--- a/lib/src/components/Baseboard.tsx
+++ b/lib/src/components/Baseboard.tsx
@@ -1,4 +1,4 @@
-import { useCallback, useEffect, useRef, useState, useMemo, useLayoutEffect, useContext, useSyncExternalStore, type ReactNode } from 'react';
+import { useCallback, useRef, useState, useMemo, useLayoutEffect, useContext, useSyncExternalStore, type ReactNode } from 'react';
 import {
   DeviceMobileSlashIcon,
   CaretLeftIcon,
@@ -12,10 +12,19 @@ import { chromeButton } from './design';
 import { SettingsDialog, type AlarmSink } from './SettingsDialog';
 import { SettingsPreview } from './SettingsPreview';
 import { Door } from './Door';
-import { DialogKeyboardContext, DoorElementsContext } from './wall/wall-context';
+import { DoorNotepadPopover } from './DoorNotepadPopover';
+import { sourceNoticeFor, type SourceNotice } from './NoteList';
+import { DoorElementsContext, useDialogKeyboardOwner } from './wall/wall-context';
 import type { DoorChip, DooredItem } from './wall/wall-types';
 import { hasTerminal } from 'dor/commands/types';
 import { IS_MAC } from '../lib/platform';
+import { hasNotepadArchive } from '../lib/notepad/archive-service';
+import {
+  getNotepadSnapshot,
+  setOpenNotepadId,
+  subscribeToNotepad,
+} from '../lib/notepad/notepad-store';
+import { revealNoteSource } from '../lib/notepad/pin';
 import {
   buildAppTitleResolver,
   DEFAULT_ACTIVITY_STATE,
@@ -56,6 +65,11 @@ export function Baseboard({ items, onReattach, notice, onDoorDragStart }: Basebo
   const speechStates = useSyncExternalStore(subscribeToAlertSpeech, getAlertSpeechSnapshot);
   const settings = useSyncExternalStore(subscribeToAlertSettings, getAlertSettings);
   const terminalStates = useSyncExternalStore(subscribeToTerminalPaneState, getTerminalPaneStateSnapshot);
+  // One subscription for every Door's note count, like the activity one above.
+  // A host with no notepad reports zero everywhere, so the Door stays a pure
+  // props component and never asks the platform anything.
+  const notepadNotes = useSyncExternalStore(subscribeToNotepad, getNotepadSnapshot);
+  const notepadAvailable = hasNotepadArchive();
   const appTitleForPane = useMemo(
     () => buildAppTitleResolver(terminalStates, activityStates),
     [terminalStates, activityStates],
@@ -76,6 +90,12 @@ export function Baseboard({ items, onReattach, notice, onDoorDragStart }: Basebo
   const [rightClusterWidth, setRightClusterWidth] = useState(0);
   const layoutMetrics = useRef({ doorGap: 0, arrowWidth: 0 });
   const [settingsOpen, setSettingsOpen] = useState(false);
+  // Which Door's notepad popover is open, with the rect it was anchored on. The
+  // rect is kept rather than re-read: a pin reattaches the Surface, so the Door
+  // may be gone by the time the popover reopens to report a dead source.
+  const [doorNotepad, setDoorNotepad] = useState<
+    { id: string; rect: DOMRect; sourceNotice: SourceNotice | null } | null
+  >(null);
   const [settingsPreview, setSettingsPreview] = useState<{ sink: AlarmSink; anchor: HTMLElement; sequence: number } | null>(null);
   const previewSequence = useRef(0);
   const closeSettingsPreview = useCallback(() => setSettingsPreview(null), []);
@@ -86,14 +106,10 @@ export function Baseboard({ items, onReattach, notice, onDoorDragStart }: Basebo
       : { pushEnabled: !current.pushEnabled });
     setSettingsPreview({ sink, anchor, sequence: ++previewSequence.current });
   };
-  const setDialogKeyboardActive = useContext(DialogKeyboardContext);
 
   // Suppress command-mode key dispatch while the Settings dialog owns the
   // keyboard, so typing a timeout doesn't trigger pane shortcuts.
-  useEffect(() => {
-    setDialogKeyboardActive(settingsOpen);
-    return () => setDialogKeyboardActive(false);
-  }, [settingsOpen, setDialogKeyboardActive]);
+  useDialogKeyboardOwner(settingsOpen);
 
   useLayoutEffect(() => {
     const el = containerRef.current;
@@ -140,7 +156,7 @@ export function Baseboard({ items, onReattach, notice, onDoorDragStart }: Basebo
     if (arrowMeasureEl.current) {
       layoutMetrics.current.arrowWidth = arrowMeasureEl.current.offsetWidth;
     }
-  }, [items, activityStates, speechStates, terminalStates]);
+  }, [items, activityStates, speechStates, terminalStates, notepadNotes]);
 
   // Reset startIndex when the set of door items changes (not just count)
   const itemKey = useMemo(() => items.map(i => i.id).join('\0'), [items]);
@@ -231,9 +247,40 @@ export function Baseboard({ items, onReattach, notice, onDoorDragStart }: Basebo
       ringSeq: activity.ringSeq,
       todo: activity.todo,
       speechState: speechStates.get(item.id),
+      noteCount: notepadAvailable ? (notepadNotes.get(item.id)?.length ?? 0) : 0,
     };
   };
 
+  // Opening a Door's notepad closes the attached one: a Wall shows a single
+  // notepad, whichever Surface it belongs to (`docs/specs/notepad.md`).
+  const openDoorNotepad = useCallback((item: DoorChip, anchor: HTMLElement) => {
+    setOpenNotepadId(null);
+    setDoorNotepad((current) => current?.id === item.id
+      ? null
+      : { id: item.id, rect: anchor.getBoundingClientRect(), sourceNotice: null });
+  }, []);
+
+  const closeDoorNotepad = useCallback(() => setDoorNotepad(null), []);
+
+  /**
+   * A pin in a Door's popover: close it, reattach the Surface, then follow the
+   * source. The reveal waits a frame because it resolves against the live
+   * terminal the reattach is only now mounting; a source that cannot be shown
+   * brings the popover back to say so.
+   */
+  const revealDoorSource = useCallback((noteId: string) => {
+    const open = doorNotepad;
+    if (!open) return;
+    const item = items.find((candidate) => candidate.id === open.id);
+    setDoorNotepad(null);
+    if (item) onReattach(item);
+    requestAnimationFrame(() => {
+      const sourceNotice = sourceNoticeFor(noteId, revealNoteSource(open.id, noteId));
+      if (!sourceNotice) return;
+      setDoorNotepad({ ...open, sourceNotice });
+    });
+  }, [doorNotepad, items, onReattach]);
+
   const scrollLeft = () => setStartIndex(Math.max(0, startIndex - 1));
   const scrollRight = () => setStartIndex(Math.min(items.length - 1, startIndex + 1));
 
@@ -273,6 +320,7 @@ export function Baseboard({ items, onReattach, notice, onDoorDragStart }: Basebo
           {...doorProps(item)}
           onClick={() => onReattach(item)}
           onDragPress={onDoorDragStart ? (press) => onDoorDragStart(item, press) : undefined}
+          onOpenNotepad={(anchor) => openDoorNotepad(item, anchor)}
         />
       ))}
 
@@ -341,6 +389,15 @@ export function Baseboard({ items, onReattach, notice, onDoorDragStart }: Basebo
         </div>
       </div>
 
+      {doorNotepad && (
+        <DoorNotepadPopover
+          surfaceId={doorNotepad.id}
+          anchorRect={doorNotepad.rect}
+          sourceNotice={doorNotepad.sourceNotice}
+          onClose={closeDoorNotepad}
+          onRevealSource={revealDoorSource}
+        />
+      )}
       {settingsPreview && (
         <SettingsPreview
           key={settingsPreview.sequence}
diff --git a/lib/src/components/Door.test.tsx b/lib/src/components/Door.test.tsx
index 080d8d8a..ee0490c0 100644
--- a/lib/src/components/Door.test.tsx
+++ b/lib/src/components/Door.test.tsx
@@ -3,7 +3,7 @@
  */
 import { act } from 'react';
 import { createRoot, type Root } from 'react-dom/client';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import { Door } from './Door';
 
 globalThis.IS_REACT_ACT_ENVIRONMENT = true;
@@ -64,3 +64,70 @@ describe('Door spoken-alarm state', () => {
     expect(door?.querySelectorAll('svg').length).toBe(2);
   });
 });
+
+describe('Door notepad button', () => {
+  function renderDoor(props: Partial<Parameters<typeof Door>[0]> = {}) {
+    const onClick = vi.fn();
+    const onOpenNotepad = vi.fn();
+    act(() => root.render(
+      <Door
+        doorId="pane-a"
+        title="build-server"
+        ringSeq={0}
+        onClick={onClick}
+        onOpenNotepad={onOpenNotepad}
+        {...props}
+      />,
+    ));
+    return { onClick, onOpenNotepad };
+  }
+
+  it('keeps the Door identity on the wrapper the baseboard measures', () => {
+    renderDoor({ noteCount: 2 });
+
+    const door = container.querySelector<HTMLElement>('[data-door-id="pane-a"]');
+    expect(door).not.toBeNull();
+    // The wrapper, not either button: the fitting pass and the selection ring
+    // both measure this element.
+    expect(door!.tagName).toBe('DIV');
+    expect(door!.querySelectorAll('button')).toHaveLength(2);
+  });
+
+  it('appears only for a Door with notes, and names the count', () => {
+    renderDoor({ noteCount: 0 });
+    expect(container.querySelector('[data-door-notepad-for]')).toBeNull();
+
+    renderDoor({ noteCount: 3 });
+    expect(container.querySelector('[data-door-notepad-for]')?.getAttribute('aria-label'))
+      .toBe('Notepad · 3 notes');
+  });
+
+  it('opens the notepad without reattaching the Surface', () => {
+    const { onClick, onOpenNotepad } = renderDoor({ noteCount: 1 });
+
+    const notepad = container.querySelector<HTMLButtonElement>('[data-door-notepad-for="pane-a"]')!;
+    act(() => { notepad.dispatchEvent(new MouseEvent('click', { bubbles: true })); });
+
+    expect(onOpenNotepad).toHaveBeenCalledTimes(1);
+    // Anchored on the whole Door, not on the button inside it.
+    expect(onOpenNotepad.mock.calls[0][0]).toBe(container.querySelector('[data-door-id="pane-a"]'));
+    expect(onClick).not.toHaveBeenCalled();
+  });
+
+  it('never starts a drag from the notepad button', () => {
+    const onDragPress = vi.fn();
+    renderDoor({ noteCount: 1, onDragPress });
+
+    const notepad = container.querySelector<HTMLButtonElement>('[data-door-notepad-for="pane-a"]')!;
+    act(() => {
+      notepad.dispatchEvent(new MouseEvent('pointerdown', { bubbles: true, button: 0 }));
+    });
+    expect(onDragPress).not.toHaveBeenCalled();
+
+    const title = container.querySelector<HTMLButtonElement>('[data-door-id="pane-a"] button')!;
+    act(() => {
+      title.dispatchEvent(new MouseEvent('pointerdown', { bubbles: true, button: 0 }));
+    });
+    expect(onDragPress).toHaveBeenCalledTimes(1);
+  });
+});
diff --git a/lib/src/components/Door.tsx b/lib/src/components/Door.tsx
index 19277dbf..304be60f 100644
--- a/lib/src/components/Door.tsx
+++ b/lib/src/components/Door.tsx
@@ -1,12 +1,13 @@
-import { type PointerEvent as ReactPointerEvent } from 'react';
+import { useRef, type PointerEvent as ReactPointerEvent } from 'react';
 import { clsx } from 'clsx';
-import { SpeakerHighIcon } from '@phosphor-icons/react';
+import { NotepadIcon, SpeakerHighIcon } from '@phosphor-icons/react';
 import type { AlertSpeechState, SessionStatus, TodoState } from '../lib/terminal-registry';
 import type { BrowserDisplayMode } from './wall/agent-browser-screen';
 import { BROWSER_DISPLAY_LABEL, BrowserDisplayIcon } from './wall/BrowserDisplayIcon';
 import { useTodoPillContent } from './TodoPillBody';
 import { alertSpeakingAnimationClass } from './bell-icon-class';
 import { AlertBell } from './AlertBell';
+import { notepadLabel } from './use-notepad';
 import {
   ALERT_SPEECH_TRACKING_CLASS,
   TERMINAL_TOP_RADIUS_CLASS,
@@ -25,14 +26,28 @@ export interface DoorProps {
   ringSeq: number;
   todo?: TodoState;
   speechState?: AlertSpeechState;
+  /** Live notes on the minimized Surface. Above zero the Door grows its second
+   *  button; a Door with no notes needs none (`docs/specs/notepad.md`). The
+   *  Baseboard reports zero on a host that has no notepad at all. */
+  noteCount?: number;
   onClick?: () => void;
   /** When provided, a primary-button press reports its start point and the Wall begins
    *  an (inactive) LathHost drag — LathHost owns the threshold, click suppression, and
    *  hit-testing from there. A sub-threshold press-release still fires `onClick`
    *  (reattach). Absent → Door stays click-only. */
   onDragPress?: (press: { clientX: number; clientY: number }) => void;
+  /** Opens the Door's notepad popover, anchored on the whole Door. Neither this
+   *  press nor its click reattaches the Surface. */
+  onOpenNotepad?: (anchor: HTMLElement) => void;
 }
 
+/**
+ * A minimized Surface on the baseboard. The outer element carries the Door's
+ * identity, geometry, and palette — it is what the selection ring and the
+ * baseboard's fitting pass measure — and holds one or two buttons: the title,
+ * which reattaches and starts the drag, and (with notes) the notepad, which
+ * does neither.
+ */
 export function Door({
   doorId,
   title,
@@ -41,8 +56,10 @@ export function Door({
   ringSeq,
   todo = false,
   speechState,
+  noteCount = 0,
   onClick,
   onDragPress,
+  onOpenNotepad,
 }: DoorProps) {
   const showBell = status !== 'WATCHING_DISABLED';
   const alertRinging = status === 'ALERT_RINGING';
@@ -51,19 +68,27 @@ export function Door({
   const spoken = speechState === 'spoken';
   const detail = browserDisplay ? BROWSER_DISPLAY_LABEL[browserDisplay] : undefined;
   const nameParts = [title, detail, speechState].filter(Boolean);
+  const doorRef = useRef<HTMLDivElement>(null);
+  const showNotepad = noteCount > 0;
 
   const onPointerDown = onDragPress
-    ? (e: ReactPointerEvent<HTMLButtonElement>): void => {
+    ? (e: ReactPointerEvent<HTMLDivElement>): void => {
         if (e.button !== 0) return;
+        // The notepad button sits inside the Door's pill but drags nothing.
+        if (e.target instanceof Element && e.target.closest('[data-door-notepad-for]')) return;
         onDragPress({ clientX: e.clientX, clientY: e.clientY });
       }
     : undefined;
 
   return (
-    <button
+    <div
+      ref={doorRef}
       data-door-id={doorId}
+      // A labelled group rather than a bare div: with two buttons inside, the
+      // display/speech detail belongs to the Door, not to either button.
+      role="group"
       className={clsx(
-        'relative flex h-6 max-w-[220px] min-w-[68px] items-center gap-2 overflow-hidden px-2.5',
+        'relative flex h-6 max-w-[220px] min-w-[68px] items-center overflow-hidden',
         'text-sm font-medium font-mono',
         TERMINAL_TOP_RADIUS_CLASS,
         speaking
@@ -71,43 +96,69 @@ export function Door({
           : 'bg-door-bg text-door-fg',
         spoken && 'shadow-[inset_0_0_0_2px_var(--color-alarm-vs-door)]',
       )}
-      onClick={onClick}
       onPointerDown={onPointerDown}
       title={nameParts.join(' — ')}
       aria-label={detail || speechState ? nameParts.join(', ') : undefined}
       data-alert-speech-state={speechState}
     >
-      {browserDisplay && <BrowserDisplayIcon mode={browserDisplay} size={12} />}
-      <span className="min-w-0 flex-1 truncate">
-        {title}
-      </span>
-      {/* `spoken` is unbounded (it lasts until the ring is attended), so it joins
-          the badge cluster instead of replacing it — see docs/specs/layout.md. */}
-      {speaking ? (
-        <span className={clsx('flex shrink-0 items-center gap-1 text-xs font-bold', ALERT_SPEECH_TRACKING_CLASS)}>
-          <SpeakerHighIcon size={13} weight="fill" />
-          <span>SPEAKING</span>
-        </span>
-      ) : (spoken || todoPill.visible || showBell) && (
-        <span className="flex shrink-0 items-center gap-1.5">
-          {spoken && (
-            <SpeakerHighIcon size={12} weight="fill" className="text-alarm-vs-door" />
-          )}
-          {todoPill.visible && (
-            <span
-              className={`todo-pill-shell text-xs font-semibold ${TODO_PILL_TRACKING_CLASS}`}
-              data-flourishing={todoPill.flourishing ? 'true' : 'false'}
-            >
-              {todoPill.body}
-            </span>
-          )}
-          {showBell && (
-            <span className={alertRinging ? 'text-alarm-vs-door' : ''}>
-              <AlertBell status={status} ringSeq={ringSeq} size={11} />
-            </span>
-          )}
+      <button
+        type="button"
+        className={clsx(
+          'flex h-full min-w-0 flex-1 items-center gap-2 overflow-hidden pl-2.5',
+          showNotepad ? 'pr-1' : 'pr-2.5',
+        )}
+        onClick={onClick}
+      >
+        {browserDisplay && <BrowserDisplayIcon mode={browserDisplay} size={12} />}
+        <span className="min-w-0 flex-1 truncate">
+          {title}
         </span>
+        {/* `spoken` is unbounded (it lasts until the ring is attended), so it joins
+            the badge cluster instead of replacing it — see docs/specs/layout.md. */}
+        {speaking ? (
+          <span className={clsx('flex shrink-0 items-center gap-1 text-xs font-bold', ALERT_SPEECH_TRACKING_CLASS)}>
+            <SpeakerHighIcon size={13} weight="fill" />
+            <span>SPEAKING</span>
+          </span>
+        ) : (spoken || todoPill.visible || showBell) && (
+          <span className="flex shrink-0 items-center gap-1.5">
+            {spoken && (
+              <SpeakerHighIcon size={12} weight="fill" className="text-alarm-vs-door" />
+            )}
+            {todoPill.visible && (
+              <span
+                className={`todo-pill-shell text-xs font-semibold ${TODO_PILL_TRACKING_CLASS}`}
+                data-flourishing={todoPill.flourishing ? 'true' : 'false'}
+              >
+                {todoPill.body}
+              </span>
+            )}
+            {showBell && (
+              <span className={alertRinging ? 'text-alarm-vs-door' : ''}>
+                <AlertBell status={status} ringSeq={ringSeq} size={11} />
+              </span>
+            )}
+          </span>
+        )}
+      </button>
+      {showNotepad && (
+        <button
+          type="button"
+          data-door-notepad-for={doorId}
+          className="flex h-full shrink-0 items-center rounded pl-0.5 pr-2 hover:bg-current/10"
+          aria-label={notepadLabel(noteCount)}
+          title={notepadLabel(noteCount)}
+          // Keep the press to itself: the popover's own outside-click dismissal
+          // would otherwise close it on the very press that opens it.
+          onMouseDown={(e) => e.stopPropagation()}
+          onClick={(e) => {
+            e.stopPropagation();
+            if (doorRef.current) onOpenNotepad?.(doorRef.current);
+          }}
+        >
+          <NotepadIcon size={12} weight="fill" />
+        </button>
       )}
-    </button>
+    </div>
   );
 }
diff --git a/lib/src/components/DoorNotepadPopover.tsx b/lib/src/components/DoorNotepadPopover.tsx
new file mode 100644
index 00000000..f291efbf
--- /dev/null
+++ b/lib/src/components/DoorNotepadPopover.tsx
@@ -0,0 +1,73 @@
+import { useLayoutEffect, useRef, useState, type CSSProperties } from 'react';
+import { createPortal } from 'react-dom';
+import { NotepadBody } from './NotepadBody';
+import type { SourceNotice } from './NoteList';
+import { useNotes } from './use-notepad';
+import { useDialogKeyboardOwner } from './wall/wall-context';
+import { clampOverlayPosition } from '../lib/ui-geometry';
+
+/** Gap between the Door's top edge and the popover above it. */
+const DOOR_POPOVER_GAP_PX = 4;
+
+/**
+ * A minimized Surface's notepad, above its Door (docs/specs/notepad.md →
+ * Notepad UI). Same list and same editing as the attached panel — both are
+ * `NotepadBody` — so what lives here is only the placement: a portal, measured
+ * and edge-clamped above the Door. Opening it never reattaches the Surface, and
+ * a pin does; the Baseboard owns that sequence and passes it in.
+ */
+export function DoorNotepadPopover({
+  surfaceId,
+  anchorRect,
+  sourceNotice,
+  onClose,
+  onRevealSource,
+}: {
+  surfaceId: string;
+  /** The Door's rect. Measured at open; the popover keeps its place if the
+   *  Door goes away under it (a pin reattaches the Surface). */
+  anchorRect: DOMRect;
+  sourceNotice: SourceNotice | null;
+  onClose: () => void;
+  onRevealSource: (noteId: string) => void;
+}) {
+  const notes = useNotes(surfaceId);
+  const popoverRef = useRef<HTMLDivElement>(null);
+  const [style, setStyle] = useState<CSSProperties>({
+    position: 'fixed',
+    left: anchorRect.left,
+    top: anchorRect.top,
+  });
+
+  // Width is content-driven up to the cap, so placement has to measure first;
+  // re-run when the list changes height under it.
+  useLayoutEffect(() => {
+    const el = popoverRef.current;
+    if (!el) return;
+    const rect = el.getBoundingClientRect();
+    setStyle(clampOverlayPosition({
+      left: anchorRect.left,
+      top: anchorRect.top - rect.height - DOOR_POPOVER_GAP_PX,
+      width: rect.width,
+      height: rect.height,
+    }));
+  }, [anchorRect, notes, sourceNotice]);
+
+  // Mounted only while open, so the lease is unconditional: it lives exactly as
+  // long as the popover, independently of any other dialog's.
+  useDialogKeyboardOwner(true);
+
+  return createPortal(
+    <NotepadBody
+      surfaceId={surfaceId}
+      containerRef={popoverRef}
+      className="max-h-[75dvh] w-fit max-w-[30rem]"
+      style={style}
+      dataAttributes={{ 'data-notepad-popover-for': surfaceId }}
+      sourceNotice={sourceNotice}
+      onClose={onClose}
+      onRevealSource={onRevealSource}
+    />,
+    document.body,
+  );
+}
diff --git a/lib/src/components/ExternalLinkModalHost.tsx b/lib/src/components/ExternalLinkModalHost.tsx
index 8e75c661..ee799bed 100644
--- a/lib/src/components/ExternalLinkModalHost.tsx
+++ b/lib/src/components/ExternalLinkModalHost.tsx
@@ -1,4 +1,4 @@
-import { useCallback, useEffect, useSyncExternalStore } from 'react';
+import { useCallback, useSyncExternalStore } from 'react';
 import { ExternalLinkModal } from './ExternalLinkModal';
 import {
   clearExternalLinkConfirmation,
@@ -6,21 +6,15 @@ import {
   subscribeExternalLinkConfirmation,
 } from '../lib/external-link-confirmation';
 import { getPlatform } from '../lib/platform';
+import { useDialogKeyboardOwner } from './wall/wall-context';
 
-export function ExternalLinkModalHost({
-  onKeyboardActiveChange,
-}: {
-  onKeyboardActiveChange: (active: boolean) => void;
-}) {
+export function ExternalLinkModalHost() {
   const pending = useSyncExternalStore(
     subscribeExternalLinkConfirmation,
     getExternalLinkConfirmationSnapshot,
   );
 
-  useEffect(() => {
-    onKeyboardActiveChange(pending !== null);
-    return () => onKeyboardActiveChange(false);
-  }, [onKeyboardActiveChange, pending]);
+  useDialogKeyboardOwner(pending !== null);
 
   const close = useCallback(() => {
     clearExternalLinkConfirmation();
diff --git a/lib/src/components/NoteList.tsx b/lib/src/components/NoteList.tsx
new file mode 100644
index 00000000..e79a8a61
--- /dev/null
+++ b/lib/src/components/NoteList.tsx
@@ -0,0 +1,474 @@
+import { memo, useCallback, useEffect, useLayoutEffect, useRef, useState } from 'react';
+import { clsx } from 'clsx';
+import { CheckIcon, CopyIcon, PushPinIcon, TrashIcon } from '@phosphor-icons/react';
+import { popupButton } from './design';
+import { noteToPlainText } from '../lib/notepad/rich-clipboard';
+import type { PinOutcome } from '../lib/notepad/pin';
+import type { LiveNote, RichTextRun } from '../lib/notepad/types';
+
+/** How long the Copy button shows its check, matching the terminal selection
+ *  popup's copy confirmation (`flashCopy`). */
+const COPY_FLASH_MS = 700;
+
+/** What a note's row says about a pin that just refused to resolve
+ *  (docs/specs/notepad.md → Source links). `alternate-buffer` is the one
+ *  failure that keeps the pin, so its row invites a retry. */
+export interface SourceNotice {
+  noteId: string;
+  kind: 'unavailable' | 'alternate-buffer';
+}
+
+const SOURCE_NOTICE_TEXT: Record<SourceNotice['kind'], string> = {
+  unavailable: 'Source no longer available',
+  'alternate-buffer': 'Exit the full-screen program to show this source',
+};
+
+/** The notice a pin's outcome earns, or `null` when it resolved and there is
+ *  nothing to say. A kept pin is the retryable one, so the kind follows
+ *  `outcome.kept` rather than the reason. */
+export function sourceNoticeFor(noteId: string, outcome: PinOutcome): SourceNotice | null {
+  if (outcome.ok) return null;
+  return { noteId, kind: outcome.kept ? 'alternate-buffer' : 'unavailable' };
+}
+
+export interface NoteListProps {
+  /** Creation order, top to bottom — the store's own order, never re-sorted. */
+  notes: readonly LiveNote[];
+  onCopy: (note: LiveNote) => void;
+  onDelete: (note: LiveNote) => void;
+  /** Absent ⇒ read-only, which is how the Archive view renders the same list. */
+  onEdit?: (noteId: string, text: string) => void;
+  /** Absent ⇒ no pins anywhere; present ⇒ one on every note still carrying a
+   *  source (docs/specs/notepad.md → Source links). */
+  onRevealSource?: (noteId: string) => void;
+  /** The note whose pin just failed to resolve, and why; its row says so. */
+  sourceNotice?: SourceNotice | null;
+  /** A freshly added note to put the caret in (Add New). */
+  autoFocusNoteId?: string | null;
+  /** Fires when an editor loses focus, so the owner can prune an untouched
+   *  empty note. */
+  onNoteBlur?: (noteId: string) => void;
+  /** Read-only: the editors refuse input and Delete and the pin are held, while
+   *  a caller is mid-commit — the Archive view committing staged deletions, or a
+   *  closure writing this Surface's notes (docs/specs/notepad.md → "Closure").
+   *  Copy stays live since it changes nothing. */
+  disabled?: boolean;
+}
+
+export function NoteList({
+  notes,
+  onCopy,
+  onDelete,
+  onEdit,
+  onRevealSource,
+  sourceNotice,
+  autoFocusNoteId,
+  onNoteBlur,
+  disabled = false,
+}: NoteListProps) {
+  return (
+    <ul>
+      {notes.map((note) => (
+        <NoteItem
+          key={note.id}
+          note={note}
+          onCopy={onCopy}
+          onDelete={onDelete}
+          onEdit={onEdit}
+          onRevealSource={onRevealSource}
+          sourceNoticeKind={sourceNotice?.noteId === note.id ? sourceNotice.kind : null}
+          autoFocus={autoFocusNoteId === note.id}
+          onNoteBlur={onNoteBlur}
+          disabled={disabled}
+        />
+      ))}
+    </ul>
+  );
+}
+
+// Memoized: a note is edited one keystroke at a time, and the store keeps every
+// other note's identity across that edit, so the list re-renders only the row
+// that changed rather than re-diffing a span per run of every rich note.
+const NoteItem = memo(function NoteItem({
+  note,
+  onCopy,
+  onDelete,
+  onEdit,
+  onRevealSource,
+  sourceNoticeKind,
+  autoFocus,
+  onNoteBlur,
+  disabled,
+}: {
+  note: LiveNote;
+  onCopy: (note: LiveNote) => void;
+  onDelete: (note: LiveNote) => void;
+  onEdit?: (noteId: string, text: string) => void;
+  onRevealSource?: (noteId: string) => void;
+  sourceNoticeKind: SourceNotice['kind'] | null;
+  autoFocus: boolean;
+  onNoteBlur?: (noteId: string) => void;
+  disabled: boolean;
+}) {
+  const [flashed, setFlashed] = useState(false);
+  // Where the caret goes once a rich note's conversion has re-rendered it as
+  // the plain editor. Held across that render, not applied to the rich DOM.
+  const [pendingCaret, setPendingCaret] = useState<number | null>(null);
+  const textareaRef = useRef<HTMLTextAreaElement>(null);
+  const richRef = useRef<HTMLDivElement>(null);
+  // Narrowed once, so every branch below reads the content it actually has.
+  const plain = note.content.kind === 'plain' ? note.content : null;
+  const rich = note.content.kind === 'terminal' ? note.content : null;
+  const editable = !!onEdit;
+
+  useEffect(() => {
+    if (!flashed) return;
+    const timer = window.setTimeout(() => setFlashed(false), COPY_FLASH_MS);
+    return () => window.clearTimeout(timer);
+  }, [flashed]);
+
+  // Grow to fit rather than scroll: a note is short, and an inner scrollbar
+  // inside the panel's own scroller reads as two nested lists.
+  const text = plain?.text ?? '';
+  useLayoutEffect(() => {
+    const el = textareaRef.current;
+    if (!el) return;
+    el.style.height = 'auto';
+    // jsdom reports 0 for every scrollHeight; leaving `auto` there keeps the
+    // `rows` fallback instead of collapsing the field to nothing.
+    if (el.scrollHeight > 0) el.style.height = `${el.scrollHeight}px`;
+  }, [text]);
+
+  useEffect(() => {
+    if (!autoFocus) return;
+    const el = textareaRef.current;
+    if (!el) return;
+    el.focus();
+    el.setSelectionRange(el.value.length, el.value.length);
+  }, [autoFocus]);
+
+  useLayoutEffect(() => {
+    if (pendingCaret === null) return;
+    const el = textareaRef.current;
+    // Still rich (nothing converted it): wait for the plain editor rather than
+    // dropping the caret on the floor.
+    if (!el) return;
+    el.focus();
+    el.setSelectionRange(pendingCaret, pendingCaret);
+    setPendingCaret(null);
+  }, [pendingCaret, plain]);
+
+  /**
+   * A rich note's first content mutation. `beforeinput` is the one event that
+   * names *what* the edit is (`inputType`) for typing, deletion, cut, and
+   * paste alike, so the whole conversion hangs off it: cancel the DOM edit,
+   * rebuild it against the note's plain text, and hand that to `onEdit`, which
+   * converts the note atomically. Moving the caret or selecting never fires
+   * here, so neither ever converts (docs/specs/notepad.md).
+   *
+   * Native rather than React's `onBeforeInput`, whose synthetic version is
+   * built from composition/`textInput` events and carries no `inputType` — it
+   * never fires for a deletion at all.
+   */
+  useEffect(() => {
+    const el = richRef.current;
+    if (!el || !onEdit || !rich) return;
+    const before = rich.runs;
+    const handle = (event: Event) => {
+      const input = event as InputEvent;
+      // Composition is the one edit not intercepted up front. An IME's
+      // `insertCompositionText` is not cancelable, so `preventDefault()` is
+      // ignored and the browser writes the composed text into the rich DOM
+      // regardless; converting here would also swap the contentEditable for a
+      // textarea mid-composition and orphan the IME. Let it run and convert
+      // once at `compositionend`, with the composed text (`commitComposition`).
+      if (input.isComposing || input.inputType === 'insertCompositionText') return;
+      event.preventDefault();
+      const plainText = runsToText(before);
+      const edit = applyPlainEdit(plainText, targetOffsets(el, input), input.inputType, inputData(input));
+      setPendingCaret(edit.caret);
+      onEdit(note.id, edit.text);
+    };
+    el.addEventListener('beforeinput', handle);
+    return () => el.removeEventListener('beforeinput', handle);
+  }, [note.id, rich, onEdit]);
+
+  /**
+   * The end of a composition the `beforeinput` handler let through. The browser
+   * has already written the composed text into the rich container, so the
+   * container's own `textContent` *is* the note's new text — convert on that,
+   * with the caret the composition left behind. React owns that DOM, and the
+   * conversion re-render replaces it wholesale, which is the point.
+   */
+  const commitComposition = useCallback(() => {
+    const el = richRef.current;
+    if (!el || !onEdit) return;
+    setPendingCaret(selectionOffsets(el).end);
+    onEdit(note.id, el.textContent ?? '');
+  }, [note.id, onEdit]);
+
+  const copy = useCallback(() => {
+    setFlashed(true);
+    onCopy(note);
+  }, [note, onCopy]);
+
+  const showPin = !!onRevealSource && !!note.source;
+
+  return (
+    // A hairline between notes, not a card each: the panel is one list, and the
+    // raised surface it sits on is already the container (DESIGN.md).
+    <li className="border-t border-border px-2 py-1.5 first:border-t-0" data-note-id={note.id}>
+      {plain ? (
+        editable ? (
+          <textarea
+            ref={textareaRef}
+            // A tab stop so the panel's focus trap reaches the editors, not
+            // only the buttons.
+            tabIndex={0}
+            rows={1}
+            aria-label="Note"
+            value={text}
+            readOnly={disabled}
+            spellCheck={false}
+            className="block w-full resize-none overflow-hidden border-0 bg-transparent p-0 font-mono text-sm leading-snug text-foreground outline-none"
+            onChange={(e) => onEdit?.(note.id, e.target.value)}
+            onBlur={() => onNoteBlur?.(note.id)}
+          />
+        ) : (
+          <div className="whitespace-pre-wrap break-words font-mono text-sm leading-snug">{text}</div>
+        )
+      ) : (
+        <div
+          ref={richRef}
+          // Escaped React spans, never `dangerouslySetInnerHTML`: captured
+          // terminal output is untrusted text. Every mutation is cancelled in
+          // the handler above, so React's tree and the DOM never diverge.
+          contentEditable={editable && !disabled}
+          suppressContentEditableWarning
+          tabIndex={editable ? 0 : undefined}
+          role={editable ? 'textbox' : undefined}
+          aria-multiline={editable ? true : undefined}
+          aria-readonly={editable && disabled ? true : undefined}
+          aria-label={editable ? 'Note' : undefined}
+          spellCheck={false}
+          className="whitespace-pre-wrap break-words font-mono text-sm leading-snug outline-none"
+          onBlur={() => onNoteBlur?.(note.id)}
+          onCompositionEnd={editable ? commitComposition : undefined}
+        >
+          {rich?.runs.map((run, index) => (
+            <span key={index} style={runStyle(run)}>{run.text}</span>
+          ))}
+        </div>
+      )}
+      {sourceNoticeKind && (
+        <div className="mt-0.5 text-xs text-muted" role="status">
+          {SOURCE_NOTICE_TEXT[sourceNoticeKind]}
+        </div>
+      )}
+      <div className="mt-0.5 flex items-center gap-0.5 text-xs text-muted">
+        <button
+          type="button"
+          className={clsx(popupButton({ flashed }), 'rounded')}
+          aria-label={flashed ? 'Copied' : 'Copy note'}
+          onClick={copy}
+        >
+          {flashed ? <CheckIcon size={12} weight="bold" /> : <CopyIcon size={12} />}
+        </button>
+        <button
+          type="button"
+          className={clsx(popupButton(), 'rounded hover:text-error')}
+          aria-label="Delete note"
+          disabled={disabled}
+          onClick={() => onDelete(note)}
+        >
+          <TrashIcon size={12} />
+        </button>
+        {showPin && (
+          <button
+            type="button"
+            className={clsx(popupButton(), 'rounded')}
+            aria-label="Show source"
+            title="Show where this came from"
+            disabled={disabled}
+            onClick={() => onRevealSource?.(note.id)}
+          >
+            <PushPinIcon size={12} />
+          </button>
+        )}
+      </div>
+    </li>
+  );
+});
+
+/** The four attributes a run may carry, and nothing else — the colors are the
+ *  note's own, the one place the app renders a color it did not pick. */
+function runStyle(run: RichTextRun) {
+  return {
+    fontWeight: run.bold ? 'bold' : undefined,
+    fontStyle: run.italic ? 'italic' : undefined,
+    color: run.foreground,
+    backgroundColor: run.background,
+  };
+}
+
+function runsToText(runs: readonly RichTextRun[]): string {
+  return noteToPlainText({ kind: 'terminal', runs: [...runs] });
+}
+
+/** `data` for a typed character; the plain flavor of the clipboard for a paste,
+ *  which is all a note ever takes in (docs/specs/notepad.md). */
+function inputData(event: InputEvent): string {
+  if (event.data != null) return event.data;
+  return event.dataTransfer?.getData('text/plain') ?? '';
+}
+
+/** The range a `beforeinput` acts on, as offsets into the container's text.
+ *  `getTargetRanges()` is the only place a word or line deletion's extent
+ *  appears — the document selection is still the bare caret — so it wins
+ *  wherever the browser supplies one, and the live selection is the fallback
+ *  for the browsers and input types that supply none. */
+function targetOffsets(container: HTMLElement, event: InputEvent): { start: number; end: number } {
+  const range = event.getTargetRanges?.()[0];
+  if (!range || !container.contains(range.startContainer) || !container.contains(range.endContainer)) {
+    return selectionOffsets(container);
+  }
+  return {
+    start: textOffsetOf(container, range.startContainer, range.startOffset),
+    end: textOffsetOf(container, range.endContainer, range.endOffset),
+  };
+}
+
+/** The document selection as offsets into the container's text. Anything
+ *  anchored outside the note (no selection at all, focus elsewhere) is treated
+ *  as a caret at the end, so an edit still lands somewhere sane. */
+function selectionOffsets(container: HTMLElement): { start: number; end: number } {
+  const end = (container.textContent ?? '').length;
+  const selection = window.getSelection?.();
+  if (!selection || selection.rangeCount === 0) return { start: end, end };
+  const range = selection.getRangeAt(0);
+  if (!container.contains(range.startContainer) || !container.contains(range.endContainer)) {
+    return { start: end, end };
+  }
+  return {
+    start: textOffsetOf(container, range.startContainer, range.startOffset),
+    end: textOffsetOf(container, range.endContainer, range.endOffset),
+  };
+}
+
+/** A DOM position as a text offset: the length of everything the container
+ *  holds before it. The note's container is spans and text only, so the range's
+ *  string is exactly the note's text. */
+function textOffsetOf(container: HTMLElement, node: Node, offset: number): number {
+  const range = document.createRange();
+  range.selectNodeContents(container);
+  range.setEnd(node, offset);
+  return range.toString().length;
+}
+
+/**
+ * One content mutation applied to a note's text, and where the caret lands.
+ * Exported for its unit test: this is the whole semantics of "the first edit
+ * converts the note", and every branch of it is one `inputType`.
+ */
+export function applyPlainEdit(
+  text: string,
+  { start, end }: { start: number; end: number },
+  inputType: string,
+  data: string,
+): { text: string; caret: number } {
+  const from = Math.min(start, end);
+  const to = Math.max(start, end);
+  const splice = (insert: string, cutFrom = from, cutTo = to) => ({
+    text: text.slice(0, cutFrom) + insert + text.slice(cutTo),
+    caret: cutFrom + insert.length,
+  });
+
+  switch (inputType) {
+    case 'insertText':
+    case 'insertFromPaste':
+    case 'insertReplacementText':
+      return splice(data);
+    case 'insertParagraph':
+    case 'insertLineBreak':
+      return splice('\n');
+    default:
+      if (inputType.startsWith('delete')) {
+        const cut = deleteRange(text, from, to, inputType);
+        return splice('', cut.from, cut.to);
+      }
+      // Something we cannot reproduce (a formatting command): convert with the
+      // text unchanged and let the plain editor take the next keystroke, rather
+      // than guess at an edit.
+      return { text, caret: to };
+  }
+}
+
+/**
+ * What a deletion covers. A non-collapsed range *is* the deletion — the browser
+ * already resolved it, into `getTargetRanges()` or the selection. A collapsed
+ * one is a keystroke whose extent only the input type names, so widen it here;
+ * every delete type then goes through the one `splice('')` above. An extent we
+ * do not know stays collapsed, which converts the note and edits nothing.
+ */
+function deleteRange(text: string, from: number, to: number, inputType: string): { from: number; to: number } {
+  if (from !== to) return { from, to };
+  switch (inputType) {
+    case 'deleteContentBackward':
+      return { from: previousBoundary(text, from), to };
+    case 'deleteContentForward':
+      return { from, to: nextBoundary(text, to) };
+    case 'deleteWordBackward':
+      return { from: wordStart(text, from), to };
+    case 'deleteWordForward':
+      return { from, to: wordEnd(text, to) };
+    case 'deleteSoftLineBackward':
+    case 'deleteHardLineBackward':
+      return { from: lineStart(text, from), to };
+    case 'deleteSoftLineForward':
+    case 'deleteHardLineForward':
+      return { from, to: lineEnd(text, to) };
+    case 'deleteEntireSoftLine':
+      return { from: lineStart(text, from), to: lineEnd(text, to) };
+    default:
+      return { from, to };
+  }
+}
+
+/** Back over the whitespace before the caret, then over the word before that:
+ *  Option/Ctrl+Backspace's extent. A word is never split mid-surrogate-pair
+ *  because both halves are non-whitespace and go together. */
+function wordStart(text: string, index: number): number {
+  return text.slice(0, index).replace(/\s+$/, '').replace(/\S+$/, '').length;
+}
+
+/** The mirror after the caret: over the whitespace, then over the word. */
+function wordEnd(text: string, index: number): number {
+  const suffix = text.slice(index);
+  return text.length - suffix.replace(/^\s+/, '').replace(/^\S+/, '').length;
+}
+
+/** The start of the caret's line — just past the previous newline, which the
+ *  deletion keeps, or the start of the note. */
+function lineStart(text: string, index: number): number {
+  return index <= 0 ? 0 : text.lastIndexOf('\n', index - 1) + 1;
+}
+
+/** The end of the caret's line — the next newline, which the deletion keeps, or
+ *  the end of the note. */
+function lineEnd(text: string, index: number): number {
+  const next = text.indexOf('\n', index);
+  return next === -1 ? text.length : next;
+}
+
+function previousBoundary(text: string, index: number): number {
+  if (index <= 0) return 0;
+  const code = text.charCodeAt(index - 1);
+  // Step over a whole surrogate pair; half of one is not a character.
+  return index >= 2 && code >= 0xdc00 && code <= 0xdfff ? index - 2 : index - 1;
+}
+
+function nextBoundary(text: string, index: number): number {
+  if (index >= text.length) return text.length;
+  const code = text.charCodeAt(index);
+  return code >= 0xd800 && code <= 0xdbff && index + 2 <= text.length ? index + 2 : index + 1;
+}
diff --git a/lib/src/components/NotepadArchiveFailure.tsx b/lib/src/components/NotepadArchiveFailure.tsx
new file mode 100644
index 00000000..ecf82700
--- /dev/null
+++ b/lib/src/components/NotepadArchiveFailure.tsx
@@ -0,0 +1,65 @@
+import { useRef } from 'react';
+import { ModalFrame, modalActionButton } from './design';
+import { resolvePaneElement } from './wall/resolve-pane-element';
+
+/** The Surface whose closure was refused, and why. */
+export interface NotepadArchiveFailure {
+  id: string;
+  message: string;
+}
+
+/**
+ * The escape hatch for a closure the archive refused
+ * (docs/specs/notepad.md → "Closure"). Anchored over the Surface that stayed
+ * open, like the kill confirmation, so it is obvious which one is still there —
+ * and at the critical layer, because without a way through it an unwritable
+ * archive would make every Surface unclosable.
+ *
+ * Keep open is the default: Close anyway discards this Surface's notes for good.
+ */
+export function NotepadArchiveFailureModal({
+  failure,
+  paneElements,
+  onKeepOpen,
+  onCloseAnyway,
+}: {
+  failure: NotepadArchiveFailure;
+  paneElements: Map<string, HTMLElement>;
+  onKeepOpen: () => void;
+  onCloseAnyway: () => void;
+}) {
+  const keepOpenRef = useRef<HTMLButtonElement>(null);
+  return (
+    <ModalFrame
+      titleId="notepad-archive-failure-title"
+      targetElement={resolvePaneElement(paneElements.get(failure.id))}
+      layer="critical"
+      align="start"
+      className="w-full max-w-[24rem]"
+      initialFocusRef={keepOpenRef}
+      onEscape={onKeepOpen}
+    >
+      <h2 id="notepad-archive-failure-title" className="text-sm leading-5 text-foreground">
+        Notes could not be archived
+      </h2>
+      <p className="mt-2 text-sm text-muted">{failure.message}</p>
+      <div className="mt-4 flex justify-end gap-2">
+        <button
+          ref={keepOpenRef}
+          type="button"
+          onClick={onKeepOpen}
+          className={`${modalActionButton({ tone: 'primary' })} min-w-[5rem]`}
+        >
+          Keep open
+        </button>
+        <button
+          type="button"
+          onClick={onCloseAnyway}
+          className={`${modalActionButton({ tone: 'secondary' })} min-w-[5rem]`}
+        >
+          Close anyway
+        </button>
+      </div>
+    </ModalFrame>
+  );
+}
diff --git a/lib/src/components/NotepadArchiveView.test.tsx b/lib/src/components/NotepadArchiveView.test.tsx
new file mode 100644
index 00000000..ccccc136
--- /dev/null
+++ b/lib/src/components/NotepadArchiveView.test.tsx
@@ -0,0 +1,318 @@
+/**
+ * @vitest-environment jsdom
+ */
+import { act } from 'react';
+import { createRoot, type Root } from 'react-dom/client';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { setPlatform } from '../lib/platform';
+import { FakePtyAdapter } from '../lib/platform/fake-adapter';
+import { __resetArchiveServiceForTests } from '../lib/notepad/archive-service';
+import { clearAllNotepads } from '../lib/notepad/notepad-store';
+import type { ArchiveBatch, ArchivedNote, NotepadArchiveV1 } from '../lib/notepad/types';
+import type { CwdState } from '../lib/terminal-state';
+import { NotepadArchiveView } from './NotepadArchiveView';
+
+globalThis.IS_REACT_ACT_ENVIRONMENT = true;
+
+let container: HTMLDivElement;
+let root: Root;
+let platform: FakePtyAdapter;
+
+/** Fixed timestamps: the header renders an absolute date, so a relative "now"
+ *  would make these assertions drift with the clock. */
+const JAN = Date.parse('2026-01-05T10:00:00Z');
+const FEB = Date.parse('2026-02-05T10:00:00Z');
+const MAR = Date.parse('2026-03-05T10:00:00Z');
+
+const LOCAL_CWD: CwdState = {
+  path: '/Users/ned/projects/dormouse',
+  pathKind: 'posix',
+  isRemote: false,
+  source: 'osc7',
+  updatedAt: JAN,
+};
+
+const REMOTE_CWD: CwdState = {
+  path: '/srv/build/dormouse',
+  host: 'build-box',
+  scheme: 'file',
+  pathKind: 'posix',
+  isRemote: true,
+  source: 'osc7',
+  updatedAt: JAN,
+};
+
+function note(id: string, text: string): ArchivedNote {
+  return { id, createdAt: JAN, content: { kind: 'plain', text } };
+}
+
+function batch(over: Partial<ArchiveBatch> & Pick<ArchiveBatch, 'id'>): ArchiveBatch {
+  return {
+    closedAt: JAN,
+    surfaceTitle: over.id,
+    surfaceKind: 'terminal',
+    cwd: null,
+    notes: [note(`${over.id}-n1`, `${over.id} first`)],
+    ...over,
+  };
+}
+
+function archive(...batches: ArchiveBatch[]): NotepadArchiveV1 {
+  return { version: 1, batches };
+}
+
+function text(): string {
+  return container.textContent ?? '';
+}
+
+function byLabel(label: string): HTMLElement {
+  const found = container.querySelector<HTMLElement>(`[aria-label="${label}"]`);
+  if (!found) throw new Error(`no element labeled ${label}`);
+  return found;
+}
+
+function buttons(label: string): HTMLButtonElement[] {
+  return [...container.querySelectorAll('button')].filter(
+    (button) => (button.textContent ?? '').trim() === label,
+  );
+}
+
+function byText(label: string): HTMLButtonElement {
+  const found = buttons(label)[0];
+  if (!found) throw new Error(`no button reading ${label}`);
+  return found;
+}
+
+/** Every batch title in render order — the assertion for newest-first. */
+function batchTitles(): string[] {
+  return [...container.querySelectorAll('section > div > span:first-child')].map(
+    (span) => span.textContent ?? '',
+  );
+}
+
+async function render(props: Partial<Parameters<typeof NotepadArchiveView>[0]> = {}) {
+  await act(async () => {
+    root.render(
+      <NotepadArchiveView onBack={props.onBack ?? (() => {})} onClose={props.onClose ?? (() => {})} />,
+    );
+  });
+  // The view loads on mount; let that settle before anything asserts on it.
+  await act(async () => {});
+}
+
+beforeEach(() => {
+  container = document.createElement('div');
+  document.body.appendChild(container);
+  root = createRoot(container);
+  platform = new FakePtyAdapter();
+  setPlatform(platform);
+  __resetArchiveServiceForTests();
+  clearAllNotepads();
+});
+
+afterEach(async () => {
+  await act(async () => root.unmount());
+  container.remove();
+  __resetArchiveServiceForTests();
+  clearAllNotepads();
+  vi.restoreAllMocks();
+});
+
+describe('NotepadArchiveView', () => {
+  it('shows the newest batch first, notes in their captured order', async () => {
+    platform.notepadArchive.seed(
+      archive(
+        batch({ id: 'middle', surfaceTitle: 'middle', closedAt: FEB }),
+        batch({ id: 'oldest', surfaceTitle: 'oldest', closedAt: JAN }),
+        batch({
+          id: 'newest',
+          surfaceTitle: 'newest',
+          closedAt: MAR,
+          notes: [note('a', 'first note'), note('b', 'second note')],
+        }),
+      ),
+    );
+
+    await render();
+
+    expect(batchTitles()).toEqual(['newest', 'middle', 'oldest']);
+    expect(text().indexOf('first note')).toBeLessThan(text().indexOf('second note'));
+  });
+
+  it('renders a local CWD whole, a remote one with its host, and none at all', async () => {
+    platform.notepadArchive.seed(
+      archive(
+        batch({ id: 'local', closedAt: MAR, cwd: LOCAL_CWD }),
+        batch({ id: 'remote', closedAt: FEB, cwd: REMOTE_CWD }),
+        batch({ id: 'browser', closedAt: JAN, surfaceKind: 'browser', cwd: null }),
+      ),
+    );
+
+    await render();
+
+    expect(text()).toContain('/Users/ned/projects/dormouse');
+    expect(text()).toContain('build-box:/srv/build/dormouse');
+    // The kind chip is the browser batch's only metadata beyond its title.
+    expect(text()).toContain('browser');
+  });
+
+  it('hides a deleted note at once, and the batch once its last note is gone', async () => {
+    platform.notepadArchive.seed(
+      archive(
+        batch({
+          id: 'pair',
+          surfaceTitle: 'pair',
+          notes: [note('a', 'keep me'), note('b', 'delete me')],
+        }),
+      ),
+    );
+
+    await render();
+    expect(text()).toContain('delete me');
+
+    // Second note row: the buttons render in note order.
+    const deletes = () => [...container.querySelectorAll<HTMLButtonElement>('[aria-label="Delete note"]')];
+    await act(async () => deletes()[1]?.click());
+    expect(text()).not.toContain('delete me');
+    expect(text()).toContain('keep me');
+    expect(text()).toContain('Deletion is irreversible once this window closes.');
+
+    await act(async () => deletes()[0]?.click());
+    expect(batchTitles()).toEqual([]);
+    expect(text()).not.toContain('keep me');
+  });
+
+  it('restores everything staged when Undo is pressed', async () => {
+    platform.notepadArchive.seed(
+      archive(
+        batch({ id: 'one', surfaceTitle: 'one', closedAt: FEB }),
+        batch({ id: 'two', surfaceTitle: 'two', closedAt: JAN }),
+      ),
+    );
+
+    await render();
+    await act(async () => byText('Delete batch').click());
+    await act(async () => byLabel('Delete note').click());
+    expect(batchTitles()).toEqual([]);
+
+    await act(async () => byText('Undo').click());
+
+    expect(batchTitles()).toEqual(['one', 'two']);
+    expect(text()).not.toContain('Deletion is irreversible');
+  });
+
+  it('commits the whole staged set as one mutation on Back', async () => {
+    platform.notepadArchive.seed(
+      archive(
+        batch({ id: 'gone', surfaceTitle: 'gone', closedAt: FEB }),
+        batch({
+          id: 'trimmed',
+          surfaceTitle: 'trimmed',
+          closedAt: JAN,
+          notes: [note('a', 'keep me'), note('b', 'delete me')],
+        }),
+      ),
+    );
+    const save = vi.spyOn(platform.notepadArchive, 'save');
+    const onBack = vi.fn();
+
+    await render({ onBack });
+    await act(async () => byText('Delete batch').click());
+    const deletes = [...container.querySelectorAll<HTMLButtonElement>('[aria-label="Delete note"]')];
+    await act(async () => deletes[1]?.click());
+
+    await act(async () => byText('Back to Settings').click());
+
+    expect(save).toHaveBeenCalledTimes(1);
+    expect(onBack).toHaveBeenCalledTimes(1);
+    const stored = save.mock.calls[0]?.[0];
+    expect(stored?.batches.map((entry) => entry.id)).toEqual(['trimmed']);
+    expect(stored?.batches[0]?.notes.map((entry) => entry.id)).toEqual(['a']);
+    // Cleared on a successful commit, so a host that later loses the webview
+    // does not re-apply deletions that already landed.
+    expect(platform.notepadArchive.lastVolatileSnapshot()?.stagedDeletions).toEqual({});
+  });
+
+  it('mirrors the staged set while the view is open', async () => {
+    platform.notepadArchive.seed(archive(batch({ id: 'one' })));
+
+    await render();
+    await act(async () => byLabel('Delete note').click());
+
+    expect(platform.notepadArchive.lastVolatileSnapshot()?.stagedDeletions).toEqual({
+      deleteBatchIds: [],
+      deleteNotes: [{ batchId: 'one', noteId: 'one-n1' }],
+    });
+  });
+
+  it('stays open with its staged state when the commit fails', async () => {
+    platform.notepadArchive.seed(
+      archive(
+        batch({
+          id: 'pair',
+          surfaceTitle: 'pair',
+          notes: [note('a', 'keep me'), note('b', 'delete me')],
+        }),
+      ),
+    );
+    vi.spyOn(platform.notepadArchive, 'save').mockRejectedValue(new Error('disk is full'));
+    const onBack = vi.fn();
+
+    await render({ onBack });
+    const deletes = [...container.querySelectorAll<HTMLButtonElement>('[aria-label="Delete note"]')];
+    await act(async () => deletes[1]?.click());
+    await act(async () => byText('Back to Settings').click());
+
+    expect(onBack).not.toHaveBeenCalled();
+    expect(text()).toContain('disk is full');
+    // Still staged, and still hidden — the retry is pressing Back again.
+    expect(text()).not.toContain('delete me');
+    expect(text()).toContain('Deletion is irreversible once this window closes.');
+    expect(byText('Back to Settings').disabled).toBe(false);
+    expect(byText('Undo').disabled).toBe(false);
+  });
+
+  it('offers one recovery for an unreadable archive and never replaces it silently', async () => {
+    platform.notepadArchive.corrupt();
+
+    await render();
+    expect(text()).toContain('could not be read');
+    expect(text()).toContain('Nothing has been changed or replaced');
+
+    await act(async () => byText('Move it aside and start a new archive').click());
+
+    // The unreadable bytes were kept, not deleted, and the view is now an empty
+    // archive rather than an error.
+    expect(platform.notepadArchive.unreadableCopies()).toHaveLength(1);
+    expect(text()).toContain('Nothing archived yet');
+  });
+
+  it('reports a load failure with a retry rather than an empty archive', async () => {
+    const load = vi
+      .spyOn(platform.notepadArchive, 'load')
+      .mockRejectedValueOnce(new Error('storage unavailable'));
+
+    await render();
+    expect(text()).toContain('storage unavailable');
+
+    load.mockRestore();
+    platform.notepadArchive.seed(archive(batch({ id: 'back', surfaceTitle: 'back' })));
+    await act(async () => byText('Retry').click());
+    await act(async () => {});
+
+    expect(batchTitles()).toEqual(['back']);
+  });
+
+  it('flashes a confirmation on the note it copied', async () => {
+    const writeText = vi.fn(async () => {});
+    vi.stubGlobal('navigator', { ...navigator, clipboard: { writeText } });
+    platform.notepadArchive.seed(archive(batch({ id: 'one' })));
+
+    await render();
+    await act(async () => byLabel('Copy note').click());
+
+    expect(writeText).toHaveBeenCalledWith('one first');
+    expect(container.querySelector('[aria-label="Copied"]')).not.toBeNull();
+    vi.unstubAllGlobals();
+  });
+});
diff --git a/lib/src/components/NotepadArchiveView.tsx b/lib/src/components/NotepadArchiveView.tsx
new file mode 100644
index 00000000..b2c3ae87
--- /dev/null
+++ b/lib/src/components/NotepadArchiveView.tsx
@@ -0,0 +1,408 @@
+import { useCallback, useEffect, useMemo, useRef, useState, useSyncExternalStore } from 'react';
+import { ArrowLeftIcon } from '@phosphor-icons/react';
+import {
+  MODAL_OVERLAY_INSET,
+  ModalCloseButton,
+  ModalFrame,
+  OVERLAY_MAX_HEIGHT,
+  modalActionButton,
+} from './design';
+import {
+  ensureArchiveLoaded,
+  getArchiveSnapshot,
+  mutateArchive,
+  refreshArchive,
+  resetUnreadableArchive,
+  subscribeToArchive,
+} from '../lib/notepad/archive-service';
+import { messageOf } from '../lib/errors';
+import { setStagedArchiveDeletions } from '../lib/notepad/notepad-store';
+import { copyNote } from './use-notepad';
+import { NoteList } from './NoteList';
+import type { ArchiveBatch, ArchivedNote } from '../lib/notepad/types';
+import { cwdDisplay } from '../lib/terminal-state';
+
+const TITLE_ID = 'notepad-archive-title';
+
+
+/**
+ * Staged deletions, held only while this view is open (docs/specs/notepad.md ->
+ * Archive). A note is keyed by its batch as well as its own id, because note ids
+ * are only unique within a batch; the space separator is safe because both
+ * halves are minted ids, and `splitNoteKey` splits on the first one either way.
+ */
+interface StagedDeletions {
+  batchIds: ReadonlySet<string>;
+  notes: ReadonlySet<string>;
+}
+
+const NOTHING_STAGED: StagedDeletions = { batchIds: new Set(), notes: new Set() };
+
+function noteKey(batchId: string, noteId: string): string {
+  return `${batchId} ${noteId}`;
+}
+
+function splitNoteKey(key: string): { batchId: string; noteId: string } {
+  const gap = key.indexOf(' ');
+  return { batchId: key.slice(0, gap), noteId: key.slice(gap + 1) };
+}
+
+function isAnythingStaged(staged: StagedDeletions): boolean {
+  return staged.batchIds.size > 0 || staged.notes.size > 0;
+}
+
+/** The one shape both the mirror and the commit want. */
+function stagedMutation(staged: StagedDeletions) {
+  return {
+    deleteBatchIds: [...staged.batchIds],
+    deleteNotes: [...staged.notes].map(splitNoteKey),
+  };
+}
+
+/** Built once: constructing an `Intl.DateTimeFormat` per batch per render is the
+ *  expensive half of formatting a date. The locale is the host's, so a fixed
+ *  timestamp still renders deterministically for a story or a snapshot. */
+const CLOSED_AT_FORMAT = new Intl.DateTimeFormat(undefined, {
+  dateStyle: 'medium',
+  timeStyle: 'short',
+});
+
+function formatClosedAt(closedAt: number): string {
+  return CLOSED_AT_FORMAT.format(new Date(closedAt));
+}
+
+/**
+ * The archive as its own view, reached from the Settings dialog's Notepad
+ * archive entry and returning there (docs/specs/notepad.md -> Archive). Wider
+ * than Settings because a batch is a captured terminal excerpt, not a form row.
+ *
+ * Deletions are staged rather than applied: every one of them hides its target
+ * immediately, and the whole set is committed as one mutation on the way out —
+ * so Undo costs nothing and a failed write leaves the view exactly as it was.
+ */
+export function NotepadArchiveView({ onBack, onClose }: { onBack: () => void; onClose: () => void }) {
+  const state = useSyncExternalStore(subscribeToArchive, getArchiveSnapshot);
+  const closeRef = useRef<HTMLButtonElement>(null);
+  const [staged, setStaged] = useState<StagedDeletions>(NOTHING_STAGED);
+  const [committing, setCommitting] = useState(false);
+  const [commitError, setCommitError] = useState<string | null>(null);
+
+  useEffect(() => {
+    void ensureArchiveLoaded();
+  }, []);
+
+  // The VS Code extension host commits these on our behalf if the webview dies
+  // before the view closes, so the mirror has to track every change rather than
+  // only the final set (docs/specs/notepad.md -> Archive and Lifecycle).
+  useEffect(() => {
+    // Nothing staged mirrors as nothing at all, so a host cannot tell an
+    // emptied set from a view that never staged anything.
+    setStagedArchiveDeletions(isAnythingStaged(staged) ? stagedMutation(staged) : {});
+  }, [staged]);
+  useEffect(() => () => setStagedArchiveDeletions({}), []);
+
+  /**
+   * Leave, committing whatever is staged first. On failure the view stays put
+   * with its staged set intact and the error inline: pressing Back or close
+   * again is the retry, which is why nothing here is cleared on the way out.
+   */
+  const leave = useCallback(
+    (after: () => void) => {
+      if (committing) return;
+      if (!isAnythingStaged(staged)) {
+        after();
+        return;
+      }
+      setCommitting(true);
+      setCommitError(null);
+      void mutateArchive(stagedMutation(staged)).then(
+        () => {
+          setStagedArchiveDeletions({});
+          setStaged(NOTHING_STAGED);
+          setCommitting(false);
+          after();
+        },
+        (error: unknown) => {
+          setCommitting(false);
+          setCommitError(messageOf(error));
+        },
+      );
+    },
+    [committing, staged],
+  );
+
+  const back = useCallback(() => leave(onBack), [leave, onBack]);
+  const close = useCallback(() => leave(onClose), [leave, onClose]);
+
+  const deleteBatch = useCallback((batchId: string) => {
+    setStaged((current) => ({
+      batchIds: new Set(current.batchIds).add(batchId),
+      notes: current.notes,
+    }));
+  }, []);
+
+  const deleteNote = useCallback((batchId: string, noteId: string) => {
+    setStaged((current) => ({
+      batchIds: current.batchIds,
+      notes: new Set(current.notes).add(noteKey(batchId, noteId)),
+    }));
+  }, []);
+
+  // Newest first, notes in their original order within each batch. A batch left
+  // with nothing visible goes with them, so deleting the last note of a batch
+  // reads as deleting the batch.
+  const visible = useMemo(() => {
+    return state.archive.batches
+      .filter((batch) => !staged.batchIds.has(batch.id))
+      .map((batch) => ({
+        batch,
+        notes: batch.notes.filter((note) => !staged.notes.has(noteKey(batch.id, note.id))),
+      }))
+      .filter((entry) => entry.notes.length > 0)
+      .sort((a, b) => b.batch.closedAt - a.batch.closedAt);
+  }, [state.archive, staged]);
+
+  return (
+    <ModalFrame
+      titleId={TITLE_ID}
+      layer="app"
+      padding="spacious"
+      overlayClassName={MODAL_OVERLAY_INSET}
+      // Only the list scrolls: an archive is unbounded, and Back / Undo / close
+      // have to stay reachable however long it gets.
+      className={`${OVERLAY_MAX_HEIGHT.modal} flex w-full max-w-[48rem] flex-col overflow-hidden`}
+      initialFocusRef={closeRef}
+      // Escape leaves the dialog entirely, as it does from Settings — Back is
+      // the one control that returns there. It commits like every other exit.
+      onEscape={close}
+    >
+      <div className="flex items-start gap-3">
+        <h2 id={TITLE_ID} className="min-w-0 flex-1 text-sm leading-5 font-semibold text-foreground">
+          Notepad archive
+        </h2>
+        <button
+          type="button"
+          className={`${modalActionButton()} flex items-center gap-1`}
+          onClick={back}
+          disabled={committing}
+        >
+          <ArrowLeftIcon size={11} weight="bold" />
+          Back to Settings
+        </button>
+        <ModalCloseButton ref={closeRef} onClick={close} disabled={committing} />
+      </div>
+
+      {isAnythingStaged(staged) ? (
+        <div className="mt-3 flex items-center gap-3 rounded bg-header-inactive-bg px-2.5 py-1.5 text-sm text-foreground">
+          <span className="min-w-0 flex-1">
+            Deletion is irreversible once this window closes.
+          </span>
+          <button
+            type="button"
+            className={modalActionButton()}
+            onClick={() => setStaged(NOTHING_STAGED)}
+            disabled={committing}
+          >
+            Undo
+          </button>
+        </div>
+      ) : null}
+
+      {commitError ? (
+        <div role="alert" className="mt-3 text-sm leading-relaxed text-error">
+          Those deletions could not be saved: {commitError}
+        </div>
+      ) : null}
+
+      <div className="mt-3 min-h-0 flex-1 overflow-y-auto">
+        {/* `absent` renders nothing at all: it is both "this host has no
+            archive" — which the Settings entry gates on, so it cannot be
+            reached — and the frame before the first load lands. The chrome
+            above still renders, so the dialog is never a dead end. */}
+        {state.status === 'loading' ? (
+          <div className="text-sm text-muted">Loading the archive…</div>
+        ) : null}
+        {state.status === 'unreadable' ? (
+          <UnreadableArchive />
+        ) : null}
+        {state.status === 'error' ? (
+          <div className="text-sm leading-relaxed text-foreground">
+            <div role="alert" className="text-error">{state.error}</div>
+            <button
+              type="button"
+              className={`${modalActionButton()} mt-2`}
+              onClick={() => void refreshArchive()}
+            >
+              Retry
+            </button>
+          </div>
+        ) : null}
+        {state.status === 'ready' ? (
+          <ArchiveList
+            entries={visible}
+            emptyArchive={state.archive.batches.length === 0}
+            busy={committing}
+            onDeleteBatch={deleteBatch}
+            onDeleteNote={deleteNote}
+          />
+        ) : null}
+      </div>
+    </ModalFrame>
+  );
+}
+
+/**
+ * Stored data validation rejected. The copy has one job beyond the apology: say
+ * that nothing was replaced, because the single recovery offered here is the
+ * only thing in the app that ever moves an archive aside.
+ */
+function UnreadableArchive() {
+  const [running, setRunning] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+
+  const recover = () => {
+    setRunning(true);
+    setError(null);
+    void resetUnreadableArchive().then(
+      () => setRunning(false),
+      (failure: unknown) => {
+        setRunning(false);
+        setError(messageOf(failure));
+      },
+    );
+  };
+
+  return (
+    <div className="text-sm leading-relaxed text-foreground">
+      <div>
+        The stored notepad archive could not be read. Nothing has been changed or
+        replaced — the archived notes are still exactly as they were on disk.
+      </div>
+      <div className="mt-1 text-muted">
+        Recovering moves that data aside, keeping a copy, and starts an empty
+        archive. Until then nothing new can be archived.
+      </div>
+      <button
+        type="button"
+        className={`${modalActionButton({ tone: 'primary' })} mt-2`}
+        onClick={recover}
+        disabled={running}
+      >
+        Move it aside and start a new archive
+      </button>
+      {error ? (
+        <div role="alert" className="mt-2 text-error">
+          {error}
+        </div>
+      ) : null}
+    </div>
+  );
+}
+
+interface VisibleBatch {
+  batch: ArchiveBatch;
+  notes: ArchivedNote[];
+}
+
+function ArchiveList({
+  entries,
+  emptyArchive,
+  busy,
+  onDeleteBatch,
+  onDeleteNote,
+}: {
+  entries: VisibleBatch[];
+  /** Nothing has ever been archived, as opposed to everything being staged for
+   *  deletion — the two empty lists want different copy. */
+  emptyArchive: boolean;
+  /** A commit is in flight. Staging during one would be dropped when the commit
+   *  succeeds and resets the set, so the list goes inert instead. */
+  busy: boolean;
+  onDeleteBatch: (batchId: string) => void;
+  onDeleteNote: (batchId: string, noteId: string) => void;
+}) {
+  if (entries.length === 0) {
+    return (
+      <div className="text-sm leading-relaxed text-muted">
+        {emptyArchive
+          ? 'Nothing archived yet. When a terminal or browser holding notes closes, its notes land here.'
+          : 'Everything here is staged for deletion. Undo above brings it all back.'}
+      </div>
+    );
+  }
+
+  return (
+    <div className="flex flex-col gap-4">
+      {entries.map((entry) => (
+        <ArchiveBatchCard
+          key={entry.batch.id}
+          batch={entry.batch}
+          notes={entry.notes}
+          busy={busy}
+          onDeleteBatch={onDeleteBatch}
+          onDeleteNote={onDeleteNote}
+        />
+      ))}
+    </div>
+  );
+}
+
+function ArchiveBatchCard({
+  batch,
+  notes,
+  busy,
+  onDeleteBatch,
+  onDeleteNote,
+}: {
+  batch: ArchiveBatch;
+  notes: ArchivedNote[];
+  busy: boolean;
+  onDeleteBatch: (batchId: string) => void;
+  onDeleteNote: (batchId: string, noteId: string) => void;
+}) {
+  // Rendered from the stored `CwdState`, never from a label persisted beside it:
+  // the whole path and the remote host are what a batch is identified by weeks
+  // later (docs/specs/terminal-state.md).
+  const cwd = batch.cwd
+    ? cwdDisplay(batch.cwd, { style: 'full', includeHost: 'always' })
+    : null;
+
+  return (
+    <section className="border-t border-border pt-3 first:border-t-0 first:pt-0">
+      <div className="flex items-start gap-2">
+        <span className="min-w-0 truncate text-sm font-semibold text-foreground" title={batch.surfaceTitle}>
+          {batch.surfaceTitle}
+        </span>
+        <span className="shrink-0 rounded bg-header-inactive-bg px-1 text-xs text-header-inactive-fg">
+          {batch.surfaceKind}
+        </span>
+        <span className="min-w-0 flex-1 truncate text-xs text-muted">
+          {formatClosedAt(batch.closedAt)}
+        </span>
+        <button
+          type="button"
+          className={modalActionButton()}
+          onClick={() => onDeleteBatch(batch.id)}
+          disabled={busy}
+        >
+          Delete batch
+        </button>
+      </div>
+      {cwd ? (
+        <div className="mt-0.5 truncate text-xs text-muted" title={cwd}>
+          {cwd}
+        </div>
+      ) : null}
+      <div className="mt-2">
+        {/* Read-only by construction: no `onEdit`, no `onRevealSource` — the
+            markers a pin needs died with the terminal this came from. */}
+        <NoteList
+          notes={notes}
+          onCopy={copyNote}
+          onDelete={(note) => onDeleteNote(batch.id, note.id)}
+          disabled={busy}
+        />
+      </div>
+    </section>
+  );
+}
diff --git a/lib/src/components/NotepadBody.tsx b/lib/src/components/NotepadBody.tsx
new file mode 100644
index 00000000..237a10b1
--- /dev/null
+++ b/lib/src/components/NotepadBody.tsx
@@ -0,0 +1,146 @@
+import { useCallback, useEffect, useState, type CSSProperties, type RefObject } from 'react';
+import { PlusIcon } from '@phosphor-icons/react';
+import { clsx } from 'clsx';
+import { ModalCloseButton, POPUP_SURFACE_CLASS, popupButton } from './design';
+import { NoteList, type SourceNotice } from './NoteList';
+import { usePopoverFocusTrap } from './use-popover-focus-trap';
+import { copyNote, useNotes, useSurfaceClosing } from './use-notepad';
+import {
+  addPlainNote,
+  deleteNote,
+  getNotes,
+  pruneEmptyNote,
+  setNoteText,
+} from '../lib/notepad/notepad-store';
+import type { LiveNote } from '../lib/notepad/types';
+
+/**
+ * One Surface's notepad: the dialog element, its header, and the editable list
+ * (docs/specs/notepad.md → "Notepad UI").
+ *
+ * Both notepads are this component — `NotepadPanel` positions it inside a
+ * Surface body, `DoorNotepadPopover` portals it above a Door — so Add New and
+ * its focus, the blur/close prune, the keyboard ownership and the pin row have
+ * one implementation rather than two that must be kept identical. What differs
+ * is placement, which the caller supplies as `className` / `style` and reads
+ * back through `containerRef`.
+ */
+export function NotepadBody({
+  surfaceId,
+  containerRef,
+  className,
+  style,
+  dataAttributes,
+  sourceNotice,
+  onClose,
+  onRevealSource,
+}: {
+  surfaceId: string;
+  /** The dialog element, so a caller can measure it (the Door popover clamps
+   *  itself against the Wall once it knows its own size). */
+  containerRef: RefObject<HTMLDivElement | null>;
+  className?: string;
+  style?: CSSProperties;
+  /** Which notepad this is, for tests and stories. */
+  dataAttributes?: Record<string, string>;
+  sourceNotice: SourceNotice | null;
+  onClose: () => void;
+  onRevealSource?: (noteId: string) => void;
+}) {
+  const notes = useNotes(surfaceId);
+  // The Surface's closure has snapshotted these notes and is writing them: the
+  // store refuses every content mutation until it settles, so the panel says so
+  // rather than accepting edits it would silently drop.
+  const closing = useSurfaceClosing(surfaceId);
+  const [addedNoteId, setAddedNoteId] = useState<string | null>(null);
+
+  // Escape, Tab cycling, and outside-click dismissal, the same contract every
+  // other pane popover uses.
+  usePopoverFocusTrap(containerRef, onClose);
+
+  // Focus the dialog itself (not a note) so Escape reaches the focus trap even
+  // when a header button opened it.
+  useEffect(() => {
+    containerRef.current?.focus({ preventScroll: true });
+  }, [containerRef]);
+
+  // An Add New that was never typed into disappears with the notepad, exactly
+  // as it does on blur.
+  useEffect(() => () => {
+    for (const note of getNotes(surfaceId)) pruneEmptyNote(surfaceId, note.id);
+  }, [surfaceId]);
+
+  const addNote = useCallback(() => {
+    // `null` when the store refused it — there is then no note to put the caret
+    // in, and `autoFocusNoteId` matches none.
+    setAddedNoteId(addPlainNote(surfaceId));
+  }, [surfaceId]);
+
+  const editNote = useCallback((noteId: string, text: string) => {
+    setNoteText(surfaceId, noteId, text);
+  }, [surfaceId]);
+
+  const removeNote = useCallback((note: LiveNote) => {
+    deleteNote(surfaceId, note.id);
+  }, [surfaceId]);
+
+  const pruneNote = useCallback((noteId: string) => {
+    pruneEmptyNote(surfaceId, noteId);
+  }, [surfaceId]);
+
+  return (
+    <div
+      ref={containerRef}
+      // A dialog by role as well as by behavior: the browser surface's
+      // key-forwarder stands down for `[role="dialog"]` targets, so typing a
+      // note over a live browser never reaches the page.
+      role="dialog"
+      aria-label="Notepad"
+      tabIndex={-1}
+      {...dataAttributes}
+      className={clsx(POPUP_SURFACE_CLASS, 'flex flex-col overflow-hidden text-sm focus:outline-none', className)}
+      style={style}
+      // Clicks and keys inside are the notepad's alone: neither the pane's
+      // focus-on-click nor a surface's own key handling may see them.
+      onMouseDown={(e) => e.stopPropagation()}
+      onKeyDown={(e) => e.stopPropagation()}
+    >
+      <div className="flex shrink-0 items-center gap-1 border-b border-border px-2 py-1">
+        <span className="min-w-0 flex-1 truncate font-medium">Notepad</span>
+        <button
+          type="button"
+          className={clsx(popupButton(), 'flex items-center gap-1 rounded')}
+          aria-label="Add new note"
+          disabled={closing}
+          onClick={addNote}
+        >
+          <PlusIcon size={12} weight="bold" />
+          Add New
+        </button>
+        <ModalCloseButton aria-label="Close notepad" onClick={onClose} />
+      </div>
+      {closing && (
+        <div className="shrink-0 border-b border-border px-2 py-1 text-xs text-muted" role="status">
+          Archiving notes…
+        </div>
+      )}
+      <div className="min-h-0 flex-1 overflow-auto">
+        {notes.length === 0 ? (
+          <p className="px-2 py-2 text-muted">No notes yet.</p>
+        ) : (
+          <NoteList
+            notes={notes}
+            onCopy={copyNote}
+            onDelete={removeNote}
+            onEdit={editNote}
+            onRevealSource={onRevealSource}
+            sourceNotice={sourceNotice}
+            autoFocusNoteId={addedNoteId}
+            onNoteBlur={pruneNote}
+            disabled={closing}
+          />
+        )}
+      </div>
+    </div>
+  );
+}
diff --git a/lib/src/components/NotepadPanel.test.tsx b/lib/src/components/NotepadPanel.test.tsx
new file mode 100644
index 00000000..eb550b91
--- /dev/null
+++ b/lib/src/components/NotepadPanel.test.tsx
@@ -0,0 +1,707 @@
+/**
+ * @vitest-environment jsdom
+ */
+import { act, StrictMode } from 'react';
+import { createRoot, type Root } from 'react-dom/client';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { NotepadPanel } from './NotepadPanel';
+import { applyPlainEdit } from './NoteList';
+import {
+  DialogKeyboardContext,
+  createDialogKeyboardCoordinator,
+  useDialogKeyboardOwner,
+  type AcquireDialogKeyboard,
+} from './wall/wall-context';
+import { FakePtyAdapter } from '../lib/platform/fake-adapter';
+import { setPlatform } from '../lib/platform';
+import { setNativeFieldValue } from '../lib/dom';
+import { archiveSurfaceNotes } from '../lib/notepad/close-coordinator';
+import { __resetArchiveServiceForTests } from '../lib/notepad/archive-service';
+import {
+  addPlainNote,
+  addTerminalNote,
+  clearAllNotepads,
+  getNotes,
+  getOpenNotepadId,
+  setOpenNotepadId,
+} from '../lib/notepad/notepad-store';
+import type { RuntimeTerminalSource } from '../lib/notepad/types';
+import { registry, type TerminalEntry } from '../lib/terminal-store';
+
+globalThis.IS_REACT_ACT_ENVIRONMENT = true;
+
+const SURFACE = 'term-1';
+
+let container: HTMLDivElement;
+let root: Root;
+let platform: FakePtyAdapter;
+/** The real coordinator, so overlapping owners are reference-counted as in a Wall. */
+let dialogKeyboardActive: { current: boolean };
+let dialogKeyboard: AcquireDialogKeyboard;
+
+beforeEach(() => {
+  container = document.createElement('div');
+  document.body.appendChild(container);
+  root = createRoot(container);
+  platform = new FakePtyAdapter();
+  setPlatform(platform);
+  dialogKeyboardActive = { current: false };
+  dialogKeyboard = createDialogKeyboardCoordinator(dialogKeyboardActive);
+  __resetArchiveServiceForTests();
+});
+
+afterEach(() => {
+  act(() => root.unmount());
+  container.remove();
+  clearAllNotepads();
+  __resetArchiveServiceForTests();
+  platform.reset();
+});
+
+/** Stands in for a dialog already up when the notepad opens (Settings, a quit modal). */
+function FirstDialogOwner() {
+  useDialogKeyboardOwner(true);
+  return null;
+}
+
+/** Both panels a Wall would mount, so "one notepad per Wall" is observable. */
+function renderPanels(ids: string[] = [SURFACE]): void {
+  act(() => {
+    root.render(
+      <StrictMode>
+        <DialogKeyboardContext.Provider value={dialogKeyboard}>
+          {ids.map((id) => <NotepadPanel key={id} surfaceId={id} />)}
+        </DialogKeyboardContext.Provider>
+      </StrictMode>,
+    );
+  });
+}
+
+function panel(id = SURFACE): HTMLElement | null {
+  return container.querySelector<HTMLElement>(`[data-notepad-panel-for="${id}"]`);
+}
+
+function open(id = SURFACE): void {
+  act(() => setOpenNotepadId(id));
+}
+
+function noteElements(): HTMLElement[] {
+  return Array.from(container.querySelectorAll<HTMLElement>('[data-note-id]'));
+}
+
+function click(el: Element | null | undefined): void {
+  expect(el).toBeTruthy();
+  act(() => { (el as HTMLElement).dispatchEvent(new MouseEvent('click', { bubbles: true })); });
+}
+
+function buttonIn(note: HTMLElement, label: string): HTMLButtonElement {
+  const button = note.querySelector<HTMLButtonElement>(`[aria-label="${label}"]`);
+  expect(button).not.toBeNull();
+  return button!;
+}
+
+describe('NotepadPanel — open and close', () => {
+  it('renders only for the Surface the store names', () => {
+    addPlainNote(SURFACE, 'first');
+    addPlainNote('term-2', 'other');
+    renderPanels([SURFACE, 'term-2']);
+
+    expect(panel()).toBeNull();
+    open();
+    expect(panel()).not.toBeNull();
+    expect(panel('term-2')).toBeNull();
+
+    // The store holds one open id, so opening the second closes the first.
+    open('term-2');
+    expect(panel()).toBeNull();
+    expect(panel('term-2')).not.toBeNull();
+  });
+
+  it('stays hidden on a host with no notepad', () => {
+    // Pocket ships no archive port; the whole affordance goes with it.
+    setPlatform({ ...platform, notepadArchive: undefined } as unknown as FakePtyAdapter);
+    addPlainNote(SURFACE, 'first');
+    renderPanels();
+    open();
+
+    expect(panel()).toBeNull();
+  });
+
+  it('closes on Escape', () => {
+    addPlainNote(SURFACE, 'first');
+    renderPanels();
+    open();
+
+    act(() => {
+      window.dispatchEvent(new KeyboardEvent('keydown', { key: 'Escape', bubbles: true }));
+    });
+
+    expect(getOpenNotepadId()).toBeNull();
+    expect(panel()).toBeNull();
+  });
+
+  it('closes on an outside mousedown but not on its own', () => {
+    addPlainNote(SURFACE, 'first');
+    renderPanels();
+    open();
+
+    act(() => {
+      noteElements()[0].dispatchEvent(new MouseEvent('mousedown', { bubbles: true }));
+    });
+    expect(panel()).not.toBeNull();
+
+    act(() => {
+      document.body.dispatchEvent(new MouseEvent('mousedown', { bubbles: true }));
+    });
+    expect(panel()).toBeNull();
+  });
+
+  it('closes on its close button', () => {
+    renderPanels();
+    open();
+
+    click(container.querySelector('[aria-label="Close notepad"]'));
+
+    expect(getOpenNotepadId()).toBeNull();
+  });
+
+  it('owns the keyboard while open, and hands it back on close', () => {
+    renderPanels();
+    open();
+    expect(dialogKeyboardActive.current).toBe(true);
+
+    act(() => setOpenNotepadId(null));
+    expect(dialogKeyboardActive.current).toBe(false);
+  });
+
+  it('leaves an overlapping dialog\'s keyboard suppression standing when it closes', () => {
+    // Settings (or any first owner) is up; opening and closing the notepad over
+    // it must not release the lease that is not the notepad's.
+    act(() => {
+      root.render(
+        <StrictMode>
+          <DialogKeyboardContext.Provider value={dialogKeyboard}>
+            <FirstDialogOwner />
+            <NotepadPanel surfaceId={SURFACE} />
+          </DialogKeyboardContext.Provider>
+        </StrictMode>,
+      );
+    });
+    expect(dialogKeyboardActive.current).toBe(true);
+
+    open();
+    act(() => setOpenNotepadId(null));
+    expect(dialogKeyboardActive.current).toBe(true);
+
+    act(() => {
+      root.render(
+        <StrictMode>
+          <DialogKeyboardContext.Provider value={dialogKeyboard}>
+            <NotepadPanel surfaceId={SURFACE} />
+          </DialogKeyboardContext.Provider>
+        </StrictMode>,
+      );
+    });
+    expect(dialogKeyboardActive.current).toBe(false);
+  });
+
+  it('keeps its keystrokes out of the surface underneath', () => {
+    // The Wall's own handler stands down via DialogKeyboardContext above; this
+    // is the other half — a pane body's React key handling never sees them.
+    const paneKeyDown = vi.fn();
+    addPlainNote(SURFACE, 'first');
+    act(() => {
+      root.render(
+        <DialogKeyboardContext.Provider value={dialogKeyboard}>
+          <div onKeyDown={paneKeyDown}>
+            <NotepadPanel surfaceId={SURFACE} />
+          </div>
+        </DialogKeyboardContext.Provider>,
+      );
+    });
+    open();
+
+    act(() => {
+      noteElements()[0].dispatchEvent(new KeyboardEvent('keydown', { key: 'k', bubbles: true }));
+    });
+
+    expect(paneKeyDown).not.toHaveBeenCalled();
+  });
+});
+
+describe('NotepadPanel — notes', () => {
+  it('lists notes in creation order and adds new ones at the bottom', () => {
+    addPlainNote(SURFACE, 'first');
+    addPlainNote(SURFACE, 'second');
+    renderPanels();
+    open();
+
+    expect(noteElements().map((el) => el.querySelector('textarea')?.value)).toEqual(['first', 'second']);
+
+    click(container.querySelector('[aria-label="Add new note"]'));
+
+    expect(noteElements()).toHaveLength(3);
+    expect(getNotes(SURFACE).map((note) => note.content)).toEqual([
+      { kind: 'plain', text: 'first' },
+      { kind: 'plain', text: 'second' },
+      { kind: 'plain', text: '' },
+    ]);
+  });
+
+  it('writes edits straight through to the store', () => {
+    addPlainNote(SURFACE, 'first');
+    renderPanels();
+    open();
+
+    const textarea = noteElements()[0].querySelector('textarea')!;
+    act(() => setNativeFieldValue(textarea, 'first edited'));
+
+    expect(getNotes(SURFACE)[0].content).toEqual({ kind: 'plain', text: 'first edited' });
+  });
+
+  it('copies a note to the clipboard and flashes a check', () => {
+    const writeText = vi.fn(() => Promise.resolve());
+    vi.stubGlobal('navigator', { ...navigator, clipboard: { writeText } });
+    addPlainNote(SURFACE, 'copy me');
+    renderPanels();
+    open();
+
+    click(buttonIn(noteElements()[0], 'Copy note'));
+
+    expect(writeText).toHaveBeenCalledWith('copy me');
+    // The check replaces the copy glyph for the flash window, and the label
+    // says so for a screen reader.
+    expect(buttonIn(noteElements()[0], 'Copied').className).toContain('animate-copy-flash');
+    vi.unstubAllGlobals();
+  });
+
+  it('deletes a note', () => {
+    addPlainNote(SURFACE, 'first');
+    addPlainNote(SURFACE, 'second');
+    renderPanels();
+    open();
+
+    click(buttonIn(noteElements()[0], 'Delete note'));
+
+    expect(getNotes(SURFACE).map((note) => note.content)).toEqual([{ kind: 'plain', text: 'second' }]);
+  });
+
+  it('prunes an untouched empty note on blur, and keeps one with text', () => {
+    renderPanels();
+    open();
+    click(container.querySelector('[aria-label="Add new note"]'));
+
+    act(() => {
+      noteElements()[0].querySelector('textarea')!.dispatchEvent(new FocusEvent('focusout', { bubbles: true }));
+    });
+    expect(getNotes(SURFACE)).toHaveLength(0);
+
+    click(container.querySelector('[aria-label="Add new note"]'));
+    const textarea = noteElements()[0].querySelector('textarea')!;
+    act(() => setNativeFieldValue(textarea, 'typed'));
+    act(() => { textarea.dispatchEvent(new FocusEvent('focusout', { bubbles: true })); });
+
+    expect(getNotes(SURFACE).map((note) => note.content)).toEqual([{ kind: 'plain', text: 'typed' }]);
+  });
+
+  it('prunes an untouched empty note when the panel closes', () => {
+    addPlainNote(SURFACE, 'kept');
+    renderPanels();
+    open();
+    click(container.querySelector('[aria-label="Add new note"]'));
+    expect(getNotes(SURFACE)).toHaveLength(2);
+
+    act(() => setOpenNotepadId(null));
+
+    expect(getNotes(SURFACE).map((note) => note.content)).toEqual([{ kind: 'plain', text: 'kept' }]);
+  });
+});
+
+describe('NotepadPanel — closing', () => {
+  it('goes read-only while its Surface is being archived, then closes with it', async () => {
+    addPlainNote(SURFACE, 'first');
+    addTerminalNote(SURFACE, [{ text: 'boom' }]);
+    renderPanels();
+    open();
+
+    let release!: () => void;
+    const gate = new Promise<void>((resolve) => { release = resolve; });
+    const save = platform.notepadArchive.save.bind(platform.notepadArchive);
+    vi.spyOn(platform.notepadArchive, 'save').mockImplementation(async (archive, base) => {
+      await gate;
+      return save(archive, base);
+    });
+
+    let closing!: Promise<void>;
+    act(() => { closing = archiveSurfaceNotes([SURFACE]); });
+
+    // The panel says what is happening rather than taking edits the closure has
+    // already snapshotted past.
+    expect(panel()!.textContent).toContain('Archiving notes…');
+    expect(panel()!.querySelector('[role="status"]')).not.toBeNull();
+    expect(noteElements()[0].querySelector('textarea')!.readOnly).toBe(true);
+    const rich = noteElements()[1].querySelector<HTMLElement>('[role="textbox"]')!;
+    expect(rich.getAttribute('contenteditable')).toBe('false');
+    expect(rich.getAttribute('aria-readonly')).toBe('true');
+    expect(container.querySelector<HTMLButtonElement>('[aria-label="Add new note"]')!.disabled).toBe(true);
+    expect(buttonIn(noteElements()[0], 'Delete note').disabled).toBe(true);
+
+    await act(async () => {
+      release();
+      await closing;
+    });
+
+    // The notes are stored and forgotten, so the panel goes with the Surface.
+    expect(getNotes(SURFACE)).toEqual([]);
+    expect(getOpenNotepadId()).toBeNull();
+    expect(panel()).toBeNull();
+  });
+});
+
+describe('NotepadPanel — rich notes', () => {
+  const RUNS = [
+    { text: 'ok ', bold: true as const, foreground: '#00ff00' },
+    { text: 'done', italic: true as const },
+  ];
+
+  function richNote(): HTMLElement {
+    const el = noteElements()[0].querySelector<HTMLElement>('[role="textbox"]');
+    expect(el).not.toBeNull();
+    return el!;
+  }
+
+  function caretAt(el: HTMLElement, offset: number): void {
+    // Every run is one text node, so the caret is placed by walking them.
+    let remaining = offset;
+    for (const child of Array.from(el.childNodes)) {
+      const length = child.textContent?.length ?? 0;
+      if (remaining <= length) {
+        const range = document.createRange();
+        range.setStart(child.firstChild ?? child, remaining);
+        range.collapse(true);
+        const selection = window.getSelection()!;
+        selection.removeAllRanges();
+        selection.addRange(range);
+        return;
+      }
+      remaining -= length;
+    }
+    throw new Error(`offset ${offset} is past the note`);
+  }
+
+  function beforeInput(el: HTMLElement, inputType: string, data: string | null = null): void {
+    act(() => {
+      el.dispatchEvent(new InputEvent('beforeinput', { inputType, data, bubbles: true, cancelable: true }));
+    });
+  }
+
+  it('renders runs as styled spans, never as markup', () => {
+    addTerminalNote(SURFACE, [{ text: '<script>', bold: true }]);
+    renderPanels();
+    open();
+
+    const spans = richNote().querySelectorAll('span');
+    expect(spans).toHaveLength(1);
+    expect(spans[0].textContent).toBe('<script>');
+    expect(spans[0].style.fontWeight).toBe('bold');
+    expect(richNote().querySelector('script')).toBeNull();
+  });
+
+  it('does not convert when the caret only moves through it', () => {
+    addTerminalNote(SURFACE, RUNS);
+    renderPanels();
+    open();
+
+    const el = richNote();
+    caretAt(el, 3);
+    act(() => {
+      el.dispatchEvent(new KeyboardEvent('keydown', { key: 'ArrowRight', bubbles: true }));
+      document.dispatchEvent(new Event('selectionchange'));
+    });
+
+    expect(getNotes(SURFACE)[0].content.kind).toBe('terminal');
+  });
+
+  it('converts to plain on the first typed character, at the caret', () => {
+    addTerminalNote(SURFACE, RUNS);
+    renderPanels();
+    open();
+
+    caretAt(richNote(), 3);
+    beforeInput(richNote(), 'insertText', '!');
+
+    expect(getNotes(SURFACE)[0].content).toEqual({ kind: 'plain', text: 'ok !done' });
+    const textarea = noteElements()[0].querySelector('textarea')!;
+    expect(textarea.selectionStart).toBe(4);
+  });
+
+  it('converts on a deletion, removing the character before the caret', () => {
+    addTerminalNote(SURFACE, RUNS);
+    renderPanels();
+    open();
+
+    caretAt(richNote(), 3);
+    beforeInput(richNote(), 'deleteContentBackward');
+
+    expect(getNotes(SURFACE)[0].content).toEqual({ kind: 'plain', text: 'okdone' });
+    expect(noteElements()[0].querySelector('textarea')!.selectionStart).toBe(2);
+  });
+
+  it('converts on a word deletion, removing the word the caret sits after', () => {
+    addTerminalNote(SURFACE, RUNS);
+    renderPanels();
+    open();
+
+    // Option/Ctrl+Backspace: the document selection is the bare caret, and no
+    // target range comes with it, so the extent is the input type's alone.
+    caretAt(richNote(), 7);
+    beforeInput(richNote(), 'deleteWordBackward');
+
+    expect(getNotes(SURFACE)[0].content).toEqual({ kind: 'plain', text: 'ok ' });
+    expect(noteElements()[0].querySelector('textarea')!.selectionStart).toBe(3);
+  });
+
+  it('deletes the range the event names, across two runs', () => {
+    addTerminalNote(SURFACE, RUNS);
+    renderPanels();
+    open();
+
+    const el = richNote();
+    // The selection stays collapsed at the end; the extent lives only in
+    // `getTargetRanges()`, and reading it is the whole point.
+    caretAt(el, 7);
+    const spans = el.querySelectorAll('span');
+    const event = new InputEvent('beforeinput', {
+      inputType: 'deleteWordBackward',
+      bubbles: true,
+      cancelable: true,
+    });
+    Object.defineProperty(event, 'getTargetRanges', {
+      value: () => [{
+        collapsed: false,
+        startContainer: spans[0].firstChild!,
+        startOffset: 2,
+        endContainer: spans[1].firstChild!,
+        endOffset: 4,
+      } as StaticRange],
+    });
+    act(() => { el.dispatchEvent(event); });
+
+    expect(getNotes(SURFACE)[0].content).toEqual({ kind: 'plain', text: 'ok' });
+    expect(noteElements()[0].querySelector('textarea')!.selectionStart).toBe(2);
+  });
+
+  it('converts a line deletion back to the start of its line', () => {
+    addTerminalNote(SURFACE, [{ text: 'one\ntwo' }]);
+    renderPanels();
+    open();
+
+    caretAt(richNote(), 6);
+    beforeInput(richNote(), 'deleteSoftLineBackward');
+
+    expect(getNotes(SURFACE)[0].content).toEqual({ kind: 'plain', text: 'one\no' });
+    expect(noteElements()[0].querySelector('textarea')!.selectionStart).toBe(4);
+  });
+
+  it('leaves a composition alone until it ends, then converts with its text', () => {
+    addTerminalNote(SURFACE, RUNS);
+    renderPanels();
+    open();
+
+    const el = richNote();
+    caretAt(el, 7);
+    // `insertCompositionText` is not cancelable, so the handler stands down and
+    // the browser writes the composed text into the rich DOM itself.
+    act(() => {
+      el.dispatchEvent(new InputEvent('beforeinput', { inputType: 'insertCompositionText', data: '日本', bubbles: true }));
+    });
+    expect(getNotes(SURFACE)[0].content.kind).toBe('terminal');
+
+    act(() => { (el.querySelectorAll('span')[1].firstChild as Text).appendData('日本'); });
+    caretAt(el, 9);
+    act(() => { el.dispatchEvent(new CompositionEvent('compositionend', { data: '日本', bubbles: true })); });
+
+    expect(getNotes(SURFACE)[0].content).toEqual({ kind: 'plain', text: 'ok done日本' });
+    expect(noteElements()[0].querySelector('textarea')!.selectionStart).toBe(9);
+  });
+
+  it('pastes as plain text', () => {
+    addTerminalNote(SURFACE, RUNS);
+    renderPanels();
+    open();
+
+    caretAt(richNote(), 7);
+    const event = new InputEvent('beforeinput', {
+      inputType: 'insertFromPaste',
+      bubbles: true,
+      cancelable: true,
+    });
+    // jsdom's InputEvent takes no dataTransfer; the flavor is what matters.
+    Object.defineProperty(event, 'dataTransfer', {
+      value: { getData: (type: string) => (type === 'text/plain' ? '+pasted' : '') },
+    });
+    act(() => { richNote().dispatchEvent(event); });
+
+    expect(getNotes(SURFACE)[0].content).toEqual({ kind: 'plain', text: 'ok done+pasted' });
+  });
+});
+
+describe('NotepadPanel — source pins', () => {
+  /** Markers from a terminal instance this test never registers, so the pin is
+   *  guaranteed to fail — which is the path with UI of its own. */
+  function deadSource(): RuntimeTerminalSource {
+    const marker = { id: 0, line: 0, isDisposed: false, dispose() {}, onDispose: () => ({ dispose() {} }) };
+    return {
+      terminalId: SURFACE,
+      startMarker: marker,
+      endMarker: marker,
+      startColumn: 0,
+      endColumn: 4,
+      shape: 'linewise',
+      expectedRawText: 'gone',
+    } as unknown as RuntimeTerminalSource;
+  }
+
+  it('edits the shared list without pin controls in the Helper view', () => {
+    const id = addPlainNote(SURFACE, 'shared')!;
+    addTerminalNote(SURFACE, [{ text: 'parent output' }], deadSource());
+    act(() => root.render(<NotepadPanel surfaceId={SURFACE} pins={false} />));
+    open();
+    expect(noteElements()).toHaveLength(2);
+    expect(container.querySelector('[aria-label="Show source"]')).toBeNull();
+    expect(getNotes(SURFACE)[1].source).toBeDefined();
+    click(buttonIn(noteElements().find(note => note.dataset.noteId === id)!, 'Delete note'));
+    expect(getNotes(SURFACE)).toHaveLength(1);
+    act(() => root.render(<NotepadPanel surfaceId={SURFACE} />));
+    expect(container.querySelector('[aria-label="Show source"]')).not.toBeNull();
+  });
+
+  it('shows the pin only on a note that has a source', () => {
+    addPlainNote(SURFACE, 'no source here');
+    addTerminalNote(SURFACE, [{ text: 'gone' }], deadSource());
+    renderPanels();
+    open();
+
+    expect(container.querySelectorAll('[aria-label="Show source"]')).toHaveLength(1);
+    expect(noteElements()[1].querySelector('[aria-label="Show source"]')).not.toBeNull();
+  });
+
+  /** Registers a terminal instance for `SURFACE` whose alternate buffer is
+   *  active, the way a full-screen program leaves it. */
+  function fullScreenTerminal(): void {
+    registry.set(SURFACE, {
+      terminal: { buffer: { active: { type: 'alternate' } } },
+    } as unknown as TerminalEntry);
+  }
+
+  afterEach(() => registry.delete(SURFACE));
+
+  it('reopens with a message when the source is gone', () => {
+    addTerminalNote(SURFACE, [{ text: 'gone' }], deadSource());
+    renderPanels();
+    open();
+
+    click(container.querySelector('[aria-label="Show source"]'));
+
+    expect(getOpenNotepadId()).toBe(SURFACE);
+    expect(panel()!.textContent).toContain('Source no longer available');
+    // The failure is terminal for the pin, so the button goes with it.
+    expect(container.querySelector('[aria-label="Show source"]')).toBeNull();
+
+    // A message belongs to the panel that reported it.
+    act(() => setOpenNotepadId(null));
+    open();
+    expect(panel()!.textContent).not.toContain('Source no longer available');
+  });
+
+  it('keeps the pin and says to exit the full-screen program', () => {
+    addTerminalNote(SURFACE, [{ text: 'gone' }], deadSource());
+    fullScreenTerminal();
+    renderPanels();
+    open();
+
+    click(container.querySelector('[aria-label="Show source"]'));
+
+    expect(getOpenNotepadId()).toBe(SURFACE);
+    expect(panel()!.textContent).toContain('Exit the full-screen program to show this source');
+    expect(panel()!.textContent).not.toContain('Source no longer available');
+    // The markers outlive the program, so the pin is still there to retry.
+    expect(container.querySelector('[aria-label="Show source"]')).not.toBeNull();
+  });
+});
+
+describe('applyPlainEdit', () => {
+  const at = (offset: number) => ({ start: offset, end: offset });
+
+  it('replaces a selection with the typed text', () => {
+    expect(applyPlainEdit('abcdef', { start: 4, end: 1 }, 'insertText', 'X')).toEqual({ text: 'aXef', caret: 2 });
+  });
+
+  it('turns a new paragraph into a newline', () => {
+    expect(applyPlainEdit('ab', at(1), 'insertParagraph', '')).toEqual({ text: 'a\nb', caret: 2 });
+  });
+
+  it('deletes forward and backward one character', () => {
+    expect(applyPlainEdit('abc', at(2), 'deleteContentBackward', '')).toEqual({ text: 'ac', caret: 1 });
+    expect(applyPlainEdit('abc', at(2), 'deleteContentForward', '')).toEqual({ text: 'ab', caret: 2 });
+  });
+
+  it('deletes a word backward over the whitespace before it', () => {
+    expect(applyPlainEdit('foo bar', at(7), 'deleteWordBackward', '')).toEqual({ text: 'foo ', caret: 4 });
+    expect(applyPlainEdit('foo bar ', at(8), 'deleteWordBackward', '')).toEqual({ text: 'foo ', caret: 4 });
+    expect(applyPlainEdit('foo', at(0), 'deleteWordBackward', '')).toEqual({ text: 'foo', caret: 0 });
+  });
+
+  it('deletes a word forward over the whitespace after it', () => {
+    expect(applyPlainEdit('foo  bar baz', at(3), 'deleteWordForward', '')).toEqual({ text: 'foo baz', caret: 3 });
+    expect(applyPlainEdit('foo', at(3), 'deleteWordForward', '')).toEqual({ text: 'foo', caret: 3 });
+  });
+
+  it('deletes to the start or end of the caret line, keeping the newlines', () => {
+    const text = 'one\ntwo\nthree';
+    expect(applyPlainEdit(text, at(6), 'deleteSoftLineBackward', '')).toEqual({ text: 'one\no\nthree', caret: 4 });
+    expect(applyPlainEdit(text, at(6), 'deleteHardLineBackward', '')).toEqual({ text: 'one\no\nthree', caret: 4 });
+    expect(applyPlainEdit(text, at(6), 'deleteSoftLineForward', '')).toEqual({ text: 'one\ntw\nthree', caret: 6 });
+    expect(applyPlainEdit(text, at(6), 'deleteHardLineForward', '')).toEqual({ text: 'one\ntw\nthree', caret: 6 });
+    expect(applyPlainEdit(text, at(6), 'deleteEntireSoftLine', '')).toEqual({ text: 'one\n\nthree', caret: 4 });
+  });
+
+  it('stops a line deletion at the edges of the note', () => {
+    // The leading newline is the previous line's, and index 0 has no previous.
+    expect(applyPlainEdit('\nabc', at(0), 'deleteHardLineBackward', '')).toEqual({ text: '\nabc', caret: 0 });
+    expect(applyPlainEdit('abc', at(3), 'deleteSoftLineForward', '')).toEqual({ text: 'abc', caret: 3 });
+    expect(applyPlainEdit('abc', at(0), 'deleteSoftLineForward', '')).toEqual({ text: '', caret: 0 });
+  });
+
+  it('takes a non-collapsed range as given, whatever the delete type', () => {
+    // The browser already resolved the extent — into `getTargetRanges()` or the
+    // selection — so no type widens it.
+    for (const inputType of [
+      'deleteContentBackward', 'deleteContentForward',
+      'deleteWordBackward', 'deleteWordForward',
+      'deleteSoftLineBackward', 'deleteHardLineBackward',
+      'deleteSoftLineForward', 'deleteHardLineForward',
+      'deleteEntireSoftLine', 'deleteByCut', 'deleteByDrag',
+    ]) {
+      expect(applyPlainEdit('one\ntwo', { start: 5, end: 2 }, inputType, '')).toEqual({ text: 'onwo', caret: 2 });
+    }
+  });
+
+  it('converts but edits nothing for a collapsed delete it cannot size', () => {
+    expect(applyPlainEdit('abc', at(1), 'deleteByComposition', '')).toEqual({ text: 'abc', caret: 1 });
+  });
+
+  it('never leaves half a surrogate pair behind', () => {
+    const text = `a${'\u{1f600}'}b`;
+    expect(applyPlainEdit(text, at(3), 'deleteContentBackward', '')).toEqual({ text: 'ab', caret: 1 });
+    expect(applyPlainEdit(text, at(1), 'deleteContentForward', '')).toEqual({ text: 'ab', caret: 1 });
+    // A word deletion takes both halves with it: neither one is whitespace.
+    expect(applyPlainEdit(`hi ${'\u{1f600}'}`, at(5), 'deleteWordBackward', '')).toEqual({ text: 'hi ', caret: 3 });
+    expect(applyPlainEdit(`${'\u{1f600}'} hi`, at(0), 'deleteWordForward', '')).toEqual({ text: ' hi', caret: 0 });
+  });
+
+  it('leaves the text alone for an edit it cannot reproduce', () => {
+    // The note still converts — the plain editor takes whatever comes next.
+    expect(applyPlainEdit('abc', at(1), 'formatBold', '')).toEqual({ text: 'abc', caret: 1 });
+  });
+});
diff --git a/lib/src/components/NotepadPanel.tsx b/lib/src/components/NotepadPanel.tsx
new file mode 100644
index 00000000..727ef82e
--- /dev/null
+++ b/lib/src/components/NotepadPanel.tsx
@@ -0,0 +1,77 @@
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { NotepadBody } from './NotepadBody';
+import { sourceNoticeFor, type SourceNotice } from './NoteList';
+import { useOpenNotepadId } from './use-notepad';
+import { hasNotepadArchive } from '../lib/notepad/archive-service';
+import { useDialogKeyboardOwner } from './wall/wall-context';
+import { setOpenNotepadId } from '../lib/notepad/notepad-store';
+import { revealNoteSource } from '../lib/notepad/pin';
+
+/**
+ * The attached notepad: a panel in the top-right corner of a Surface's body,
+ * three quarters of it wide and tall (docs/specs/notepad.md → Notepad UI).
+ *
+ * Mounted by every Surface body but rendered only for the one open notepad —
+ * the store keeps a single `openNotepadId`, so a Wall never shows two. It stays
+ * mounted while closed so a failed pin can reopen it with its message.
+ */
+export function NotepadPanel({ surfaceId, pins = true }: { surfaceId: string; pins?: boolean }) {
+  const openId = useOpenNotepadId();
+  const [sourceNotice, setSourceNotice] = useState<SourceNotice | null>(null);
+  const open = openId === surfaceId;
+
+  // A pin closes the panel, follows the source, and on failure reopens it
+  // saying so. Both stores settle inside this one handler, so the panel below
+  // never unmounts in between and the message survives.
+  const revealSource = useCallback((noteId: string) => {
+    setOpenNotepadId(null);
+    const notice = sourceNoticeFor(noteId, revealNoteSource(surfaceId, noteId));
+    setSourceNotice(notice);
+    if (notice) setOpenNotepadId(surfaceId);
+  }, [surfaceId]);
+
+  // A message belongs to the panel that reported it; the next open starts clean.
+  useEffect(() => {
+    if (!open) setSourceNotice(null);
+  }, [open]);
+
+  if (!hasNotepadArchive() || !open) return null;
+  return (
+    <OpenNotepadPanel
+      surfaceId={surfaceId}
+      sourceNotice={sourceNotice}
+      onRevealSource={pins ? revealSource : undefined}
+    />
+  );
+}
+
+function OpenNotepadPanel({
+  surfaceId,
+  sourceNotice,
+  onRevealSource,
+}: {
+  surfaceId: string;
+  sourceNotice: SourceNotice | null;
+  onRevealSource?: (noteId: string) => void;
+}) {
+  const panelRef = useRef<HTMLDivElement>(null);
+
+  const close = useCallback(() => setOpenNotepadId(null), []);
+
+  // The panel owns the keyboard while open, so command-mode keys stay dormant
+  // under a note being typed into. Mounted only while open, so the lease is
+  // unconditional and independent of any other dialog's.
+  useDialogKeyboardOwner(true);
+
+  return (
+    <NotepadBody
+      surfaceId={surfaceId}
+      containerRef={panelRef}
+      className="absolute right-1 top-1 h-3/4 w-3/4"
+      dataAttributes={{ 'data-notepad-panel-for': surfaceId }}
+      sourceNotice={sourceNotice}
+      onClose={close}
+      onRevealSource={onRevealSource}
+    />
+  );
+}
diff --git a/lib/src/components/SelectionPopup.test.tsx b/lib/src/components/SelectionPopup.test.tsx
index 8f346d0f..344f162d 100644
--- a/lib/src/components/SelectionPopup.test.tsx
+++ b/lib/src/components/SelectionPopup.test.tsx
@@ -1,87 +1,254 @@
-/** @vitest-environment jsdom */
+/**
+ * @vitest-environment jsdom
+ */
 import { act } from 'react';
 import { createRoot, type Root } from 'react-dom/client';
-import { afterEach, beforeEach, expect, it, vi } from 'vitest';
-import { SelectionPopup } from './SelectionPopup';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+vi.mock('../lib/clipboard', () => ({ copyRaw: vi.fn(), copyRewrapped: vi.fn() }));
+vi.mock('../lib/platform', () => ({ IS_MAC: true }));
+// The registry barrel boots xterm; the popup only reads the measured grid.
+vi.mock('../lib/terminal-registry', () => ({ getTerminalOverlayDims: vi.fn() }));
+// Capture is exercised on its own; here it is only the button's effect.
+vi.mock('../lib/notepad/capture', () => ({
+  addSelectionToNotepad: vi.fn(() => true),
+  isNotepadChordBound: vi.fn(() => true),
+}));
+// Whether the host has a notepad at all — one gate, shared with the headers and
+// the Door (`hasNotepadArchive` in `lib/src/lib/notepad/archive-service.ts`).
+vi.mock('../lib/notepad/archive-service', () => ({ hasNotepadArchive: vi.fn(() => true) }));
+
 import { copyRaw } from '../lib/clipboard';
+import { addSelectionToNotepad, isNotepadChordBound } from '../lib/notepad/capture';
+import { hasNotepadArchive } from '../lib/notepad/archive-service';
 import {
-  __resetMouseSelectionForTests, beginDrag, bumpRenderTick, endDrag, flashCopy, getMouseSelectionState, setSelection,
+  __resetMouseSelectionForTests,
+  beginDrag,
+  bumpRenderTick,
+  endDrag,
+  flashCopy,
+  getMouseSelectionState,
+  setSelection,
 } from '../lib/mouse-selection';
-import type { TerminalOverlayDims } from '../lib/terminal-store';
-
-const mocks = vi.hoisted(() => ({ dims: null as TerminalOverlayDims | null }));
-vi.mock('../lib/terminal-registry', () => ({ getTerminalOverlayDims: () => mocks.dims }));
-vi.mock('../lib/clipboard', () => ({ copyRaw: vi.fn(), copyRewrapped: vi.fn() }));
+import { getTerminalOverlayDims } from '../lib/terminal-registry';
+import { SelectionPopup } from './SelectionPopup';
 
 globalThis.IS_REACT_ACT_ENVIRONMENT = true;
-let root: Root;
+
+const DIMS = {
+  cols: 80,
+  rows: 24,
+  viewportY: 0,
+  baseY: 0,
+  elementWidth: 900,
+  elementHeight: 400,
+  cellWidth: 8,
+  cellHeight: 16,
+  gridLeft: 4,
+  gridTop: 4,
+};
+
 let container: HTMLDivElement;
+let root: Root;
+
+function render(): void {
+  act(() => root.render(<SelectionPopup terminalId="term-1" />));
+}
+
+/** Render with a finalized selection, which is what raises the popup. */
+function renderWithSelection(): void {
+  act(() => {
+    setSelection('term-1', {
+      startRow: 1,
+      startCol: 0,
+      endRow: 2,
+      endCol: 10,
+      shape: 'linewise',
+      dragging: false,
+      startedInScrollback: false,
+    });
+  });
+  render();
+}
+
+/** Render one selection and read back where the clamp placed the popup. */
+function renderAndReadLeft(selection: { startRow: number; startCol: number; endRow: number; endCol: number }): number {
+  act(() => {
+    setSelection('term-1', {
+      ...selection,
+      shape: 'linewise',
+      dragging: false,
+      startedInScrollback: false,
+    });
+  });
+  render();
+  const popup = container.querySelector<HTMLElement>('[data-selection-popup-for="term-1"]');
+  return Number.parseFloat(popup?.style.left ?? 'NaN');
+}
+
+const buttons = () => Array.from(container.querySelectorAll('button')).map((b) => b.textContent ?? '');
+const notepadButton = () =>
+  Array.from(container.querySelectorAll('button')).find((b) => b.textContent?.includes('Add to notepad'));
 
 beforeEach(() => {
   __resetMouseSelectionForTests();
-  vi.mocked(copyRaw).mockReset();
-  mocks.dims = {
-    cols: 80, rows: 24, viewportY: 0, baseY: 10,
-    elementWidth: 800, elementHeight: 240, cellWidth: 10, cellHeight: 10, gridLeft: 0, gridTop: 0,
-  };
+  vi.mocked(getTerminalOverlayDims).mockReturnValue({ ...DIMS });
+  vi.mocked(addSelectionToNotepad).mockClear().mockReturnValue(true);
+  vi.mocked(hasNotepadArchive).mockReturnValue(true);
+  vi.mocked(isNotepadChordBound).mockReturnValue(true);
   container = document.createElement('div');
   document.body.appendChild(container);
   root = createRoot(container);
-  beginDrag('one', { row: 5, col: 3, altKey: false, startedInScrollback: true });
-  endDrag('one');
-  act(() => root.render(<SelectionPopup terminalId="one" />));
 });
 
 afterEach(() => {
   act(() => root.unmount());
   container.remove();
   vi.useRealTimers();
-  __resetMouseSelectionForTests();
 });
 
-it('reanchors after scrolling with the same finalized selection', () => {
-  const popup = () => container.querySelector<HTMLElement>('[data-selection-popup-for]')!;
-  expect(popup().style.top).toBe('74px');
-  mocks.dims!.viewportY = 3;
-  act(() => bumpRenderTick());
-  expect(popup().style.top).toBe('44px');
-});
+describe('SelectionPopup: Add to notepad', () => {
+  it('offers the capture after the two copies, with its chord', () => {
+    renderWithSelection();
 
-it('dismisses immediately when selection is canceled during the copied flash', () => {
-  vi.useFakeTimers();
-  act(() => flashCopy('one', 'raw'));
-  act(() => setSelection('one', null));
-  expect(container.querySelector('[data-selection-popup-for]')).toBeNull();
-});
+    expect(buttons()).toEqual(['[Cmd+C] Copy Raw', '[Cmd+Shift+C] Copy Rewrapped', '[Cmd+N] Add to notepad']);
+  });
 
-it('keeps a newer copied selection for its own confirmation duration', () => {
-  vi.useFakeTimers();
-  act(() => flashCopy('one', 'raw'));
-  act(() => vi.advanceTimersByTime(400));
-  act(() => {
-    beginDrag('one', { row: 8, col: 1, altKey: false, startedInScrollback: true });
-    endDrag('one');
-    flashCopy('one', 'raw');
+  it('hides the button entirely on a host with no notepad', () => {
+    vi.mocked(hasNotepadArchive).mockReturnValue(false);
+    renderWithSelection();
+
+    expect(notepadButton()).toBeUndefined();
+    expect(buttons()).toHaveLength(2);
   });
-  act(() => vi.advanceTimersByTime(300));
-  expect(getMouseSelectionState('one').selection?.startRow).toBe(8);
-  act(() => vi.advanceTimersByTime(400));
-  expect(getMouseSelectionState('one').selection).toBeNull();
-});
 
-it('retains a selection without a success flash when copying fails', async () => {
-  vi.mocked(copyRaw).mockResolvedValue(false);
-  await act(async () => container.querySelector<HTMLButtonElement>('button')!.click());
-  expect(getMouseSelectionState('one').copyFlash).toBeNull();
-  expect(getMouseSelectionState('one').selection).not.toBeNull();
+  it('keeps the button but shows no chord when the browser reserves it', () => {
+    vi.mocked(isNotepadChordBound).mockReturnValue(false);
+    renderWithSelection();
+
+    expect(notepadButton()?.textContent).toBe('Add to notepad');
+    // The copy chords are unaffected — only N is the browser's.
+    expect(buttons()[0]).toBe('[Cmd+C] Copy Raw');
+  });
+
+  it('captures and flashes on click, then dismisses the selection', () => {
+    vi.useFakeTimers();
+    try {
+      renderWithSelection();
+      act(() => {
+        notepadButton()?.dispatchEvent(new MouseEvent('click', { bubbles: true }));
+      });
+
+      expect(addSelectionToNotepad).toHaveBeenCalledWith('term-1');
+      expect(getMouseSelectionState('term-1').copyFlash).toBe('notepad');
+      // The check is laid over the (hidden, still-measured) shortcut, so the
+      // button keeps its width while it flashes.
+      expect(notepadButton()?.className).toContain('animate-copy-flash');
+      expect(notepadButton()?.querySelector('.invisible')?.textContent).toBe('[Cmd+N]');
+
+      // The same timer the copies use clears the flash *and* the selection, so
+      // the popup dismisses without ever opening the notepad.
+      act(() => {
+        vi.runAllTimers();
+      });
+      expect(getMouseSelectionState('term-1').copyFlash).toBeNull();
+      expect(getMouseSelectionState('term-1').selection).toBeNull();
+      expect(container.querySelector('button')).toBeNull();
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
+  it('does not flash when there was nothing to capture', () => {
+    vi.mocked(addSelectionToNotepad).mockReturnValue(false);
+    renderWithSelection();
+    act(() => {
+      notepadButton()?.dispatchEvent(new MouseEvent('click', { bubbles: true }));
+    });
+
+    expect(getMouseSelectionState('term-1').copyFlash).toBeNull();
+    expect(getMouseSelectionState('term-1').selection).not.toBeNull();
+  });
+
+  it('reserves room for the third button when clamping to the right edge', () => {
+    // End column 60 of an 600px-wide element is past where either row fits, so
+    // the left is the reserve and nothing else.
+    vi.mocked(getTerminalOverlayDims).mockReturnValue({ ...DIMS, elementWidth: 600 });
+    const leftWith = renderAndReadLeft({ startRow: 1, startCol: 0, endRow: 2, endCol: 60 });
+
+    act(() => root.unmount());
+    root = createRoot(container);
+    vi.mocked(hasNotepadArchive).mockReturnValue(false);
+    const leftWithout = renderAndReadLeft({ startRow: 1, startCol: 0, endRow: 2, endCol: 60 });
+
+    expect(leftWith).toBeGreaterThan(0);
+    expect(leftWith).toBeLessThan(leftWithout);
+  });
 });
 
-it('does not clear a newer selection when a previous copy finishes', async () => {
-  let complete!: (copied: boolean) => void;
-  vi.mocked(copyRaw).mockImplementation(() => new Promise((resolve) => { complete = resolve; }));
-  act(() => container.querySelector<HTMLButtonElement>('button')!.click());
-  act(() => beginDrag('one', { row: 8, col: 1, altKey: false, startedInScrollback: true }));
-  await act(async () => complete(true));
-  expect(getMouseSelectionState('one').copyFlash).toBeNull();
-  expect(getMouseSelectionState('one').selection?.startRow).toBe(8);
+describe('SelectionPopup: copy and flash', () => {
+  // A ten-line viewport over ten scrollback lines, so a scroll moves the anchor
+  // by whole cells.
+  const COPY_DIMS = { ...DIMS, baseY: 10, elementWidth: 800, elementHeight: 240, cellWidth: 10, cellHeight: 10, gridLeft: 0, gridTop: 0 };
+  let dims: typeof COPY_DIMS;
+  const popup = () => container.querySelector<HTMLElement>('[data-selection-popup-for]')!;
+  const copyRawButton = () => container.querySelector<HTMLButtonElement>('button')!;
+  /** A finalized drag starting in scrollback, as the mouse handlers raise it. */
+  const drag = (row: number, col: number) => {
+    beginDrag('term-1', { row, col, altKey: false, startedInScrollback: true });
+    endDrag('term-1');
+  };
+
+  beforeEach(() => {
+    dims = { ...COPY_DIMS };
+    vi.mocked(getTerminalOverlayDims).mockImplementation(() => dims);
+    vi.mocked(copyRaw).mockReset();
+    drag(5, 3);
+    render();
+  });
+
+  it('reanchors after scrolling with the same finalized selection', () => {
+    expect(popup().style.top).toBe('74px');
+    dims.viewportY = 3;
+    act(() => bumpRenderTick());
+    expect(popup().style.top).toBe('44px');
+  });
+
+  it('dismisses immediately when selection is canceled during the copied flash', () => {
+    vi.useFakeTimers();
+    act(() => flashCopy('term-1', 'raw'));
+    act(() => setSelection('term-1', null));
+    expect(container.querySelector('[data-selection-popup-for]')).toBeNull();
+  });
+
+  it('keeps a newer copied selection for its own confirmation duration', () => {
+    vi.useFakeTimers();
+    act(() => flashCopy('term-1', 'raw'));
+    act(() => vi.advanceTimersByTime(400));
+    act(() => {
+      drag(8, 1);
+      flashCopy('term-1', 'raw');
+    });
+    act(() => vi.advanceTimersByTime(300));
+    expect(getMouseSelectionState('term-1').selection?.startRow).toBe(8);
+    act(() => vi.advanceTimersByTime(400));
+    expect(getMouseSelectionState('term-1').selection).toBeNull();
+  });
+
+  it('retains a selection without a success flash when copying fails', async () => {
+    vi.mocked(copyRaw).mockResolvedValue(false);
+    await act(async () => copyRawButton().click());
+    expect(getMouseSelectionState('term-1').copyFlash).toBeNull();
+    expect(getMouseSelectionState('term-1').selection).not.toBeNull();
+  });
+
+  it('does not clear a newer selection when a previous copy finishes', async () => {
+    let complete!: (copied: boolean) => void;
+    vi.mocked(copyRaw).mockImplementation(() => new Promise((resolve) => { complete = resolve; }));
+    act(() => copyRawButton().click());
+    act(() => beginDrag('term-1', { row: 8, col: 1, altKey: false, startedInScrollback: true }));
+    await act(async () => complete(true));
+    expect(getMouseSelectionState('term-1').copyFlash).toBeNull();
+    expect(getMouseSelectionState('term-1').selection?.startRow).toBe(8);
+  });
 });
diff --git a/lib/src/components/SelectionPopup.tsx b/lib/src/components/SelectionPopup.tsx
index 26406b81..6cb2d02b 100644
--- a/lib/src/components/SelectionPopup.tsx
+++ b/lib/src/components/SelectionPopup.tsx
@@ -1,14 +1,18 @@
 import { useContext, useLayoutEffect, useState, useEffect, useSyncExternalStore, type CSSProperties } from 'react';
 import {
   DEFAULT_MOUSE_SELECTION_STATE,
+  flashCopy,
   getMouseSelectionSnapshot,
   getRenderTick,
   setSelection,
   subscribeToMouseSelection,
   subscribeToRenderTick,
+  type CopyFlashKind,
 } from '../lib/mouse-selection';
 import { copySelection } from '../lib/copy-selection';
 import { CheckIcon } from '@phosphor-icons/react';
+import { hasNotepadArchive } from '../lib/notepad/archive-service';
+import { addSelectionToNotepad, isNotepadChordBound } from '../lib/notepad/capture';
 import { IS_MAC } from '../lib/platform';
 import { getTerminalOverlayDims } from '../lib/terminal-registry';
 import { PopupButtonRow, popupButton, Shortcut } from './design';
@@ -24,9 +28,22 @@ interface Props {
   terminalId: string;
 }
 
+// The left clamp has to know how wide the popup will be before it exists, and
+// the row is three variable-length labels wide (or two, with no notepad). Mono
+// `text-sm` is 12px with a ~0.6em advance; each button adds `px-1.5` either
+// side and the row itself a 1px border either side.
+const CHAR_PX = 7.2;
+const BUTTON_PADDING_PX = 12;
+const ROW_BORDER_PX = 2;
+
+function estimatePopupWidth(labels: readonly string[]): number {
+  return labels.reduce((sum, label) => sum + label.length * CHAR_PX + BUTTON_PADDING_PX, ROW_BORDER_PX);
+}
+
 /**
- * Popup shown after a selection is finalized (mouse-up). Offers Copy Raw
- * and Copy Rewrapped. Dismissed on Esc, click-outside, or a successful copy.
+ * Popup shown after a selection is finalized (mouse-up). Offers Copy Raw,
+ * Copy Rewrapped, and — where the host has a notepad — Add to notepad.
+ * Dismissed on Esc, click-outside, or a successful copy or capture.
  */
 export function SelectionPopup({ terminalId }: Props) {
   const touchUi = useContext(TouchUiContext);
@@ -39,6 +56,17 @@ export function SelectionPopup({ terminalId }: Props) {
 
   const [anchor, setAnchor] = useState<Anchor | null>(null);
 
+  const showNotepad = hasNotepadArchive();
+  // The touch UI has no keyboard, and the website demo's browser has already
+  // claimed the chord, so both keep the button and drop the label.
+  const showShortcuts = !touchUi;
+  const copyShortcut = IS_MAC ? 'Cmd+C' : 'Ctrl+C';
+  const rewrapShortcut = IS_MAC ? 'Cmd+Shift+C' : 'Ctrl+Shift+C';
+  const notepadShortcut = isNotepadChordBound() ? (IS_MAC ? 'Cmd+N' : 'Ctrl+N') : null;
+
+  const label = (text: string, shortcut: string | null) =>
+    showShortcuts && shortcut ? `[${shortcut}] ${text}` : text;
+
   useLayoutEffect(() => {
     if (!shouldRender || !selection) {
       setAnchor(null);
@@ -46,6 +74,13 @@ export function SelectionPopup({ terminalId }: Props) {
     }
     const dims = getTerminalOverlayDims(terminalId);
     if (!dims || dims.cols === 0 || dims.rows === 0) return;
+    // Estimated here rather than per render: this clamp is its only consumer,
+    // and the popup re-renders on every xterm frame of every pane.
+    const popupWidth = estimatePopupWidth([
+      label('Copy Raw', copyShortcut),
+      label('Copy Rewrapped', rewrapShortcut),
+      ...(showNotepad ? [label('Add to notepad', notepadShortcut)] : []),
+    ]);
     // Use the measured cell grid so the anchor aligns with the border
     // outline (the overlay pulls from the same dims).
     const { cellWidth, cellHeight, gridLeft, gridTop } = dims;
@@ -58,7 +93,12 @@ export function SelectionPopup({ terminalId }: Props) {
     // this, the popup (shorter than the hint) would appear closer to the
     // selection than the hint did on drag-up.
     const draggedDown = selection.endRow >= selection.startRow;
-    const left = Math.min(dims.elementWidth - 300, Math.max(0, gridLeft + selection.endCol * cellWidth));
+    // Outer `max(0, …)`: in a pane too narrow to hold the whole row, pin it to
+    // the left edge rather than pushing its first button off screen.
+    const left = Math.max(
+      0,
+      Math.min(dims.elementWidth - popupWidth, gridLeft + selection.endCol * cellWidth),
+    );
     let next: Anchor;
     if (touchUi) {
       // Mobile: always sit above the selection so the dragging thumb (which ends
@@ -83,7 +123,7 @@ export function SelectionPopup({ terminalId }: Props) {
     setAnchor((prev) => (prev && prev.left === next.left && prev.top === next.top && prev.bottom === next.bottom)
       ? prev
       : next);
-  }, [terminalId, shouldRender, selection, touchUi, renderTick]);
+  }, [terminalId, shouldRender, selection, touchUi, renderTick, showNotepad, showShortcuts, copyShortcut, rewrapShortcut, notepadShortcut]);
 
   useEffect(() => {
     if (!shouldRender) return;
@@ -114,9 +154,6 @@ export function SelectionPopup({ terminalId }: Props) {
 
   if (!shouldRender || !anchor) return null;
 
-  const copyShortcut = IS_MAC ? 'Cmd+C' : 'Ctrl+C';
-  const rewrapShortcut = IS_MAC ? 'Cmd+Shift+C' : 'Ctrl+Shift+C';
-
   const style: CSSProperties = {
     position: 'absolute',
     left: anchor.left,
@@ -127,14 +164,20 @@ export function SelectionPopup({ terminalId }: Props) {
 
   const onCopy = (rewrapped: boolean) => copySelection(terminalId, rewrapped);
 
-  const flashed = (kind: 'raw' | 'rewrapped') => state.copyFlash === kind;
-  const buttonClass = (kind: 'raw' | 'rewrapped') => popupButton({ flashed: flashed(kind) });
+  // The flash is the whole confirmation: it clears the selection when it ends,
+  // which dismisses the popup without ever showing the notepad.
+  const onAddToNotepad = () => {
+    if (addSelectionToNotepad(terminalId)) flashCopy(terminalId, 'notepad');
+  };
 
-  // The touch UI has no keyboard, so drop the shortcut hint there and keep only the
-  // copy-success check. On desktop the check sits over the (hidden) shortcut so the
-  // button width stays put while it flashes.
-  const leadingIndicator = (kind: 'raw' | 'rewrapped', shortcut: string) => {
-    if (touchUi) {
+  const flashed = (kind: CopyFlashKind) => state.copyFlash === kind;
+  const buttonClass = (kind: CopyFlashKind) => popupButton({ flashed: flashed(kind) });
+
+  // With a shortcut the check sits over the (hidden) label, so the button width
+  // stays put while it flashes; with none there is nothing to hide behind and
+  // the check simply appears.
+  const leadingIndicator = (kind: CopyFlashKind, shortcut: string | null) => {
+    if (!showShortcuts || !shortcut) {
       return flashed(kind) ? (
         <span className="mr-1 inline-flex items-center align-middle">
           <CheckIcon size={12} weight="bold" />
@@ -177,6 +220,16 @@ export function SelectionPopup({ terminalId }: Props) {
         {leadingIndicator('rewrapped', rewrapShortcut)}
         Copy Rewrapped
       </button>
+      {showNotepad && (
+        <button
+          type="button"
+          className={buttonClass('notepad')}
+          onClick={onAddToNotepad}
+        >
+          {leadingIndicator('notepad', notepadShortcut)}
+          Add to notepad
+        </button>
+      )}
     </PopupButtonRow>
   );
 }
diff --git a/lib/src/components/SettingsDialog.test.tsx b/lib/src/components/SettingsDialog.test.tsx
new file mode 100644
index 00000000..7220ad5a
--- /dev/null
+++ b/lib/src/components/SettingsDialog.test.tsx
@@ -0,0 +1,75 @@
+/**
+ * @vitest-environment jsdom
+ */
+import { act } from 'react';
+import { createRoot, type Root } from 'react-dom/client';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { setPlatform } from '../lib/platform';
+import { FakePtyAdapter } from '../lib/platform/fake-adapter';
+import { __resetArchiveServiceForTests } from '../lib/notepad/archive-service';
+import { clearAllNotepads } from '../lib/notepad/notepad-store';
+import { SettingsDialog } from './SettingsDialog';
+
+globalThis.IS_REACT_ACT_ENVIRONMENT = true;
+
+let container: HTMLDivElement;
+let root: Root;
+let platform: FakePtyAdapter;
+
+function text(): string {
+  return container.textContent ?? '';
+}
+
+function byText(label: string): HTMLButtonElement {
+  const found = [...container.querySelectorAll('button')].find(
+    (button) => (button.textContent ?? '').trim() === label,
+  );
+  if (!found) throw new Error(`no button reading ${label}`);
+  return found;
+}
+
+async function render() {
+  await act(async () => root.render(<SettingsDialog onClose={() => {}} />));
+  await act(async () => {});
+}
+
+beforeEach(() => {
+  container = document.createElement('div');
+  document.body.appendChild(container);
+  root = createRoot(container);
+  platform = new FakePtyAdapter();
+  setPlatform(platform);
+  __resetArchiveServiceForTests();
+  clearAllNotepads();
+});
+
+afterEach(async () => {
+  await act(async () => root.unmount());
+  container.remove();
+  __resetArchiveServiceForTests();
+  clearAllNotepads();
+});
+
+describe('SettingsDialog notepad archive entry', () => {
+  it('opens the Archive view in place and comes back', async () => {
+    await render();
+    expect(text()).toContain('Notepad archive');
+
+    await act(async () => byText('Open archive').click());
+    // Same dialog, different view: the archive's own chrome is what proves it.
+    expect(byText('Back to Settings')).toBeTruthy();
+    expect(text()).toContain('Nothing archived yet');
+
+    await act(async () => byText('Back to Settings').click());
+    expect(byText('Open archive')).toBeTruthy();
+  });
+
+  it('offers no entry on a host with no archive port', async () => {
+    // Pocket's shape: the adapter simply has no `notepadArchive` at all.
+    Reflect.deleteProperty(platform, 'notepadArchive');
+
+    await render();
+
+    expect(text()).not.toContain('Notepad archive');
+  });
+});
diff --git a/lib/src/components/SettingsDialog.tsx b/lib/src/components/SettingsDialog.tsx
index 891a35d1..af3ed798 100644
--- a/lib/src/components/SettingsDialog.tsx
+++ b/lib/src/components/SettingsDialog.tsx
@@ -8,14 +8,17 @@ import {
   OnOffSwitch,
   Shortcut,
   UNDER_SWITCH_INDENT,
+  modalActionButton,
 } from './design';
 import { ExternalTextLink } from './ExternalTextLink';
+import { NotepadArchiveView } from './NotepadArchiveView';
 import { ThemePicker } from './ThemePicker';
 import { ShellPicker } from './ShellPicker';
 import { WatchedCommandList } from './WatchedCommandList';
 import { RemoteControlSection } from './RemoteControlSection';
 import { PushTestButton, SpeakTestButton } from './AlarmTestButtons';
 import { getPlatform } from '../lib/platform';
+import { hasNotepadArchive } from '../lib/notepad/archive-service';
 import { getShellsSnapshot, subscribeToShells } from '../lib/shell-store';
 import {
   clampAlertDelayMs,
@@ -92,6 +95,10 @@ export function SettingsDialog({ onClose }: { onClose: () => void }) {
   // One union rather than a boolean per picker, so two menus can never be open
   // at once and Escape has a single thing to close.
   const [openMenu, setOpenMenu] = useState<'theme' | 'shell' | null>(null);
+  // The archive replaces this dialog's content rather than stacking a second
+  // modal on it: one dialog, two views, so the baseboard button that opened it
+  // still owns exactly one thing (docs/specs/notepad.md -> Archive).
+  const [view, setView] = useState<'settings' | 'archive'>('settings');
   // Stable, because an open picker feeds this to `useCloseOnOutsideAndEscape`:
   // a fresh arrow each render would tear down and re-add its three window
   // listeners on every re-render of this dialog.
@@ -106,6 +113,11 @@ export function SettingsDialog({ onClose }: { onClose: () => void }) {
   // to offer. That also covers every host whose adapter detects no shells and
   // every burrow that never seeds the store (fake = 1, remote = 0).
   const showShell = !getPlatform().hostOwnsShells && shellState.shells.length >= 2;
+  const showArchive = hasNotepadArchive();
+
+  if (view === 'archive') {
+    return <NotepadArchiveView onBack={() => setView('settings')} onClose={onClose} />;
+  }
 
   return (
     <ModalFrame
@@ -195,10 +207,29 @@ export function SettingsDialog({ onClose }: { onClose: () => void }) {
       <AlarmSettingsSection sink="speech" />
       <AlarmSettingsSection sink="push" />
 
-      {/* Last, and directly under the push section that points at it: push is
+      {/* Directly under the push section that points at it: push is
           the feature that makes a reader care, and "no Burrow" is the reason it
           has nowhere to go. Renders nothing on a build with no Burrow service. */}
       <RemoteControlSection />
+
+      {/* Last: the only row here that leads somewhere instead of setting
+          something, so it reads as the door it is. */}
+      {showArchive ? (
+        <section className={SECTION}>
+          <div className="text-sm text-foreground">Notepad archive</div>
+          <div className="mt-1 text-sm leading-relaxed text-muted">
+            Notes kept from terminals and browsers that have closed. They stay
+            until you delete them.
+          </div>
+          <button
+            type="button"
+            className={`${modalActionButton()} mt-2`}
+            onClick={() => setView('archive')}
+          >
+            Open archive
+          </button>
+        </section>
+      ) : null}
     </ModalFrame>
   );
 }
diff --git a/lib/src/components/Wall.test.tsx b/lib/src/components/Wall.test.tsx
index 52d8c3c7..e0908d64 100644
--- a/lib/src/components/Wall.test.tsx
+++ b/lib/src/components/Wall.test.tsx
@@ -12,12 +12,16 @@ import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import { SURFACE_CONTROL_METHODS } from 'dor/protocol';
 import { sessionForKey } from 'dor-lib-common/agent-browser';
 import { Wall } from './Wall';
+import * as helpers from '../lib/helper-terminal';
 import { getAgentBrowserScreenController } from './wall/agent-browser-screen';
 import { setPlatform } from '../lib/platform';
 import { FakePtyAdapter } from '../lib/platform/fake-adapter';
 import type { PlatformAdapter } from '../lib/platform/types';
 import * as terminalRegistry from '../lib/terminal-registry';
 import { UNNAMED_PANEL_TITLE } from '../lib/terminal-registry';
+import { __resetArchiveServiceForTests } from '../lib/notepad/archive-service';
+import { addPlainNote, beginClosing, clearAllNotepads, getNotes } from '../lib/notepad/notepad-store';
+import type { NotepadArchiveV1 } from '../lib/notepad/types';
 import { createTerminalPaneState, type TerminalPaneState } from '../lib/terminal-state';
 
 globalThis.IS_REACT_ACT_ENVIRONMENT = true;
@@ -43,6 +47,8 @@ function leafCount(): number {
 }
 
 beforeEach(() => {
+  __resetArchiveServiceForTests();
+  clearAllNotepads();
   fake = new FakePtyAdapter();
   setPlatform(fake);
   // jsdom lacks these; Baseboard / dynamic-palette / reduced-motion need them.
@@ -77,6 +83,9 @@ afterEach(() => {
   act(() => root.unmount());
   container.remove();
   vi.clearAllMocks();
+  vi.restoreAllMocks();
+  __resetArchiveServiceForTests();
+  clearAllNotepads();
 });
 
 async function flush(): Promise<void> {
@@ -162,42 +171,159 @@ describe('Wall on the Lath engine', () => {
       expect(writeSpy.mock.calls).toEqual([['pane-a', '\x03']]);
     } finally {
       vi.useRealTimers();
-      stateSpy.mockRestore();
-      integratedSpy.mockRestore();
-      writeSpy.mockRestore();
     }
   });
 
+  it('cancels an ensure restart even when the prompt is already back before the wait', async () => {
+    await act(async () => {
+      root.render(<Wall initialPaneIds={['pane-a']} initialMode="command" showBaseboard />);
+    });
+    await flush();
+    const cwd = { path: '/repo', pathKind: 'posix', isRemote: false, source: 'osc633', updatedAt: 0 } as const;
+    let state: TerminalPaneState = createTerminalPaneState({
+      cwd,
+      currentCommand: {
+        id: 'run-1', rawCommandLine: 'pnpm dev', displayCommand: 'pnpm dev',
+        cwdAtStart: cwd, startedAt: 0, source: 'osc633_E',
+      },
+    });
+    vi.spyOn(terminalRegistry, 'getTerminalPaneState').mockImplementation(() => state);
+    vi.spyOn(terminalRegistry, 'isPaneOscDriven').mockReturnValue(true);
+    const controller = new AbortController();
+    // The interrupt lands on a prompt synchronously, so the wait resolves without
+    // polling; the cancel is queued ahead of that resolution's continuation.
+    const writeSpy = vi.spyOn(fake, 'writePty').mockImplementation((_id, data) => {
+      if (data !== '\x03') return;
+      state = createTerminalPaneState({ cwd });
+      queueMicrotask(() => controller.abort());
+    });
+    const respond = vi.fn();
+    await act(async () => {
+      window.dispatchEvent(new CustomEvent('dormouse:control-request', {
+        detail: {
+          method: SURFACE_CONTROL_METHODS.ensure,
+          params: { command: ['pnpm', 'dev'], cwd: '/repo', restart: true },
+          signal: controller.signal,
+          respond,
+        },
+      }));
+    });
+    expect(respond).toHaveBeenCalledWith({ ok: false, error: "surface 'surface:1' restart was cancelled" });
+    expect(writeSpy.mock.calls).toEqual([['pane-a', '\x03']]);
+  });
+
   it('removes an unintegrated ensure split as soon as its client cancels', async () => {
     await act(async () => {
       root.render(<Wall initialPaneIds={['pane-a']} initialMode="command" showBaseboard />);
     });
     await flush();
-    const integratedSpy = vi.spyOn(terminalRegistry, 'isPaneOscDriven').mockReturnValue(false);
-    const shellSpy = vi.spyOn(terminalRegistry, 'getDefaultShellOpts').mockReturnValue({ shell: '/bin/bash' });
+    vi.spyOn(terminalRegistry, 'isPaneOscDriven').mockReturnValue(false);
+    vi.spyOn(terminalRegistry, 'getDefaultShellOpts').mockReturnValue({ shell: '/bin/bash' });
     const controller = new AbortController();
     const respond = vi.fn();
+    await act(async () => {
+      window.dispatchEvent(new CustomEvent('dormouse:control-request', {
+        detail: {
+          method: SURFACE_CONTROL_METHODS.ensure,
+          params: { command: ['pnpm', 'dev'], cwd: '/repo', surface: 'surface:1' },
+          signal: controller.signal,
+          respond,
+        },
+      }));
+    });
+    expect(leafCount()).toBe(2);
+    expect(respond).not.toHaveBeenCalled();
+    await act(async () => { controller.abort(); });
+    expect(respond).toHaveBeenCalledWith({ ok: false, error: 'ensure was cancelled' });
+    await flush();
+    expect(leafCount()).toBe(1);
+    expect(container.querySelector('[data-lath-leaf="pane-a"]')).not.toBeNull();
+  });
+
+  it('reuses a running Surface while another archive caller holds its notes freeze', async () => {
+    await act(async () => root.render(<Wall initialPaneIds={['pane-a']} initialMode="command" />));
+    await flush();
+    const cwd = { path: '/repo', pathKind: 'posix', isRemote: false, source: 'osc633', updatedAt: 0 } as const;
+    vi.spyOn(terminalRegistry, 'getTerminalPaneState').mockReturnValue(createTerminalPaneState({
+      cwd,
+      currentCommand: { id: 'run', rawCommandLine: 'pnpm dev', displayCommand: 'pnpm dev', cwdAtStart: cwd, startedAt: 0, source: 'osc633_E' },
+    }));
+    const release = beginClosing(['pane-a']);
+    const respond = vi.fn();
     try {
       await act(async () => {
-        window.dispatchEvent(new CustomEvent('dormouse:control-request', {
-          detail: {
-            method: SURFACE_CONTROL_METHODS.ensure,
-            params: { command: ['pnpm', 'dev'], cwd: '/repo', surface: 'surface:1' },
-            signal: controller.signal,
-            respond,
-          },
-        }));
+        window.dispatchEvent(new CustomEvent('dormouse:control-request', { detail: {
+          method: SURFACE_CONTROL_METHODS.ensure, params: { command: ['pnpm', 'dev'], cwd: '/repo' }, respond,
+        } }));
       });
-      expect(leafCount()).toBe(2);
-      expect(respond).not.toHaveBeenCalled();
-      await act(async () => { controller.abort(); });
-      expect(respond).toHaveBeenCalledWith({ ok: false, error: 'ensure was cancelled' });
-      await flush();
+      expect(respond).toHaveBeenCalledWith({ ok: true, result: expect.objectContaining({ status: 'existing', surfaceId: 'pane-a' }) });
       expect(leafCount()).toBe(1);
-      expect(container.querySelector('[data-lath-leaf="pane-a"]')).not.toBeNull();
-    } finally {
-      integratedSpy.mockRestore();
-      shellSpy.mockRestore();
+    } finally { release(); }
+  });
+
+  it('does not reuse a running Surface while its own close is archiving', async () => {
+    await act(async () => root.render(<Wall initialPaneIds={['pane-a']} initialMode="command" />));
+    await flush();
+    const cwd = { path: '/repo', pathKind: 'posix', isRemote: false, source: 'osc633', updatedAt: 0 } as const;
+    vi.spyOn(terminalRegistry, 'getTerminalPaneState').mockReturnValue(createTerminalPaneState({
+      cwd,
+      currentCommand: { id: 'run', rawCommandLine: 'pnpm dev', displayCommand: 'pnpm dev', cwdAtStart: cwd, startedAt: 0, source: 'osc633_E' },
+    }));
+    vi.spyOn(terminalRegistry, 'isPaneOscDriven').mockReturnValue(true);
+    act(() => { addPlainNote('pane-a', 'keep this note'); });
+    let release!: () => void;
+    const gate = new Promise<void>(resolve => { release = resolve; });
+    const saveOriginal = fake.notepadArchive.save.bind(fake.notepadArchive);
+    const save = vi.spyOn(fake.notepadArchive, 'save').mockImplementation(async (...args) => { await gate; return saveOriginal(...args); });
+    const killed = vi.fn();
+    await act(async () => {
+      window.dispatchEvent(new CustomEvent('dormouse:control-request', { detail: {
+        method: SURFACE_CONTROL_METHODS.kill, params: { surface: 'surface:1', confirmation: { mode: 'dangerously' } }, respond: killed,
+      } }));
+    });
+    await flush();
+    expect(save).toHaveBeenCalled();
+    const respond = vi.fn();
+    try {
+      await act(async () => {
+        window.dispatchEvent(new CustomEvent('dormouse:control-request', { detail: {
+          method: SURFACE_CONTROL_METHODS.ensure, params: { command: ['pnpm', 'dev'], cwd: '/repo' }, respond,
+        } }));
+      });
+      expect(respond).toHaveBeenCalledWith({ ok: true, result: expect.objectContaining({ status: 'created' }) });
+      expect(killed).not.toHaveBeenCalled();
+    } finally { release(); await flush(); }
+    expect(killed).toHaveBeenCalledWith({ ok: true, result: expect.objectContaining({ status: 'killed', surfaceId: 'pane-a' }) });
+  });
+
+  it.each([false, true])('preserves notes entered in a cancelled ensure pane (archive fails: %s)', async fails => {
+    await act(async () => root.render(<Wall initialPaneIds={['pane-a']} initialMode="command" />));
+    await flush();
+    vi.spyOn(terminalRegistry, 'isPaneOscDriven').mockReturnValue(false);
+    vi.spyOn(terminalRegistry, 'getDefaultShellOpts').mockReturnValue({ shell: '/bin/bash' });
+    const controller = new AbortController();
+    const respond = vi.fn();
+    await act(async () => {
+      window.dispatchEvent(new CustomEvent('dormouse:control-request', { detail: {
+        method: SURFACE_CONTROL_METHODS.ensure, params: { command: ['pnpm', 'dev'], cwd: '/repo', surface: 'surface:1' }, signal: controller.signal, respond,
+      } }));
+    });
+    const temporaryId = Array.from(container.querySelectorAll('[data-lath-leaf]')).map(el => el.getAttribute('data-lath-leaf')!).find(id => id !== 'pane-a')!;
+    expect(temporaryId).toBeTruthy();
+    act(() => { addPlainNote(temporaryId, 'written while integration is pending'); });
+    if (fails) vi.spyOn(fake.notepadArchive, 'save').mockRejectedValue(new Error('disk full'));
+    await act(async () => controller.abort());
+    await flush();
+    if (fails) {
+      expect(respond).toHaveBeenCalledWith({ ok: false, error: expect.stringContaining('temporary surface kept open: notepad archive failed: disk full') });
+      expect(getNotes(temporaryId)).toHaveLength(1);
+      expect(container.querySelector(`[data-lath-leaf="${temporaryId}"]`)).not.toBeNull();
+    } else {
+      expect(respond).toHaveBeenCalledWith({ ok: false, error: 'ensure was cancelled' });
+      expect(container.querySelector(`[data-lath-leaf="${temporaryId}"]`)).toBeNull();
+      const archive = (await fake.notepadArchive.load())?.raw as NotepadArchiveV1;
+      expect(archive.batches.flatMap(batch => batch.notes)).toEqual([expect.objectContaining({ content: { kind: 'plain', text: 'written while integration is pending' } })]);
+      expect(getNotes(temporaryId)).toEqual([]);
     }
   });
 
@@ -1542,6 +1668,356 @@ describe('Wall on the Lath engine', () => {
     expect(focusOf(newId)).toBe('false');
   });
 
+  // --- Notepad closure (docs/specs/notepad.md → "Closure") ---
+
+  /** What the host actually stored. */
+  async function storedArchive(): Promise<NotepadArchiveV1> {
+    const loaded = await fake.notepadArchive.load();
+    return (loaded?.raw ?? { version: 1, batches: [] }) as NotepadArchiveV1;
+  }
+
+  /** The Keep open / Close anyway prompt, when it is up. */
+  function archiveFailureModal(): HTMLElement | null {
+    return container.querySelector<HTMLElement>('[aria-labelledby="notepad-archive-failure-title"]');
+  }
+
+  function clickButton(label: string): void {
+    const button = Array.from(container.querySelectorAll<HTMLButtonElement>('button'))
+      .find((candidate) => candidate.textContent?.trim() === label);
+    expect(button, `no "${label}" button`).toBeDefined();
+    act(() => { button!.click(); });
+  }
+
+  /** The pane header's Kill button — a user-visible closure, which does prompt.
+   *  `isUntouched` short-circuits the kill confirmation so this is one click. */
+  async function clickHeaderKill(paneId: string): Promise<void> {
+    const untouched = vi.spyOn(terminalRegistry, 'isUntouched').mockReturnValue(true);
+    try {
+      const button = container.querySelector<HTMLButtonElement>(
+        `[data-lath-leaf="${paneId}"] button[aria-label="Kill"]`,
+      );
+      expect(button, `no Kill button on ${paneId}`).not.toBeNull();
+      await act(async () => {
+        button!.dispatchEvent(new MouseEvent('click', { bubbles: true }));
+      });
+      await flush();
+    } finally {
+      untouched.mockRestore();
+    }
+  }
+
+  /** A Helper on pane-a whose host work inspection answers `busy`, switchable mid-test. */
+  function spyOnHelper(): { dispose: ReturnType<typeof vi.spyOn>; setBusy: (value: boolean) => void } {
+    let helper: helpers.HelperTerminal | undefined = { id: 'helper-a', parentId: 'pane-a', command: '', status: 'off' };
+    let busy = false;
+    vi.spyOn(helpers, 'getHelper').mockImplementation(id => id === 'pane-a' ? helper : undefined);
+    vi.spyOn(helpers, 'helperHasWork').mockImplementation(async () => busy);
+    vi.spyOn(helpers, 'openHelper').mockImplementation(async () => helper!);
+    const dispose = vi.spyOn(helpers, 'closeHelperParent').mockImplementation(() => { helper = undefined; });
+    return { dispose, setBusy: (value) => { busy = value; } };
+  }
+
+  async function renderNotedPane(): Promise<void> {
+    await act(async () => root.render(<Wall initialPaneIds={['pane-a']} initialMode="command" showBaseboard />));
+    await flush();
+    act(() => { addPlainNote('pane-a', 'shared helper note'); });
+  }
+
+  it('closes an idle Helper with its source and archives the shared notes once', async () => {
+    const { dispose } = spyOnHelper();
+    await renderNotedPane();
+    expect((await dispatchKill('surface:1'))?.ok).toBe(true);
+    await flush();
+    expect(getNotes('pane-a')).toEqual([]);
+    expect(dispose).toHaveBeenCalledWith('pane-a');
+    expect((await storedArchive()).batches).toHaveLength(1);
+  });
+
+  it('refuses a source whose Helper has running work before touching the archive', async () => {
+    const { dispose, setBusy } = spyOnHelper();
+    const save = vi.spyOn(fake.notepadArchive, 'save');
+    setBusy(true);
+    await renderNotedPane();
+    expect((await dispatchKill('surface:1'))?.ok).toBe(false);
+    await flush();
+    expect(getNotes('pane-a')).toHaveLength(1);
+    expect(dispose).not.toHaveBeenCalled();
+    expect(container.querySelector('[data-lath-leaf="pane-a"]')).not.toBeNull();
+    expect(save).not.toHaveBeenCalled();
+  });
+
+  // The kill gesture (`requestKill`): docs/specs/layout.md → "Kill confirmation".
+  const confirmKillOverlay = () => Array.from(container.querySelectorAll('h2')).find(h => h.textContent === 'Confirm kill') ?? null;
+
+  it('closes an untouched pane at once and stages the confirm overlay for a touched one', async () => {
+    const untouched = vi.spyOn(terminalRegistry, 'isUntouched').mockReturnValue(true);
+    await act(async () => root.render(<Wall initialPaneIds={['pane-a', 'pane-b']} initialMode="command" showBaseboard />));
+    await flush();
+    const kill = (id: string) => act(async () => {
+      container.querySelector<HTMLButtonElement>(`[data-lath-leaf="${id}"] button[aria-label="Kill"]`)!.dispatchEvent(new MouseEvent('click', { bubbles: true }));
+    });
+    await kill('pane-b');
+    await flush();
+    expect(confirmKillOverlay()).toBeNull();
+    expect(container.querySelector('[data-lath-leaf="pane-b"]')).toBeNull();
+    untouched.mockReturnValue(false);
+    await kill('pane-a');
+    expect(confirmKillOverlay()).not.toBeNull();
+    expect(container.querySelector('[data-lath-leaf="pane-a"]')).not.toBeNull();
+  });
+
+  /** Minimize pane-a beside pane-b (the Door stays selected) and press the kill key on it. */
+  async function killSelectedDoor(): Promise<void> {
+    await act(async () => root.render(<Wall initialPaneIds={['pane-a', 'pane-b']} initialMode="command" showBaseboard />));
+    await flush();
+    await act(async () => { container.querySelector<HTMLElement>('[data-lath-leaf="pane-a"] [aria-label="Minimize"]')!.click(); });
+    await flush();
+    expect(container.querySelector('[data-door-id="pane-a"]')).not.toBeNull();
+    await act(async () => { window.dispatchEvent(new KeyboardEvent('keydown', { key: 'x', bubbles: true })); });
+    await flushFrame();
+    await flush();
+  }
+
+  it('reattaches an untouched Door only far enough to close it, with no overlay', async () => {
+    vi.spyOn(terminalRegistry, 'isUntouched').mockReturnValue(true);
+    await killSelectedDoor();
+    expect(container.querySelector('[data-door-id="pane-a"]')).toBeNull();
+    expect(container.querySelector('[data-lath-leaf="pane-a"]')).toBeNull();
+    expect(confirmKillOverlay()).toBeNull();
+  });
+
+  it('reattaches a touched Door into the confirm overlay', async () => {
+    vi.spyOn(terminalRegistry, 'isUntouched').mockReturnValue(false);
+    await killSelectedDoor();
+    expect(container.querySelector('[data-door-id="pane-a"]')).toBeNull();
+    expect(container.querySelector('[data-lath-leaf="pane-a"]')).not.toBeNull();
+    expect(confirmKillOverlay()).not.toBeNull();
+  });
+
+  it('drops a kill gesture whose Helper inspection outlives the pane', async () => {
+    vi.spyOn(terminalRegistry, 'isUntouched').mockReturnValue(false);
+    const helper: helpers.HelperTerminal = { id: 'helper-a', parentId: 'pane-a', command: '', status: 'off' };
+    vi.spyOn(helpers, 'getHelper').mockImplementation(id => id === 'pane-a' ? helper : undefined);
+    vi.spyOn(helpers, 'closeHelperParent').mockImplementation(() => {});
+    const inspections: Array<(busy: boolean) => void> = [];
+    vi.spyOn(helpers, 'helperHasWork').mockImplementation(() => new Promise<boolean>(resolve => { inspections.push(resolve); }));
+    await act(async () => root.render(<Wall initialPaneIds={['pane-a', 'pane-b']} initialMode="command" showBaseboard />));
+    await flush();
+    await act(async () => {
+      container.querySelector<HTMLButtonElement>('[data-lath-leaf="pane-a"] button[aria-label="Kill"]')!.dispatchEvent(new MouseEvent('click', { bubbles: true }));
+    });
+    expect(inspections).toHaveLength(1);
+    // A `dor kill` lands while the gesture's inspection is still pending and
+    // closes the pane first (its own two inspections answered idle).
+    let killed: { ok: boolean } | undefined;
+    window.dispatchEvent(new CustomEvent('dormouse:control-request', {
+      detail: { method: SURFACE_CONTROL_METHODS.kill, params: { surface: 'surface:1', confirmation: { mode: 'dangerously' } }, respond: (r: typeof killed) => { killed = r; } },
+    }));
+    for (const index of [1, 2]) {
+      await act(async () => { while (inspections.length <= index) await new Promise(r => setTimeout(r, 0)); });
+      await act(async () => { inspections[index](false); });
+    }
+    await flush();
+    expect(killed?.ok).toBe(true);
+    await act(async () => { inspections[0](false); });
+    await flush();
+    expect(confirmKillOverlay()).toBeNull();
+  });
+
+  it('keeps the notes and pending batch when Helper work starts during the write, replacing the batch on retry', async () => {
+    const { dispose, setBusy } = spyOnHelper();
+    const saveOriginal = fake.notepadArchive.save.bind(fake.notepadArchive);
+    const save = vi.spyOn(fake.notepadArchive, 'save').mockImplementation(async (...args) => {
+      const result = await saveOriginal(...args);
+      setBusy(true);
+      return result;
+    });
+    await renderNotedPane();
+    expect((await dispatchKill('surface:1'))?.ok).toBe(false);
+    await flush();
+    expect(getNotes('pane-a')).toHaveLength(1);
+    expect(dispose).not.toHaveBeenCalled();
+    expect(container.querySelector('[data-lath-leaf="pane-a"]')).not.toBeNull();
+    expect((await storedArchive()).batches).toHaveLength(1);
+    setBusy(false);
+    save.mockImplementation(saveOriginal);
+    expect((await dispatchKill('surface:1'))?.ok).toBe(true);
+    expect((await storedArchive()).batches).toHaveLength(1);
+    expect(getNotes('pane-a')).toEqual([]);
+  });
+
+  it('runs the Helper guard again before Close anyway discards the notes', async () => {
+    const { dispose, setBusy } = spyOnHelper();
+    vi.spyOn(fake.notepadArchive, 'save').mockRejectedValue(new Error('disk full'));
+    await renderNotedPane();
+    await clickHeaderKill('pane-a');
+    expect(archiveFailureModal()).not.toBeNull();
+    setBusy(true);
+    clickButton('Close anyway');
+    await flush();
+    await flush();
+    expect(getNotes('pane-a')).toHaveLength(1);
+    expect(dispose).not.toHaveBeenCalled();
+    expect(container.querySelector('[data-lath-leaf="pane-a"]')).not.toBeNull();
+  });
+
+  it('archives a closing Surface\'s notes before tearing it down', async () => {
+    await act(async () => {
+      root.render(<Wall initialPaneIds={['pane-a']} initialMode="command" showBaseboard />);
+    });
+    await flush();
+    act(() => { addPlainNote('pane-a', 'ssh key is in 1password'); });
+
+    expect((await dispatchKill('surface:1'))?.ok).toBe(true);
+    await flush();
+
+    const archive = await storedArchive();
+    expect(archive.batches).toHaveLength(1);
+    expect(archive.batches[0].notes[0].content).toEqual({ kind: 'plain', text: 'ssh key is in 1password' });
+    // The metadata resolver the Wall installs supplies the derived pane label.
+    expect(archive.batches[0].surfaceKind).toBe('terminal');
+    expect(getNotes('pane-a')).toEqual([]);
+    expect(container.querySelector('[data-lath-leaf="pane-a"]')).toBeNull();
+  });
+
+  it('keeps the Surface and asks when the archive refuses the write', async () => {
+    vi.spyOn(fake.notepadArchive, 'save').mockRejectedValue(new Error('disk is full'));
+    await act(async () => {
+      root.render(<Wall initialPaneIds={['pane-a']} initialMode="command" showBaseboard />);
+    });
+    await flush();
+    act(() => { addPlainNote('pane-a', 'keep me'); });
+
+    await clickHeaderKill('pane-a');
+
+    expect(container.querySelector('[data-lath-leaf="pane-a"]')).not.toBeNull();
+    expect(getNotes('pane-a')).toHaveLength(1);
+    expect(archiveFailureModal()).not.toBeNull();
+  });
+
+  it('answers a refused `dor kill` with the error and raises no prompt', async () => {
+    // The caller is a command, not someone looking at the Wall: a modal here
+    // would block a Wall nobody is watching (docs/specs/notepad.md → "Closure").
+    vi.spyOn(fake.notepadArchive, 'save').mockRejectedValue(new Error('disk is full'));
+    await act(async () => {
+      root.render(<Wall initialPaneIds={['pane-a']} initialMode="command" showBaseboard />);
+    });
+    await flush();
+    act(() => { addPlainNote('pane-a', 'keep me'); });
+
+    const response = await dispatchKill('surface:1');
+    await flush();
+
+    expect(response?.ok).toBe(false);
+    expect((response as { error?: string }).error).toContain('notepad archive failed');
+    expect((response as { error?: string }).error).toContain('disk is full');
+    expect(container.querySelector('[data-lath-leaf="pane-a"]')).not.toBeNull();
+    expect(getNotes('pane-a')).toHaveLength(1);
+    expect(archiveFailureModal()).toBeNull();
+  });
+
+  it('Keep open dismisses the prompt and leaves everything alone', async () => {
+    vi.spyOn(fake.notepadArchive, 'save').mockRejectedValue(new Error('disk is full'));
+    await act(async () => {
+      root.render(<Wall initialPaneIds={['pane-a']} initialMode="command" showBaseboard />);
+    });
+    await flush();
+    act(() => { addPlainNote('pane-a', 'keep me'); });
+    await clickHeaderKill('pane-a');
+
+    clickButton('Keep open');
+    await flush();
+
+    expect(archiveFailureModal()).toBeNull();
+    expect(container.querySelector('[data-lath-leaf="pane-a"]')).not.toBeNull();
+    expect(getNotes('pane-a')).toHaveLength(1);
+  });
+
+  it('Close anyway discards the notes and removes the Surface without a batch', async () => {
+    vi.spyOn(fake.notepadArchive, 'save').mockRejectedValue(new Error('disk is full'));
+    await act(async () => {
+      root.render(<Wall initialPaneIds={['pane-a']} initialMode="command" showBaseboard />);
+    });
+    await flush();
+    act(() => { addPlainNote('pane-a', 'expendable'); });
+    await clickHeaderKill('pane-a');
+
+    clickButton('Close anyway');
+    await flush();
+
+    expect(archiveFailureModal()).toBeNull();
+    expect(container.querySelector('[data-lath-leaf="pane-a"]')).toBeNull();
+    expect(getNotes('pane-a')).toEqual([]);
+    expect((await storedArchive()).batches).toEqual([]);
+  });
+
+  it('queues a second refused closure behind the first prompt', async () => {
+    // One slot would leave pane-a waiting forever: its prompt is replaced, and
+    // nothing is left to answer for it.
+    // Distinct messages are how the prompt on screen names its Surface.
+    vi.spyOn(fake.notepadArchive, 'save')
+      .mockRejectedValueOnce(new Error('a could not be written'))
+      .mockRejectedValueOnce(new Error('b could not be written'));
+    await act(async () => {
+      root.render(<Wall initialPaneIds={['pane-a', 'pane-b']} initialMode="command" showBaseboard />);
+    });
+    await flush();
+    act(() => {
+      addPlainNote('pane-a', 'from a');
+      addPlainNote('pane-b', 'from b');
+    });
+
+    await clickHeaderKill('pane-a');
+    await clickHeaderKill('pane-b');
+
+    // A's prompt is the one on screen; B's is behind it.
+    expect(archiveFailureModal()?.textContent).toContain('a could not be written');
+    clickButton('Keep open');
+    await flush();
+
+    expect(archiveFailureModal()?.textContent).toContain('b could not be written');
+    clickButton('Close anyway');
+    await flush();
+
+    expect(archiveFailureModal()).toBeNull();
+    expect(container.querySelector('[data-lath-leaf="pane-a"]')).not.toBeNull();
+    expect(getNotes('pane-a')).toHaveLength(1);
+    expect(container.querySelector('[data-lath-leaf="pane-b"]')).toBeNull();
+  });
+
+  it('migrates a notepad to the new id when a replacement mints one', async () => {
+    await act(async () => {
+      root.render(<Wall initialPaneIds={['pane-a']} initialMode="command" showBaseboard />);
+    });
+    await flush();
+    const untouchedSpy = vi.spyOn(terminalRegistry, 'isUntouched').mockImplementation((id) => id === 'pane-a');
+
+    try {
+      act(() => { addPlainNote('pane-a', 'survives the swap'); });
+
+      let response: { ok: boolean; result?: { surfaceId: string } } | undefined;
+      await act(async () => {
+        window.dispatchEvent(new CustomEvent('dormouse:control-request', {
+          detail: {
+            method: SURFACE_CONTROL_METHODS.iframe,
+            params: { url: 'http://localhost:5173/' },
+            respond: (r: typeof response) => { response = r; },
+          },
+        }));
+      });
+      await flush();
+
+      const newId = response!.result!.surfaceId;
+      expect(newId).not.toBe('pane-a');
+      expect(getNotes('pane-a')).toEqual([]);
+      expect(getNotes(newId).map((note) => note.content)).toEqual([{ kind: 'plain', text: 'survives the swap' }]);
+      // A replacement is not a closure, so nothing was archived.
+      expect((await storedArchive()).batches).toEqual([]);
+    } finally {
+      untouchedSpy.mockRestore();
+    }
+  });
+
   it('seeds multiple initial panes with the aspect-aware layout (geometry is measured before the seed)', async () => {
     // jsdom has no layout, so stub the container measurement wide. The seed reads the
     // store's geometry via `autoEdge`; if that geometry lags behind the measurement
diff --git a/lib/src/components/Wall.tsx b/lib/src/components/Wall.tsx
index f447aa24..ce29bf16 100644
--- a/lib/src/components/Wall.tsx
+++ b/lib/src/components/Wall.tsx
@@ -3,7 +3,7 @@ import { TERMINAL_CONTEXT_EXIT_MS } from './design';
 import { motionIsInstant } from '../lib/ui-geometry';
 import type { PortMode } from './wall/TerminalContextView';
 import type { PortUrlEntry } from './wall/port-url';
-import { beginPromotion, cancelPromotion, disposeHelper, finishPromotion, getHelper, helperHasWork, type HelperTerminal } from '../lib/helper-terminal';
+import { beginPromotion, cancelPromotion, closeHelperParent, finishPromotion, getHelper, helperHasWork } from '../lib/helper-terminal';
 import { isHelperSession } from '../lib/terminal-store';
 import { useRef, useState, useEffect, useCallback, useMemo, useSyncExternalStore, lazy, Suspense, type ReactNode } from 'react';
 import { clsx } from 'clsx';
@@ -24,9 +24,14 @@ import { markAgentBrowserSessionClosed } from './wall/agent-browser-sessions';
 import { isAllowedAgentBrowserBinary } from '../lib/agent-browser-binary';
 import { disposeAgentBrowserSurfaceController } from './wall/agent-browser-surface-controller';
 import { KILL_CONFIRM_MS, KILL_SHAKE_MS, KillConfirmOverlay, randomKillChar, type ConfirmKill } from './KillConfirm';
+import { NotepadArchiveFailureModal, type NotepadArchiveFailure } from './NotepadArchiveFailure';
+import { messageOf } from '../lib/errors';
+import { archiveSurfaceNotes } from '../lib/notepad/close-coordinator';
+import { beginClosing, isSurfaceClosing, removeSurface, setNotepadSurfaceMetaResolver, transferNotepad } from '../lib/notepad/notepad-store';
 import {
   clearSessionAttention,
   clearLocalSurfaceActivity,
+  deriveSessionLabel,
   disposeSession,
   dismissOrToggleAlert,
   focusSession,
@@ -98,10 +103,12 @@ import {
   SelectedIdContext,
   WindowFocusedContext,
   ZoomedIdContext,
+  createDialogKeyboardCoordinator,
+  useDialogKeyboardOwner,
   type PaneWriteActions,
   type WallActions,
 } from './wall/wall-context';
-import type { DoorAfterRestoreAction, DoorChip, DooredItem, WallEvent, WallMode, WallSelectionKind } from './wall/wall-types';
+import type { CloseSurfaceMode, DoorAfterRestoreAction, DoorChip, DooredItem, WallEvent, WallMode, WallSelectionKind } from './wall/wall-types';
 
 type ShellSpawnRequest = {
   shell?: string;
@@ -282,7 +289,6 @@ export function Wall({
     const timer = setTimeout(() => setTerminalContext(current => current === terminalContext ? null : current), TERMINAL_CONTEXT_EXIT_MS);
     return () => clearTimeout(timer);
   }, [terminalContext]);
-  const pendingHelperCloses = useRef(new Set<string>());
   // The Lath engine handle — Dormouse's tiling engine. Constructed lazily exactly
   // once per Wall mount, so `createLathWallEngine` is not re-invoked each render
   // (docs/specs/tiling-engine.md).
@@ -332,10 +338,10 @@ export function Wall({
     };
   }, []);
 
+  // One reference-counted lease per open dialog: overlapping dialogs each hold
+  // their own, so the one closing cannot release the other's suppression.
   const dialogKeyboardActiveRef = useRef(false);
-  const setDialogKeyboardActive = useCallback((active: boolean) => {
-    dialogKeyboardActiveRef.current = active;
-  }, []);
+  const [acquireDialogKeyboard] = useState(() => createDialogKeyboardCoordinator(dialogKeyboardActiveRef));
 
   // Consumed once by the Lath seed effect to restore existing sessions
   const initialPaneIdsRef = useRef(initialPaneIds);
@@ -375,6 +381,11 @@ export function Wall({
 
   // UI state
   const [confirmKill, setConfirmKill] = useState<ConfirmKill | null>(null);
+  // Closures the archive refused, oldest first: each Surface is still here,
+  // still holding its notes, until the user answers for it
+  // (docs/specs/notepad.md → "Closure"). A queue rather than one slot — a second
+  // refusal while the first prompt is up must not orphan the first Surface.
+  const [archiveFailures, setArchiveFailures] = useState<NotepadArchiveFailure[]>([]);
   const [renamingPaneId, setRenamingPaneId] = useState<string | null>(null);
   // Runtime Doors carry id + token only; the restored rows' metadata goes into the
   // store via the seed effect below.
@@ -431,6 +442,12 @@ export function Wall({
     [doors, lath, doorDisplayMetadata],
   );
   const confirmKillRef = useRef(confirmKill);
+  /** Surfaces with a `closeSurface` in flight. Wall-owned on purpose: the notepad
+   *  store's `isSurfaceClosing` is the shared notes freeze, held by any archive
+   *  caller (the standalone quit gate over every noted Surface, past its own
+   *  deadline), so reading it here would make those Surfaces unclosable. */
+  const pendingSurfaceCloses = useRef(new Set<string>());
+  const isClosingSurface = useCallback((id: string) => pendingSurfaceCloses.current.has(id), []);
   confirmKillRef.current = confirmKill;
 
   // The navigation/query seam for the keyboard handlers, backed by the engine + its
@@ -536,41 +553,40 @@ export function Wall({
     }, 1500);
   }, []);
 
-  /** Resolves true when the helper's running work (or a failed inspection)
-   *  blocks closing its source; the source is then revealed with the reason
+  /** Why the helper's running work (or a failed inspection) blocks closing its
+   *  source, or null when the source may close
    *  (docs/specs/terminal-context.md → Promotion and source closure). */
-  const helperBlocksClose = useCallback(async (id: string, helper: HelperTerminal): Promise<boolean> => {
-    let warning: string;
-    try {
-      if (!await helperHasWork(helper)) return false;
-      warning = 'Helper has running work. Stop it in the helper, then close this terminal again.';
-    } catch (error) {
-      warning = `Could not inspect helper processes: ${String(error)}`;
+  const helperRefusal = useCallback(async (id: string): Promise<string | null> => {
+    let helper = getHelper(id);
+    while (helper) {
+      let warning: string | null = null;
+      try {
+        if (await helperHasWork(helper)) warning = 'Helper has running work. Stop it in the helper, then close this terminal again.';
+      } catch (error) {
+        warning = `Could not inspect helper processes: ${messageOf(error)}`;
+      }
+      // A reset or promotion can finish while host inspection is pending; the
+      // replacement is inspected in turn.
+      if (getHelper(id) === helper) return warning;
+      helper = getHelper(id);
     }
-    // A helper replaced or promoted mid-inspection is re-gated by the caller.
-    if (getHelper(id) !== helper) return false;
+    return null;
+  }, []);
+
+  /** Reveal a source whose closure its helper refused, with the reason. */
+  const revealRefusal = useCallback((id: string, warning: string) => {
     const door = doorsRef.current.find(item => item.id === id);
-    if (door) handleReattachRef.current(door);
+    // Command mode, as `requestKill`'s own Door path: the overlay takes focus.
+    if (door) handleReattachRef.current(door, { enterPassthrough: false });
     setConfirmKill(null);
     setTerminalContext({ id, warning });
-    return true;
   }, []);
 
-  const killPaneImmediately = useCallback((id: string): void | boolean | Promise<void | boolean> => {
-    const helper = getHelper(id);
-    if (helper) {
-      if (pendingHelperCloses.current.has(id)) return false;
-      pendingHelperCloses.current.add(id);
-      return helperBlocksClose(id, helper).then(blocked => {
-        pendingHelperCloses.current.delete(id);
-        if (blocked) return false;
-        if (getHelper(id) === helper) {
-          disposeHelper(id);
-          setTerminalContext(current => current?.id === id ? null : current);
-        }
-        return killPaneImmediately(id);
-      });
-    }
+  /** Tear a Surface down with no archive step; who may call it is
+   *  docs/specs/notepad.md → "Closure". */
+  const killPaneImmediately = useCallback((id: string): void => {
+    closeHelperParent(id);
+    setTerminalContext(current => current?.id === id ? null : current);
     // A second kill for a pane already mid-fade is a no-op (idempotent) — it must
     // not re-fire the event, re-dispose, or schedule a second removal.
     if (lath.isDying(id)) return;
@@ -638,7 +654,78 @@ export function Wall({
     }, lath.exitMs);
     clearLocalSurfaceActivity(id);
     fireEvent({ type: 'kill', id });
-  }, [fireEvent, forgetSurfaceRef, selectPane, lath, nav, helperBlocksClose]);
+  }, [fireEvent, forgetSurfaceRef, selectPane, lath, nav]);
+
+  /**
+   * A permanent, user-visible Surface closure: helper guard, archive, helper
+   * guard again, teardown (docs/specs/notepad.md → "Closure";
+   * docs/specs/terminal-context.md → "Promotion and source closure"). Resolves
+   * `null` once the Surface is gone, else this attempt's error with the Surface
+   * left as it was: `prompt` raises Keep open / Close anyway, `silent` (`dor
+   * kill`) raises nothing, `discard` is the Close anyway answer.
+   */
+  const closeSurface = useCallback(async (id: string, mode: CloseSurfaceMode = 'prompt'): Promise<string | null> => {
+    if (pendingSurfaceCloses.current.has(id)) return 'This terminal is already closing';
+    pendingSurfaceCloses.current.add(id);
+    const release = beginClosing([id]);
+    try {
+      const refused = await helperRefusal(id);
+      if (refused) { revealRefusal(id, refused); return refused; }
+      if (mode !== 'discard') {
+        try {
+          await archiveSurfaceNotes([id], { retainNotes: true });
+        } catch (error) {
+          const message = messageOf(error);
+          if (mode === 'prompt') {
+            setArchiveFailures(queue => queue.some(failure => failure.id === id)
+              ? queue.map(failure => failure.id === id ? { id, message } : failure)
+              : [...queue, { id, message }]);
+          }
+          return `notepad archive failed: ${message}`;
+        }
+      }
+      // Work may have begun while the archive was writing; `discard` awaited
+      // nothing since its first guard, so it is not asked twice.
+      const refusedAfterArchive = mode === 'discard' ? null : await helperRefusal(id);
+      if (refusedAfterArchive) { revealRefusal(id, refusedAfterArchive); return refusedAfterArchive; }
+      removeSurface(id);
+      killPaneImmediately(id);
+      return null;
+    } finally {
+      release();
+      pendingSurfaceCloses.current.delete(id);
+    }
+  }, [killPaneImmediately, helperRefusal, revealRefusal]);
+  const closeSurfaceRef = useRef(closeSurface);
+  closeSurfaceRef.current = closeSurface;
+
+  /**
+   * The kill gesture on a Surface, from the header, the keyboard, or a Door: a
+   * Door reattaches first, an untouched shell closes at once, anything else
+   * stages the confirm overlay. A source whose helper has running work is
+   * revealed with the reason instead, and nothing is staged.
+   */
+  const requestKill = useCallback((id: string) => {
+    const stage = () => {
+      const door = doorsRef.current.find(item => item.id === id);
+      if (door) {
+        handleReattachRef.current(door, { enterPassthrough: false, afterRestore: isUntouched(id) ? 'close' : 'confirm-kill' });
+        return;
+      }
+      // The helper inspection below can outlive the Surface (an exit, a `dor
+      // kill`); a confirm overlay for a gone pane would never clear itself.
+      if (!nav.hasPane(id) || lath.isDying(id)) return;
+      if (isUntouched(id)) { void closeSurface(id); return; }
+      setConfirmKill({ id, char: randomKillChar() });
+    };
+    if (!getHelper(id)) { stage(); return; }
+    void helperRefusal(id).then(refused => (refused ? revealRefusal(id, refused) : stage()));
+  }, [closeSurface, helperRefusal, revealRefusal, lath, nav]);
+
+  /** The head of the refused-closure queue is answered; show the next. */
+  const shiftArchiveFailure = useCallback(() => {
+    setArchiveFailures((queue) => queue.slice(1));
+  }, []);
 
   const acceptKill = useCallback(() => {
     const ck = confirmKillRef.current;
@@ -650,9 +737,9 @@ export function Wall({
     // `isDying` guard in killPaneImmediately is the second line of defense.)
     confirmKillRef.current = staged;
     setConfirmKill(staged);
-    killPaneImmediately(ck.id);
+    void closeSurface(ck.id);
     confirmTimerRef.current = setTimeout(() => setConfirmKill(null), KILL_CONFIRM_MS);
-  }, [killPaneImmediately]);
+  }, [closeSurface]);
 
   /** Select a door in the baseboard */
   const selectDoor = useCallback((id: string) => {
@@ -739,6 +826,37 @@ export function Wall({
     if (id) focusSession(id, false);
   }, [releaseZoomExcept]);
 
+  // The notepad store knows note text and nothing else, so the Wall tells it who
+  // each Surface is: the label the Door and the pane header already show, the
+  // Surface kind, and the Session's live CWD. An archive batch and the volatile
+  // mirror both read through this, so they describe a Surface identically
+  // (docs/specs/notepad.md → "Closure").
+  useEffect(() => {
+    setNotepadSurfaceMetaResolver((surfaceId) => {
+      const meta = lath.getMeta(surfaceId);
+      if (!meta) return null;
+      const kind = surfaceKindFromParams(meta.params);
+      const title = persistedPanelTitle(meta.title);
+      return {
+        surfaceTitle: hasTerminal(kind) ? deriveSessionLabel(surfaceId, title) : title,
+        surfaceKind: kind,
+        // The whole canonical CwdState, not a formatted label: the Archive view
+        // renders remote hosts and path kinds through the same utilities a live
+        // header does.
+        cwd: getTerminalPaneState(surfaceId).cwd,
+      };
+    });
+    return () => setNotepadSurfaceMetaResolver(null);
+  }, [lath]);
+
+  // A refused closure owns the keyboard while it is up, like the other modal
+  // hosts: a command-mode shortcut behind it must not kill a different pane.
+  // Keyed on "is a prompt up", not on the queue: moving to the next failure must
+  // not drop and re-raise the flag under another dialog host.
+  // Wall renders above its own Provider, so it hands the coordinator in directly.
+  const anyArchiveFailure = archiveFailures.length > 0;
+  useDialogKeyboardOwner(anyArchiveFailure, acquireDialogKeyboard);
+
   useEffect(() => {
     // An iframe surface taking focus blurs this window without backgrounding the
     // app (document.hasFocus() stays true). Only clear cross-session attention
@@ -874,14 +992,18 @@ export function Wall({
         // Guard against removal between scheduling and execution.
         if (!nav.hasPane(item.id)) return;
         focusSession(item.id, false);
-        if (afterRestore === 'kill-immediately') {
-          killPaneImmediately(item.id);
+        if (afterRestore === 'close') {
+          void closeSurfaceRef.current(item.id);
         } else if (afterRestore === 'confirm-kill') {
           setConfirmKill({ id: item.id, char: randomKillChar() });
         } else if (typeof afterRestore === 'object' && afterRestore.type === 'replace-terminal') {
           // Atomic identity swap in place — no transient add/remove.
+          closeHelperParent(item.id);
           lath.store.replaceLeaf(item.id, afterRestore.newId, terminalLeafMeta());
           disposeSession(item.id);
+          // An in-place shell replacement is not a closure: the notes follow the
+          // new id rather than being archived (docs/specs/notepad.md → "Closure").
+          transferNotepad(item.id, afterRestore.newId);
           forgetSurfaceRef(item.id);
           selectPane(afterRestore.newId);
           if (afterRestore.announce) {
@@ -890,7 +1012,7 @@ export function Wall({
         }
       });
     }
-  }, [selectPane, removeDoorAndSelect, enterTerminalMode, killPaneImmediately, forgetSurfaceRef, showShellSpawnNotice, lath, nav]);
+  }, [selectPane, removeDoorAndSelect, enterTerminalMode, forgetSurfaceRef, showShellSpawnNotice, lath, nav]);
   const handleReattachRef = useRef(handleReattach);
   handleReattachRef.current = handleReattach;
 
@@ -1136,6 +1258,9 @@ export function Wall({
       const ref = transferSurfaceRef(reference.id, newId);
       lath.store.replaceLeaf(reference.id, newId, browserMeta);
       disposeSession(reference.id);
+      // A replacement in place is not a closure — the notepad rides along to the
+      // new id instead of being archived (docs/specs/notepad.md → "Closure").
+      transferNotepad(reference.id, newId);
       // Replacing the pane the user is selected on forces selection onto the
       // replacement; replacing any other pane leaves the user's selection —
       // including a door selection — untouched.
@@ -1184,8 +1309,13 @@ export function Wall({
     // The old renderer's controller is going away with this swap; release its
     // client-side resources (no-op for a non-agent-browser surface).
     disposeAgentBrowserSurfaceController(oldId);
+    // A browser Surface has no helper; the terminal's goes with the old id.
+    closeHelperParent(oldId);
     const newId = generatePaneId();
     transferSurfaceRef(oldId, newId);
+    // A renderer swap is not a closure — the notepad follows the new id
+    // (docs/specs/notepad.md → "Closure").
+    transferNotepad(oldId, newId);
     lath.store.replaceLeaf(oldId, newId, browserLeafMeta(next.title, next.params));
     clearLocalSurfaceActivity(oldId);
     selectPane(newId);
@@ -1218,6 +1348,9 @@ export function Wall({
       if (shouldReplaceUntouched) {
         lath.store.replaceLeaf(selectedPaneId!, newId, terminalLeafMeta());
         disposeSession(selectedPaneId!);
+        // Swapping the shell in place keeps the notepad; only a closure archives
+        // it (docs/specs/notepad.md → "Closure").
+        transferNotepad(selectedPaneId!, newId);
         forgetSurfaceRef(selectedPaneId!);
         selectPane(newId);
         if (detail.announce) {
@@ -1256,7 +1389,7 @@ export function Wall({
   }, [generatePaneId, surfaceRefForId, forgetSurfaceRef, selectPane, enterTerminalMode, showShellSpawnNotice, lath, nav]);
 
   // --- dor control plane (the `dor` CLI's webview handler) ---
-  const { updateSurfaceParams } = useDorControl({
+  const { findSurfaceByParams, updateSurfaceParams } = useDorControl({
     lath,
     nav,
     doorsRef,
@@ -1265,7 +1398,8 @@ export function Wall({
     surfaceRefForId,
     createSplitSurface,
     createContentSurface,
-    killPaneImmediately,
+    isClosingSurface,
+    closeSurface,
     lastAgentBrowserBinaryPathRef,
   });
 
@@ -1301,19 +1435,9 @@ export function Wall({
 
   const wallActions: WallActions = useMemo(() => ({
     onKill: (id: string) => {
+      // The confirm keystroke must reach the Wall, not the pane's xterm.
       exitTerminalMode();
-      const confirmSource = () => {
-        const door = doorsRef.current.find(item => item.id === id);
-        if (door) {
-          handleReattachRef.current(door, { enterPassthrough: false, afterRestore: isUntouched(id) ? 'kill-immediately' : 'confirm-kill' });
-          return;
-        }
-        if (isUntouched(id)) { void killPaneImmediately(id); return; }
-        setConfirmKill({ id, char: randomKillChar() });
-      };
-      const helper = getHelper(id);
-      if (!helper) { confirmSource(); return; }
-      void helperBlocksClose(id, helper).then(blocked => { if (!blocked) confirmSource(); });
+      requestKill(id);
     },
     onAlertButton: (id: string, displayedStatus: SessionStatus) => {
       return dismissOrToggleAlert(id, displayedStatus);
@@ -1492,7 +1616,7 @@ export function Wall({
       });
     },
     resolveSurfaceRef: surfaceRefForId,
-  }), [addSplitPanel, minimizePane, enterTerminalMode, exitTerminalMode, killPaneImmediately, helperBlocksClose, replaceSurface, buildDorSurfaces, createContentSurface, surfaceRefForId, updateSurfaceParams, lath, nav]);
+  }), [addSplitPanel, minimizePane, enterTerminalMode, exitTerminalMode, requestKill, replaceSurface, buildDorSurfaces, createContentSurface, surfaceRefForId, updateSurfaceParams, lath, nav]);
   const contextPortLaunches = useRef(new Map<string, Promise<void>>());
   const openContextPort = useCallback(async (id: string, entry: PortUrlEntry, mode: PortMode): Promise<void> => {
     const platform = getPlatform();
@@ -1503,10 +1627,7 @@ export function Wall({
     const operation = (async () => {
       const reference = buildDorSurfaces().find(surface => surface.id === id);
       if (!reference) throw new Error('The parent terminal is no longer available');
-      const existing = buildDorSurfaceList().find(surface => {
-        const params = lath.getMeta(surface.id)?.params;
-        return params?.contextPortKey === key && !lath.isDying(surface.id);
-      });
+      const existing = findSurfaceByParams(params => (params as { contextPortKey?: unknown } | undefined)?.contextPortKey === key);
       if (existing) {
         revealSurface(existing.id);
         if (mode !== 'iframe') {
@@ -1524,7 +1645,7 @@ export function Wall({
       if (mode === 'iframe') return;
       const result = await platform.agentBrowserOpen!(entry.url, { headed: mode === 'ab-popout' }, lastAgentBrowserBinaryPathRef.current);
       if (!result.ok || !result.session) {
-        killPaneImmediately(created.value.id);
+        await closeSurface(created.value.id);
         throw new Error(result.error ?? 'Could not open agent browser');
       }
       if (result.binaryPath) lastAgentBrowserBinaryPathRef.current = result.binaryPath;
@@ -1534,11 +1655,11 @@ export function Wall({
     })();
     contextPortLaunches.current.set(key, operation);
     try { await operation; } finally { contextPortLaunches.current.delete(key); }
-  }, [buildDorSurfaces, buildDorSurfaceList, createContentSurface, enterTerminalMode, killPaneImmediately, lath, revealSurface, updateSurfaceParams]);
+  }, [buildDorSurfaces, findSurfaceByParams, createContentSurface, enterTerminalMode, closeSurface, lath, revealSurface, updateSurfaceParams]);
   const contextActions = useMemo(() => ({
     id: terminalContext && !terminalContext.closing ? terminalContext.id : null,
     mounted: terminalContext,
-    open: (id: string, options?: TerminalContextOpenOptions) => { if (isHelperSession(id)) return; setTerminalContext({ id, ...options }); },
+    open: (id: string, options?: TerminalContextOpenOptions) => { if (isHelperSession(id) || isSurfaceClosing(id) || lath.isDying(id)) return; setTerminalContext({ id, ...options }); },
     close: () => {
       const instant = motionIsInstant();
       setTerminalContext(current => {
@@ -1548,6 +1669,7 @@ export function Wall({
       });
     },
     promote: async (id: string) => {
+      if (isSurfaceClosing(id)) throw new Error('This terminal is closing');
       if (!getHelper(id) || !nav.hasPane(id)) throw new Error('Helper cannot be placed beside this terminal');
       const helper = await beginPromotion(id);
       const placed = lath.store.addLeaf(helper.id, terminalLeafMeta(), { refId: id, edge: lath.store.autoEdgeFor(id) });
@@ -1593,10 +1715,9 @@ export function Wall({
     enterTerminalMode,
     exitTerminalMode,
     minimizePane,
-    killPaneImmediately,
+    requestKill,
     acceptKill,
     rejectKill,
-    setConfirmKill,
     setRenamingPaneId,
     fireEvent,
   });
@@ -1681,7 +1802,7 @@ export function Wall({
           <RenamingIdContext.Provider value={renamingPaneId}>
           <ZoomedIdContext.Provider value={zoomedId}>
           <WindowFocusedContext.Provider value={windowFocused}>
-          <DialogKeyboardContext.Provider value={setDialogKeyboardActive}>
+          <DialogKeyboardContext.Provider value={acquireDialogKeyboard}>
           <div className="flex-1 min-h-0 flex flex-col bg-app-bg text-app-fg font-sans overflow-hidden">
             {/* The tiling area — 2px bottom inset keeps rounded panes distinct from the baseboard when present. */}
             {/* 1.75 = PANE_GUTTER_PX (7px) in design.tsx — keep in sync. */}
@@ -1720,20 +1841,33 @@ export function Wall({
               />
             )}
 
+            {/* The archive refused this Surface's notes — it is still open.
+                One prompt at a time: answering the head reveals the next. */}
+            {archiveFailures[0] && (
+              <NotepadArchiveFailureModal
+                failure={archiveFailures[0]}
+                paneElements={paneElements}
+                onKeepOpen={shiftArchiveFailure}
+                onCloseAnyway={() => {
+                  // Retry the Helper guard before discarding the shared notes.
+                  const { id } = archiveFailures[0];
+                  shiftArchiveFailure();
+                  void closeSurface(id, 'discard');
+                }}
+              />
+            )}
+
             <ShellSpawnNotice
               notice={shellSpawnNotice}
               paneElements={paneElements}
               version={paneElementsVersion}
             />
 
-            <ExternalLinkModalHost onKeyboardActiveChange={setDialogKeyboardActive} />
-            <AgentBrowserScreenModalHost
-              onKeyboardActiveChange={setDialogKeyboardActive}
-              resolveLabel={surfaceRefForId}
-            />
+            <ExternalLinkModalHost />
+            <AgentBrowserScreenModalHost resolveLabel={surfaceRefForId} />
             {enableBurrow ? (
               <Suspense fallback={null}>
-                <RemotePairingModalHost onKeyboardActiveChange={setDialogKeyboardActive} />
+                <RemotePairingModalHost />
               </Suspense>
             ) : null}
             {dialogHost}
diff --git a/lib/src/components/use-notepad.ts b/lib/src/components/use-notepad.ts
new file mode 100644
index 00000000..9d602807
--- /dev/null
+++ b/lib/src/components/use-notepad.ts
@@ -0,0 +1,61 @@
+// What every notepad trigger needs from the store: the counts and open id the
+// headers and Doors subscribe to, and the two strings/actions they share
+// (docs/specs/notepad.md). Whether the host has a notepad at all is
+// `hasNotepadArchive()` in `lib/src/lib/notepad/archive-service.ts`.
+import { useCallback, useSyncExternalStore } from 'react';
+import {
+  getNotes,
+  getOpenNotepadId,
+  isSurfaceClosing,
+  noteCount,
+  subscribeToClosing,
+  subscribeToNotepad,
+  subscribeToOpenNotepad,
+} from '../lib/notepad/notepad-store';
+import { copyNoteToClipboard } from '../lib/notepad/rich-clipboard';
+import type { LiveNote } from '../lib/notepad/types';
+
+/** A Surface's note count. A number rather than the notes themselves, so a
+ *  header re-renders only when the count it draws actually moves. */
+export function useNoteCount(surfaceId: string): number {
+  return useSyncExternalStore(
+    subscribeToNotepad,
+    useCallback(() => noteCount(surfaceId), [surfaceId]),
+  );
+}
+
+/** A Surface's notes. The store hands back a stable array per surface, so this
+ *  is safe as a `useSyncExternalStore` snapshot. */
+export function useNotes(surfaceId: string): readonly LiveNote[] {
+  return useSyncExternalStore(
+    subscribeToNotepad,
+    useCallback(() => getNotes(surfaceId), [surfaceId]),
+  );
+}
+
+/** Whether a closure is holding this Surface's notes mid-write, so the panel
+ *  renders read-only (docs/specs/notepad.md → "Closure"). */
+export function useSurfaceClosing(surfaceId: string): boolean {
+  return useSyncExternalStore(
+    subscribeToClosing,
+    useCallback(() => isSurfaceClosing(surfaceId), [surfaceId]),
+  );
+}
+
+/** The one Surface whose notepad is open, Wall-wide. */
+export function useOpenNotepadId(): string | null {
+  return useSyncExternalStore(subscribeToOpenNotepad, getOpenNotepadId);
+}
+
+/** Accessible name and tooltip for the notepad triggers, count included so a
+ *  filled icon says how filled it is. */
+export function notepadLabel(count: number): string {
+  if (count === 0) return 'Notepad';
+  return `Notepad · ${count} ${count === 1 ? 'note' : 'notes'}`;
+}
+
+/** Fire-and-forget: the clipboard write is best effort by contract, and the
+ *  Copy button's own check is the feedback. */
+export function copyNote(note: LiveNote): void {
+  void copyNoteToClipboard(note.content);
+}
diff --git a/lib/src/components/use-popover-focus-trap.ts b/lib/src/components/use-popover-focus-trap.ts
new file mode 100644
index 00000000..4903bf32
--- /dev/null
+++ b/lib/src/components/use-popover-focus-trap.ts
@@ -0,0 +1,50 @@
+import { useEffect } from 'react';
+import { stepFocus } from './focus-step';
+
+/** What Tab reaches inside a popover: real buttons plus explicit tab stops. */
+export const POPOVER_FOCUSABLE_SELECTOR = 'button:not([disabled]), [tabindex]:not([tabindex="-1"])';
+
+/**
+ * Manages focus trapping, Escape-to-close, and click-outside-to-close for
+ * portal-based popovers. Scopes keyboard handling to the popover's DOM subtree
+ * so Tab/Escape don't leak to the rest of the app.
+ */
+export function usePopoverFocusTrap(
+  ref: React.RefObject<HTMLElement | null>,
+  onClose: () => void,
+) {
+  useEffect(() => {
+    const el = ref.current;
+    if (!el) return;
+
+    const handleMouseDown = (e: MouseEvent) => {
+      if (!el.contains(e.target as Node)) onClose();
+    };
+
+    const handleKeyDown = (e: KeyboardEvent) => {
+      // Only handle keys when focus is inside the popover
+      if (!el.contains(document.activeElement)) return;
+
+      if (e.key === 'Escape') {
+        e.preventDefault();
+        e.stopPropagation();
+        onClose();
+        return;
+      }
+      if (e.key !== 'Tab') return;
+
+      e.preventDefault();
+      stepFocus(
+        Array.from(el.querySelectorAll<HTMLElement>(POPOVER_FOCUSABLE_SELECTOR)),
+        e.shiftKey ? -1 : 1,
+      );
+    };
+
+    window.addEventListener('mousedown', handleMouseDown);
+    window.addEventListener('keydown', handleKeyDown, true);
+    return () => {
+      window.removeEventListener('mousedown', handleMouseDown);
+      window.removeEventListener('keydown', handleKeyDown, true);
+    };
+  }, [ref, onClose]);
+}
diff --git a/lib/src/components/wall/BrowserPanel.tsx b/lib/src/components/wall/BrowserPanel.tsx
index 266ce5f7..103bd121 100644
--- a/lib/src/components/wall/BrowserPanel.tsx
+++ b/lib/src/components/wall/BrowserPanel.tsx
@@ -14,6 +14,7 @@ import { resolveRenderMode } from './browser-surface';
 import type { PaneProps } from './pane-props';
 import { AgentBrowserPanel } from './AgentBrowserPanel';
 import { IframePanel } from './IframePanel';
+import { NotepadPanel } from '../NotepadPanel';
 
 /** Canonical persisted state for a browser surface. `renderMode` + `url` are the
  *  single source of truth across swaps; the agent-browser fields ride flat and are
@@ -31,6 +32,14 @@ export type BrowserPanelParams = {
 
 export function BrowserPanel(props: PaneProps) {
   const renderMode = resolveRenderMode(props.params);
-  if (renderMode === 'iframe') return <IframePanel {...props} />;
-  return <AgentBrowserPanel {...props} renderMode={renderMode} />;
+  // The wrapper is the notepad panel's containing block, and the one thing both
+  // renderers share; each child still fills it and owns its own chrome.
+  return (
+    <div className="relative h-full w-full">
+      {renderMode === 'iframe'
+        ? <IframePanel {...props} />
+        : <AgentBrowserPanel {...props} renderMode={renderMode} />}
+      <NotepadPanel surfaceId={props.id} />
+    </div>
+  );
 }
diff --git a/lib/src/components/wall/NotepadHeaderButton.tsx b/lib/src/components/wall/NotepadHeaderButton.tsx
new file mode 100644
index 00000000..892f6f1e
--- /dev/null
+++ b/lib/src/components/wall/NotepadHeaderButton.tsx
@@ -0,0 +1,43 @@
+import { NotepadIcon } from '@phosphor-icons/react';
+import { HeaderActionButton } from '../HeaderActionButton';
+import { notepadLabel, useNoteCount, useOpenNotepadId } from '../use-notepad';
+import { hasNotepadArchive } from '../../lib/notepad/archive-service';
+import { setOpenNotepadId } from '../../lib/notepad/notepad-store';
+
+/**
+ * The pane header's notepad toggle, filled while the Surface has notes
+ * (docs/specs/notepad.md → "Notepad UI"; `docs/specs/layout.md` → "Pane header"
+ * owns where it sits). One component for both headers so the terminal and the
+ * browser Surface open the same notepad the same way.
+ */
+export function NotepadHeaderButton({
+  surfaceId,
+  hideWhenEmpty = false,
+}: {
+  surfaceId: string;
+  /** The minimal tier: an empty notepad yields its space to the title, one with
+   *  notes stays, so notes are never invisible. */
+  hideWhenEmpty?: boolean;
+}) {
+  const notes = useNoteCount(surfaceId);
+  const open = useOpenNotepadId() === surfaceId;
+  if (!hasNotepadArchive() || (hideWhenEmpty && notes === 0)) return null;
+
+  const label = notepadLabel(notes);
+  return (
+    <div className="ml-1 shrink-0">
+      <HeaderActionButton
+        className="flex h-5 min-w-5 items-center justify-center rounded transition-colors shrink-0 hover:bg-current/10"
+        onMouseDown={(e) => e.stopPropagation()}
+        onClick={(e) => {
+          e.stopPropagation();
+          setOpenNotepadId(open ? null : surfaceId);
+        }}
+        ariaLabel={label}
+        tooltip={label}
+      >
+        <NotepadIcon size={14} weight={notes > 0 ? 'fill' : 'regular'} />
+      </HeaderActionButton>
+    </div>
+  );
+}
diff --git a/lib/src/components/wall/SurfacePaneHeader.tsx b/lib/src/components/wall/SurfacePaneHeader.tsx
index 7bce7ef6..9ec95bfe 100644
--- a/lib/src/components/wall/SurfacePaneHeader.tsx
+++ b/lib/src/components/wall/SurfacePaneHeader.tsx
@@ -12,6 +12,7 @@ import {
 } from '@phosphor-icons/react';
 import { HeaderActionButton } from '../HeaderActionButton';
 import { HEADER_PALETTE_TRANSITION_CLASS, paneZoomButtonClass, TERMINAL_TOP_RADIUS_CLASS } from '../design';
+import { NotepadHeaderButton } from './NotepadHeaderButton';
 import {
   useAgentBrowserChromeSnapshot,
   useAgentBrowserScreenController,
@@ -24,12 +25,12 @@ import type { PaneProps } from './pane-props';
 import { loopbackPort, normalizeNavUrl, pathDisplay } from './browser-url';
 import { triggerDevServerRescan, useDevServerMatch } from './agent-browser-ports';
 import {
-  DialogKeyboardContext,
   ModeContext,
   SelectedIdContext,
   WallActionsContext,
   WindowFocusedContext,
   ZoomedIdContext,
+  useDialogKeyboardOwner,
 } from './wall-context';
 
 export function SurfacePaneHeader({ id, title }: PaneProps) {
@@ -66,13 +67,8 @@ export function SurfacePaneHeader({ id, title }: PaneProps) {
   // navigate elsewhere. While it's open we flag dialog-keyboard so the Wall's
   // keyboard handler stands down (the panel's own key-forwarder skips editable
   // targets); the editor closes itself when the surface stops being a browser.
-  const setDialogKeyboardActive = useContext(DialogKeyboardContext);
   const [editingUrl, setEditingUrl] = useState(false);
-  useEffect(() => {
-    if (!editingUrl) return;
-    setDialogKeyboardActive(true);
-    return () => setDialogKeyboardActive(false);
-  }, [editingUrl, setDialogKeyboardActive]);
+  useDialogKeyboardOwner(editingUrl);
   useEffect(() => {
     if (!screen && editingUrl) setEditingUrl(false);
   }, [screen, editingUrl]);
@@ -191,6 +187,7 @@ export function SurfacePaneHeader({ id, title }: PaneProps) {
         <span className="min-w-0 flex-1 truncate font-medium">{title ?? id}</span>
       )}
 
+      <NotepadHeaderButton surfaceId={id} />
       <div className="ml-1 hidden shrink-0 items-center gap-0.5 min-[420px]:flex">
         <HeaderActionButton
           className="flex h-5 min-w-5 items-center justify-center rounded transition-colors hover:bg-current/10"
diff --git a/lib/src/components/wall/TerminalContext.test.tsx b/lib/src/components/wall/TerminalContext.test.tsx
index 22d810c1..38595def 100644
--- a/lib/src/components/wall/TerminalContext.test.tsx
+++ b/lib/src/components/wall/TerminalContext.test.tsx
@@ -5,6 +5,9 @@ import { afterEach, beforeEach, expect, it, vi } from 'vitest';
 import { TerminalContextView, type TerminalContextViewProps } from './TerminalContextView';
 import { TerminalPaneHeader } from './TerminalPaneHeader';
 import { TerminalPanel } from './TerminalPanel';
+import { TerminalContext } from './TerminalContext';
+import * as helpers from '../../lib/helper-terminal';
+import { addPlainNote, clearAllNotepads, getNotes, getOpenNotepadId } from '../../lib/notepad/notepad-store';
 import { TerminalContextContext } from './wall-context';
 import { ensureResizeObserver } from './wall-test-utils';
 import { setMouseReporting, removeMouseSelectionState } from '../../lib/mouse-selection';
@@ -166,3 +169,24 @@ it('shares header, alert and uncaptured body entry points; captured mouse has no
   rightClick(body); rightClick(body, true); expect(open).toHaveBeenCalledTimes(3);
   rightClick(header); expect(open).toHaveBeenCalledTimes(4);
 });
+
+it('opens the parent notepad from the Helper control and keeps edits on that parent', async () => {
+  const helper: helpers.HelperTerminal = { id: 'helper', parentId: 'parent', command: '', status: 'off' };
+  const get = vi.spyOn(helpers, 'getHelper').mockReturnValue(helper);
+  const open = vi.spyOn(helpers, 'openHelper').mockResolvedValue(helper);
+  try {
+    addPlainNote('parent', 'shared note');
+    await act(async () => root.render(<TerminalContext id="parent" />));
+    const toggle = container.querySelector<HTMLButtonElement>('[aria-label="Notepad · 1 note"]');
+    expect(toggle).not.toBeNull();
+    await act(async () => toggle!.click());
+    expect(getOpenNotepadId()).toBe('parent');
+    expect(container.querySelector('[role="dialog"]')?.textContent).toContain('shared note');
+    await click('Delete note');
+    expect(getNotes('parent')).toEqual([]);
+    expect(getNotes('helper')).toEqual([]);
+  } finally {
+    get.mockRestore(); open.mockRestore();
+    act(() => clearAllNotepads());
+  }
+});
diff --git a/lib/src/components/wall/TerminalContext.tsx b/lib/src/components/wall/TerminalContext.tsx
index 340e156b..88b5b54a 100644
--- a/lib/src/components/wall/TerminalContext.tsx
+++ b/lib/src/components/wall/TerminalContext.tsx
@@ -1,4 +1,8 @@
 import { useCallback, useContext, useEffect, useMemo, useState, useSyncExternalStore } from 'react';
+import { NotepadPanel } from '../NotepadPanel';
+import { NotepadHeaderButton } from './NotepadHeaderButton';
+import { isSurfaceClosing } from '../../lib/notepad/notepad-store';
+import { messageOf } from '../../lib/errors';
 import { TerminalPane } from '../TerminalPane';
 import { TerminalContextView, type ContextScan } from './TerminalContextView';
 import { TerminalContextContext, WallActionsContext, type TerminalContextState } from './wall-context';
@@ -10,8 +14,6 @@ import { writeTextToClipboard } from '../../lib/clipboard';
 import { listenerUrlsByPort } from './port-url';
 import { DEFAULT_HELPER_COMMAND } from '../../lib/terminal-context-types';
 
-const errorText = (error: unknown) => (error instanceof Error ? error.message : String(error));
-
 export function TerminalContext({ id, title, closing, origin, warning: openWarning }: TerminalContextState & { title?: string }) {
   const context = useContext(TerminalContextContext);
   const actions = useContext(WallActionsContext);
@@ -35,7 +37,7 @@ export function TerminalContext({ id, title, closing, origin, warning: openWarni
   const display = (location: CwdState) => cwdDisplay(location, { style: 'full', homePath: home });
   useEffect(() => {
     let cancelled = false;
-    void openHelper(id).catch(e => { if (!cancelled) setHelperError(errorText(e)); });
+    void openHelper(id).catch(e => { if (!cancelled) setHelperError(messageOf(e)); });
     void platform.terminalContext?.({ op: 'settings' }).then(info => { if (!cancelled) { setHome(info.home ?? ''); setDefaultCommand(info.command ?? DEFAULT_HELPER_COMMAND); } }).catch(() => {});
     void platform.getOpenPorts(id).then(ports => { if (!cancelled) setScan({ status: 'loaded', entries: listenerUrlsByPort(ports) }); }, () => { if (!cancelled) setScan({ status: 'failed' }); });
     return () => { cancelled = true; };
@@ -61,7 +63,9 @@ export function TerminalContext({ id, title, closing, origin, warning: openWarni
     onWatch={() => { if (argv0) setCommandWatched(argv0, !isCommandWatched(argv0)); }} onTodo={() => toggleSessionTodo(id)}
     onPort={(entry, mode) => context.openPort(id, entry, mode)}
     onModify={async command => { await platform.terminalContext?.({ op: 'settings', command }); setDefaultCommand(command); }}
-    onReset={async () => { disposeHelper(id); await openHelper(id); }} onPromote={() => context.promote(id)}>
+    notepadAction={<NotepadHeaderButton surfaceId={id} />}
+    notepadPanel={<NotepadPanel surfaceId={id} pins={false} />}
+    onReset={async () => { if (isSurfaceClosing(id)) throw new Error('This terminal is closing'); disposeHelper(id); await openHelper(id); }} onPromote={() => context.promote(id)}>
     {helper && <div data-helper-terminal={helper.id} className="h-full px-3 py-2" onMouseDown={() => focusSession(helper.id, true)}><TerminalPane key={helper.id} id={helper.id} isFocused={false} /></div>}
   </TerminalContextView>;
 }
diff --git a/lib/src/components/wall/TerminalContextView.tsx b/lib/src/components/wall/TerminalContextView.tsx
index f65a509c..8d40be1f 100644
--- a/lib/src/components/wall/TerminalContextView.tsx
+++ b/lib/src/components/wall/TerminalContextView.tsx
@@ -7,11 +7,41 @@ import type { PortUrlEntry } from './port-url';
 import type { HelperStatus } from '../../lib/helper-terminal';
 import { WindowFocusedContext } from './wall-context';
 import { motionIsInstant } from '../../lib/ui-geometry';
+import { messageOf } from '../../lib/errors';
 
 export type PortMode = 'system' | 'iframe' | 'ab-screencast' | 'ab-popout';
 export type ContextScan = { status: 'scanning' | 'failed' } | { status: 'loaded'; entries: PortUrlEntry[] };
 /** Every action may fail asynchronously; the view reports the failure. */
 type Action = () => void | Promise<void>;
+const SPINNING = <CircleNotchIcon size={13} className="shrink-0 animate-spin" />;
+const PAUSED = <PauseIcon size={13} className="shrink-0" />;
+const SETTLED = <CheckIcon size={13} className="shrink-0" />;
+/** One row per helper state (docs/specs/terminal-context.md → Helper lifecycle);
+ *  a `reset` state offers Reset in place of Modify. */
+const HELPER_STATUS: Record<HelperStatus, { icon: ReactNode; label: (command: string) => string; reset?: boolean }> = {
+  waiting: { icon: SPINNING, label: () => 'Waiting for shell…' },
+  running: { icon: SPINNING, label: command => `Running ${command}…` },
+  completed: { icon: SETTLED, label: command => `${command} autoran` },
+  preserved: { icon: PAUSED, label: () => 'Skipping autorun to preserve user keystrokes', reset: true },
+  off: { icon: PAUSED, label: () => 'Autorun off' },
+  unsupported: { icon: PAUSED, label: () => 'Autorun skipped: shell readiness unavailable' },
+  exited: { icon: SETTLED, label: () => 'Helper exited', reset: true },
+};
+
+/** The port row's launch targets; `needs` names the host capability that enables one. */
+const PORT_ACTIONS: readonly ({ mode: PortMode; label: string; icon: ReactNode; text: string } & ({ needs?: undefined } | { needs: 'canIframe' | 'canAgent'; unavailable: string }))[] = [
+  { mode: 'system', label: 'Open in system browser', icon: <ArrowSquareOutIcon size={15} />, text: 'System browser' },
+  { mode: 'iframe', label: 'Open in iframe embed', needs: 'canIframe', unavailable: 'Iframe unavailable on this host', icon: <FrameCornersIcon size={15} />, text: 'Iframe' },
+  { mode: 'ab-screencast', label: 'Open in agent-browser screencast', needs: 'canAgent', unavailable: 'Agent browser unavailable on this host', icon: <AgentRobotIcon size={17} />, text: 'Agent browser' },
+  { mode: 'ab-popout', label: 'Open in agent-browser popout', needs: 'canAgent', unavailable: 'Popout unavailable on this host', icon: <><AgentRobotIcon size={17} /><ArrowSquareOutIcon size={13} /></>, text: 'Popout' },
+];
+
+const DETAILS = {
+  title: { label: 'Title sources', heading: 'Why this title?' },
+  modify: { label: 'Default helper autorun command', heading: 'Default helper autorun command' },
+  reset: { label: 'Reset helper terminal', heading: 'Reset helper terminal?' },
+} as const;
+type Detail = keyof typeof DETAILS;
 export interface TerminalContextViewProps {
   /** Exit in progress: the view is inert, and `onClose` is not called again. */
   closing?: boolean;
@@ -23,11 +53,11 @@ export interface TerminalContextViewProps {
   notification?: { title: string | null; body: string | null } | null;
   status: HelperStatus; command: string; warning?: string;
   explorerLabel: string; canExplore: boolean; canAgent: boolean; canIframe: boolean;
-  children: ReactNode;
+  children: ReactNode; notepadAction?: ReactNode; notepadPanel?: ReactNode;
   onClose(): void; onCopyRef: Action; onCopyPath: Action; onExplore: Action;
   onWatch(): void; onTodo(): void; onPort(entry: PortUrlEntry, mode: PortMode): void | Promise<void>;
   onModify(command: string): Promise<void>; onReset: Action; onPromote: Action;
-  initialDetail?: 'title' | 'modify' | 'reset' | null;
+  initialDetail?: Detail | null;
 }
 
 export function ContextAction({ children, label, onClick, disabled = false, busy = false, muted = false }: { children: ReactNode; label: string; onClick?: () => void; disabled?: boolean; busy?: boolean; muted?: boolean }) {
@@ -132,11 +162,11 @@ export function TerminalContextView(p: TerminalContextViewProps) {
   const [error, setError] = useState('');
   const entries = p.scan.status === 'loaded' ? p.scan.entries : [];
   const selected = entries.find(entry => entry.port === port) ?? entries[0];
-  const preserved = p.status === 'preserved';
-  const attempt = async (action: Action) => { setError(''); try { await action(); return true; } catch (e) { setError(String(e instanceof Error ? e.message : e)); return false; } };
+  const attempt = async (action: Action) => { setError(''); try { await action(); return true; } catch (e) { setError(messageOf(e)); return false; } };
   /** A detail-dialog action: closes the dialog on success and holds the buttons meanwhile. */
   const submit = async (action: Action) => { setBusy(true); if (await attempt(action)) setDetail(null); setBusy(false); };
-  const status = p.status === 'waiting' ? 'Waiting for shell…' : p.status === 'off' ? 'Autorun off' : p.status === 'unsupported' ? 'Autorun skipped: shell readiness unavailable' : p.status === 'exited' ? 'Helper exited' : preserved ? 'Skipping autorun to preserve user keystrokes' : p.status === 'running' ? `Running ${p.command}…` : `${p.command} autoran`;
+  const status = HELPER_STATUS[p.status];
+  const statusLabel = status.label(p.command);
   return <section ref={surface} aria-label="Terminal context" data-terminal-context tabIndex={-1} inert={p.closing} aria-hidden={p.closing || undefined} style={SURFACE_STYLE}
     className={`${TERMINAL_CONTEXT_SURFACE_CLASS} ${motionClass} ${p.closing ? 'pointer-events-none' : ''} absolute inset-4 flex flex-col overflow-hidden text-sm`}
     onContextMenu={event => event.preventDefault()}
@@ -163,10 +193,10 @@ export function TerminalContextView(p: TerminalContextViewProps) {
             {p.scan.status === 'scanning' ? <span className="text-muted">Scanning ports…</span> : p.scan.status === 'failed' ? <span className="text-error">Port scan failed · Reopen to try again</span> : !selected ? <span className="text-muted">No listening ports</span> : <>
               {entries.length > 1 ? <div className="inline-flex shrink-0 items-center gap-2"><select aria-label="Port" value={selected.port} onChange={e => setPort(Number(e.target.value))} className="h-6 rounded border border-input-border bg-input-bg px-1 text-foreground">{entries.map(entry => <option key={entry.port} value={entry.port}>{entry.host}:{entry.port}{entry.processName ? ` · ${entry.processName}` : ''}</option>)}</select><span className="text-muted">{entries.length} ports</span></div> : <><span>{selected.host}:{selected.port}</span><span className="text-muted">{selected.processName}</span></>}
               <div className="ml-1 inline-flex shrink-0 items-center gap-1 border-l border-border pl-2">
-                <ContextAction label="Open in system browser" onClick={() => void attempt(() => p.onPort(selected, 'system'))}><ArrowSquareOutIcon size={15} />System browser</ContextAction>
-                <ContextAction label={p.canIframe ? 'Open in iframe embed' : 'Iframe unavailable on this host'} disabled={!p.canIframe} onClick={() => void attempt(() => p.onPort(selected, 'iframe'))}><FrameCornersIcon size={15} />Iframe</ContextAction>
-                <ContextAction label={p.canAgent ? 'Open in agent-browser screencast' : 'Agent browser unavailable on this host'} disabled={!p.canAgent} onClick={() => void attempt(() => p.onPort(selected, 'ab-screencast'))}><AgentRobotIcon size={17} />Agent browser</ContextAction>
-                <ContextAction label={p.canAgent ? 'Open in agent-browser popout' : 'Popout unavailable on this host'} disabled={!p.canAgent} onClick={() => void attempt(() => p.onPort(selected, 'ab-popout'))}><AgentRobotIcon size={17} /><ArrowSquareOutIcon size={13} />Popout</ContextAction>
+                {PORT_ACTIONS.map(action => {
+                  const unavailable = action.needs && !p[action.needs] ? action.unavailable : null;
+                  return <ContextAction key={action.mode} label={unavailable ?? action.label} disabled={!!unavailable} onClick={() => void attempt(() => p.onPort(selected, action.mode))}>{action.icon}{action.text}</ContextAction>;
+                })}
               </div>
             </>}
           </div>
@@ -177,17 +207,18 @@ export function TerminalContextView(p: TerminalContextViewProps) {
       <div className="@container flex min-h-0 flex-1 flex-col border-t border-border">
         <div aria-label="Helper terminal status" className="flex h-9 shrink-0 items-center gap-3 whitespace-nowrap px-3">
           <span className="hidden shrink-0 items-center gap-2 font-semibold @[48rem]:flex"><TerminalIcon size={15} />Helper terminal</span>
-          <div className="flex min-w-0 items-center gap-2 text-muted">{p.status === 'running' || p.status === 'waiting' ? <CircleNotchIcon size={13} className="shrink-0 animate-spin" /> : preserved || p.status === 'off' || p.status === 'unsupported' ? <PauseIcon size={13} className="shrink-0" /> : <CheckIcon size={13} className="shrink-0" />}<span className="truncate" title={status}>{status}</span>
-            {preserved || p.status === 'exited' ? <ContextAction label="Reset helper terminal" onClick={() => setDetail('reset')}><ArrowCounterClockwiseIcon size={13} />Reset…</ContextAction> : <ContextAction label="Modify autorun command" onClick={() => { setCommand(p.defaultCommand ?? p.command); setDetail('modify'); }}><SlidersHorizontalIcon size={15} />Modify</ContextAction>}
+          <div className="flex min-w-0 items-center gap-2 text-muted">{status.icon}<span className="truncate" title={statusLabel}>{statusLabel}</span>
+            {status.reset ? <ContextAction label="Reset helper terminal" onClick={() => setDetail('reset')}><ArrowCounterClockwiseIcon size={13} />Reset…</ContextAction> : <ContextAction label="Modify autorun command" onClick={() => { setCommand(p.defaultCommand ?? p.command); setDetail('modify'); }}><SlidersHorizontalIcon size={15} />Modify</ContextAction>}
           </div>
-          <div className="ml-auto shrink-0"><ContextAction label="Move this terminal into a new pane" busy={busy} onClick={() => void submit(p.onPromote)}><ArrowLineUpIcon size={15} />Promote</ContextAction></div>
+          <div className="ml-auto flex shrink-0 items-center gap-2">{p.notepadAction}<ContextAction label="Move this terminal into a new pane" busy={busy} onClick={() => void submit(p.onPromote)}><ArrowLineUpIcon size={15} />Promote</ContextAction></div>
         </div>
         {p.mismatch && <div role="alert" className="mx-3 mb-2 flex shrink-0 items-start gap-2 border-l-4 border-error bg-error/10 px-3 py-2"><WarningIcon size={18} weight="fill" className="shrink-0 text-error" /><div><div className="font-semibold">Helper directory differs from parent</div><div className="mt-1 grid grid-cols-[4rem_1fr] gap-x-2"><span className="text-muted">Helper</span><strong>{p.helperCwd}</strong><span className="text-muted">Parent</span><span>{p.cwd}</span></div></div></div>}
         {(p.warning || (!detail && error)) && <div role="alert" className="mx-3 mb-2 border-l-4 border-error bg-error/10 px-3 py-2">{p.warning || error}</div>}
         <div className="min-h-0 flex-1 bg-terminal-bg text-terminal-fg">{p.children}</div>
       </div>
-    {detail && <div className="absolute inset-0 z-10 bg-app-bg/35" onClick={() => setDetail(null)}><div ref={detailRoot} role="dialog" aria-modal="true" aria-label={detail === 'title' ? 'Title sources' : detail === 'modify' ? 'Default helper autorun command' : 'Reset helper terminal'} className={`${POPUP_SURFACE_CLASS} absolute left-3 right-3 top-9 p-4`} onClick={e => e.stopPropagation()}>
-      <div className="mb-3 flex items-center justify-between font-semibold"><span>{detail === 'title' ? 'Why this title?' : detail === 'modify' ? 'Default helper autorun command' : 'Reset helper terminal?'}</span><ContextAction label="Close details" onClick={() => setDetail(null)} muted><XIcon size={14} /></ContextAction></div>
+    {p.notepadPanel}
+    {detail && <div className="absolute inset-0 z-10 bg-app-bg/35" onClick={() => setDetail(null)}><div ref={detailRoot} role="dialog" aria-modal="true" aria-label={DETAILS[detail].label} className={`${POPUP_SURFACE_CLASS} absolute left-3 right-3 top-9 p-4`} onClick={e => e.stopPropagation()}>
+      <div className="mb-3 flex items-center justify-between font-semibold"><span>{DETAILS[detail].heading}</span><ContextAction label="Close details" onClick={() => setDetail(null)} muted><XIcon size={14} /></ContextAction></div>
       {detail === 'title' ? <div className="grid grid-cols-[8rem_1fr_auto] gap-x-3 gap-y-2">{p.titleSources.map((source, index) => <div className="contents" key={index}><span className="text-muted">{source.source}</span><span>{source.value}</span><span className="text-muted">{source.note}</span></div>)}</div> : detail === 'modify' ? <><input autoFocus aria-label="Default helper autorun command" value={command} onChange={e => setCommand(e.target.value)} maxLength={4096} placeholder="Leave empty to turn autorun off" className="w-full border-b border-input-border bg-input-bg px-2 py-1.5 outline-focus-ring" /><p className="mb-4 mt-2 text-muted">Global default. Applies to new and reset helpers. Leave empty to turn autorun off.</p><div className="flex justify-end gap-2"><ContextAction label="Reset helper terminal" onClick={() => setDetail('reset')}>Reset helper…</ContextAction><ContextAction label="Save default" busy={busy} onClick={() => void submit(() => p.onModify(command))}>Save default</ContextAction></div></> : <><p>Discard this helper, including scrollback, unfinished input, and any running program? Unsaved edits will be lost.</p><p className="mb-4 mt-2 text-muted">A fresh helper starts in the parent's current directory using the global autorun default.</p><div className="flex justify-end gap-2"><ContextAction label="Keep helper" onClick={() => setDetail(null)}>Keep helper</ContextAction><ContextAction label="Discard and reset" busy={busy} onClick={() => void submit(p.onReset)}>Discard and reset</ContextAction></div></>}
       {error && <p role="alert" className="mt-2 text-error">{error}</p>}
     </div></div>}
diff --git a/lib/src/components/wall/TerminalPaneHeader.test.tsx b/lib/src/components/wall/TerminalPaneHeader.test.tsx
index 3838919b..0703a6ae 100644
--- a/lib/src/components/wall/TerminalPaneHeader.test.tsx
+++ b/lib/src/components/wall/TerminalPaneHeader.test.tsx
@@ -12,6 +12,13 @@ import { FakePtyAdapter } from '../../lib/platform/fake-adapter';
 import { setPlatform } from '../../lib/platform';
 import { setNativeFieldValue } from '../../lib/dom';
 import { removeTerminalPaneState } from '../../lib/terminal-registry';
+import { removeMouseSelectionState, setMouseReporting } from '../../lib/mouse-selection';
+import {
+  addPlainNote,
+  clearAllNotepads,
+  getOpenNotepadId,
+  setOpenNotepadId,
+} from '../../lib/notepad/notepad-store';
 
 globalThis.IS_REACT_ACT_ENVIRONMENT = true;
 
@@ -143,3 +150,100 @@ describe('TerminalPaneHeader — inline rename', () => {
     expect(document.body.textContent).toContain('<idle> nope');
   });
 });
+
+describe('TerminalPaneHeader — notepad icon', () => {
+  // The tier is ResizeObserver-driven, so the suite's inert stub can only ever
+  // show `full`. This one reports a width the test picks.
+  let headerWidth = 400;
+  let previousObserver: typeof ResizeObserver;
+
+  beforeEach(() => {
+    headerWidth = 400;
+    previousObserver = globalThis.ResizeObserver;
+    globalThis.ResizeObserver = class {
+      constructor(private readonly callback: ResizeObserverCallback) {}
+      observe(target: Element): void {
+        this.callback(
+          [{ target, contentRect: { width: headerWidth } } as unknown as ResizeObserverEntry],
+          this as unknown as ResizeObserver,
+        );
+      }
+      unobserve(): void {}
+      disconnect(): void {}
+    } as unknown as typeof ResizeObserver;
+  });
+
+  afterEach(() => {
+    globalThis.ResizeObserver = previousObserver;
+    // Still mounted at this point (the outer hook unmounts), so both stores
+    // notify a live header.
+    act(() => {
+      clearAllNotepads();
+      removeMouseSelectionState('term-1');
+    });
+  });
+
+  function notepadButton(): HTMLButtonElement | null {
+    return container.querySelector<HTMLButtonElement>('[aria-label^="Notepad"]');
+  }
+
+  it('sits after the mouse-override icon and before the split controls', () => {
+    setMouseReporting('term-1', 'any');
+    renderHeader(stubActions(), null);
+
+    const labels = Array.from(container.querySelectorAll<HTMLElement>('button[aria-label]'))
+      .map((button) => button.getAttribute('aria-label'));
+    expect(labels).toEqual([
+      'Alerts are per command',
+      'Override mouse capture',
+      'Notepad',
+      'Split left/right',
+      'Split top/bottom',
+      'Zoom',
+      'Minimize',
+      'Kill',
+    ]);
+  });
+
+  it('fills the icon and names the count once the Surface has notes', () => {
+    renderHeader(stubActions(), null);
+    const empty = notepadButton()!.innerHTML;
+    expect(notepadButton()!.getAttribute('aria-label')).toBe('Notepad');
+
+    act(() => { addPlainNote('term-1', 'a note'); });
+
+    expect(notepadButton()!.getAttribute('aria-label')).toBe('Notepad · 1 note');
+    expect(notepadButton()!.innerHTML).not.toBe(empty);
+
+    act(() => { addPlainNote('term-1', 'another'); });
+    expect(notepadButton()!.getAttribute('aria-label')).toBe('Notepad · 2 notes');
+  });
+
+  it('keeps its place at the compact tier and yields it at minimal only when empty', () => {
+    headerWidth = 200;
+    renderHeader(stubActions(), null);
+    expect(notepadButton()).not.toBeNull();
+
+    headerWidth = 100;
+    act(() => root.unmount());
+    root = createRoot(container);
+    renderHeader(stubActions(), null);
+    expect(notepadButton()).toBeNull();
+
+    // Notes are never invisible: the icon comes back to carry them.
+    act(() => { addPlainNote('term-1', 'a note'); });
+    expect(notepadButton()).not.toBeNull();
+  });
+
+  it('toggles the one open notepad', () => {
+    renderHeader(stubActions(), null);
+
+    act(() => { notepadButton()!.dispatchEvent(new MouseEvent('click', { bubbles: true })); });
+    expect(getOpenNotepadId()).toBe('term-1');
+
+    act(() => { notepadButton()!.dispatchEvent(new MouseEvent('click', { bubbles: true })); });
+    expect(getOpenNotepadId()).toBeNull();
+
+    setOpenNotepadId(null);
+  });
+});
diff --git a/lib/src/components/wall/TerminalPaneHeader.tsx b/lib/src/components/wall/TerminalPaneHeader.tsx
index 972e3bf8..3c20239c 100644
--- a/lib/src/components/wall/TerminalPaneHeader.tsx
+++ b/lib/src/components/wall/TerminalPaneHeader.tsx
@@ -16,6 +16,7 @@ import { HeaderActionButton } from '../HeaderActionButton';
 import { HEADER_PALETTE_TRANSITION_CLASS, paneZoomButtonClass, POPUP_SURFACE_CLASS, TERMINAL_TOP_RADIUS_CLASS, TODO_PILL_TRACKING_CLASS } from '../design';
 import { AlertBell } from '../AlertBell';
 import { useTodoPillContent } from '../TodoPillBody';
+import { NotepadHeaderButton } from './NotepadHeaderButton';
 import type { PaneProps } from './pane-props';
 import { IllegalRenameWarning, type RenameRejection } from './IllegalRenameWarning';
 import { InlineEditInput } from './InlineEditInput';
@@ -305,6 +306,7 @@ export function TerminalPaneHeader({ id, title }: PaneProps) {
               </HeaderActionButton>
             </div>
           )}
+          <NotepadHeaderButton surfaceId={id} hideWhenEmpty={tier === 'minimal'} />
           {tier === 'full' && (
             <div className="ml-1 flex shrink-0 items-center gap-0.5">
               <HeaderActionButton
diff --git a/lib/src/components/wall/TerminalPanel.tsx b/lib/src/components/wall/TerminalPanel.tsx
index a96eaf06..8f1e4046 100644
--- a/lib/src/components/wall/TerminalPanel.tsx
+++ b/lib/src/components/wall/TerminalPanel.tsx
@@ -1,5 +1,6 @@
 import { useContext, useRef } from 'react';
 import { TerminalPane } from '../TerminalPane';
+import { NotepadPanel } from '../NotepadPanel';
 import { TERMINAL_BOTTOM_RADIUS_CLASS } from '../design';
 import { getMouseSelectionState } from '../../lib/mouse-selection';
 import type { PaneProps } from './pane-props';
@@ -29,6 +30,7 @@ export function TerminalPanel(props: PaneProps) {
       context.open(props.id, { origin: { x: event.clientX, y: event.clientY } });
     }}>
       <TerminalPane id={props.id} isFocused={isFocused} />
+      {context.mounted?.id !== props.id && <NotepadPanel surfaceId={props.id} />}
     </div>
   );
 }
diff --git a/lib/src/components/wall/dialog-keyboard.test.ts b/lib/src/components/wall/dialog-keyboard.test.ts
new file mode 100644
index 00000000..b5517456
--- /dev/null
+++ b/lib/src/components/wall/dialog-keyboard.test.ts
@@ -0,0 +1,20 @@
+import { describe, expect, it } from 'vitest';
+import { createDialogKeyboardCoordinator } from './wall-context';
+
+describe('dialog keyboard coordinator', () => {
+  it('stays active until every independent owner releases its lease', () => {
+    const active = { current: false };
+    const acquire = createDialogKeyboardCoordinator(active);
+    const releaseNotepad = acquire();
+    const releaseSettings = acquire();
+    expect(active.current).toBe(true);
+
+    releaseSettings();
+    expect(active.current).toBe(true);
+    releaseNotepad();
+    expect(active.current).toBe(false);
+
+    releaseNotepad();
+    expect(active.current).toBe(false);
+  });
+});
diff --git a/lib/src/components/wall/keyboard/handle-mouse-selection-keys.test.ts b/lib/src/components/wall/keyboard/handle-mouse-selection-keys.test.ts
index afed05b2..1099f936 100644
--- a/lib/src/components/wall/keyboard/handle-mouse-selection-keys.test.ts
+++ b/lib/src/components/wall/keyboard/handle-mouse-selection-keys.test.ts
@@ -19,6 +19,12 @@ vi.mock('../../../lib/mouse-selection', () => ({
   flashCopy: vi.fn(),
   setSelection: vi.fn(),
 }));
+// The notepad chord is gated on the host having a notepad and not having ceded
+// the chord to the browser; both are platform reads, so drive them directly.
+vi.mock('../../../lib/notepad/capture', () => ({
+  addSelectionToNotepad: vi.fn(() => true),
+  isNotepadChordBound: vi.fn(() => true),
+}));
 
 function makeCtx(overrides: { surfaceType?: string } = {}): WallKeyboardCtx {
   return {
@@ -45,6 +51,9 @@ describe('handleMouseSelectionKeys', () => {
     const { getMouseSelectionState } = await import('../../../lib/mouse-selection');
     // Reset to the no-selection default; individual tests override as needed.
     vi.mocked(getMouseSelectionState).mockReturnValue({ selection: null } as never);
+    const { addSelectionToNotepad, isNotepadChordBound } = await import('../../../lib/notepad/capture');
+    vi.mocked(addSelectionToNotepad).mockClear().mockReturnValue(true);
+    vi.mocked(isNotepadChordBound).mockClear().mockReturnValue(true);
   });
 
   it('does not intercept Cmd+V on a non-xterm textarea', async () => {
@@ -152,3 +161,80 @@ describe('handleMouseSelectionKeys', () => {
     expect(flashCopy).toHaveBeenCalledWith('pane-a', 'rewrapped');
   });
 });
+
+describe('handleMouseSelectionKeys: notepad chord', () => {
+  const withSelection = async () => {
+    const { getMouseSelectionState } = await import('../../../lib/mouse-selection');
+    vi.mocked(getMouseSelectionState).mockReturnValue({ selection: { dragging: false } } as never);
+  };
+
+  beforeEach(async () => {
+    const { getMouseSelectionState, flashCopy } = await import('../../../lib/mouse-selection');
+    vi.mocked(getMouseSelectionState).mockReturnValue({ selection: null } as never);
+    vi.mocked(flashCopy).mockClear();
+    const { addSelectionToNotepad, isNotepadChordBound } = await import('../../../lib/notepad/capture');
+    vi.mocked(addSelectionToNotepad).mockClear().mockReturnValue(true);
+    vi.mocked(isNotepadChordBound).mockClear().mockReturnValue(true);
+  });
+
+  it('captures and flashes on Cmd+N with a finalized selection', async () => {
+    const { flashCopy } = await import('../../../lib/mouse-selection');
+    const { addSelectionToNotepad } = await import('../../../lib/notepad/capture');
+    await withSelection();
+    const e = fakeEvent(document.createElement('div'), { key: 'n', metaKey: true });
+
+    expect(handleMouseSelectionKeys(e, makeCtx())).toBe(true);
+    expect(e.defaultPrevented).toBe(true);
+    expect(addSelectionToNotepad).toHaveBeenCalledWith('pane-a');
+    expect(flashCopy).toHaveBeenCalledWith('pane-a', 'notepad');
+  });
+
+  it('does not flash when there was nothing to capture', async () => {
+    const { flashCopy } = await import('../../../lib/mouse-selection');
+    const { addSelectionToNotepad } = await import('../../../lib/notepad/capture');
+    vi.mocked(addSelectionToNotepad).mockReturnValue(false);
+    await withSelection();
+
+    expect(handleMouseSelectionKeys(fakeEvent(document.createElement('div'), { key: 'n', metaKey: true }), makeCtx())).toBe(true);
+    expect(flashCopy).not.toHaveBeenCalled();
+  });
+
+  it('falls through without a selection, so Ctrl+N stays readline next-history', async () => {
+    const { addSelectionToNotepad } = await import('../../../lib/notepad/capture');
+    const e = fakeEvent(document.createElement('div'), { key: 'n', metaKey: true });
+
+    expect(handleMouseSelectionKeys(e, makeCtx())).toBe(false);
+    expect(e.defaultPrevented).toBe(false);
+    expect(addSelectionToNotepad).not.toHaveBeenCalled();
+  });
+
+  it('falls through when the host has no notepad or the browser reserves the chord', async () => {
+    const { addSelectionToNotepad, isNotepadChordBound } = await import('../../../lib/notepad/capture');
+    vi.mocked(isNotepadChordBound).mockReturnValue(false);
+    await withSelection();
+    const e = fakeEvent(document.createElement('div'), { key: 'n', metaKey: true });
+
+    expect(handleMouseSelectionKeys(e, makeCtx())).toBe(false);
+    expect(e.defaultPrevented).toBe(false);
+    expect(addSelectionToNotepad).not.toHaveBeenCalled();
+  });
+
+  it('leaves Cmd+Shift+N alone', async () => {
+    const { addSelectionToNotepad } = await import('../../../lib/notepad/capture');
+    await withSelection();
+    const e = fakeEvent(document.createElement('div'), { key: 'N', metaKey: true, shiftKey: true });
+
+    expect(handleMouseSelectionKeys(e, makeCtx())).toBe(false);
+    expect(e.defaultPrevented).toBe(false);
+    expect(addSelectionToNotepad).not.toHaveBeenCalled();
+  });
+
+  it('leaves a bare "n" alone', async () => {
+    const { addSelectionToNotepad } = await import('../../../lib/notepad/capture');
+    await withSelection();
+    const e = fakeEvent(document.createElement('div'), { key: 'n' });
+
+    expect(handleMouseSelectionKeys(e, makeCtx())).toBe(false);
+    expect(addSelectionToNotepad).not.toHaveBeenCalled();
+  });
+});
diff --git a/lib/src/components/wall/keyboard/handle-mouse-selection-keys.ts b/lib/src/components/wall/keyboard/handle-mouse-selection-keys.ts
index 4c9b2300..fdcd60f2 100644
--- a/lib/src/components/wall/keyboard/handle-mouse-selection-keys.ts
+++ b/lib/src/components/wall/keyboard/handle-mouse-selection-keys.ts
@@ -3,15 +3,17 @@ import { copySelection } from '../../../lib/copy-selection';
 import { isEditableTarget, isTerminalInputProxy } from '../../../lib/dom';
 import {
   extendSelectionToToken,
+  flashCopy,
   getMouseSelectionState,
   setSelection as setMouseSelection,
 } from '../../../lib/mouse-selection';
+import { addSelectionToNotepad, isNotepadChordBound } from '../../../lib/notepad/capture';
 import { hasCopyModifier, hasPasteModifier } from './chords';
 import type { WallKeyboardCtx } from './types';
 
 /**
  * Mouse-selection-aware shortcuts: token extension + Escape during drag,
- * Cmd-C / Cmd-Shift-C / Cmd-V outside drag. Returns true if handled.
+ * Cmd-C / Cmd-Shift-C / Cmd-N / Cmd-V outside drag. Returns true if handled.
  */
 export function handleMouseSelectionKeys(e: KeyboardEvent, ctx: WallKeyboardCtx): boolean {
   // Don't shadow native clipboard ops when focus is inside a real text
@@ -63,6 +65,18 @@ export function handleMouseSelectionKeys(e: KeyboardEvent, ctx: WallKeyboardCtx)
     void copySelection(sid, e.shiftKey);
     return true;
   }
+  // Only ever with a finalized selection: with none, Ctrl+N has to reach the
+  // program as readline's next-history. `stopImmediatePropagation` on this
+  // capture-phase window listener (`use-wall-keyboard.ts`) is also what keeps
+  // the chord out of VS Code's keydown forwarding to the workbench
+  // (`docs/specs/vscode.md` → "Webview hosting").
+  const notepadChord = !!sel && !sel.dragging && hasCopyModifier(e) && !e.shiftKey && keyLower === 'n';
+  if (notepadChord && isNotepadChordBound()) {
+    e.preventDefault();
+    e.stopImmediatePropagation();
+    if (addSelectionToNotepad(sid)) flashCopy(sid, 'notepad');
+    return true;
+  }
   // Paste takes either modifier on every platform (see `hasPasteModifier`).
   // Trade-off: shadows readline's ^V verbatim-insert; not worth surfacing as a
   // setting until someone asks for it.
diff --git a/lib/src/components/wall/keyboard/handle-pane-shortcuts.test.ts b/lib/src/components/wall/keyboard/handle-pane-shortcuts.test.ts
index ccd63aa2..5d92fc07 100644
--- a/lib/src/components/wall/keyboard/handle-pane-shortcuts.test.ts
+++ b/lib/src/components/wall/keyboard/handle-pane-shortcuts.test.ts
@@ -11,21 +11,15 @@ import type { WallKeyboardCtx } from './types';
 const terminalRegistryMocks = vi.hoisted(() => ({
   dismissOrToggleAlert: vi.fn(),
   getActivity: vi.fn(() => ({ status: 'WATCHING_DISABLED' })),
-  isUntouched: vi.fn(),
   toggleSessionTodo: vi.fn(),
 }));
 
 vi.mock('../../../lib/terminal-registry', () => ({
   dismissOrToggleAlert: terminalRegistryMocks.dismissOrToggleAlert,
   getActivity: terminalRegistryMocks.getActivity,
-  isUntouched: terminalRegistryMocks.isUntouched,
   toggleSessionTodo: terminalRegistryMocks.toggleSessionTodo,
 }));
 
-vi.mock('../../KillConfirm', () => ({
-  randomKillChar: () => 'Q',
-}));
-
 vi.mock('./handle-mouse-selection-keys', () => ({ handleMouseSelectionKeys: () => false }));
 
 // jsdom here ships no `CSS` global; the header lookup escapes ids via CSS.escape.
@@ -62,8 +56,7 @@ function makeCtx(overrides: Partial<WallKeyboardCtx> = {}): WallKeyboardCtx {
     handleReattachRef: { current: vi.fn() },
     selectPane: vi.fn(),
     enterTerminalMode: vi.fn(),
-    killPaneImmediately: vi.fn(),
-    setConfirmKill: vi.fn(),
+    requestKill: vi.fn(),
     setRenamingPaneId: vi.fn(),
     fireEvent: vi.fn(),
     ...overrides,
@@ -79,62 +72,17 @@ function keydownMeta(key: string): KeyboardEvent {
 }
 
 describe('handlePaneShortcuts kill behavior', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    terminalRegistryMocks.isUntouched.mockReturnValue(false);
-  });
+  beforeEach(() => vi.clearAllMocks());
 
-  it('kills untouched panes immediately without staging confirmation', () => {
-    terminalRegistryMocks.isUntouched.mockReturnValue(true);
+  it.each(['x', 'k'])('hands the %s gesture to the Wall kill request', (key) => {
     const ctx = makeCtx();
-    const event = keydown('x');
+    const event = keydown(key);
 
     expect(handlePaneShortcuts(event, ctx, { current: null })).toBe(true);
 
-    expect(ctx.killPaneImmediately).toHaveBeenCalledWith('pane-a');
-    expect(ctx.setConfirmKill).not.toHaveBeenCalled();
+    expect(ctx.requestKill).toHaveBeenCalledWith('pane-a');
     expect(event.defaultPrevented).toBe(true);
   });
-
-  it('keeps confirmation for touched panes', () => {
-    const ctx = makeCtx();
-
-    expect(handlePaneShortcuts(keydown('x'), ctx, { current: null })).toBe(true);
-
-    expect(ctx.killPaneImmediately).not.toHaveBeenCalled();
-    expect(ctx.setConfirmKill).toHaveBeenCalledWith({ id: 'pane-a', char: 'Q' });
-  });
-
-  it('reattaches untouched doors into an immediate kill path', () => {
-    terminalRegistryMocks.isUntouched.mockReturnValue(true);
-    const reattach = vi.fn();
-    const ctx = makeCtx({
-      selectedTypeRef: { current: 'door' },
-      handleReattachRef: { current: reattach },
-    });
-
-    expect(handlePaneShortcuts(keydown('x'), ctx, { current: null })).toBe(true);
-
-    expect(reattach).toHaveBeenCalledWith(
-      { id: 'pane-a', title: 'Pane A' },
-      { enterPassthrough: false, afterRestore: 'kill-immediately' },
-    );
-  });
-
-  it('reattaches touched doors into the confirmation path', () => {
-    const reattach = vi.fn();
-    const ctx = makeCtx({
-      selectedTypeRef: { current: 'door' },
-      handleReattachRef: { current: reattach },
-    });
-
-    expect(handlePaneShortcuts(keydown('x'), ctx, { current: null })).toBe(true);
-
-    expect(reattach).toHaveBeenCalledWith(
-      { id: 'pane-a', title: 'Pane A' },
-      { enterPassthrough: false, afterRestore: 'confirm-kill' },
-    );
-  });
 });
 
 describe('comma rename eligibility', () => {
diff --git a/lib/src/components/wall/keyboard/handle-pane-shortcuts.ts b/lib/src/components/wall/keyboard/handle-pane-shortcuts.ts
index 62582d4c..90b35c8e 100644
--- a/lib/src/components/wall/keyboard/handle-pane-shortcuts.ts
+++ b/lib/src/components/wall/keyboard/handle-pane-shortcuts.ts
@@ -1,11 +1,8 @@
-import { getHelper } from '../../../lib/helper-terminal';
 import {
   dismissOrToggleAlert,
   getActivity,
-  isUntouched,
   toggleSessionTodo,
 } from '../../../lib/terminal-registry';
-import { randomKillChar } from '../../KillConfirm';
 import { hasTerminal } from 'dor/commands/types';
 import { surfaceKindFromParams } from '../browser-surface';
 import { ARROW_OPPOSITES, isArrowKey, type NavHistoryRef, type WallKeyboardCtx } from './types';
@@ -84,23 +81,7 @@ export function handlePaneShortcuts(
   if ((e.key === 'k' || e.key === 'x') && sid) {
     e.preventDefault();
     e.stopPropagation();
-    if (getHelper(sid)) { ctx.wallActionsRef.current.onKill(sid); return true; }
-    if (ctx.selectedTypeRef.current === 'door') {
-      const item = ctx.doorsRef.current.find((d) => d.id === sid);
-      if (item) {
-        ctx.handleReattachRef.current(item, {
-          enterPassthrough: false,
-          afterRestore: isUntouched(sid) ? 'kill-immediately' : 'confirm-kill',
-        });
-      }
-      return true;
-    }
-    if (isUntouched(sid)) {
-      ctx.killPaneImmediately(sid);
-      return true;
-    }
-    const char = randomKillChar();
-    ctx.setConfirmKill({ id: sid, char });
+    ctx.requestKill(sid);
     return true;
   }
 
diff --git a/lib/src/components/wall/keyboard/types.ts b/lib/src/components/wall/keyboard/types.ts
index 104abfdd..48da3fd6 100644
--- a/lib/src/components/wall/keyboard/types.ts
+++ b/lib/src/components/wall/keyboard/types.ts
@@ -37,10 +37,11 @@ export interface WallKeyboardCtx {
   enterTerminalMode: (id: string) => void;
   exitTerminalMode: () => void;
   minimizePane: (id: string) => void;
-  killPaneImmediately: (id: string) => void;
+  /** The kill gesture: `requestKill` in `lib/src/components/Wall.tsx` decides
+   *  between reattach, immediate closure, and the confirm overlay. */
+  requestKill: (id: string) => void;
   acceptKill: () => void;
   rejectKill: () => void;
-  setConfirmKill: Dispatch<SetStateAction<ConfirmKill | null>>;
   setRenamingPaneId: Dispatch<SetStateAction<string | null>>;
   fireEvent: (event: WallEvent) => void;
 }
diff --git a/lib/src/components/wall/use-dor-control.ts b/lib/src/components/wall/use-dor-control.ts
index 23890e1f..f690af08 100644
--- a/lib/src/components/wall/use-dor-control.ts
+++ b/lib/src/components/wall/use-dor-control.ts
@@ -26,7 +26,7 @@ import { agentBrowserSessionFromParams } from './browser-surface';
 import { listenerUrlsByPort } from './port-url';
 import { dorDirectionForEdge, type LathWallEngine } from './lath-wall-engine';
 import type { WallNav } from './keyboard/types';
-import type { DooredItem } from './wall-types';
+import type { CloseSurfaceMode, DooredItem } from './wall-types';
 
 type DorControlParams = {
   command?: unknown;
@@ -237,34 +237,40 @@ const RESTART_POLL_INTERVAL_MS = 100;
 const RESTART_INTERRUPT_TIMEOUT_MS = 15_000;
 const RESTART_START_TIMEOUT_MS = 15_000;
 
-/** Resolve true once `predicate` holds for the surface's live state, false on timeout. */
+type WaitOutcome = 'ready' | 'timeout' | 'aborted';
+
+/** Resolve once `predicate` holds for the surface's live state, the timeout
+ *  passes, or `signal` aborts — whichever comes first. */
 function waitForTerminalState(
   id: string,
   predicate: (state: TerminalPaneState) => boolean,
   timeoutMs: number,
   signal?: AbortSignal,
-): Promise<boolean> {
-  if (signal?.aborted) return Promise.resolve(false);
-  if (predicate(getTerminalPaneState(id))) return Promise.resolve(true);
+): Promise<WaitOutcome> {
+  if (signal?.aborted) return Promise.resolve('aborted');
+  if (predicate(getTerminalPaneState(id))) return Promise.resolve('ready');
   return new Promise((resolve) => {
     let elapsed = 0;
-    const finish = (ready: boolean) => {
+    const finish = (outcome: WaitOutcome) => {
       clearInterval(timer);
       signal?.removeEventListener('abort', cancel);
-      resolve(ready);
+      resolve(outcome);
     };
-    const cancel = () => finish(false);
+    const cancel = () => finish('aborted');
     const timer = setInterval(() => {
       if (predicate(getTerminalPaneState(id))) {
-        finish(true);
+        finish('ready');
       } else if ((elapsed += RESTART_POLL_INTERVAL_MS) >= timeoutMs) {
-        finish(false);
+        finish('timeout');
       }
     }, RESTART_POLL_INTERVAL_MS);
     signal?.addEventListener('abort', cancel, { once: true });
   });
 }
 
+const RESTART_CANCELLED: ParseResult<undefined> = { ok: false, message: 'restart was cancelled' };
+const ENSURE_CANCELLED = 'ensure was cancelled';
+
 /**
  * Restart a surface already running `command` in `cwd`: interrupt it (Ctrl+C),
  * wait for the shell to return to its prompt, type the command again, and wait
@@ -272,7 +278,8 @@ function waitForTerminalState(
  * doors too (their PTY keeps running). Returns a message on failure.
  */
 async function restartSurfaceInPlace(id: string, command: string, cwd: string, signal?: AbortSignal): Promise<ParseResult<undefined>> {
-  if (signal?.aborted) return { ok: false, message: 'restart was cancelled' };
+  // Checked before the interrupt is written, not just before each wait.
+  if (signal?.aborted) return RESTART_CANCELLED;
   // A match is by construction OSC-driven (surfaceRunsCommand only matches a
   // shell that reports its command), so this never fires on the real path — but
   // it guarantees we never fire Ctrl+C into a non-integration shell (e.g. cmd.exe
@@ -286,8 +293,11 @@ async function restartSurfaceInPlace(id: string, command: string, cwd: string, s
     RESTART_INTERRUPT_TIMEOUT_MS,
     signal,
   );
-  if (signal?.aborted) return { ok: false, message: 'restart was cancelled' };
-  if (!interrupted) return { ok: false, message: 'did not return to a prompt after interrupt' };
+  // Re-check the signal itself, not only the outcome: an already-satisfied wait
+  // resolves without polling, so a cancel queued before that continuation would
+  // otherwise slip past and type the command.
+  if (signal?.aborted || interrupted === 'aborted') return RESTART_CANCELLED;
+  if (interrupted === 'timeout') return { ok: false, message: 'did not return to a prompt after interrupt' };
   platform.writePty(id, `${command}\r`);
   const restarted = await waitForTerminalState(
     id,
@@ -295,8 +305,8 @@ async function restartSurfaceInPlace(id: string, command: string, cwd: string, s
     RESTART_START_TIMEOUT_MS,
     signal,
   );
-  if (signal?.aborted) return { ok: false, message: 'restart was cancelled' };
-  if (!restarted) return { ok: false, message: 'command did not restart' };
+  if (signal?.aborted || restarted === 'aborted') return RESTART_CANCELLED;
+  if (restarted === 'timeout') return { ok: false, message: 'command did not restart' };
   return { ok: true, value: undefined };
 }
 
@@ -348,7 +358,7 @@ function dorCommandString(args: string[] | undefined): string | undefined {
  * surface-resolution/query helpers. This is CLI policy — surface targeting,
  * param coercion, command quoting, restart/integration timing — not wall layout;
  * the layout primitives it drives (`createSplitSurface`, `createContentSurface`,
- * `killPaneImmediately`, `buildDorSurfaces`, `surfaceRefForId`) are owned by the
+ * `closeSurface`, `buildDorSurfaces`, `surfaceRefForId`) are owned by the
  * Wall and injected here (docs/specs/dor-cli.md).
  */
 export function useDorControl({
@@ -360,7 +370,8 @@ export function useDorControl({
   surfaceRefForId,
   createSplitSurface,
   createContentSurface,
-  killPaneImmediately,
+  isClosingSurface,
+  closeSurface,
   lastAgentBrowserBinaryPathRef,
 }: {
   /** The Lath engine — visible-pane projection (`lath.listPanes()`), aspect-ratio
@@ -392,10 +403,18 @@ export function useDorControl({
     title: string;
     focusNeutral?: boolean;
   }) => ParseResult<{ id: string; ref: string; status: 'created' | 'replaced' }>;
-  killPaneImmediately: (id: string) => void | boolean | Promise<void | boolean>;
+  /** A Wall closure in flight, independent of another caller freezing notes. */
+  isClosingSurface: (id: string) => boolean;
+  /** The user-visible closure path: archive the Surface's notes, then tear it
+   *  down. A string means the closure was refused, and is why; the Surface is
+   *  still here. */
+  closeSurface: (id: string, mode?: CloseSurfaceMode) => Promise<string | null>;
   /** The last binary path a `dor ab` surface resolved on a terminal's PATH. */
   lastAgentBrowserBinaryPathRef: MutableRefObject<string | undefined>;
 }): {
+  /** The live surface (visible pane or minimized door) whose params match, or
+   *  null. Shared with the context's port launches in Wall.tsx. */
+  findSurfaceByParams: (isMatch: (params: unknown) => boolean) => { id: string; minimized: boolean } | null;
   /** Fold a params patch onto a surface (visible pane or minimized door) — the
    *  one write path a background daemon boot uses to hand a session-less pane
    *  its `{session, wsPort, binaryPath}`. */
@@ -466,13 +485,18 @@ export function useDorControl({
     return target;
   }, [requireListedSurface]);
 
+  /** A Surface a command may still target: not mid-fade, and not mid-closure
+   *  (`closeSurface` archives before it tears down; a match made meanwhile
+   *  would be acted on moments before it vanishes). */
+  const isTargetable = useCallback((id: string) => !lath.isDying(id) && !isClosingSurface(id), [lath, isClosingSurface]);
+
   const findSurfaceIdRunningCommand = useCallback((command: string, cwdPath: string): string | null => {
     const ids = [
       ...lath.listPanes().map((panel) => panel.id),
       ...doorsRef.current.map((door) => door.id),
     ];
-    return ids.find((id) => surfaceRunsCommand(getTerminalPaneState(id), command, cwdPath)) ?? null;
-  }, [lath]);
+    return ids.find((id) => isTargetable(id) && surfaceRunsCommand(getTerminalPaneState(id), command, cwdPath)) ?? null;
+  }, [lath, isTargetable]);
 
   /**
    * The surface (visible pane or minimized door — panes win) whose params match,
@@ -480,12 +504,12 @@ export function useDorControl({
    * survives webview reloads. Null when nothing matches.
    */
   const findSurfaceByParams = useCallback((isMatch: (params: unknown) => boolean): { id: string; minimized: boolean } | null => {
-    const panel = lath.listPanes().find((candidate) => isMatch(candidate.params));
+    const panel = lath.listPanes().find((candidate) => isTargetable(candidate.id) && isMatch(candidate.params));
     if (panel) return { id: panel.id, minimized: false };
-    const door = doorsRef.current.find((candidate) => isMatch(lath.getMeta(candidate.id)?.params));
+    const door = doorsRef.current.find((candidate) => isTargetable(candidate.id) && isMatch(lath.getMeta(candidate.id)?.params));
     if (door) return { id: door.id, minimized: true };
     return null;
-  }, [lath]);
+  }, [lath, isTargetable]);
 
   /** The agent-browser session ↔ surface registry: the surface bound to
    *  `session`, or null if none exists. */
@@ -655,7 +679,7 @@ export function useDorControl({
 
       if (detail.method === SURFACE_CONTROL_METHODS.ensure) {
         if (detail.signal?.aborted) {
-          detail.respond({ ok: false, error: 'ensure was cancelled' });
+          detail.respond({ ok: false, error: ENSURE_CANCELLED });
           return;
         }
         const command = dorCommandString(stringArrayParam(params.command));
@@ -742,14 +766,13 @@ export function useDorControl({
           INTEGRATION_DETECT_TIMEOUT_MS,
           detail.signal,
         );
-        if (!integrated) {
-          // Tear down the throwaway split. The focus-neutral create never selected
-          // it, so the kill's live selection check leaves the caller's selection
-          // where ensure found it. A `--minimize` create is already a door;
-          // killPaneImmediately tears the door down too — disposing the session and
-          // removing it from the baseboard.
-          killPaneImmediately(result.value.id);
-          detail.respond({ ok: false, error: detail.signal?.aborted ? 'ensure was cancelled' : missingIntegrationError(ensureShell) });
+        if (detail.signal?.aborted || integrated !== 'ready') {
+          // The temporary pane is visible during integration detection and may
+          // have acquired notes. Preserve the ordinary closure contract even
+          // when the client has gone away (docs/specs/notepad.md → "Closure").
+          const reason = detail.signal?.aborted || integrated === 'aborted' ? ENSURE_CANCELLED : missingIntegrationError(ensureShell);
+          const refused = await closeSurface(result.value.id, 'silent');
+          detail.respond({ ok: false, error: refused ? `${reason}; temporary surface kept open: ${refused}` : reason });
           return;
         }
         detail.respond({
@@ -875,8 +898,14 @@ export function useDorControl({
             return;
           }
         }
-        if (await killPaneImmediately(target.id) === false) {
-          detail.respond({ ok: false, error: 'Helper has running work; stop it in the helper before closing the parent' });
+        // `dor kill` is a user-visible permanent closure, so it archives the
+        // Surface's notes first. A refused archive leaves the Surface running
+        // and answers with the error rather than silently dropping the notes —
+        // and raises no pane prompt, because the caller is a command, not
+        // someone looking at the Wall (docs/specs/notepad.md → "Closure").
+        const refused = await closeSurface(target.id, 'silent');
+        if (refused) {
+          detail.respond({ ok: false, error: refused });
           return;
         }
         detail.respond({
@@ -1056,7 +1085,7 @@ export function useDorControl({
 
     window.addEventListener('dormouse:control-request', handler);
     return () => window.removeEventListener('dormouse:control-request', handler);
-  }, [buildDorSurfaces, buildDorSurfaceList, createContentSurface, createSplitSurface, ensureAgentBrowserSurface, findSurfaceIdRunningCommand, killPaneImmediately, requireBrowserSurface, requireListedSurface, requireTerminalSurface, resolveListedSurface, resolveVisibleSurface, surfaceRefForId, lath, nav]);
+  }, [buildDorSurfaces, buildDorSurfaceList, closeSurface, createContentSurface, createSplitSurface, ensureAgentBrowserSurface, findSurfaceIdRunningCommand, requireBrowserSurface, requireListedSurface, requireTerminalSurface, resolveListedSurface, resolveVisibleSurface, surfaceRefForId, lath, nav]);
 
-  return { updateSurfaceParams };
+  return { findSurfaceByParams, updateSurfaceParams };
 }
diff --git a/lib/src/components/wall/wall-context.tsx b/lib/src/components/wall/wall-context.tsx
index 52d3875a..74a62b32 100644
--- a/lib/src/components/wall/wall-context.tsx
+++ b/lib/src/components/wall/wall-context.tsx
@@ -1,6 +1,6 @@
 import type { PortMode } from './TerminalContextView';
 import type { PortUrlEntry } from './port-url';
-import { createContext } from 'react';
+import { createContext, useContext, useEffect } from 'react';
 import type { AlertButtonActionResult, SessionStatus, SetTerminalUserTitleResult } from '../../lib/terminal-registry';
 import type { WallMode } from './wall-types';
 import type { RenderMode } from './agent-browser-screen';
@@ -96,7 +96,39 @@ export const RenamingIdContext = createContext<string | null>(null);
 export const ZoomedIdContext = createContext<string | null>(null);
 export const WindowFocusedContext = createContext(true);
 
-export const DialogKeyboardContext = createContext<(active: boolean) => void>(() => {});
+/** Take one keyboard-suppression lease; the returned release drops it (idempotent). */
+export type AcquireDialogKeyboard = () => () => void;
+
+export const DialogKeyboardContext = createContext<AcquireDialogKeyboard>(() => () => {});
+
+/** Reference-count the leases over one Wall's dialog-keyboard flag, so a dialog
+ *  closing over another one leaves the survivor's suppression standing
+ *  (docs/specs/layout.md → "Keyboard shortcuts (command mode)"). */
+export function createDialogKeyboardCoordinator(
+  activeRef: { current: boolean },
+): AcquireDialogKeyboard {
+  let ownerCount = 0;
+  return () => {
+    ownerCount += 1;
+    activeRef.current = true;
+    let released = false;
+    return () => {
+      if (released) return;
+      released = true;
+      ownerCount = Math.max(0, ownerCount - 1);
+      activeRef.current = ownerCount > 0;
+    };
+  };
+}
+
+/** Hold one independently reference-counted lease while `active`; unmounting
+ *  releases it. `acquireOverride` is for a caller that sits above its own
+ *  `DialogKeyboardContext.Provider` (Wall itself) and so cannot read the context. */
+export function useDialogKeyboardOwner(active: boolean, acquireOverride?: AcquireDialogKeyboard): void {
+  const contextAcquire = useContext(DialogKeyboardContext);
+  const acquire = acquireOverride ?? contextAcquire;
+  useEffect(() => (active ? acquire() : undefined), [acquire, active]);
+}
 
 export interface TerminalContextOpenOptions {
   warning?: string;
diff --git a/lib/src/components/wall/wall-types.ts b/lib/src/components/wall/wall-types.ts
index 3f12ea10..0bc898d1 100644
--- a/lib/src/components/wall/wall-types.ts
+++ b/lib/src/components/wall/wall-types.ts
@@ -30,9 +30,14 @@ export type WallMode = 'command' | 'passthrough';
 
 export type WallSelectionKind = 'pane' | 'door';
 
+/** How a Surface closure answers the archive: `prompt` raises the Keep open /
+ *  Close anyway prompt on refusal, `silent` only returns the refusal, `discard`
+ *  drops the notes instead of archiving them (docs/specs/notepad.md → "Closure"). */
+export type CloseSurfaceMode = 'prompt' | 'silent' | 'discard';
+
 export type DoorAfterRestoreAction =
   | 'confirm-kill'
-  | 'kill-immediately'
+  | 'close'
   | {
       type: 'replace-terminal';
       newId: string;
diff --git a/lib/src/lib/errors.ts b/lib/src/lib/errors.ts
new file mode 100644
index 00000000..7bc719d3
--- /dev/null
+++ b/lib/src/lib/errors.ts
@@ -0,0 +1,6 @@
+/** A rejection as something a user can read: an `Error`'s message when it has
+ *  one, otherwise the value itself stringified (so an empty-message `Error`
+ *  still reports as `Error` rather than as a blank line). */
+export function messageOf(error: unknown): string {
+  return error instanceof Error && error.message ? error.message : String(error);
+}
diff --git a/lib/src/lib/helper-terminal.test.ts b/lib/src/lib/helper-terminal.test.ts
index c8883934..bf49f2ff 100644
--- a/lib/src/lib/helper-terminal.test.ts
+++ b/lib/src/lib/helper-terminal.test.ts
@@ -2,12 +2,12 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import { registry, pendingShellOpts, type TerminalEntry } from './terminal-store';
 import { applyTerminalSemanticEvents, resetTerminalPaneState, removeTerminalPaneState } from './terminal-state-store';
-import { beginPromotion, cancelPromotion, disposeHelper, finishPromotion, getHelper, helperHasWork, openHelper, restoreHelper, setHelperVisible, subscribeHelpers } from './helper-terminal';
+import { beginPromotion, cancelPromotion, closeHelperParent, disposeHelper, finishPromotion, getHelper, helperHasWork, openHelper, restoreHelper, setHelperVisible, subscribeHelpers } from './helper-terminal';
 
 const host = vi.hoisted(() => ({ writePty: vi.fn(), terminalContext: vi.fn() }));
 vi.mock('./platform', () => ({ getPlatform: () => host }));
 vi.mock('./terminal-lifecycle', () => ({
-  unmountElement: vi.fn(),
+  parkElement: vi.fn(),
   setPendingShellOpts: (id: string, options: unknown) => pendingShellOpts.set(id, options as never),
   getOrCreateTerminal: (id: string) => { const entry = { untouched: true, helper: pendingShellOpts.get(id)?.helper } as TerminalEntry; registry.set(id, entry); resetTerminalPaneState(id); return entry; },
   disposeSession: (id: string) => { registry.delete(id); removeTerminalPaneState(id); },
@@ -22,6 +22,27 @@ afterEach(() => { setHelperVisible('parent', false); disposeHelper('parent'); re
 const prompt = (id: string) => applyTerminalSemanticEvents(id, [{ type: 'promptStart' }, { type: 'promptEnd' }]);
 
 describe('helper lifecycle', () => {
+  it('rejects late helper startup while its closing parent remains registered for the fade', async () => {
+    let resolve!: (value: unknown) => void;
+    host.terminalContext.mockImplementationOnce(() => new Promise(r => { resolve = r; }));
+    const opening = openHelper('parent');
+    closeHelperParent('parent');
+    expect(registry.has('parent')).toBe(true);
+    resolve({ command: 'git status' });
+    await expect(opening).rejects.toThrow('The parent terminal has closed');
+    expect(getHelper('parent')).toBeUndefined();
+    expect([...registry.keys()]).toEqual(['parent']);
+    expect(pendingShellOpts.size).toBe(0);
+  });
+
+  it('rejects parent retirement during promotion and allows reopening after rollback', async () => {
+    const helper = await openHelper('parent');
+    await beginPromotion('parent');
+    expect(() => closeHelperParent('parent')).toThrow(/promotion/i);
+    await cancelPromotion('parent');
+    expect(await openHelper('parent')).toBe(helper);
+  });
+
   it.each(['exited', 'preserved', 'completed'] as const)('publishes %s on reopening before another polling tick', async status => {
     const helper = await openHelper('parent');
     helper.status = 'running';
diff --git a/lib/src/lib/helper-terminal.ts b/lib/src/lib/helper-terminal.ts
index 1740a469..0557d4ed 100644
--- a/lib/src/lib/helper-terminal.ts
+++ b/lib/src/lib/helper-terminal.ts
@@ -1,6 +1,6 @@
 import { getPlatform } from './platform';
 import { registry } from './terminal-store';
-import { disposeSession, getOrCreateTerminal, setPendingShellOpts, unmountElement } from './terminal-lifecycle';
+import { disposeSession, getOrCreateTerminal, parkElement, setPendingShellOpts } from './terminal-lifecycle';
 import { getDefaultShellOpts } from './shell-defaults';
 import { getTerminalPaneState, isPaneOscDriven, seedLaunchedCommand } from './terminal-state-store';
 import { DEFAULT_HELPER_COMMAND, type HelperIdentity } from './terminal-context-types';
@@ -70,15 +70,22 @@ function watchHelper(helper: HelperTerminal, launchCwd?: string): void {
   }, STATUS_POLL_MS);
 }
 
+/** Recover a live helper PTY whose source also survived. Replays do not prove
+ *  absence of user input, so recovery always disarms autorun. */
 export function restoreHelper(id: string, identity: HelperIdentity): void {
-  // Replays do not prove absence of user input. Recovery always disarms autorun.
   const helper: HelperTerminal = { ...identity, id, status: 'preserved' };
   helpers.set(identity.parentId, helper);
   watchHelper(helper);
-  unmountElement(id);
+  parkElement(id);
   notifyHelpers();
 }
 
+/** A live helper PTY whose source did not survive becomes an ordinary Session:
+ *  the host stops treating it as auxiliary, on the same handshake as promotion. */
+export function adoptOrphanedHelper(id: string): void {
+  void getPlatform().terminalContext?.({ op: 'promote', id });
+}
+
 export async function helperHasWork(helper: HelperTerminal): Promise<boolean> {
   const entry = registry.get(helper.id);
   if (helper.promoting) return true;
@@ -106,6 +113,24 @@ export function disposeHelper(parentId: string): void {
   disposeSession(helper.id);
 }
 
+/** Parents torn down while their registry entry lingers for the kill fade; a
+ *  WeakSet so the mark leaves with the entry. */
+const closedParents = new WeakSet<object>();
+
+/** The parent Surface is retiring (kill, renderer swap, shell replacement):
+ *  dispose its helper, and refuse an `openHelper` whose host round trip lands
+ *  afterwards, which would otherwise spawn a helper PTY nothing can reach. */
+export function closeHelperParent(parentId: string): void {
+  disposeHelper(parentId);
+  const entry = registry.get(parentId);
+  if (entry) closedParents.add(entry);
+}
+
+function parentIsOpen(parentId: string): boolean {
+  const entry = registry.get(parentId);
+  return !!entry && !closedParents.has(entry);
+}
+
 export async function openHelper(parentId: string): Promise<HelperTerminal> {
   const inFlight = pending.get(parentId);
   if (inFlight) return inFlight;
@@ -129,7 +154,7 @@ export async function openHelper(parentId: string): Promise<HelperTerminal> {
     const platform = getPlatform();
     if (!platform.terminalContext) throw new Error('Helper terminals are unavailable on this host');
     const settings = await platform.terminalContext({ op: 'settings' });
-    if (!registry.has(parentId)) throw new Error('The parent terminal has closed');
+    if (!parentIsOpen(parentId)) throw new Error('The parent terminal has closed');
     const id = `helper-${crypto.randomUUID()}`;
     const cwd = getTerminalPaneState(parentId).cwd;
     const command = settings.command ?? DEFAULT_HELPER_COMMAND;
@@ -137,7 +162,7 @@ export async function openHelper(parentId: string): Promise<HelperTerminal> {
     helpers.set(parentId, helper);
     setPendingShellOpts(id, { ...getDefaultShellOpts(), cwd: cwd && !cwd.isRemote ? cwd.path : undefined, helper: { parentId, command } });
     getOrCreateTerminal(id);
-    unmountElement(id);
+    parkElement(id);
     notifyHelpers();
     watchHelper(helper, cwd?.path);
     return helper;
diff --git a/lib/src/lib/mouse-selection.test.ts b/lib/src/lib/mouse-selection.test.ts
index 028b956a..ff6bc8d3 100644
--- a/lib/src/lib/mouse-selection.test.ts
+++ b/lib/src/lib/mouse-selection.test.ts
@@ -288,6 +288,24 @@ describe('mouse-selection: flashCopy race', () => {
     expect(getMouseSelectionState('a').copyFlash).toBeNull();
     expect(getMouseSelectionState('a').selection?.startRow).toBe(10);
   });
+
+  it("a notepad capture's flash clears the selection like a copy's, dismissing the popup", () => {
+    vi.useFakeTimers();
+    try {
+      beginDrag('a', { row: 0, col: 0, altKey: false, startedInScrollback: false });
+      endDrag('a');
+
+      flashCopy('a', 'notepad', 500);
+      expect(getMouseSelectionState('a').copyFlash).toBe('notepad');
+      expect(getMouseSelectionState('a').selection).not.toBeNull();
+
+      vi.advanceTimersByTime(500);
+      expect(getMouseSelectionState('a').copyFlash).toBeNull();
+      expect(getMouseSelectionState('a').selection).toBeNull();
+    } finally {
+      vi.useRealTimers();
+    }
+  });
 });
 
 describe('mouse-selection: snapshot caching', () => {
diff --git a/lib/src/lib/mouse-selection.ts b/lib/src/lib/mouse-selection.ts
index ff8833f5..da1ea2ee 100644
--- a/lib/src/lib/mouse-selection.ts
+++ b/lib/src/lib/mouse-selection.ts
@@ -35,7 +35,10 @@ export interface TokenHint {
   text: string;
 }
 
-export type CopyFlashKind = 'raw' | 'rewrapped';
+/** `'notepad'` rides the same flash as the two copies: capturing a selection
+ *  confirms in place and dismisses the popup, it does not open the notepad
+ *  (docs/specs/notepad.md → Capture). */
+export type CopyFlashKind = 'raw' | 'rewrapped' | 'notepad';
 
 export interface MouseSelectionState {
   mouseReporting: MouseTrackingMode;
@@ -44,8 +47,8 @@ export interface MouseSelectionState {
   selection: Selection | null;
   hintToken: TokenHint | null;
   /**
-   * Set briefly after Cmd+C / Cmd+Shift+C or a popup-button click, so the
-   * popup can flash a "Copied!" confirmation before everything clears.
+   * Set briefly after Cmd+C / Cmd+Shift+C / Cmd+N or a popup-button click, so
+   * the popup can flash a confirmation before everything clears.
    */
   copyFlash: CopyFlashKind | null;
 }
@@ -241,9 +244,9 @@ export function setDragAlt(id: string, altKey: boolean): void {
 }
 
 /**
- * Trigger the "Copied!" flash. The popup reads `copyFlash` and renders a
- * confirmation state; after `durationMs` the flash clears along with the
- * selection, dismissing the popup.
+ * Trigger the confirmation flash ("Copied!", or "Added" for a notepad capture).
+ * The popup reads `copyFlash` and renders a confirmation state; after
+ * `durationMs` the flash clears along with the selection, dismissing the popup.
  */
 export function flashCopy(id: string, kind: CopyFlashKind, durationMs = 700): void {
   const s = ensure(id);
diff --git a/lib/src/lib/notepad/archive-model.test.ts b/lib/src/lib/notepad/archive-model.test.ts
new file mode 100644
index 00000000..3ae45f8d
--- /dev/null
+++ b/lib/src/lib/notepad/archive-model.test.ts
@@ -0,0 +1,378 @@
+import { describe, expect, it, vi } from 'vitest';
+import type { IMarker } from '@xterm/xterm';
+import type { CwdState } from '../terminal-state';
+import {
+  applyArchiveMutation,
+  batchFromVolatile,
+  buildArchiveBatch,
+  isEmptyMutation,
+  readCwdState,
+  readNotepadArchive,
+  toArchivedNote,
+} from './archive-model';
+import type { ArchiveBatch, LiveNote, NotepadArchiveV1, RuntimeTerminalSource } from './types';
+
+const LOCAL_CWD: CwdState = {
+  path: '/home/ned/projects',
+  pathKind: 'posix',
+  isRemote: false,
+  source: 'osc7',
+  updatedAt: 1_700_000_000_000,
+};
+
+const REMOTE_CWD: CwdState = {
+  path: '/srv/app',
+  uri: 'file://build-box/srv/app',
+  host: 'build-box',
+  scheme: 'file',
+  pathKind: 'posix',
+  isRemote: true,
+  source: 'osc7',
+  updatedAt: 1_700_000_000_001,
+};
+
+function batch(id: string, notes: Array<{ id: string; text: string }>, cwd: CwdState | null = LOCAL_CWD): ArchiveBatch {
+  return {
+    id,
+    closedAt: 1_700_000_000_000,
+    surfaceTitle: `pane ${id}`,
+    surfaceKind: 'terminal',
+    cwd,
+    notes: notes.map((note) => ({
+      id: note.id,
+      createdAt: 1_700_000_000_000,
+      content: { kind: 'plain', text: note.text },
+    })),
+  };
+}
+
+function archive(...batches: ArchiveBatch[]): NotepadArchiveV1 {
+  return { version: 1, batches };
+}
+
+describe('readNotepadArchive', () => {
+  it('accepts a valid archive', () => {
+    const value = archive(batch('b1', [{ id: 'n1', text: 'hello' }]));
+    expect(readNotepadArchive(value)).toEqual(value);
+  });
+
+  it('accepts the JSON-string form a host state API may hand back', () => {
+    const value = archive(batch('b1', [{ id: 'n1', text: 'hello' }]), batch('b2', [], null));
+    expect(readNotepadArchive(JSON.stringify(value))).toEqual(value);
+  });
+
+  it('rejects a string that is not JSON', () => {
+    expect(readNotepadArchive('{ not json')).toBeNull();
+  });
+
+  it('rejects a missing or wrong version', () => {
+    expect(readNotepadArchive({ batches: [] })).toBeNull();
+    expect(readNotepadArchive({ version: 2, batches: [] })).toBeNull();
+    expect(readNotepadArchive(null)).toBeNull();
+    expect(readNotepadArchive({ version: 1 })).toBeNull();
+  });
+
+  it('rejects a run whose color is not a normalized hex triple', () => {
+    const rich = {
+      version: 1,
+      batches: [
+        {
+          ...batch('b1', []),
+          notes: [
+            {
+              id: 'n1',
+              createdAt: 1,
+              content: { kind: 'terminal', runs: [{ text: 'x', foreground: 'red' }] },
+            },
+          ],
+        },
+      ],
+    };
+    expect(readNotepadArchive(rich)).toBeNull();
+    rich.batches[0].notes[0].content.runs[0].foreground = '#FF0000';
+    expect(readNotepadArchive(rich), 'uppercase is not normalized').toBeNull();
+    rich.batches[0].notes[0].content.runs[0].foreground = '#ff0000';
+    expect(readNotepadArchive(rich)).not.toBeNull();
+  });
+
+  it('rejects a batch whose cwd is the wrong shape', () => {
+    const bad = { ...batch('b1', [{ id: 'n1', text: 'x' }]), cwd: { path: '/tmp' } };
+    expect(readNotepadArchive({ version: 1, batches: [bad] })).toBeNull();
+  });
+
+  it('rejects duplicate batch ids outright', () => {
+    const value = archive(batch('b1', [{ id: 'n1', text: 'a' }]), batch('b1', [{ id: 'n2', text: 'b' }]));
+    expect(readNotepadArchive(value)).toBeNull();
+  });
+
+  it('rejects an unknown field at every level', () => {
+    // Not dropped: every mutation rewrites the whole archive from what was read
+    // back, so a field only a newer build understands would be erased on the
+    // next save. Refusing makes it a reported failure instead of silent loss.
+    const one = batch('b1', [{ id: 'n1', text: 'a' }]);
+    const wrap = (b: unknown) => ({ version: 1, batches: [b] });
+    expect(readNotepadArchive(wrap(one))).not.toBeNull();
+
+    expect(readNotepadArchive({ version: 1, batches: [one], extra: 'x' }), 'archive').toBeNull();
+    expect(readNotepadArchive(wrap({ ...one, surfaceLabel: 'x' })), 'batch').toBeNull();
+    expect(readNotepadArchive(wrap({ ...one, cwd: { ...LOCAL_CWD, drive: 'C:' } })), 'cwd').toBeNull();
+    expect(readCwdState({ ...LOCAL_CWD, drive: 'C:' }), 'cwd on its own').toBeNull();
+    expect(
+      readNotepadArchive(wrap({ ...one, notes: [{ ...one.notes[0], source: { terminalId: 't1' } }] })),
+      'note',
+    ).toBeNull();
+    expect(
+      readNotepadArchive(
+        wrap({ ...one, notes: [{ ...one.notes[0], content: { kind: 'plain', text: 'a', html: '<b>a</b>' } }] }),
+      ),
+      'content',
+    ).toBeNull();
+    expect(
+      readNotepadArchive(
+        wrap({
+          ...one,
+          notes: [{ ...one.notes[0], content: { kind: 'terminal', runs: [{ text: 'a', underline: true }] } }],
+        }),
+      ),
+      'run',
+    ).toBeNull();
+  });
+});
+
+describe('readCwdState', () => {
+  it('reads a local cwd', () => {
+    expect(readCwdState(LOCAL_CWD)).toEqual(LOCAL_CWD);
+  });
+
+  it('reads a remote cwd with its host and uri', () => {
+    expect(readCwdState(REMOTE_CWD)).toEqual(REMOTE_CWD);
+  });
+
+  it('rejects a bad source, path kind, or scheme', () => {
+    expect(readCwdState({ ...LOCAL_CWD, source: 'guess' })).toBeNull();
+    expect(readCwdState({ ...LOCAL_CWD, pathKind: 'dos' })).toBeNull();
+    expect(readCwdState({ ...LOCAL_CWD, scheme: 'https' })).toBeNull();
+    expect(readCwdState(null)).toBeNull();
+  });
+
+  it('leaves a null cwd to the batch reader, which keeps it', () => {
+    expect(readCwdState(null)).toBeNull();
+    const read = readNotepadArchive(archive(batch('b1', [{ id: 'n1', text: 'a' }], null)));
+    expect(read!.batches[0].cwd).toBeNull();
+  });
+
+  it('keeps a remote cwd through a whole archive round trip', () => {
+    const read = readNotepadArchive(JSON.stringify(archive(batch('b1', [{ id: 'n1', text: 'a' }], REMOTE_CWD))));
+    expect(read!.batches[0].cwd).toEqual(REMOTE_CWD);
+  });
+});
+
+describe('applyArchiveMutation', () => {
+  it('appends, and appending a batch id already present is a no-op', () => {
+    const start = archive(batch('b1', [{ id: 'n1', text: 'a' }]));
+    const appended = applyArchiveMutation(start, { append: [batch('b2', [{ id: 'n2', text: 'b' }])] });
+    expect(appended.batches.map((b) => b.id)).toEqual(['b1', 'b2']);
+    const again = applyArchiveMutation(appended, { append: [batch('b2', [{ id: 'n2', text: 'changed' }])] });
+    expect(again.batches).toEqual(appended.batches);
+  });
+
+  it('skips an appended batch whose notes are all already stored', () => {
+    // A write that landed but reported failure is retried under a *fresh* batch
+    // id, so batch-id idempotence alone would duplicate every note in it.
+    const start = archive(batch('b1', [{ id: 'n1', text: 'a' }]));
+    const next = applyArchiveMutation(start, { append: [batch('b2', [{ id: 'n1', text: 'a' }])] });
+    expect(next.batches.map((b) => b.id)).toEqual(['b1']);
+  });
+
+  it('keeps only the new notes when an appended batch partly overlaps', () => {
+    // The Surface stayed open after the reported failure and the user kept
+    // typing: the second attempt must land exactly what the first did not.
+    const start = archive(batch('b1', [{ id: 'n1', text: 'a' }]));
+    const next = applyArchiveMutation(start, {
+      append: [batch('b2', [{ id: 'n1', text: 'a' }, { id: 'n2', text: 'b' }])],
+    });
+    expect(next.batches.map((b) => b.id)).toEqual(['b1', 'b2']);
+    expect(next.batches[1].notes.map((n) => n.id)).toEqual(['n2']);
+  });
+
+  it('deduplicates note ids across two batches appended together', () => {
+    const next = applyArchiveMutation(archive(), {
+      append: [batch('b1', [{ id: 'n1', text: 'a' }]), batch('b2', [{ id: 'n1', text: 'a' }])],
+    });
+    expect(next.batches.map((b) => b.id)).toEqual(['b1']);
+  });
+
+  it('deletes whole batches', () => {
+    const start = archive(batch('b1', [{ id: 'n1', text: 'a' }]), batch('b2', [{ id: 'n2', text: 'b' }]));
+    const next = applyArchiveMutation(start, { deleteBatchIds: ['b1', 'gone'] });
+    expect(next.batches.map((b) => b.id)).toEqual(['b2']);
+  });
+
+  it('deletes individual notes and keeps the rest in order', () => {
+    const start = archive(
+      batch('b1', [
+        { id: 'n1', text: 'a' },
+        { id: 'n2', text: 'b' },
+        { id: 'n3', text: 'c' },
+      ]),
+    );
+    const next = applyArchiveMutation(start, { deleteNotes: [{ batchId: 'b1', noteId: 'n2' }] });
+    expect(next.batches[0].notes.map((n) => n.id)).toEqual(['n1', 'n3']);
+  });
+
+  it('drops a batch emptied by note deletes', () => {
+    const start = archive(batch('b1', [{ id: 'n1', text: 'a' }]), batch('b2', [{ id: 'n2', text: 'b' }]));
+    const next = applyArchiveMutation(start, {
+      deleteNotes: [{ batchId: 'b1', noteId: 'n1' }],
+    });
+    expect(next.batches.map((b) => b.id)).toEqual(['b2']);
+  });
+
+  it('is a fixpoint: applying the same mutation twice changes nothing', () => {
+    const start = archive(batch('b1', [{ id: 'n1', text: 'a' }, { id: 'n2', text: 'b' }]));
+    const mutation = {
+      append: [batch('b2', [{ id: 'n3', text: 'c' }])],
+      deleteBatchIds: ['gone'],
+      deleteNotes: [{ batchId: 'b1', noteId: 'n1' }],
+    };
+    const once = applyArchiveMutation(start, mutation);
+    const twice = applyArchiveMutation(once, mutation);
+    expect(twice).toEqual(once);
+  });
+
+  it('applies deletes before appends within one mutation', () => {
+    const start = archive(batch('b1', [{ id: 'n1', text: 'a' }]));
+    const next = applyArchiveMutation(start, {
+      append: [batch('b2', [{ id: 'n2', text: 'b' }, { id: 'n3', text: 'c' }])],
+      deleteNotes: [{ batchId: 'b2', noteId: 'n2' }],
+    });
+    // The delete names a batch that is not stored yet, so it is a no-op and the
+    // appended batch lands whole.
+    expect(next.batches.map((b) => b.id)).toEqual(['b1', 'b2']);
+    expect(next.batches[1].notes.map((n) => n.id)).toEqual(['n2', 'n3']);
+  });
+
+  it('replaces a batch deleted and re-appended under one id', () => {
+    // A closure retried after a write that landed and then reported failure: the
+    // user edited n1, added n3, and deleted n2 while the Surface stayed open.
+    const start = archive(batch('b1', [{ id: 'n1', text: 'a' }, { id: 'n2', text: 'b' }]));
+    const next = applyArchiveMutation(start, {
+      deleteBatchIds: ['b1'],
+      append: [batch('b1', [{ id: 'n1', text: 'edited' }, { id: 'n3', text: 'c' }])],
+    });
+
+    expect(next.batches.map((b) => b.id)).toEqual(['b1']);
+    // The dedupe runs after the deletes, so the replaced batch's copy of n1 is
+    // not "already stored" and the edited one is what survives.
+    expect(next.batches[0].notes.map((n) => [n.id, n.content])).toEqual([
+      ['n1', { kind: 'plain', text: 'edited' }],
+      ['n3', { kind: 'plain', text: 'c' }],
+    ]);
+  });
+
+  it('still dedupes a note against a batch the mutation is not replacing', () => {
+    // The VS Code mirror path mints a fresh batch id per teardown and relies on
+    // this: nothing addresses the batch its notes may already be sitting in.
+    const start = archive(batch('b1', [{ id: 'n1', text: 'a' }]));
+    const next = applyArchiveMutation(start, {
+      deleteBatchIds: ['b2'],
+      append: [batch('b3', [{ id: 'n1', text: 'a' }, { id: 'n2', text: 'b' }])],
+    });
+    expect(next.batches.map((b) => b.id)).toEqual(['b1', 'b3']);
+    expect(next.batches[1].notes.map((n) => n.id)).toEqual(['n2']);
+  });
+
+  it('does not mutate the archive it was given', () => {
+    const start = archive(batch('b1', [{ id: 'n1', text: 'a' }]));
+    const before = JSON.stringify(start);
+    applyArchiveMutation(start, { append: [batch('b2', [])], deleteBatchIds: ['b1'] });
+    expect(JSON.stringify(start)).toBe(before);
+  });
+
+  it('recognizes an empty mutation', () => {
+    expect(isEmptyMutation({})).toBe(true);
+    expect(isEmptyMutation({ append: [], deleteBatchIds: [], deleteNotes: [] })).toBe(true);
+    expect(isEmptyMutation({ deleteBatchIds: ['b1'] })).toBe(false);
+  });
+});
+
+function fakeMarker(): IMarker {
+  return { id: 1, line: 4, isDisposed: false, dispose: vi.fn(), onDispose: vi.fn() } as unknown as IMarker;
+}
+
+function fakeSource(terminalId = 't1'): RuntimeTerminalSource {
+  return {
+    terminalId,
+    startMarker: fakeMarker(),
+    endMarker: fakeMarker(),
+    startColumn: 0,
+    endColumn: 10,
+    shape: 'linewise',
+    expectedRawText: 'hello',
+  };
+}
+
+describe('buildArchiveBatch', () => {
+  it('strips the runtime source from every note', () => {
+    const notes: LiveNote[] = [
+      { id: 'n1', createdAt: 1, content: { kind: 'terminal', runs: [{ text: 'hello', bold: true }] }, source: fakeSource() },
+      { id: 'n2', createdAt: 2, content: { kind: 'plain', text: 'typed' } },
+    ];
+    const built = buildArchiveBatch({
+      id: 'b1',
+      closedAt: 9,
+      surfaceTitle: 'zsh',
+      surfaceKind: 'terminal',
+      cwd: LOCAL_CWD,
+      notes,
+    });
+    expect(built.notes).toEqual([
+      { id: 'n1', createdAt: 1, content: { kind: 'terminal', runs: [{ text: 'hello', bold: true }] } },
+      { id: 'n2', createdAt: 2, content: { kind: 'plain', text: 'typed' } },
+    ]);
+    expect(built.notes[0]).not.toHaveProperty('source');
+    // What the builder emits reads back, which is what the host will store —
+    // and under strict keys that also pins that it emits no field the reader
+    // would refuse.
+    expect(readNotepadArchive({ version: 1, batches: [built] })).not.toBeNull();
+  });
+
+  it('toArchivedNote drops the source but keeps id, time, and content', () => {
+    const note: LiveNote = { id: 'n1', createdAt: 5, content: { kind: 'plain', text: 'x' }, source: fakeSource() };
+    expect(toArchivedNote(note)).toEqual({ id: 'n1', createdAt: 5, content: { kind: 'plain', text: 'x' } });
+  });
+});
+
+describe('batchFromVolatile', () => {
+  it('returns null when the mirrored Surface has no notes', () => {
+    expect(
+      batchFromVolatile(
+        { surfaceId: 's1', surfaceTitle: 'zsh', surfaceKind: 'terminal', cwd: null, notes: [] },
+        'b1',
+        9,
+      ),
+    ).toBeNull();
+  });
+
+  it('builds a batch carrying the mirrored metadata', () => {
+    const built = batchFromVolatile(
+      {
+        surfaceId: 's1',
+        surfaceTitle: 'build',
+        surfaceKind: 'terminal',
+        cwd: REMOTE_CWD,
+        notes: [{ id: 'n1', createdAt: 1, content: { kind: 'plain', text: 'x' } }],
+      },
+      'b1',
+      9,
+    );
+    expect(built).toEqual({
+      id: 'b1',
+      closedAt: 9,
+      surfaceTitle: 'build',
+      surfaceKind: 'terminal',
+      cwd: REMOTE_CWD,
+      notes: [{ id: 'n1', createdAt: 1, content: { kind: 'plain', text: 'x' } }],
+    });
+  });
+});
diff --git a/lib/src/lib/notepad/archive-model.ts b/lib/src/lib/notepad/archive-model.ts
new file mode 100644
index 00000000..432c7c87
--- /dev/null
+++ b/lib/src/lib/notepad/archive-model.ts
@@ -0,0 +1,310 @@
+// Pure archive logic shared by the webview and the VS Code extension host:
+// validation of whatever a host hands back, the idempotent mutation, and the
+// projection from live notes to an archive batch. No DOM, no xterm.
+import { SURFACE_KINDS, type SurfaceKind } from 'dor/commands/types';
+import type { CwdState, CwdSource, PathKind } from '../terminal-state';
+import type {
+  ArchiveBatch,
+  ArchivedNote,
+  LiveNote,
+  NoteContent,
+  NotepadArchiveMutation,
+  NotepadArchiveV1,
+  RichTextRun,
+  VolatileSurfaceNotes,
+} from './types';
+
+export const EMPTY_ARCHIVE: NotepadArchiveV1 = Object.freeze({ version: 1, batches: [] }) as NotepadArchiveV1;
+
+const HEX_COLOR = /^#[0-9a-f]{6}$/;
+const CWD_SOURCES: readonly CwdSource[] = ['osc7', 'osc9_9', 'osc633', 'osc1337', 'process', 'manual'];
+const PATH_KINDS: readonly PathKind[] = ['posix', 'windows', 'unknown'];
+
+/** Every reader gates on this: a key it does not know is a validation failure,
+ *  because `runMutation` rewrites the whole archive from what was read back
+ *  (`lib/src/lib/notepad/archive-service.ts`), so a field only a newer build
+ *  understands would be erased by this build's next save. */
+function hasOnlyKeys(record: Record<string, unknown>, allowed: readonly string[]): boolean {
+  return Object.keys(record).every((key) => allowed.includes(key));
+}
+
+function isRecord(value: unknown, allowed?: readonly string[]): value is Record<string, unknown> {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
+  return !allowed || hasOnlyKeys(value as Record<string, unknown>, allowed);
+}
+
+/**
+ * Pin an allowlist to the type it guards: an entry the type does not have is
+ * rejected by `keyof T`, and a key the type *has* that the list forgot leaves
+ * `Exclude` non-empty and fails the call.
+ *
+ * That second direction is the point. Adding a field to `CwdState` in
+ * `terminal-state.ts` and not to `CWD_KEYS` would make every stored archive
+ * unreadable the moment one carried it, since an unknown key fails validation
+ * wholesale — so it is a compile error here instead.
+ */
+function allKeysOf<T>() {
+  return <K extends readonly (keyof T)[]>(
+    keys: K & (Exclude<keyof T, K[number]> extends never ? unknown : never),
+  ): K => keys;
+}
+
+const RUN_KEYS = allKeysOf<RichTextRun>()(['text', 'bold', 'italic', 'foreground', 'background'] as const);
+const PLAIN_CONTENT_KEYS = allKeysOf<Extract<NoteContent, { kind: 'plain' }>>()(['kind', 'text'] as const);
+const TERMINAL_CONTENT_KEYS = allKeysOf<Extract<NoteContent, { kind: 'terminal' }>>()(['kind', 'runs'] as const);
+const NOTE_KEYS = allKeysOf<ArchivedNote>()(['id', 'createdAt', 'content'] as const);
+const CWD_KEYS = allKeysOf<CwdState>()(
+  ['uri', 'path', 'host', 'scheme', 'pathKind', 'isRemote', 'source', 'updatedAt'] as const,
+);
+const BATCH_KEYS = allKeysOf<ArchiveBatch>()(
+  ['id', 'closedAt', 'surfaceTitle', 'surfaceKind', 'cwd', 'notes'] as const,
+);
+const ARCHIVE_KEYS = allKeysOf<NotepadArchiveV1>()(['version', 'batches'] as const);
+
+function readRun(value: unknown): RichTextRun | null {
+  if (!isRecord(value, RUN_KEYS)) return null;
+  if (typeof value.text !== 'string') return null;
+  const run: RichTextRun = { text: value.text };
+  if (value.bold !== undefined) {
+    if (value.bold !== true) return null;
+    run.bold = true;
+  }
+  if (value.italic !== undefined) {
+    if (value.italic !== true) return null;
+    run.italic = true;
+  }
+  for (const key of ['foreground', 'background'] as const) {
+    const color = value[key];
+    if (color === undefined) continue;
+    if (typeof color !== 'string' || !HEX_COLOR.test(color)) return null;
+    run[key] = color;
+  }
+  return run;
+}
+
+function readContent(value: unknown): NoteContent | null {
+  if (!isRecord(value)) return null;
+  if (value.kind === 'plain') {
+    if (!isRecord(value, PLAIN_CONTENT_KEYS) || typeof value.text !== 'string') return null;
+    return { kind: 'plain', text: value.text };
+  }
+  if (value.kind === 'terminal') {
+    if (!isRecord(value, TERMINAL_CONTENT_KEYS) || !Array.isArray(value.runs)) return null;
+    const runs: RichTextRun[] = [];
+    for (const raw of value.runs) {
+      const run = readRun(raw);
+      if (!run) return null;
+      runs.push(run);
+    }
+    return { kind: 'terminal', runs };
+  }
+  return null;
+}
+
+/** One archived note, or `null` for anything that is not exactly one. Exported
+ *  because the boot global carrying the VS Code mirror validates the same shape
+ *  (`readInjectedVolatileNotepad` in `lib/src/lib/vscode-notepad-global.ts`). */
+export function readArchivedNote(value: unknown): ArchivedNote | null {
+  if (!isRecord(value, NOTE_KEYS)) return null;
+  if (typeof value.id !== 'string' || !value.id) return null;
+  if (typeof value.createdAt !== 'number' || !Number.isFinite(value.createdAt)) return null;
+  const content = readContent(value.content);
+  if (!content) return null;
+  return { id: value.id, createdAt: value.createdAt, content };
+}
+
+/** Accepts exactly the `CwdState` shape (`lib/src/lib/terminal-state.ts`):
+ *  required `path`, `pathKind`, `isRemote`, `source`, `updatedAt`; optional
+ *  `uri`, `host`, `scheme: 'file'`; nothing else. */
+export function readCwdState(value: unknown): CwdState | null {
+  if (!isRecord(value, CWD_KEYS)) return null;
+  if (typeof value.path !== 'string') return null;
+  if (typeof value.pathKind !== 'string' || !PATH_KINDS.includes(value.pathKind as PathKind)) return null;
+  if (typeof value.isRemote !== 'boolean') return null;
+  if (typeof value.source !== 'string' || !CWD_SOURCES.includes(value.source as CwdSource)) return null;
+  if (typeof value.updatedAt !== 'number' || !Number.isFinite(value.updatedAt)) return null;
+  const cwd: CwdState = {
+    path: value.path,
+    pathKind: value.pathKind as PathKind,
+    isRemote: value.isRemote,
+    source: value.source as CwdSource,
+    updatedAt: value.updatedAt,
+  };
+  if (value.uri !== undefined) {
+    if (typeof value.uri !== 'string') return null;
+    cwd.uri = value.uri;
+  }
+  if (value.host !== undefined) {
+    if (typeof value.host !== 'string') return null;
+    cwd.host = value.host;
+  }
+  if (value.scheme !== undefined) {
+    if (value.scheme !== 'file') return null;
+    cwd.scheme = 'file';
+  }
+  return cwd;
+}
+
+/** The mirror's PTY id: a non-empty string, or nothing. Mirror-only, so it never
+ *  goes through a batch reader — a batch carrying it would be rejected on the
+ *  next load — and the answer is `undefined` rather than `null` because the
+ *  field is spread in, never assigned (`VolatileSurfaceNotes` in
+ *  `lib/src/lib/notepad/types.ts`). A Surface without one is simply not asked
+ *  where its process is. */
+export function readMirrorTerminalId(value: unknown): string | undefined {
+  return typeof value === 'string' && value ? value : undefined;
+}
+
+function readBatch(value: unknown): ArchiveBatch | null {
+  if (!isRecord(value, BATCH_KEYS)) return null;
+  if (typeof value.id !== 'string' || !value.id) return null;
+  if (typeof value.closedAt !== 'number' || !Number.isFinite(value.closedAt)) return null;
+  if (typeof value.surfaceTitle !== 'string') return null;
+  if (typeof value.surfaceKind !== 'string' || !SURFACE_KINDS.includes(value.surfaceKind as SurfaceKind)) return null;
+  let cwd: CwdState | null = null;
+  if (value.cwd !== null) {
+    cwd = readCwdState(value.cwd);
+    if (!cwd) return null;
+  }
+  if (!Array.isArray(value.notes)) return null;
+  const notes: ArchivedNote[] = [];
+  for (const raw of value.notes) {
+    const note = readArchivedNote(raw);
+    if (!note) return null;
+    notes.push(note);
+  }
+  return {
+    id: value.id,
+    closedAt: value.closedAt,
+    surfaceTitle: value.surfaceTitle,
+    surfaceKind: value.surfaceKind as SurfaceKind,
+    cwd,
+    notes,
+  };
+}
+
+/**
+ * Validate a stored archive. Accepts the parsed object or its JSON string
+ * (host state APIs may hand back the serialized form). Returns `null` for
+ * anything that is not exactly a v1 archive — the caller reports it as
+ * unreadable rather than replacing it (docs/specs/notepad.md → Archive).
+ * A key outside the known shape, at any level, fails validation too: every
+ * mutation rewrites the whole archive, so a field this build does not know would
+ * be erased on the next save rather than carried forward.
+ */
+export function readNotepadArchive(raw: unknown): NotepadArchiveV1 | null {
+  let value = raw;
+  if (typeof value === 'string') {
+    try {
+      value = JSON.parse(value);
+    } catch {
+      return null;
+    }
+  }
+  if (!isRecord(value, ARCHIVE_KEYS)) return null;
+  if (value.version !== 1 || !Array.isArray(value.batches)) return null;
+  const batches: ArchiveBatch[] = [];
+  const seen = new Set<string>();
+  for (const rawBatch of value.batches) {
+    const batch = readBatch(rawBatch);
+    if (!batch || seen.has(batch.id)) return null;
+    seen.add(batch.id);
+    batches.push(batch);
+  }
+  return { version: 1, batches };
+}
+
+/** Apply a mutation immutably: batch deletes, then note deletes, then appends
+ *  (idempotent by batch **and** note id); batches emptied by note deletes are
+ *  dropped. Applying the same mutation twice yields the same archive. */
+export function applyArchiveMutation(archive: NotepadArchiveV1, mutation: NotepadArchiveMutation): NotepadArchiveV1 {
+  let batches = archive.batches.slice();
+  if (mutation.deleteBatchIds?.length) {
+    const gone = new Set(mutation.deleteBatchIds);
+    batches = batches.filter((b) => !gone.has(b.id));
+  }
+  if (mutation.deleteNotes?.length) {
+    const goneByBatch = new Map<string, Set<string>>();
+    for (const { batchId, noteId } of mutation.deleteNotes) {
+      let set = goneByBatch.get(batchId);
+      if (!set) {
+        set = new Set();
+        goneByBatch.set(batchId, set);
+      }
+      set.add(noteId);
+    }
+    batches = batches.flatMap((b) => {
+      const gone = goneByBatch.get(b.id);
+      if (!gone) return [b];
+      const notes = b.notes.filter((n) => !gone.has(n.id));
+      return notes.length === 0 ? [] : [{ ...b, notes }];
+    });
+  }
+  // Both sets are read *after* the deletes, which is what makes deleting and
+  // re-appending one id a wholesale replacement: the batch a retried closure is
+  // replacing is neither present nor holding stored notes by the time its
+  // replacement is appended.
+  const present = new Set(batches.map((b) => b.id));
+  // Every note id already stored. A note id is a UUID, so "already archived" is
+  // exact, which is what keeps the VS Code mirror path — the one appender that
+  // still mints a fresh batch id per teardown — from duplicating notes an
+  // earlier write stored.
+  const stored = new Set<string>();
+  for (const batch of batches) for (const note of batch.notes) stored.add(note.id);
+  for (const batch of mutation.append ?? []) {
+    if (present.has(batch.id)) continue;
+    const notes = batch.notes.filter((note) => !stored.has(note.id));
+    // Nothing new in it: the whole batch is a repeat, so it is not appended at
+    // all rather than appended empty.
+    if (notes.length === 0) continue;
+    present.add(batch.id);
+    for (const note of notes) stored.add(note.id);
+    batches.push(notes.length === batch.notes.length ? batch : { ...batch, notes });
+  }
+  return { version: 1, batches };
+}
+
+export function isEmptyMutation(mutation: NotepadArchiveMutation): boolean {
+  return !mutation.append?.length && !mutation.deleteBatchIds?.length && !mutation.deleteNotes?.length;
+}
+
+/** Strip the runtime source link; the archive never carries markers. */
+export function toArchivedNote(note: LiveNote): ArchivedNote {
+  return { id: note.id, createdAt: note.createdAt, content: note.content };
+}
+
+/** The batch a closing Surface appends. `id` is that Surface's remembered
+ *  batch id (`pendingBatchId`), which every attempt deletes and re-appends, so
+ *  a retry replaces whatever an earlier one landed. */
+export function buildArchiveBatch(input: {
+  id: string;
+  closedAt: number;
+  surfaceTitle: string;
+  surfaceKind: SurfaceKind;
+  cwd: CwdState | null;
+  notes: ReadonlyArray<LiveNote | ArchivedNote>;
+}): ArchiveBatch {
+  return {
+    id: input.id,
+    closedAt: input.closedAt,
+    surfaceTitle: input.surfaceTitle,
+    surfaceKind: input.surfaceKind,
+    cwd: input.cwd,
+    notes: input.notes.map(toArchivedNote),
+  };
+}
+
+/** The batch the VS Code host appends for a mirrored Surface it is tearing
+ *  down (editor-panel disposal, deactivation). `null` when there is nothing
+ *  to archive. */
+export function batchFromVolatile(surface: VolatileSurfaceNotes, id: string, closedAt: number): ArchiveBatch | null {
+  if (surface.notes.length === 0) return null;
+  return buildArchiveBatch({
+    id,
+    closedAt,
+    surfaceTitle: surface.surfaceTitle,
+    surfaceKind: surface.surfaceKind,
+    cwd: surface.cwd,
+    notes: surface.notes,
+  });
+}
diff --git a/lib/src/lib/notepad/archive-service.test.ts b/lib/src/lib/notepad/archive-service.test.ts
new file mode 100644
index 00000000..c0d12e46
--- /dev/null
+++ b/lib/src/lib/notepad/archive-service.test.ts
@@ -0,0 +1,232 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { FakePtyAdapter, setPlatform } from '../platform';
+import type { PlatformAdapter } from '../platform/types';
+import { applyArchiveMutation } from './archive-model';
+import {
+  ARCHIVE_ABSENT_MESSAGE,
+  ARCHIVE_UNREADABLE_MESSAGE,
+  __resetArchiveServiceForTests,
+  ensureArchiveLoaded,
+  getArchiveSnapshot,
+  hasNotepadArchive,
+  mutateArchive,
+  refreshArchive,
+  resetUnreadableArchive,
+  subscribeToArchive,
+} from './archive-service';
+import { createMemoryNotepadArchivePort, type MemoryNotepadArchivePort } from './memory-archive-port';
+import type { ArchiveBatch, NotepadArchivePort, NotepadArchiveV1 } from './types';
+
+function batch(id: string, noteText = id): ArchiveBatch {
+  return {
+    id,
+    closedAt: 1_700_000_000_000,
+    surfaceTitle: `pane ${id}`,
+    surfaceKind: 'terminal',
+    cwd: null,
+    notes: [{ id: `${id}-n1`, createdAt: 1, content: { kind: 'plain', text: noteText } }],
+  };
+}
+
+/** A platform that is nothing but its archive port — the service reads no other
+ *  adapter surface. */
+function installPort(port: NotepadArchivePort | undefined): void {
+  setPlatform({ notepadArchive: port } as unknown as PlatformAdapter);
+}
+
+let port: MemoryNotepadArchivePort;
+
+beforeEach(() => {
+  __resetArchiveServiceForTests();
+  port = createMemoryNotepadArchivePort();
+  installPort(port);
+});
+
+afterEach(() => {
+  __resetArchiveServiceForTests();
+});
+
+describe('loading', () => {
+  it('reports an empty archive as ready when nothing was ever archived', async () => {
+    await ensureArchiveLoaded();
+    expect(getArchiveSnapshot()).toEqual({ status: 'ready', archive: { version: 1, batches: [] } });
+  });
+
+  it('loads what the host stored and notifies subscribers', async () => {
+    port.seed({ version: 1, batches: [batch('b1')] });
+    const listener = vi.fn();
+    subscribeToArchive(listener);
+    await ensureArchiveLoaded();
+    expect(getArchiveSnapshot().status).toBe('ready');
+    expect(getArchiveSnapshot().archive.batches.map((b) => b.id)).toEqual(['b1']);
+    expect(listener).toHaveBeenCalled();
+  });
+
+  it('shares simultaneous loads and refreshes on each reopening', async () => {
+    const load = vi.spyOn(port, 'load');
+    await Promise.all([ensureArchiveLoaded(), ensureArchiveLoaded()]);
+    expect(load).toHaveBeenCalledTimes(1);
+    port.seed({ version: 1, batches: [batch('other-window')] });
+    await ensureArchiveLoaded();
+    expect(getArchiveSnapshot().archive.batches.map((b) => b.id)).toEqual(['other-window']);
+    port.seed({ version: 1, batches: [] });
+    await ensureArchiveLoaded();
+    expect(getArchiveSnapshot().archive.batches).toEqual([]);
+    expect(load).toHaveBeenCalledTimes(3);
+  });
+
+  it('is absent when the host has no archive port', async () => {
+    installPort(undefined);
+    expect(hasNotepadArchive()).toBe(false);
+    await ensureArchiveLoaded();
+    expect(getArchiveSnapshot().status).toBe('absent');
+    await expect(mutateArchive({ append: [batch('b1')] })).rejects.toThrow(ARCHIVE_ABSENT_MESSAGE);
+  });
+
+  it('reports a read failure as a transient error', async () => {
+    vi.spyOn(port, 'load').mockRejectedValueOnce(new Error('disk on fire'));
+    await ensureArchiveLoaded();
+    expect(getArchiveSnapshot().status).toBe('error');
+    expect(getArchiveSnapshot().error).toBe('disk on fire');
+  });
+});
+
+describe('unreadable data', () => {
+  it('reports it and never replaces it', async () => {
+    port.corrupt({ version: 99, batches: 'nope' });
+    await ensureArchiveLoaded();
+    expect(getArchiveSnapshot().status).toBe('unreadable');
+    expect(getArchiveSnapshot().error).toBe(ARCHIVE_UNREADABLE_MESSAGE);
+    expect(getArchiveSnapshot().archive.batches).toEqual([]);
+
+    await expect(mutateArchive({ append: [batch('b1')] })).rejects.toThrow(ARCHIVE_UNREADABLE_MESSAGE);
+    // The failed append must not have written over it.
+    expect((await port.load())?.raw).toEqual({ version: 99, batches: 'nope' });
+    expect(getArchiveSnapshot().status).toBe('unreadable');
+  });
+
+  it('recovers only on the user-initiated reset, keeping the old data aside', async () => {
+    port.corrupt('{ not json');
+    await ensureArchiveLoaded();
+    expect(getArchiveSnapshot().status).toBe('unreadable');
+
+    await resetUnreadableArchive();
+    expect(getArchiveSnapshot().status).toBe('ready');
+    expect(getArchiveSnapshot().archive.batches).toEqual([]);
+    expect(port.unreadableCopies()).toEqual(['{ not json']);
+
+    await mutateArchive({ append: [batch('b1')] });
+    expect(getArchiveSnapshot().archive.batches.map((b) => b.id)).toEqual(['b1']);
+  });
+});
+
+describe('mutating', () => {
+  it('appends and deletes through the host store', async () => {
+    await mutateArchive({ append: [batch('b1'), batch('b2')] });
+    expect(getArchiveSnapshot().archive.batches.map((b) => b.id)).toEqual(['b1', 'b2']);
+    expect(getArchiveSnapshot().status).toBe('ready');
+
+    await mutateArchive({ deleteBatchIds: ['b1'] });
+    expect(getArchiveSnapshot().archive.batches.map((b) => b.id)).toEqual(['b2']);
+
+    await mutateArchive({ deleteNotes: [{ batchId: 'b2', noteId: 'b2-n1' }] });
+    expect(getArchiveSnapshot().archive.batches).toEqual([]);
+    expect((await port.load())?.raw).toEqual({ version: 1, batches: [] });
+  });
+
+  it('touches the host not at all for an empty mutation', async () => {
+    const load = vi.spyOn(port, 'load');
+    const save = vi.spyOn(port, 'save');
+    await mutateArchive({});
+    await mutateArchive({ append: [], deleteBatchIds: [] });
+    expect(load).not.toHaveBeenCalled();
+    expect(save).not.toHaveBeenCalled();
+  });
+
+  it('serializes concurrent mutations so both land without a conflict', async () => {
+    let conflicts = 0;
+    const save = port.save.bind(port);
+    vi.spyOn(port, 'save').mockImplementation(async (archive, base) => {
+      const outcome = await save(archive, base);
+      if (outcome === 'conflict') conflicts += 1;
+      return outcome;
+    });
+
+    await Promise.all([
+      mutateArchive({ append: [batch('b1')] }),
+      mutateArchive({ append: [batch('b2')] }),
+    ]);
+
+    expect(getArchiveSnapshot().archive.batches.map((b) => b.id)).toEqual(['b1', 'b2']);
+    expect(conflicts).toBe(0);
+  });
+
+  it('reloads and reapplies when someone else wrote first, landing both batches', async () => {
+    const stolen = batch('outsider');
+    let firstSave = true;
+    const real = port.save.bind(port);
+    vi.spyOn(port, 'save').mockImplementation(async (archive, base) => {
+      if (!firstSave) return real(archive, base);
+      firstSave = false;
+      // Another writer (a second Window, the extension host) got there between
+      // our load and our save.
+      const loaded = await port.load();
+      const current = (loaded?.raw as NotepadArchiveV1 | undefined) ?? { version: 1, batches: [] };
+      await real(applyArchiveMutation(current, { append: [stolen] }), loaded?.revision ?? null);
+      return 'conflict';
+    });
+
+    await mutateArchive({ append: [batch('mine')] });
+
+    expect(getArchiveSnapshot().archive.batches.map((b) => b.id)).toEqual(['outsider', 'mine']);
+    expect(getArchiveSnapshot().status).toBe('ready');
+  });
+
+  it('gives up after a bounded number of conflicts', async () => {
+    vi.spyOn(port, 'save').mockResolvedValue('conflict');
+    await expect(mutateArchive({ append: [batch('b1')] })).rejects.toThrow(/kept changing/);
+    expect(getArchiveSnapshot().status).toBe('error');
+    expect(port.save).toHaveBeenCalledTimes(5);
+  });
+
+  it('surfaces a save failure and leaves the archive unchanged', async () => {
+    await mutateArchive({ append: [batch('b1')] });
+    const before = getArchiveSnapshot().archive;
+
+    vi.spyOn(port, 'save').mockRejectedValueOnce(new Error('read-only volume'));
+    await expect(mutateArchive({ append: [batch('b2')] })).rejects.toThrow('read-only volume');
+
+    expect(getArchiveSnapshot().status).toBe('error');
+    expect(getArchiveSnapshot().error).toBe('read-only volume');
+    expect(getArchiveSnapshot().archive).toBe(before);
+    expect((await port.load())?.raw).toEqual({ version: 1, batches: [batch('b1')] });
+
+    // The queue survives one caller's failure.
+    await mutateArchive({ append: [batch('b3')] });
+    expect(getArchiveSnapshot().archive.batches.map((b) => b.id)).toEqual(['b1', 'b3']);
+  });
+
+  it('is idempotent by batch id across retries of the same closure', async () => {
+    await mutateArchive({ append: [batch('b1')] });
+    await mutateArchive({ append: [batch('b1')] });
+    expect(getArchiveSnapshot().archive.batches).toHaveLength(1);
+  });
+});
+
+describe('through FakePtyAdapter', () => {
+  it('uses the adapter own in-memory port, including its seed and corrupt seams', async () => {
+    const adapter = new FakePtyAdapter();
+    setPlatform(adapter);
+    adapter.notepadArchive.seed({ version: 1, batches: [batch('seeded')] });
+    await ensureArchiveLoaded();
+    expect(getArchiveSnapshot().archive.batches.map((b) => b.id)).toEqual(['seeded']);
+
+    await mutateArchive({ append: [batch('closed')] });
+    expect(adapter.notepadArchive.lastVolatileSnapshot()).toBeNull();
+    expect(getArchiveSnapshot().archive.batches.map((b) => b.id)).toEqual(['seeded', 'closed']);
+
+    adapter.notepadArchive.corrupt();
+    await refreshArchive();
+    expect(getArchiveSnapshot().status).toBe('unreadable');
+  });
+});
diff --git a/lib/src/lib/notepad/archive-service.ts b/lib/src/lib/notepad/archive-service.ts
new file mode 100644
index 00000000..5de629b1
--- /dev/null
+++ b/lib/src/lib/notepad/archive-service.ts
@@ -0,0 +1,209 @@
+// The one path between the UI and `getPlatform().notepadArchive`: a
+// `useSyncExternalStore` store holding the loaded archive, and the
+// read-modify-write that every mutation goes through
+// (docs/specs/notepad.md → Archive).
+//
+// Hosts only store bytes and a revision, so the compare-and-swap lives here:
+// load, validate, `applyArchiveMutation`, save against the revision we read,
+// and on `'conflict'` do it again over whoever won. Mutations are idempotent by
+// batch and note id, which is what makes that retry safe — a closure that
+// already landed is re-applied as a no-op rather than a duplicate batch.
+import { createSerialQueue } from '../../host/remote/serial-queue';
+import { messageOf } from '../errors';
+import { getPlatformOrNull } from '../platform';
+import {
+  applyArchiveMutation,
+  EMPTY_ARCHIVE,
+  isEmptyMutation,
+  readNotepadArchive,
+} from './archive-model';
+import type { NotepadArchiveMutation, NotepadArchivePort, NotepadArchiveV1 } from './types';
+
+export type NotepadArchiveStatus = 'absent' | 'loading' | 'ready' | 'unreadable' | 'error';
+
+export interface NotepadArchiveState {
+  /** `absent` = this host has no archive port at all (Pocket, or before a
+   *  platform exists). `unreadable` = stored data that validation rejected; the
+   *  archive below is empty but the stored bytes are untouched. */
+  status: NotepadArchiveStatus;
+  archive: NotepadArchiveV1;
+  /** User-presentable; set for `unreadable` and `error`. */
+  error?: string;
+}
+
+/** A save cannot win against an endlessly-rewritten archive, and an unbounded
+ *  retry would spin instead of surfacing that. */
+const MAX_SAVE_ATTEMPTS = 5;
+
+export const ARCHIVE_ABSENT_MESSAGE = 'This host has no notepad archive.';
+export const ARCHIVE_UNREADABLE_MESSAGE =
+  'The notepad archive could not be read. Recover it from the Archive view to start a new one.';
+export const ARCHIVE_BUSY_MESSAGE =
+  'The notepad archive kept changing while saving. Try again.';
+
+const INITIAL_STATE: NotepadArchiveState = { status: 'absent', archive: EMPTY_ARCHIVE };
+
+let state: NotepadArchiveState = INITIAL_STATE;
+const listeners = new Set<() => void>();
+
+function setState(next: NotepadArchiveState): void {
+  state = next;
+  listeners.forEach((listener) => listener());
+}
+
+export function subscribeToArchive(listener: () => void): () => void {
+  listeners.add(listener);
+  return () => {
+    listeners.delete(listener);
+  };
+}
+
+/** Stable snapshot reference (changes only on mutation) for `useSyncExternalStore`. */
+export function getArchiveSnapshot(): NotepadArchiveState {
+  return state;
+}
+
+/** The host's port, or `undefined` when there is none — no platform installed
+ *  yet reads the same as a host without a notepad. */
+function archivePort(): NotepadArchivePort | undefined {
+  return getPlatformOrNull()?.notepadArchive;
+}
+
+/** Whether this host has a notepad at all. Absent on Pocket, which hides the
+ *  header icon, the Door button, the popup action, and the Settings entry with
+ *  it. The one availability gate — every caller reads it. */
+export function hasNotepadArchive(): boolean {
+  return archivePort() !== undefined;
+}
+
+let inFlightLoad: Promise<void> | null = null;
+
+async function runLoad(port: NotepadArchivePort): Promise<void> {
+  setState({ status: 'loading', archive: state.archive });
+  try {
+    const loaded = await port.load();
+    if (!loaded) {
+      setState({ status: 'ready', archive: EMPTY_ARCHIVE });
+      return;
+    }
+    const archive = readNotepadArchive(loaded.raw);
+    if (!archive) {
+      // Never replace it: the stored bytes stay exactly as they are until the
+      // user asks for recovery (`resetUnreadableArchive`).
+      setState({ status: 'unreadable', archive: EMPTY_ARCHIVE, error: ARCHIVE_UNREADABLE_MESSAGE });
+      return;
+    }
+    setState({ status: 'ready', archive });
+  } catch (error) {
+    setState({ status: 'error', archive: state.archive, error: messageOf(error) });
+  }
+}
+
+/** Re-read the stored archive unconditionally. Never rejects — a failed read is
+ *  reported through the state so every subscriber sees the same thing. */
+export function refreshArchive(): Promise<void> {
+  const port = archivePort();
+  if (!port) {
+    setState({ status: 'absent', archive: EMPTY_ARCHIVE });
+    return Promise.resolve();
+  }
+  const load = enqueue(() => runLoad(port));
+  inFlightLoad = load;
+  void load.then(() => {
+    if (inFlightLoad === load) inFlightLoad = null;
+  });
+  return load;
+}
+
+/** Re-read on each Archive opening; simultaneous callers share the load. */
+export function ensureArchiveLoaded(): Promise<void> {
+  if (inFlightLoad) return inFlightLoad;
+  return refreshArchive();
+}
+
+// One queue for every mutation. Two closing Surfaces would otherwise read the
+// same revision and one would lose its batch to the other's conflict; serialized,
+// the second reads what the first wrote.
+let enqueue = createSerialQueue();
+
+async function runMutation(port: NotepadArchivePort, mutation: NotepadArchiveMutation): Promise<void> {
+  for (let attempt = 0; attempt < MAX_SAVE_ATTEMPTS; attempt++) {
+    let loaded;
+    try {
+      loaded = await port.load();
+    } catch (error) {
+      setState({ status: 'error', archive: state.archive, error: messageOf(error) });
+      throw error instanceof Error ? error : new Error(messageOf(error));
+    }
+    const base = loaded ? readNotepadArchive(loaded.raw) : EMPTY_ARCHIVE;
+    if (!base) {
+      setState({ status: 'unreadable', archive: EMPTY_ARCHIVE, error: ARCHIVE_UNREADABLE_MESSAGE });
+      throw new Error(ARCHIVE_UNREADABLE_MESSAGE);
+    }
+    const next = applyArchiveMutation(base, mutation);
+    let outcome: 'ok' | 'conflict';
+    try {
+      outcome = await port.save(next, loaded?.revision ?? null);
+    } catch (error) {
+      // The stored archive is whatever it was; publish the failure and leave
+      // our copy alone rather than pretending the write landed.
+      setState({ status: 'error', archive: state.archive, error: messageOf(error) });
+      throw error instanceof Error ? error : new Error(messageOf(error));
+    }
+    if (outcome === 'ok') {
+      setState({ status: 'ready', archive: next });
+      return;
+    }
+    // Conflict: someone else wrote between our load and save. Re-read and
+    // re-apply — idempotency makes the second pass land only what is missing.
+  }
+  setState({ status: 'error', archive: state.archive, error: ARCHIVE_BUSY_MESSAGE });
+  throw new Error(ARCHIVE_BUSY_MESSAGE);
+}
+
+/**
+ * Apply one mutation to the stored archive. Rejects with a user-presentable
+ * message when the archive cannot be written — closure paths surface that as
+ * "Keep open / Close anyway" rather than dropping the notes.
+ */
+export function mutateArchive(mutation: NotepadArchiveMutation): Promise<void> {
+  // Nothing to write is not a reason to touch the host's store, and a closure
+  // with no notes takes this path.
+  if (isEmptyMutation(mutation)) return Promise.resolve();
+  const port = archivePort();
+  if (!port) {
+    setState({ status: 'absent', archive: EMPTY_ARCHIVE });
+    return Promise.reject(new Error(ARCHIVE_ABSENT_MESSAGE));
+  }
+  return enqueue(() => runMutation(port, mutation));
+}
+
+/**
+ * Move unreadable stored data aside and start empty. The only path that
+ * replaces an archive validation rejected, and only ever from an explicit user
+ * action in the Archive view.
+ */
+export async function resetUnreadableArchive(): Promise<void> {
+  const port = archivePort();
+  if (!port) {
+    setState({ status: 'absent', archive: EMPTY_ARCHIVE });
+    throw new Error(ARCHIVE_ABSENT_MESSAGE);
+  }
+  await enqueue(async () => {
+    try {
+      await port.resetUnreadable();
+    } catch (error) {
+      setState({ status: 'error', archive: state.archive, error: messageOf(error) });
+      throw error instanceof Error ? error : new Error(messageOf(error));
+    }
+  });
+  await refreshArchive();
+}
+
+/** Test-only helper. Do not use in application code. */
+export function __resetArchiveServiceForTests(): void {
+  state = INITIAL_STATE;
+  listeners.clear();
+  inFlightLoad = null;
+  enqueue = createSerialQueue();
+}
diff --git a/lib/src/lib/notepad/capture.test.ts b/lib/src/lib/notepad/capture.test.ts
new file mode 100644
index 00000000..710a373a
--- /dev/null
+++ b/lib/src/lib/notepad/capture.test.ts
@@ -0,0 +1,239 @@
+/**
+ * @vitest-environment jsdom
+ */
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import type { IMarker, Terminal } from '@xterm/xterm';
+
+const mocks = vi.hoisted(() => ({
+  getTerminalInstance: vi.fn<(id: string) => unknown>(),
+}));
+
+// The registry barrel drags in the whole terminal lifecycle; capture only needs
+// the one lookup, so stub it rather than boot xterm here.
+vi.mock('../terminal-registry', () => ({ getTerminalInstance: mocks.getTerminalInstance }));
+
+import { __resetMouseSelectionForTests, setSelection, type Selection } from '../mouse-selection';
+import { FakePtyAdapter, setPlatform } from '../platform';
+import { hasNotepadArchive } from './archive-service';
+import { addSelectionToNotepad, isNotepadChordBound } from './capture';
+import { registry, type TerminalEntry } from '../terminal-store';
+import { beginClosing, clearAllNotepads, getNotes } from './notepad-store';
+
+class FakeMarker {
+  isDisposed = false;
+  constructor(public line: number) {}
+  dispose(): void {
+    this.isDisposed = true;
+    this.line = -1;
+  }
+}
+
+/** A terminal made of plain unstyled rows — enough for both the rich walk
+ *  (cells) and the raw read (`translateToString`) to agree. */
+function makeTerminal(lines: string[], opts: { type?: 'normal' | 'alternate' } = {}): Terminal {
+  const cols = Math.max(1, ...lines.map((line) => line.length));
+  const cell = (ch: string) => ({
+    getChars: () => ch,
+    getWidth: () => 1,
+    isBold: () => 0,
+    isItalic: () => 0,
+    isInverse: () => 0,
+    isFgDefault: () => true,
+    isFgPalette: () => false,
+    isFgRGB: () => false,
+    getFgColor: () => 0,
+    isBgDefault: () => true,
+    isBgPalette: () => false,
+    isBgRGB: () => false,
+    getBgColor: () => 0,
+  });
+  const getLine = (y: number) => {
+    if (lines[y] === undefined) return undefined;
+    const padded = lines[y].padEnd(cols, ' ');
+    return {
+      isWrapped: false,
+      length: cols,
+      getCell: (x: number) => (x < cols ? cell(padded[x]) : undefined),
+      translateToString: (_trim?: boolean, start = 0, end = cols) => padded.slice(start, end),
+    };
+  };
+  return {
+    cols,
+    options: { drawBoldTextInBrightColors: true },
+    buffer: {
+      active: {
+        type: opts.type ?? 'normal',
+        baseY: 0,
+        cursorY: 0,
+        length: lines.length,
+        getLine,
+      },
+    },
+    registerMarker: (offset = 0) => new FakeMarker(offset) as unknown as IMarker,
+  } as unknown as Terminal;
+}
+
+function sel(overrides: Partial<Selection> = {}): Selection {
+  return {
+    startRow: 0,
+    startCol: 0,
+    endRow: 1,
+    endCol: 4,
+    shape: 'linewise',
+    dragging: false,
+    startedInScrollback: false,
+    ...overrides,
+  };
+}
+
+const LINES = ['alpha one', 'bravo two'];
+
+beforeEach(() => {
+  clearAllNotepads();
+  __resetMouseSelectionForTests();
+  mocks.getTerminalInstance.mockReset();
+  setPlatform(new FakePtyAdapter());
+});
+
+afterEach(() => registry.delete('helper-1'));
+
+describe('addSelectionToNotepad', () => {
+  it('captures Helper output into the parent without registering any markers', () => {
+    const terminal = makeTerminal(LINES);
+    const markers = vi.spyOn(terminal, 'registerMarker');
+    mocks.getTerminalInstance.mockReturnValue(terminal);
+    registry.set('helper-1', { helper: { parentId: 'term-1', command: '' } } as TerminalEntry);
+    setSelection('helper-1', sel());
+    expect(addSelectionToNotepad('helper-1')).toBe(true);
+    expect(getNotes('helper-1')).toEqual([]);
+    expect(getNotes('term-1')).toHaveLength(1);
+    expect(getNotes('term-1')[0].source).toBeUndefined();
+    expect(markers).not.toHaveBeenCalled();
+
+    const release = beginClosing(['term-1']);
+    expect(addSelectionToNotepad('helper-1')).toBe(false);
+    expect(getNotes('term-1')).toHaveLength(1);
+    release();
+
+    // Promotion changes ownership only for subsequent captures.
+    registry.get('helper-1')!.helper = undefined;
+    expect(addSelectionToNotepad('helper-1')).toBe(true);
+    expect(getNotes('helper-1')[0].source?.terminalId).toBe('helper-1');
+    expect(getNotes('term-1')).toHaveLength(1);
+  });
+
+  it('captures the finalized selection as a rich note pinned to its source', () => {
+    mocks.getTerminalInstance.mockReturnValue(makeTerminal(LINES));
+    setSelection('term-1', sel());
+
+    expect(addSelectionToNotepad('term-1')).toBe(true);
+
+    // The Surface id of a terminal Surface is its terminal id, so the note
+    // lands under the same key the selection came from.
+    const notes = getNotes('term-1');
+    expect(notes).toHaveLength(1);
+    expect(notes[0].content).toEqual({ kind: 'terminal', runs: [{ text: 'alpha one\nbravo' }] });
+    expect(notes[0].source).toMatchObject({
+      terminalId: 'term-1',
+      startColumn: 0,
+      endColumn: 4,
+      shape: 'linewise',
+      expectedRawText: 'alpha one\nbravo',
+    });
+  });
+
+  it('leaves the notepad closed and captures again on a second call', () => {
+    mocks.getTerminalInstance.mockReturnValue(makeTerminal(LINES));
+    setSelection('term-1', sel());
+
+    addSelectionToNotepad('term-1');
+    addSelectionToNotepad('term-1');
+
+    expect(getNotes('term-1')).toHaveLength(2);
+  });
+
+  it('captures with no pin on the alternate buffer', () => {
+    mocks.getTerminalInstance.mockReturnValue(makeTerminal(LINES, { type: 'alternate' }));
+    setSelection('term-1', sel());
+
+    expect(addSelectionToNotepad('term-1')).toBe(true);
+    expect(getNotes('term-1')[0].source).toBeUndefined();
+  });
+
+  it('normalizes a reversed selection', () => {
+    mocks.getTerminalInstance.mockReturnValue(makeTerminal(LINES));
+    setSelection('term-1', sel({ startRow: 1, startCol: 4, endRow: 0, endCol: 0 }));
+
+    expect(addSelectionToNotepad('term-1')).toBe(true);
+    expect(getNotes('term-1')[0].source).toMatchObject({ startColumn: 0, endColumn: 4 });
+  });
+
+  it('does nothing without a selection', () => {
+    mocks.getTerminalInstance.mockReturnValue(makeTerminal(LINES));
+
+    expect(addSelectionToNotepad('term-1')).toBe(false);
+    expect(getNotes('term-1')).toHaveLength(0);
+  });
+
+  it('does nothing mid-drag', () => {
+    mocks.getTerminalInstance.mockReturnValue(makeTerminal(LINES));
+    setSelection('term-1', sel({ dragging: true }));
+
+    expect(addSelectionToNotepad('term-1')).toBe(false);
+    expect(getNotes('term-1')).toHaveLength(0);
+  });
+
+  it('refuses the capture while the Surface is closing, and releases its markers', () => {
+    const terminal = makeTerminal(LINES);
+    mocks.getTerminalInstance.mockReturnValue(terminal);
+    setSelection('term-1', sel());
+    const markers: FakeMarker[] = [];
+    terminal.registerMarker = ((offset = 0) => {
+      const created = new FakeMarker(offset);
+      markers.push(created);
+      return created as unknown as IMarker;
+    }) as Terminal['registerMarker'];
+
+    const release = beginClosing(['term-1']);
+    // `false`, so the popup does not flash "Added" for a note nobody took.
+    expect(addSelectionToNotepad('term-1')).toBe(false);
+    expect(getNotes('term-1')).toHaveLength(0);
+    // The pin was registered before the store refused it, and no note owns it.
+    expect(markers).toHaveLength(2);
+    expect(markers.every((m) => m.isDisposed)).toBe(true);
+
+    release();
+    expect(addSelectionToNotepad('term-1')).toBe(true);
+  });
+
+  it('does nothing when the terminal instance is gone', () => {
+    mocks.getTerminalInstance.mockReturnValue(null);
+    setSelection('term-1', sel());
+
+    expect(addSelectionToNotepad('term-1')).toBe(false);
+    expect(getNotes('term-1')).toHaveLength(0);
+  });
+});
+
+describe('isNotepadChordBound', () => {
+  it('binds the chord on a host that has a notepad and has not ceded it', () => {
+    const adapter = new FakePtyAdapter();
+    setPlatform(adapter);
+    expect(hasNotepadArchive()).toBe(true);
+    expect(isNotepadChordBound()).toBe(true);
+
+    // The website demo keeps the button and binds no chord.
+    (adapter as { browserReservesNotepadChord?: boolean }).browserReservesNotepadChord = true;
+    expect(hasNotepadArchive()).toBe(true);
+    expect(isNotepadChordBound()).toBe(false);
+  });
+
+  it('binds nothing on a host with no notepad', () => {
+    const adapter = new FakePtyAdapter();
+    (adapter as { notepadArchive?: unknown }).notepadArchive = undefined;
+    setPlatform(adapter);
+
+    expect(hasNotepadArchive()).toBe(false);
+    expect(isNotepadChordBound()).toBe(false);
+  });
+});
diff --git a/lib/src/lib/notepad/capture.ts b/lib/src/lib/notepad/capture.ts
new file mode 100644
index 00000000..2a1000bb
--- /dev/null
+++ b/lib/src/lib/notepad/capture.ts
@@ -0,0 +1,38 @@
+// "Add to notepad" for a finalized terminal selection (docs/specs/notepad.md →
+// Capture). Reached from the selection popup's third button and from the
+// Cmd/Ctrl+N chord, both of which flash and dismiss the selection themselves —
+// a capture never opens the notepad.
+import { registry } from '../terminal-store';
+import { getMouseSelectionState } from '../mouse-selection';
+import { getPlatformOrNull } from '../platform';
+import { getTerminalInstance } from '../terminal-registry';
+import { hasNotepadArchive } from './archive-service';
+import { addTerminalNote } from './notepad-store';
+import { captureRichSelection } from './rich-extract';
+import { registerTerminalSource } from './source-link';
+
+/** Whether Cmd/Ctrl+N is ours to bind. The website demo runs in a browser that
+ *  reserves the chord for a new window, so it keeps the button and shows no
+ *  shortcut. */
+export function isNotepadChordBound(): boolean {
+  return hasNotepadArchive() && getPlatformOrNull()?.browserReservesNotepadChord !== true;
+}
+
+/** Capture the terminal's finalized selection into its notepad as a rich note,
+ *  with a source pin when the normal buffer is active. Returns `false` when
+ *  there is no finalized selection, no live terminal to read, or the Surface is
+ *  closing — the caller flashes "Added" only on a `true`. */
+export function addSelectionToNotepad(terminalId: string): boolean {
+  const sel = getMouseSelectionState(terminalId).selection;
+  // Mid-drag there is nothing settled to capture; the popup is not up either.
+  if (!sel || sel.dragging) return false;
+  const terminal = getTerminalInstance(terminalId);
+  if (!terminal) return false;
+
+  const { runs, rawText } = captureRichSelection(terminal, sel);
+  // Helpers capture into the parent's list without ever creating source markers.
+  const parentId = registry.get(terminalId)?.helper?.parentId;
+  const source = parentId ? null : registerTerminalSource(terminal, terminalId, sel, rawText);
+  // The owner's closing freeze also refuses captures from its helper.
+  return addTerminalNote(parentId ?? terminalId, runs, source ?? undefined) !== null;
+}
diff --git a/lib/src/lib/notepad/close-coordinator.test.ts b/lib/src/lib/notepad/close-coordinator.test.ts
new file mode 100644
index 00000000..2fa2c733
--- /dev/null
+++ b/lib/src/lib/notepad/close-coordinator.test.ts
@@ -0,0 +1,484 @@
+import type { SurfaceKind } from 'dor/commands/types';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { FakePtyAdapter, setPlatform } from '../platform';
+import type { CwdState } from '../terminal-state';
+import {
+  ensureTerminalPaneState,
+  getTerminalPaneState,
+  removeTerminalPaneState,
+} from '../terminal-state-store';
+import { __resetArchiveServiceForTests } from './archive-service';
+import { archiveSurfaceNotes, PROCESS_CWD_REFRESH_MS } from './close-coordinator';
+import {
+  addPlainNote,
+  addTerminalNote,
+  clearAllNotepads,
+  deleteNote,
+  getNotes,
+  isSurfaceClosing,
+  setNotepadSurfaceMetaResolver,
+  setNoteText,
+} from './notepad-store';
+import type { NotepadArchiveV1, RuntimeTerminalSource } from './types';
+
+const CWD: CwdState = {
+  path: '/srv/app',
+  uri: 'file:///srv/app',
+  host: 'build-box',
+  scheme: 'file',
+  pathKind: 'posix',
+  isRemote: true,
+  source: 'osc7',
+  updatedAt: 5,
+};
+
+const PANE_IDS = ['s1', 's2', 's3'];
+
+/**
+ * The Wall's resolver in miniature: the CWD is read live out of the pane state,
+ * not fixed, so a refresh the closure performs shows up in the batch it builds.
+ */
+function installMetaResolver(surfaceKind: SurfaceKind = 'terminal', surfaceTitle = 'pnpm dev'): void {
+  setNotepadSurfaceMetaResolver((id) => ({
+    surfaceTitle,
+    surfaceKind,
+    cwd: getTerminalPaneState(id).cwd,
+  }));
+}
+
+let adapter: FakePtyAdapter;
+
+/** What the host actually stored, after validation. */
+async function stored(): Promise<NotepadArchiveV1> {
+  const loaded = await adapter.notepadArchive.load();
+  return (loaded?.raw ?? { version: 1, batches: [] }) as NotepadArchiveV1;
+}
+
+function marker(): { dispose: ReturnType<typeof vi.fn> } {
+  return { id: 1, line: 3, isDisposed: false, dispose: vi.fn(), onDispose: vi.fn() } as never;
+}
+
+function source(terminalId = 's1'): RuntimeTerminalSource & {
+  startMarker: { dispose: ReturnType<typeof vi.fn> };
+  endMarker: { dispose: ReturnType<typeof vi.fn> };
+} {
+  return {
+    terminalId,
+    startMarker: marker(),
+    endMarker: marker(),
+    startColumn: 0,
+    endColumn: 4,
+    shape: 'linewise',
+    expectedRawText: 'boom',
+  } as never;
+}
+
+/** A `save` parked until `release`, so a test can act on the store while a
+ *  closure is mid-write. `entered` settles once the coordinator is inside it. */
+function heldSave(): { entered: Promise<void>; release: () => void } {
+  const real = adapter.notepadArchive.save.bind(adapter.notepadArchive);
+  let markEntered!: () => void;
+  const entered = new Promise<void>((resolve) => { markEntered = resolve; });
+  let open!: () => void;
+  const gate = new Promise<void>((resolve) => { open = resolve; });
+  vi.spyOn(adapter.notepadArchive, 'save').mockImplementation(async (archive, base) => {
+    markEntered();
+    await gate;
+    return real(archive, base);
+  });
+  return { entered, release: () => open() };
+}
+
+beforeEach(() => {
+  __resetArchiveServiceForTests();
+  clearAllNotepads();
+  adapter = new FakePtyAdapter();
+  setPlatform(adapter);
+});
+
+afterEach(() => {
+  __resetArchiveServiceForTests();
+  clearAllNotepads();
+  PANE_IDS.forEach(removeTerminalPaneState);
+});
+
+describe('archiveSurfaceNotes', () => {
+  it('touches the archive at all only when there are notes', async () => {
+    const save = vi.spyOn(adapter.notepadArchive, 'save');
+    await archiveSurfaceNotes(['s1']);
+    expect(save).not.toHaveBeenCalled();
+    expect(await stored()).toEqual({ version: 1, batches: [] });
+  });
+
+  it('archives one batch per Surface and forgets the notes', async () => {
+    installMetaResolver();
+    ensureTerminalPaneState('s1', { cwd: CWD });
+    addPlainNote('s1', 'remember this');
+
+    await archiveSurfaceNotes(['s1']);
+
+    const archive = await stored();
+    expect(archive.batches).toHaveLength(1);
+    expect(archive.batches[0]).toMatchObject({
+      surfaceTitle: 'pnpm dev',
+      surfaceKind: 'terminal',
+      // The whole canonical CwdState is snapshotted, remote identity included.
+      cwd: CWD,
+      notes: [{ content: { kind: 'plain', text: 'remember this' } }],
+    });
+    expect(getNotes('s1')).toEqual([]);
+  });
+
+  it('falls back to empty metadata when no resolver is installed', async () => {
+    addPlainNote('s1', 'orphan');
+    await archiveSurfaceNotes(['s1']);
+    expect((await stored()).batches[0]).toMatchObject({
+      surfaceTitle: '',
+      surfaceKind: 'terminal',
+      cwd: null,
+    });
+  });
+
+  it('never archives the runtime source link', async () => {
+    addTerminalNote('s1', [{ text: 'boom', bold: true }], {
+      terminalId: 's1',
+      startMarker: { id: 1, line: 3, isDisposed: false, dispose: vi.fn(), onDispose: vi.fn() },
+      endMarker: { id: 2, line: 4, isDisposed: false, dispose: vi.fn(), onDispose: vi.fn() },
+      startColumn: 0,
+      endColumn: 4,
+      shape: 'linewise',
+      expectedRawText: 'boom',
+    } as never);
+
+    await archiveSurfaceNotes(['s1']);
+
+    expect(JSON.stringify(await stored())).not.toContain('Marker');
+  });
+
+  it('appends every closing Surface in one mutation', async () => {
+    const save = vi.spyOn(adapter.notepadArchive, 'save');
+    addPlainNote('s1', 'one');
+    addPlainNote('s2', 'two');
+    // No notes: removed without adding a batch, and without blocking the others.
+    await archiveSurfaceNotes(['s1', 's2', 's3']);
+
+    expect(save).toHaveBeenCalledTimes(1);
+    const archive = await stored();
+    expect(archive.batches.map((b) => b.notes[0].content)).toEqual([
+      { kind: 'plain', text: 'one' },
+      { kind: 'plain', text: 'two' },
+    ]);
+  });
+
+  it('keeps the notes in place when the archive refuses the write', async () => {
+    vi.spyOn(adapter.notepadArchive, 'save').mockRejectedValue(new Error('disk is full'));
+    addPlainNote('s1', 'still here');
+
+    await expect(archiveSurfaceNotes(['s1'])).rejects.toThrow('disk is full');
+
+    expect(getNotes('s1')).toHaveLength(1);
+    expect((await stored()).batches).toEqual([]);
+  });
+
+  it('retries a genuinely failed write without duplicating anything', async () => {
+    const save = vi.spyOn(adapter.notepadArchive, 'save').mockRejectedValueOnce(new Error('disk is full'));
+    addPlainNote('s1', 'once');
+
+    await expect(archiveSurfaceNotes(['s1'])).rejects.toThrow('disk is full');
+    await archiveSurfaceNotes(['s1']);
+
+    expect(save).toHaveBeenCalledTimes(2);
+    const archive = await stored();
+    expect(archive.batches).toHaveLength(1);
+    expect(getNotes('s1')).toEqual([]);
+  });
+
+  it('replaces the batch a write that landed but reported failure already stored', async () => {
+    // The VS Code adapter's request timeout produces exactly this: the host
+    // stored the batch, the webview was told it did not, and the Surface stayed
+    // open for the user to keep working in.
+    const real = adapter.notepadArchive.save.bind(adapter.notepadArchive);
+    vi.spyOn(adapter.notepadArchive, 'save').mockImplementationOnce(async (archive, base) => {
+      await real(archive, base);
+      throw new Error('the request timed out');
+    });
+    const x = addPlainNote('s1', 'X')!;
+    const y = addPlainNote('s1', 'Y')!;
+
+    await expect(archiveSurfaceNotes(['s1'])).rejects.toThrow('the request timed out');
+    const landed = (await stored()).batches[0].id;
+
+    setNoteText('s1', x, 'X edited');
+    addPlainNote('s1', 'Z');
+    deleteNote('s1', y);
+    await archiveSurfaceNotes(['s1']);
+
+    const archive = await stored();
+    // One batch under the same id, replaced wholesale: a fresh id per attempt
+    // would have kept the stale X (its note id was already stored) and dropped
+    // the edit with `removeSurface`.
+    expect(archive.batches).toHaveLength(1);
+    expect(archive.batches[0].id).toBe(landed);
+    expect(archive.batches[0].notes.map((n) => n.content)).toEqual([
+      { kind: 'plain', text: 'X edited' },
+      { kind: 'plain', text: 'Z' },
+    ]);
+    expect(getNotes('s1')).toEqual([]);
+  });
+
+  it('deletes the landed batch when the retried closure has nothing left', async () => {
+    // Same land-then-reject as above, except the user answered Keep open by
+    // emptying the notepad. The stored batch holds exactly the notes they
+    // deleted after being told none were archived, so it goes too.
+    const real = adapter.notepadArchive.save.bind(adapter.notepadArchive);
+    vi.spyOn(adapter.notepadArchive, 'save').mockImplementationOnce(async (archive, base) => {
+      await real(archive, base);
+      throw new Error('the request timed out');
+    });
+    const only = addPlainNote('s1', 'delete me')!;
+
+    await expect(archiveSurfaceNotes(['s1'])).rejects.toThrow('the request timed out');
+    expect((await stored()).batches).toHaveLength(1);
+
+    deleteNote('s1', only);
+    await archiveSurfaceNotes(['s1']);
+
+    expect((await stored()).batches).toEqual([]);
+    // Forgotten with the closure, so a Surface id reused later starts clean.
+    addPlainNote('s1', 'a later Session');
+    await archiveSurfaceNotes(['s1']);
+    expect((await stored()).batches).toHaveLength(1);
+  });
+
+  it('writes nothing for an empty Surface that never landed a batch', async () => {
+    const save = vi.spyOn(adapter.notepadArchive, 'save');
+    // An untouched Add New is not a note, so there is no remembered id either.
+    addPlainNote('s1');
+
+    await archiveSurfaceNotes(['s1']);
+
+    expect(save).not.toHaveBeenCalled();
+    expect(getNotes('s1')).toEqual([]);
+  });
+
+  it('stamps each closure attempt with a fresh closedAt', async () => {
+    vi.spyOn(adapter.notepadArchive, 'save').mockRejectedValueOnce(new Error('disk is full'));
+    const nowSpy = vi.spyOn(Date, 'now').mockReturnValue(1_000);
+    try {
+      addPlainNote('s1', 'once');
+      await expect(archiveSurfaceNotes(['s1'])).rejects.toThrow('disk is full');
+      nowSpy.mockReturnValue(9_000);
+      await archiveSurfaceNotes(['s1']);
+    } finally {
+      nowSpy.mockRestore();
+    }
+
+    expect((await stored()).batches[0].closedAt).toBe(9_000);
+  });
+
+  it('leaves the live notes alone when the caller has already given up', async () => {
+    // The standalone quit gate's deadline fired and the user chose Cancel: the
+    // batch is stored, but emptying the notepads now would delete notes in front
+    // of someone who just said no.
+    const controller = new AbortController();
+    const realSave = adapter.notepadArchive.save.bind(adapter.notepadArchive);
+    vi.spyOn(adapter.notepadArchive, 'save').mockImplementation(async (archive, base) => {
+      controller.abort(); // the deadline fires while the write is in flight
+      return realSave(archive, base);
+    });
+    addPlainNote('s1', 'still mine');
+
+    await archiveSurfaceNotes(['s1'], { signal: controller.signal });
+
+    // Stored — and still on screen, so a later close re-archives it (once).
+    expect((await stored()).batches).toHaveLength(1);
+    expect(getNotes('s1')).toHaveLength(1);
+  });
+
+  it('mints a fresh batch id for the next closure of the same id', async () => {
+    // The remembered id is forgotten the moment a closure lands, so a Surface
+    // id reused by a later Session archives beside the first rather than over
+    // it.
+    addPlainNote('s1', 'first');
+    await archiveSurfaceNotes(['s1']);
+    addPlainNote('s1', 'second');
+    await archiveSurfaceNotes(['s1']);
+
+    const archive = await stored();
+    expect(archive.batches).toHaveLength(2);
+    expect(new Set(archive.batches.map((b) => b.id)).size).toBe(2);
+  });
+
+  it('freezes the notepad from the snapshot until the write settles', async () => {
+    const held = heldSave();
+    const first = addPlainNote('s1', 'snapshotted')!;
+    const closing = archiveSurfaceNotes(['s1']);
+    await held.entered;
+
+    // Everything that would change what is being written is refused. An edit is
+    // the worst of them: the batch already holds the pre-edit text, and the
+    // forget step below would then take the edit with it.
+    expect(isSurfaceClosing('s1')).toBe(true);
+    setNoteText('s1', first, 'edited mid-write');
+    expect(addPlainNote('s1', 'added mid-write')).toBeNull();
+    const captured = source();
+    expect(addTerminalNote('s1', [{ text: 'boom' }], captured)).toBeNull();
+    // Nobody else can reach the markers of a note that was never added.
+    expect(captured.startMarker.dispose).toHaveBeenCalledTimes(1);
+    expect(captured.endMarker.dispose).toHaveBeenCalledTimes(1);
+    deleteNote('s1', first);
+    expect(getNotes('s1').map((n) => n.content)).toEqual([{ kind: 'plain', text: 'snapshotted' }]);
+
+    held.release();
+    await closing;
+
+    expect(isSurfaceClosing('s1')).toBe(false);
+    const archive = await stored();
+    expect(archive.batches).toHaveLength(1);
+    expect(archive.batches[0].notes.map((n) => n.content)).toEqual([
+      { kind: 'plain', text: 'snapshotted' },
+    ]);
+    expect(getNotes('s1')).toEqual([]);
+  });
+
+  it('archives one batch for two overlapping closures of one Surface', async () => {
+    const held = heldSave();
+    addPlainNote('s1', 'only once');
+
+    const first = archiveSurfaceNotes(['s1']);
+    const second = archiveSurfaceNotes(['s1']);
+    await held.entered;
+    held.release();
+    await expect(Promise.all([first, second])).resolves.toEqual([undefined, undefined]);
+
+    const archive = await stored();
+    expect(archive.batches).toHaveLength(1);
+    expect(archive.batches[0].notes).toHaveLength(1);
+    // Counted, not flagged: the freeze lifts only once *both* have settled.
+    expect(isSurfaceClosing('s1')).toBe(false);
+    expect(addPlainNote('s1', 'after')).not.toBeNull();
+  });
+
+  it('thaws the notepad when the write is refused', async () => {
+    vi.spyOn(adapter.notepadArchive, 'save').mockRejectedValue(new Error('disk is full'));
+    const id = addPlainNote('s1', 'still here')!;
+
+    await expect(archiveSurfaceNotes(['s1'])).rejects.toThrow('disk is full');
+
+    // The Surface stayed open behind Keep open, so its notepad is the user's
+    // again.
+    expect(isSurfaceClosing('s1')).toBe(false);
+    setNoteText('s1', id, 'edited after the failure');
+    expect(getNotes('s1')[0].content).toEqual({ kind: 'plain', text: 'edited after the failure' });
+  });
+
+  it('never archives an empty plain note', async () => {
+    const save = vi.spyOn(adapter.notepadArchive, 'save');
+    // An untouched Add New that was still focused when the kill landed.
+    addPlainNote('s1');
+    addPlainNote('s1', 'typed');
+    // Nothing but an untouched Add New: this Surface closes as if it had none.
+    addPlainNote('s2');
+
+    await archiveSurfaceNotes(['s1', 's2']);
+
+    expect(save).toHaveBeenCalledTimes(1);
+    const archive = await stored();
+    expect(archive.batches).toHaveLength(1);
+    expect(archive.batches[0].notes.map((n) => n.content)).toEqual([{ kind: 'plain', text: 'typed' }]);
+    expect(getNotes('s2')).toEqual([]);
+  });
+
+  describe('process CWD refresh', () => {
+    it('fills a batch from the live PTY when the shell reported no CWD', async () => {
+      // A shell with no CWD escapes (no OSC 7 / 9;9 / 633 / 1337) never reports
+      // one, but its PTY is alive right up to the kill.
+      installMetaResolver();
+      ensureTerminalPaneState('s1');
+      const getCwd = vi.spyOn(adapter, 'getCwd').mockResolvedValue('/Users/me/project');
+      addPlainNote('s1', 'where was I');
+
+      await archiveSurfaceNotes(['s1']);
+
+      expect(getCwd).toHaveBeenCalledWith('s1');
+      expect((await stored()).batches[0].cwd).toMatchObject({
+        path: '/Users/me/project',
+        source: 'process',
+      });
+    });
+
+    it('archives notes when a fallback CWD lookup throws synchronously', async () => {
+      installMetaResolver();
+      addPlainNote('s1', 'keep this');
+      vi.spyOn(adapter, 'getCwd').mockImplementation(() => { throw new Error('PTY unavailable'); });
+      await archiveSurfaceNotes(['s1']);
+      expect((await stored()).batches[0].notes[0].content).toEqual({ kind: 'plain', text: 'keep this' });
+      expect(getNotes('s1')).toEqual([]);
+    });
+
+    it('never overrides a CWD the shell integration reported, and does not ask', async () => {
+      installMetaResolver();
+      ensureTerminalPaneState('s1', { cwd: CWD });
+      const getCwd = vi.spyOn(adapter, 'getCwd').mockResolvedValue('/somewhere/else');
+      addPlainNote('s1', 'osc7 wins');
+
+      await archiveSurfaceNotes(['s1']);
+
+      // The answer would be discarded, and asking is an `lsof` on the PTY
+      // host's event loop.
+      expect(getCwd).not.toHaveBeenCalled();
+      expect((await stored()).batches[0].cwd).toEqual(CWD);
+    });
+
+    it('never asks about a Surface that has no terminal', async () => {
+      installMetaResolver('browser', 'example.com');
+      const getCwd = vi.spyOn(adapter, 'getCwd');
+      addPlainNote('s1', 'a browser note');
+
+      await archiveSurfaceNotes(['s1']);
+
+      expect(getCwd).not.toHaveBeenCalled();
+      expect((await stored()).batches[0]).toMatchObject({ surfaceKind: 'browser', cwd: null });
+    });
+
+    it('closes within the bound when the host never answers', async () => {
+      vi.useFakeTimers();
+      try {
+        installMetaResolver();
+        ensureTerminalPaneState('s1');
+        vi.spyOn(adapter, 'getCwd').mockReturnValue(new Promise<string | null>(() => {}));
+        addPlainNote('s1', 'closing anyway');
+
+        const closing = archiveSurfaceNotes(['s1']);
+        await vi.advanceTimersByTimeAsync(PROCESS_CWD_REFRESH_MS);
+        await closing;
+      } finally {
+        vi.useRealTimers();
+      }
+
+      expect((await stored()).batches[0].cwd).toBeNull();
+      expect(getNotes('s1')).toEqual([]);
+    });
+
+    it('keeps the last reported CWD when the host rejects', async () => {
+      installMetaResolver();
+      ensureTerminalPaneState('s1', { cwd: CWD });
+      vi.spyOn(adapter, 'getCwd').mockRejectedValue(new Error('the PTY is gone'));
+      addPlainNote('s1', 'still archived');
+
+      await expect(archiveSurfaceNotes(['s1'])).resolves.toBeUndefined();
+
+      expect((await stored()).batches[0].cwd).toEqual(CWD);
+    });
+  });
+
+  it('closes without an archive at all on a host that has none', async () => {
+    const bare = new FakePtyAdapter();
+    delete (bare as { notepadArchive?: unknown }).notepadArchive;
+    setPlatform(bare);
+    addPlainNote('s1', 'nowhere to put this');
+
+    await expect(archiveSurfaceNotes(['s1'])).resolves.toBeUndefined();
+    expect(getNotes('s1')).toEqual([]);
+  });
+});
diff --git a/lib/src/lib/notepad/close-coordinator.ts b/lib/src/lib/notepad/close-coordinator.ts
new file mode 100644
index 00000000..08133046
--- /dev/null
+++ b/lib/src/lib/notepad/close-coordinator.ts
@@ -0,0 +1,169 @@
+// Every user-visible permanent Surface closure passes through here first: the
+// notes become one archive batch per Surface, all of them appended in a single
+// mutation, and only then does the caller tear the Surface down
+// (docs/specs/notepad.md → "Closure"). Separate from the store because the store
+// is synchronous state and this is the one place that awaits the host.
+import { hasTerminal } from 'dor/commands/types';
+import { getPlatformOrNull } from '../platform';
+import { settleAllWithin } from '../settle-within';
+import { processCwdMayReplace } from '../terminal-state';
+import { fillTerminalProcessCwd } from '../terminal-state-store';
+import { buildArchiveBatch } from './archive-model';
+import { hasNotepadArchive, mutateArchive } from './archive-service';
+import {
+  beginClosing,
+  getNotepadSurfaceMeta,
+  getNotes,
+  isEmptyPlainNote,
+  peekPendingBatchId,
+  pendingBatchId,
+  removeSurface,
+} from './notepad-store';
+import type { ArchiveBatch, LiveNote } from './types';
+
+/** How long a closure waits for the host to inspect a live PTY's working
+ *  directory. The answer is a fallback, so it must never hold a kill up: past
+ *  this the batch archives whatever the Session last reported. */
+export const PROCESS_CWD_REFRESH_MS = 1000;
+
+/**
+ * Ask the host where each closing terminal Session's process actually is,
+ * before its batch reads the metadata.
+ *
+ * A shell with no CWD escapes (no OSC 7, 9;9, 633 or 1337) never reports one,
+ * so its batch would archive `cwd: null` even though the PTY is alive right now
+ * and the host can inspect it — the same fallback the session-save path uses.
+ * Only the Surfaces whose answer could actually be used are asked: `getCwd` is a
+ * synchronous `lsof` on the PTY host's event loop, and an integration-reported
+ * CWD stands (`docs/specs/notepad.md` → "Closure"). Concurrent and bounded: a
+ * closure is a keystroke away from a kill, and this is metadata.
+ */
+async function refreshProcessCwds(surfaceIds: readonly string[]): Promise<void> {
+  const platform = getPlatformOrNull();
+  if (!platform) return;
+  const asking = surfaceIds.filter((surfaceId) => {
+    const meta = getNotepadSurfaceMeta(surfaceId);
+    return !!meta && hasTerminal(meta.surfaceKind) && processCwdMayReplace(meta.cwd?.source);
+  });
+  const paths = await settleAllWithin(
+    asking.map(async (surfaceId) => platform.getCwd(surfaceId)),
+    PROCESS_CWD_REFRESH_MS,
+    null,
+  );
+  asking.forEach((surfaceId, index) => fillTerminalProcessCwd(surfaceId, paths[index]));
+}
+
+export interface ArchiveSurfaceNotesOptions {
+  /** Aborted once the caller has stopped waiting for this archive (the
+   *  standalone quit gate's deadline). The mutation still finishes — it may
+   *  already be mid-flight — but the live notes are then left alone. */
+  signal?: AbortSignal;
+  /** The caller forgets the notes itself (`removeSurface`) once its own later
+   *  closure gates settle; until then they and their pending batch stay. */
+  retainNotes?: boolean;
+}
+
+/**
+ * Archive the notes of every Surface in `surfaceIds` and forget them.
+ *
+ * Resolves once the notes are safely stored (or there were none). Rejects with
+ * the archive service's user-presentable error when the write fails, leaving
+ * every note in place so the caller can offer Keep open / Close anyway rather
+ * than dropping them.
+ */
+export async function archiveSurfaceNotes(
+  surfaceIds: readonly string[],
+  options?: ArchiveSurfaceNotesOptions,
+): Promise<void> {
+  /** The forget step, where this call owns it. */
+  const forget = options?.retainNotes ? () => {} : removeSurface;
+  // No archive port means no notepad on this host at all, so there is nothing
+  // captured to lose and nowhere to write it — closure must not be blockable.
+  if (!hasNotepadArchive()) {
+    for (const surfaceId of surfaceIds) forget(surfaceId);
+    return;
+  }
+  // The freeze comes before the first `getNotes`, so the batches below and the
+  // notes the user can no longer touch are the same set: nothing taken during
+  // the write can be archived stale or dropped by the forget step
+  // (docs/specs/notepad.md → "Closure").
+  const release = beginClosing(surfaceIds);
+  try {
+    // Read once, under the freeze, before anything awaits: these notes cannot
+    // change again, and a Surface absent here is one with nothing to archive.
+    const archivableNotes = new Map<string, LiveNote[]>();
+    for (const surfaceId of surfaceIds) {
+      const notes = getNotes(surfaceId).filter((note) => !isEmptyPlainNote(note));
+      if (notes.length > 0) archivableNotes.set(surfaceId, notes);
+    }
+    // Before a single batch is built, so a Surface whose shell reports no CWD
+    // still archives where it was.
+    await refreshProcessCwds([...archivableNotes.keys()]);
+
+    const batches: ArchiveBatch[] = [];
+    /** Every archiving Surface's pending batch id — the one it appends under, or
+     *  the one an earlier attempt landed that it has nothing left to re-append
+     *  to. Deleting exactly these is a no-op on a first attempt and a wholesale
+     *  replacement on a retry. */
+    const deleteBatchIds: string[] = [];
+    const archiving: string[] = [];
+    // One closure, one instant: every batch this call appends closed together.
+    const closedAt = Date.now();
+
+    for (const surfaceId of surfaceIds) {
+      const notes = archivableNotes.get(surfaceId);
+      if (!notes) {
+        // Nothing to append. A remembered id means an earlier attempt landed a
+        // batch and *then* reported failure, and the user has since deleted
+        // every note it held — so the stored batch goes with them rather than
+        // outliving notes they were told were never archived
+        // (docs/specs/notepad.md → "Closure").
+        const landed = peekPendingBatchId(surfaceId);
+        if (!landed) {
+          // A Surface that never held a note closes without touching the archive.
+          forget(surfaceId);
+          continue;
+        }
+        deleteBatchIds.push(landed);
+        archiving.push(surfaceId);
+        continue;
+      }
+      // Read again here, after the refresh above moved it, and before teardown:
+      // the CWD in particular is only knowable while the Session is alive.
+      const meta = getNotepadSurfaceMeta(surfaceId);
+      // This Surface's remembered id, so a retry addresses the batch an earlier
+      // attempt may already have landed. `closedAt` is this attempt's own: the
+      // batch below is what closes, whenever that turns out to be.
+      const id = pendingBatchId(surfaceId);
+      deleteBatchIds.push(id);
+      batches.push(buildArchiveBatch({
+        id,
+        closedAt,
+        surfaceTitle: meta?.surfaceTitle ?? '',
+        surfaceKind: meta?.surfaceKind ?? 'terminal',
+        cwd: meta?.cwd ?? null,
+        notes,
+      }));
+      archiving.push(surfaceId);
+    }
+
+    if (deleteBatchIds.length === 0) return;
+    // One mutation for the whole closure, so a multi-Surface close (the
+    // standalone quit gate) is a single read-modify-write that either lands
+    // entirely or not at all. The edits, additions, and deletions made since a
+    // write that landed and then reported failure are all in the batch that
+    // survives — including the case where nothing is left to re-append and the
+    // delete stands alone (docs/specs/notepad.md → "Model").
+    await mutateArchive({ deleteBatchIds, append: batches });
+    // Aborted means the caller gave up waiting and told the user their notes
+    // were not stored — the quit was cancelled, the Surfaces are still on
+    // screen, and emptying them now would delete notes in front of someone who
+    // just said no. The batch is stored and its id stays remembered, so the next
+    // close replaces it rather than adding a second copy.
+    if (options?.signal?.aborted) return;
+    for (const surfaceId of archiving) forget(surfaceId);
+  } finally {
+    // Whether the write landed or rejected, the notepad is the user's again.
+    release();
+  }
+}
diff --git a/lib/src/lib/notepad/memory-archive-port.ts b/lib/src/lib/notepad/memory-archive-port.ts
new file mode 100644
index 00000000..fddf940f
--- /dev/null
+++ b/lib/src/lib/notepad/memory-archive-port.ts
@@ -0,0 +1,87 @@
+// The archive store as plain memory: the website demo's entire implementation,
+// the standalone browser-dev harness's stand-in for the Tauri file, and what
+// `FakePtyAdapter` hands tests and stories. It honors the same
+// compare-and-swap contract as the real hosts, so a conflict exercised here is
+// the same retry loop the file and `globalState` hosts drive
+// (docs/specs/notepad.md).
+import type {
+  NotepadArchiveLoadResult,
+  NotepadArchivePort,
+  NotepadArchiveV1,
+  VolatileNotepadSnapshot,
+} from './types';
+
+export interface MemoryNotepadArchivePort extends NotepadArchivePort {
+  /** Install stored data without going through `save` — the seam tests,
+   *  stories, and the dev harness use to start from a populated archive. */
+  seed(archive: NotepadArchiveV1): void;
+  /** Store something `readNotepadArchive` rejects, so the unreadable path can
+   *  be exercised without hand-writing a corrupt file. */
+  corrupt(raw?: unknown): void;
+  /** Copies moved aside by `resetUnreadable`, newest last. Nothing this port
+   *  holds is ever destroyed by recovery. */
+  unreadableCopies(): readonly unknown[];
+  /** The last mirror `syncVolatile` received; `null` until one arrives. */
+  lastVolatileSnapshot(): VolatileNotepadSnapshot | null;
+  /** Forget everything, including the set-aside copies (test teardown). */
+  clear(): void;
+}
+
+/** Stored data is JSON on every real host, so the memory port round-trips it
+ *  too: a caller that mutates the archive it saved must not reach back into
+ *  the store. */
+function clone<T>(value: T): T {
+  return JSON.parse(JSON.stringify(value)) as T;
+}
+
+export function createMemoryNotepadArchivePort(): MemoryNotepadArchivePort {
+  // `undefined` is "nothing has ever been archived" (a `null` load); any other
+  // value is stored bytes, valid or not — validation is the shared layer's job.
+  let stored: unknown | undefined;
+  let revision = 0;
+  const setAside: unknown[] = [];
+  let volatileSnapshot: VolatileNotepadSnapshot | null = null;
+
+  const revisionToken = (): string | null => (stored === undefined ? null : String(revision));
+
+  return {
+    async load(): Promise<NotepadArchiveLoadResult | null> {
+      const token = revisionToken();
+      return token === null ? null : { raw: stored, revision: token };
+    },
+    async save(archive: NotepadArchiveV1, baseRevision: string | null): Promise<'ok' | 'conflict'> {
+      if (baseRevision !== revisionToken()) return 'conflict';
+      stored = clone(archive);
+      revision += 1;
+      return 'ok';
+    },
+    async resetUnreadable(): Promise<void> {
+      if (stored !== undefined) setAside.push(stored);
+      stored = undefined;
+      revision += 1;
+    },
+    syncVolatile(snapshot: VolatileNotepadSnapshot): void {
+      volatileSnapshot = snapshot;
+    },
+    seed(archive: NotepadArchiveV1): void {
+      stored = clone(archive);
+      revision += 1;
+    },
+    corrupt(raw: unknown = '{ not an archive'): void {
+      stored = raw;
+      revision += 1;
+    },
+    unreadableCopies(): readonly unknown[] {
+      return setAside;
+    },
+    lastVolatileSnapshot(): VolatileNotepadSnapshot | null {
+      return volatileSnapshot;
+    },
+    clear(): void {
+      stored = undefined;
+      revision += 1;
+      setAside.length = 0;
+      volatileSnapshot = null;
+    },
+  };
+}
diff --git a/lib/src/lib/notepad/never-persisted.test.ts b/lib/src/lib/notepad/never-persisted.test.ts
new file mode 100644
index 00000000..bcfd2390
--- /dev/null
+++ b/lib/src/lib/notepad/never-persisted.test.ts
@@ -0,0 +1,86 @@
+/**
+ * @vitest-environment jsdom
+ *
+ * Live notes are absent from every existing session-persistence format
+ * (docs/specs/notepad.md). This is the guard for that rule rather than a test of
+ * any one module: it drives the real save path with notes on a pane and on a
+ * Door, and asserts the note text reaches none of the blobs — the persisted
+ * Session, the Lath layout inside it, the key/value round trip a host stores,
+ * or the standalone Window wrapper. The volatile mirror is the single exception,
+ * and it is host memory, never disk.
+ */
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { FakePtyAdapter, setPlatform } from '../platform';
+import { setWorkspacesEnabled } from '../feature-flags';
+import { saveSession } from '../session-save';
+import { readPersistedSession, type PersistedDoor } from '../session-types';
+import { saveSessionState, storedValueForSession } from '../window-persistence';
+import { addPlainNote, addTerminalNote, buildVolatileSnapshot, clearAllNotepads } from './notepad-store';
+
+/** Distinctive enough that a substring hit anywhere is a real leak. */
+const SECRET = 'AKIA-NOTE-SECRET-9f3';
+
+const DOOR: PersistedDoor = { id: 'door-b', title: 'zsh', component: 'terminal' };
+
+const LATH_LAYOUT = {
+  version: 1 as const,
+  tree: { root: { kind: 'leaf' as const, id: 'pane-a' } },
+  leafMeta: {
+    'pane-a': { component: 'terminal', tabComponent: 'terminal', title: 'Pane A' },
+    'door-b': { component: 'terminal', tabComponent: 'terminal', title: 'zsh' },
+  },
+};
+
+let adapter: FakePtyAdapter;
+
+beforeEach(() => {
+  clearAllNotepads();
+  adapter = new FakePtyAdapter();
+  setPlatform(adapter);
+});
+
+afterEach(() => {
+  clearAllNotepads();
+  setWorkspacesEnabled(false);
+});
+
+describe('live notes are never persisted', () => {
+  it('keeps note text out of every session blob a host stores', async () => {
+    addPlainNote('pane-a', SECRET);
+    addTerminalNote('pane-a', [{ text: `${SECRET} rich`, bold: true }]);
+    addPlainNote('door-b', `${SECRET} minimized`);
+
+    await saveSession(
+      adapter,
+      [{ id: 'pane-a', title: 'Pane A' }],
+      [DOOR],
+      LATH_LAYOUT,
+      { 'pane-a': 'surface:1', 'door-b': 'surface:2' },
+      3,
+    );
+
+    // The save really happened — otherwise "no note text" would be vacuous.
+    const saved = readPersistedSession(adapter.getState());
+    expect(saved?.panes.map((pane) => pane.id).sort()).toEqual(['door-b', 'pane-a']);
+    expect(JSON.stringify(saved)).not.toContain(SECRET);
+
+    // The key/value round trip below the save (localStorage, the Tauri-backed
+    // session store) carries only what the projection produced.
+    const store = new Map<string, string>();
+    const storage = {
+      getItem: (key: string) => store.get(key) ?? null,
+      setItem: (key: string, value: string) => void store.set(key, value),
+    };
+    saveSessionState(storage, 'dormouse.session', saved);
+    expect(store.get('dormouse.session')).not.toContain(SECRET);
+
+    // The standalone Window wrapper (workspaces flag on) re-nests the same
+    // Session, so it inherits the property rather than reintroducing notes.
+    setWorkspacesEnabled(true);
+    expect(JSON.stringify(storedValueForSession(null, saved))).not.toContain(SECRET);
+
+    // The one place the notes do live outside the store: host memory, cleared on
+    // restart and never written to disk.
+    expect(JSON.stringify(buildVolatileSnapshot())).toContain(SECRET);
+  });
+});
diff --git a/lib/src/lib/notepad/notepad-store.test.ts b/lib/src/lib/notepad/notepad-store.test.ts
new file mode 100644
index 00000000..fff3d784
--- /dev/null
+++ b/lib/src/lib/notepad/notepad-store.test.ts
@@ -0,0 +1,583 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import type { IMarker } from '@xterm/xterm';
+import { FakePtyAdapter, setPlatform } from '../platform';
+import type { CwdState } from '../terminal-state';
+import {
+  addPlainNote,
+  addTerminalNote,
+  beginClosing,
+  buildVolatileSnapshot,
+  clearAllNotepads,
+  deleteNote,
+  dropSource,
+  dropSourcesForTerminal,
+  getNotepadSnapshot,
+  getNotes,
+  getOpenNotepadId,
+  hydrateNotepadFromVolatile,
+  isSurfaceClosing,
+  noteCount,
+  pendingBatchId,
+  pruneEmptyNote,
+  removeSurface,
+  setNotepadSurfaceMetaResolver,
+  setNoteText,
+  setOpenNotepadId,
+  setStagedArchiveDeletions,
+  subscribeToClosing,
+  subscribeToNotepad,
+  subscribeToOpenNotepad,
+  transferNotepad,
+} from './notepad-store';
+import type { RuntimeTerminalSource } from './types';
+
+let adapter: FakePtyAdapter;
+
+/** One microtask tick — the volatile sync is coalesced onto the microtask
+ *  queue, so a test that asserts on it has to let that run. */
+const flush = (): Promise<void> => Promise.resolve();
+
+function marker(): IMarker & { dispose: ReturnType<typeof vi.fn> } {
+  return { id: 1, line: 3, isDisposed: false, dispose: vi.fn(), onDispose: vi.fn() } as unknown as IMarker & {
+    dispose: ReturnType<typeof vi.fn>;
+  };
+}
+
+function source(terminalId = 'term-1'): RuntimeTerminalSource {
+  return {
+    terminalId,
+    startMarker: marker(),
+    endMarker: marker(),
+    startColumn: 0,
+    endColumn: 12,
+    shape: 'linewise',
+    expectedRawText: 'error: boom',
+  };
+}
+
+beforeEach(async () => {
+  clearAllNotepads();
+  adapter = new FakePtyAdapter();
+  setPlatform(adapter);
+  await flush();
+});
+
+describe('notes', () => {
+  it('adds, edits, deletes, and keeps creation order', () => {
+    const first = addPlainNote('s1', 'one');
+    const second = addPlainNote('s1');
+    const third = addTerminalNote('s1', [{ text: 'boom', bold: true }]);
+    expect(getNotes('s1').map((n) => n.id)).toEqual([first, second, third]);
+    expect(noteCount('s1')).toBe(3);
+
+    setNoteText('s1', second, 'two');
+    expect(getNotes('s1')[1].content).toEqual({ kind: 'plain', text: 'two' });
+
+    deleteNote('s1', second);
+    expect(getNotes('s1').map((n) => n.id)).toEqual([first, third]);
+    expect(noteCount('s2')).toBe(0);
+    expect(getNotes('s2')).toEqual([]);
+  });
+
+  it('keeps Surfaces separate and forgets a Surface with no notes left', () => {
+    addPlainNote('s1', 'a');
+    const other = addPlainNote('s2', 'b');
+    expect(getNotepadSnapshot().size).toBe(2);
+    deleteNote('s2', other);
+    expect(getNotepadSnapshot().has('s2')).toBe(false);
+    expect(getNotes('s1')).toHaveLength(1);
+  });
+
+  it('notifies subscribers and hands out a stable snapshot between changes', () => {
+    const listener = vi.fn();
+    const unsubscribe = subscribeToNotepad(listener);
+    const before = getNotepadSnapshot();
+    expect(getNotepadSnapshot()).toBe(before);
+
+    addPlainNote('s1', 'a');
+    expect(listener).toHaveBeenCalledTimes(1);
+    const after = getNotepadSnapshot();
+    expect(after).not.toBe(before);
+    expect(getNotepadSnapshot()).toBe(after);
+
+    unsubscribe();
+    addPlainNote('s1', 'b');
+    expect(listener).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe('rich to plain conversion', () => {
+  it('converts only when the text actually changes', () => {
+    const id = addTerminalNote('s1', [{ text: 'boom', foreground: '#ff0000' }]);
+
+    // Reading, focusing, moving the caret: none of that reaches the store.
+    expect(getNotes('s1')[0].content).toEqual({ kind: 'terminal', runs: [{ text: 'boom', foreground: '#ff0000' }] });
+    expect(noteCount('s1')).toBe(1);
+
+    setNoteText('s1', id, 'boomm');
+    expect(getNotes('s1')[0].content).toEqual({ kind: 'plain', text: 'boomm' });
+  });
+
+  it('leaves a plain note alone when the text is unchanged', () => {
+    const id = addPlainNote('s1', 'same');
+    const before = getNotes('s1')[0];
+    setNoteText('s1', id, 'same');
+    expect(getNotes('s1')[0]).toBe(before);
+  });
+
+  it('keeps the source link across the conversion', () => {
+    const src = source();
+    const id = addTerminalNote('s1', [{ text: 'boom' }], src);
+    setNoteText('s1', id, 'edited');
+    expect(getNotes('s1')[0].source).toBe(src);
+    expect(src.startMarker.dispose).not.toHaveBeenCalled();
+  });
+
+  it('ignores an unknown Surface or note', () => {
+    setNoteText('nope', 'nope', 'x');
+    const id = addPlainNote('s1', 'a');
+    setNoteText('s1', 'other', 'x');
+    expect(getNotes('s1')[0].content).toEqual({ kind: 'plain', text: 'a' });
+    expect(id).toBeTruthy();
+  });
+});
+
+describe('pruneEmptyNote', () => {
+  it('removes an untouched empty plain note', () => {
+    const id = addPlainNote('s1');
+    expect(pruneEmptyNote('s1', id)).toBe(true);
+    expect(noteCount('s1')).toBe(0);
+  });
+
+  it('keeps a note with text and a rich note that was never edited', () => {
+    const typed = addPlainNote('s1', 'x');
+    const rich = addTerminalNote('s1', []);
+    expect(pruneEmptyNote('s1', typed)).toBe(false);
+    expect(pruneEmptyNote('s1', rich)).toBe(false);
+    expect(pruneEmptyNote('s1', 'gone')).toBe(false);
+    expect(noteCount('s1')).toBe(2);
+  });
+});
+
+describe('source links', () => {
+  it('dropSource disposes both markers and leaves the note', () => {
+    const src = source();
+    const id = addTerminalNote('s1', [{ text: 'boom' }], src);
+    dropSource('s1', id);
+    expect(src.startMarker.dispose).toHaveBeenCalledTimes(1);
+    expect(src.endMarker.dispose).toHaveBeenCalledTimes(1);
+    expect(getNotes('s1')).toHaveLength(1);
+    expect(getNotes('s1')[0].source).toBeUndefined();
+    // Idempotent: a second drop finds nothing to dispose.
+    dropSource('s1', id);
+    expect(src.startMarker.dispose).toHaveBeenCalledTimes(1);
+  });
+
+  it('dropSourcesForTerminal clears every pin into that terminal, across Surfaces', () => {
+    const doomed = source('term-1');
+    const alsoDoomed = source('term-1');
+    const survivor = source('term-2');
+    addTerminalNote('s1', [{ text: 'a' }], doomed);
+    addPlainNote('s1', 'typed');
+    addTerminalNote('s2', [{ text: 'b' }], alsoDoomed);
+    addTerminalNote('s2', [{ text: 'c' }], survivor);
+
+    const listener = vi.fn();
+    subscribeToNotepad(listener);
+    dropSourcesForTerminal('term-1');
+
+    expect(listener).toHaveBeenCalledTimes(1);
+    expect(doomed.startMarker.dispose).toHaveBeenCalled();
+    expect(alsoDoomed.endMarker.dispose).toHaveBeenCalled();
+    expect(survivor.startMarker.dispose).not.toHaveBeenCalled();
+    expect(getNotes('s1').map((n) => n.source)).toEqual([undefined, undefined]);
+    expect(getNotes('s2').map((n) => n.source)).toEqual([undefined, survivor]);
+
+    // Nothing left to drop: no second notification.
+    dropSourcesForTerminal('term-1');
+    expect(listener).toHaveBeenCalledTimes(1);
+  });
+
+  it('deleting a note disposes the markers it owned', () => {
+    const src = source();
+    const id = addTerminalNote('s1', [{ text: 'a' }], src);
+    deleteNote('s1', id);
+    expect(src.startMarker.dispose).toHaveBeenCalledTimes(1);
+    expect(src.endMarker.dispose).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe('surface lifecycle', () => {
+  it('transferNotepad moves the notes and drops pins into the replaced terminal', () => {
+    const oldPin = source('old');
+    const otherPin = source('other');
+    addTerminalNote('old', [{ text: 'a' }], oldPin);
+    addTerminalNote('old', [{ text: 'b' }], otherPin);
+    addPlainNote('old', 'typed');
+    setOpenNotepadId('old');
+
+    transferNotepad('old', 'new');
+
+    expect(getNotes('old')).toEqual([]);
+    expect(getNotes('new').map((n) => n.content)).toEqual([
+      { kind: 'terminal', runs: [{ text: 'a' }] },
+      { kind: 'terminal', runs: [{ text: 'b' }] },
+      { kind: 'plain', text: 'typed' },
+    ]);
+    expect(oldPin.startMarker.dispose).toHaveBeenCalled();
+    expect(getNotes('new')[0].source).toBeUndefined();
+    // A pin into some other terminal is still live; only the replaced one goes.
+    expect(getNotes('new')[1].source).toBe(otherPin);
+    expect(otherPin.startMarker.dispose).not.toHaveBeenCalled();
+    // The open panel follows the Surface to its new id.
+    expect(getOpenNotepadId()).toBe('new');
+  });
+
+  it('transferNotepad moves the open panel even when there are no notes to carry', () => {
+    // The old id stops existing either way, so an open panel left pointing at it
+    // would be stranded on a Surface that is gone.
+    setOpenNotepadId('old');
+
+    transferNotepad('old', 'new');
+
+    expect(getOpenNotepadId()).toBe('new');
+  });
+
+  it('transferNotepad is a no-op for an empty or self-referential move', () => {
+    const listener = vi.fn();
+    subscribeToNotepad(listener);
+    transferNotepad('empty', 'new');
+    addPlainNote('s1', 'a');
+    transferNotepad('s1', 's1');
+    expect(listener).toHaveBeenCalledTimes(1);
+    expect(getNotes('s1')).toHaveLength(1);
+  });
+
+  it('removeSurface forgets the notes, disposes markers, and closes its panel', () => {
+    const src = source();
+    addTerminalNote('s1', [{ text: 'a' }], src);
+    setOpenNotepadId('s1');
+    removeSurface('s1');
+    expect(src.startMarker.dispose).toHaveBeenCalledTimes(1);
+    expect(src.endMarker.dispose).toHaveBeenCalledTimes(1);
+    expect(getNotes('s1')).toEqual([]);
+    expect(getNotepadSnapshot().has('s1')).toBe(false);
+    expect(getOpenNotepadId()).toBeNull();
+  });
+});
+
+describe('pendingBatchId', () => {
+  it('is remembered per Surface until that Surface is removed', () => {
+    const id = pendingBatchId('s1');
+    expect(pendingBatchId('s1')).toBe(id);
+    expect(pendingBatchId('s2')).not.toBe(id);
+
+    // The closure landed, so the next one is a new batch rather than a
+    // replacement.
+    removeSurface('s1');
+    expect(pendingBatchId('s1')).not.toBe(id);
+  });
+
+  it('follows an in-place replacement to the new Surface id', () => {
+    const id = pendingBatchId('old');
+    addPlainNote('old', 'a');
+
+    transferNotepad('old', 'new');
+
+    // Whatever an earlier attempt landed is still addressable under the id the
+    // notes now live on.
+    expect(pendingBatchId('new')).toBe(id);
+    expect(pendingBatchId('old')).not.toBe(id);
+  });
+
+  it('follows a replacement that carries no notes at all', () => {
+    const id = pendingBatchId('old');
+    transferNotepad('old', 'new');
+    expect(pendingBatchId('new')).toBe(id);
+  });
+});
+
+describe('the closure freeze', () => {
+  it('refuses every content mutation until the release runs', () => {
+    const src = source('s1');
+    const kept = addPlainNote('s1', 'snapshotted')!;
+    const blank = addPlainNote('s1')!;
+    const pinned = addTerminalNote('s1', [{ text: 'boom' }], src)!;
+
+    const release = beginClosing(['s1']);
+    expect(isSurfaceClosing('s1')).toBe(true);
+
+    expect(addPlainNote('s1', 'nope')).toBeNull();
+    const refused = source('s1');
+    expect(addTerminalNote('s1', [{ text: 'nope' }], refused)).toBeNull();
+    // Nothing else can reach the markers of a note that was never added.
+    expect(refused.startMarker.dispose).toHaveBeenCalledTimes(1);
+    expect(refused.endMarker.dispose).toHaveBeenCalledTimes(1);
+    setNoteText('s1', kept, 'edited');
+    deleteNote('s1', kept);
+    // Even the blur prune stands down: the batch already holds this note.
+    expect(pruneEmptyNote('s1', blank)).toBe(false);
+    dropSource('s1', pinned);
+    transferNotepad('s1', 'new');
+
+    expect(getNotes('s1').map((n) => n.content)).toEqual([
+      { kind: 'plain', text: 'snapshotted' },
+      { kind: 'plain', text: '' },
+      { kind: 'terminal', runs: [{ text: 'boom' }] },
+    ]);
+    expect(getNotes('s1')[2].source).toBe(src);
+    expect(getNotes('new')).toEqual([]);
+
+    release();
+    expect(isSurfaceClosing('s1')).toBe(false);
+    setNoteText('s1', kept, 'edited');
+    expect(getNotes('s1')[0].content).toEqual({ kind: 'plain', text: 'edited' });
+  });
+
+  it('counts overlapping closures, and a double release thaws nothing extra', () => {
+    const first = beginClosing(['s1']);
+    const second = beginClosing(['s1']);
+
+    first();
+    first();
+    expect(isSurfaceClosing('s1')).toBe(true);
+
+    second();
+    expect(isSurfaceClosing('s1')).toBe(false);
+  });
+
+  it('lets the teardown paths through, and wakes the closing subscribers only', () => {
+    const src = source('term-1');
+    addTerminalNote('s1', [{ text: 'boom' }], src);
+    const listener = vi.fn();
+    const closingListener = vi.fn();
+    subscribeToNotepad(listener);
+    subscribeToClosing(closingListener);
+
+    // The freeze itself is a notification: the panel has to go read-only. Its
+    // own, though — no note moved, so no Door re-renders and no mirror is
+    // re-posted.
+    const release = beginClosing(['s1']);
+    expect(closingListener).toHaveBeenCalledTimes(1);
+    expect(listener).not.toHaveBeenCalled();
+
+    // The coordinator's own forget step, and the teardown paths that run
+    // whatever a closure is doing.
+    dropSourcesForTerminal('term-1');
+    expect(getNotes('s1')[0].source).toBeUndefined();
+    hydrateNotepadFromVolatile(
+      {
+        surfaces: [{ surfaceId: 's2', surfaceTitle: '', surfaceKind: 'terminal', cwd: null, notes: [{ id: 'n1', createdAt: 1, content: { kind: 'plain', text: 'live resume' } }] }],
+        stagedDeletions: {},
+      },
+      ['s2'],
+    );
+    expect(getNotes('s2')).toHaveLength(1);
+    removeSurface('s1');
+    expect(getNotes('s1')).toEqual([]);
+
+    release();
+    // Still frozen for nobody: clearAllNotepads forgets the map outright.
+    beginClosing(['s3']);
+    clearAllNotepads();
+    expect(isSurfaceClosing('s3')).toBe(false);
+  });
+});
+
+describe('open panel', () => {
+  it('holds one id at a time and notifies its own subscribers', () => {
+    const listener = vi.fn();
+    const unsubscribe = subscribeToOpenNotepad(listener);
+    expect(getOpenNotepadId()).toBeNull();
+
+    setOpenNotepadId('s1');
+    expect(getOpenNotepadId()).toBe('s1');
+    setOpenNotepadId('s1');
+    expect(listener).toHaveBeenCalledTimes(1);
+
+    setOpenNotepadId('s2');
+    expect(getOpenNotepadId()).toBe('s2');
+    setOpenNotepadId(null);
+    expect(listener).toHaveBeenCalledTimes(3);
+
+    unsubscribe();
+    setOpenNotepadId('s3');
+    expect(listener).toHaveBeenCalledTimes(3);
+  });
+
+  it('does not wake note subscribers', () => {
+    const listener = vi.fn();
+    subscribeToNotepad(listener);
+    setOpenNotepadId('s1');
+    expect(listener).not.toHaveBeenCalled();
+  });
+});
+
+const CWD: CwdState = {
+  path: '/srv/app',
+  pathKind: 'posix',
+  isRemote: false,
+  source: 'osc7',
+  updatedAt: 5,
+};
+
+describe('volatile mirror', () => {
+  it('mirrors every Surface holding notes, without markers, once per burst', async () => {
+    const sync = vi.spyOn(adapter.notepadArchive, 'syncVolatile');
+    setNotepadSurfaceMetaResolver((surfaceId) =>
+      surfaceId === 's1' ? { surfaceTitle: 'zsh', surfaceKind: 'terminal', cwd: CWD } : null,
+    );
+
+    const src = source();
+    addTerminalNote('s1', [{ text: 'boom', bold: true }], src);
+    addPlainNote('s1', 'typed');
+    addPlainNote('s2', 'elsewhere');
+    await flush();
+
+    // A burst of edits is one snapshot, not one per keystroke.
+    expect(sync).toHaveBeenCalledTimes(1);
+    const snapshot = adapter.notepadArchive.lastVolatileSnapshot()!;
+    expect(snapshot.surfaces).toEqual([
+      {
+        surfaceId: 's1',
+        surfaceTitle: 'zsh',
+        surfaceKind: 'terminal',
+        cwd: CWD,
+        // The Session id, so a VS Code teardown can ask this PTY where it is.
+        terminalId: 's1',
+        notes: [
+          { id: expect.any(String), createdAt: expect.any(Number), content: { kind: 'terminal', runs: [{ text: 'boom', bold: true }] } },
+          { id: expect.any(String), createdAt: expect.any(Number), content: { kind: 'plain', text: 'typed' } },
+        ],
+      },
+      {
+        // No resolver answer yet: empty metadata rather than a missing Surface.
+        surfaceId: 's2',
+        surfaceTitle: '',
+        surfaceKind: 'terminal',
+        cwd: null,
+        notes: [{ id: expect.any(String), createdAt: expect.any(Number), content: { kind: 'plain', text: 'elsewhere' } }],
+      },
+    ]);
+    expect(JSON.stringify(snapshot)).not.toContain('startMarker');
+  });
+
+  it('carries the PTY id for terminal Surfaces only, resolved to the Session', async () => {
+    setNotepadSurfaceMetaResolver((surfaceId) => ({
+      surfaceTitle: surfaceId,
+      surfaceKind: surfaceId === 's1' ? 'terminal' : 'browser',
+      cwd: null,
+    }));
+    addPlainNote('s1', 'a terminal');
+    addPlainNote('s2', 'a browser');
+    await flush();
+
+    const surfaces = adapter.notepadArchive.lastVolatileSnapshot()!.surfaces;
+    expect(surfaces.map((surface) => surface.terminalId)).toEqual(['s1', undefined]);
+    // Absent, not `undefined`: the mirror is round-tripped through the archive
+    // validator on the host, which rejects a field it does not know.
+    expect(Object.keys(surfaces[1])).not.toContain('terminalId');
+  });
+
+  it('carries staged archive deletions', async () => {
+    setStagedArchiveDeletions({ deleteBatchIds: ['b1'], deleteNotes: [{ batchId: 'b2', noteId: 'n7' }] });
+    addPlainNote('s1', 'a');
+    await flush();
+    expect(adapter.notepadArchive.lastVolatileSnapshot()!.stagedDeletions).toEqual({
+      deleteBatchIds: ['b1'],
+      deleteNotes: [{ batchId: 'b2', noteId: 'n7' }],
+    });
+  });
+
+  it('drops a Surface from the mirror once its last note goes', async () => {
+    const id = addPlainNote('s1', 'a');
+    await flush();
+    expect(adapter.notepadArchive.lastVolatileSnapshot()!.surfaces).toHaveLength(1);
+    deleteNote('s1', id);
+    await flush();
+    expect(adapter.notepadArchive.lastVolatileSnapshot()!.surfaces).toEqual([]);
+  });
+
+  it('keeps working on a host with no archive port at all', async () => {
+    const bare = new FakePtyAdapter();
+    delete (bare as { notepadArchive?: unknown }).notepadArchive;
+    setPlatform(bare);
+    addPlainNote('s1', 'a');
+    await expect(flush()).resolves.toBeUndefined();
+    expect(buildVolatileSnapshot().surfaces).toHaveLength(1);
+  });
+});
+
+describe('hydrateNotepadFromVolatile', () => {
+  it('restores only live Surfaces, and never over an existing notepad', () => {
+    addPlainNote('live-with-notes', 'already here');
+    hydrateNotepadFromVolatile(
+      {
+        surfaces: [
+          {
+            surfaceId: 'live',
+            surfaceTitle: 'zsh',
+            surfaceKind: 'terminal',
+            cwd: null,
+            notes: [{ id: 'n1', createdAt: 1, content: { kind: 'terminal', runs: [{ text: 'boom' }] } }],
+          },
+          {
+            surfaceId: 'dead',
+            surfaceTitle: 'gone',
+            surfaceKind: 'terminal',
+            cwd: null,
+            notes: [{ id: 'n2', createdAt: 2, content: { kind: 'plain', text: 'lost' } }],
+          },
+          {
+            surfaceId: 'live-with-notes',
+            surfaceTitle: 'zsh',
+            surfaceKind: 'terminal',
+            cwd: null,
+            notes: [{ id: 'n3', createdAt: 3, content: { kind: 'plain', text: 'stale' } }],
+          },
+        ],
+        stagedDeletions: {},
+      },
+      ['live', 'live-with-notes'],
+    );
+
+    expect(getNotes('live').map((n) => n.id)).toEqual(['n1']);
+    // Restored notes carry no source: the markers died with the old webview.
+    expect(getNotes('live')[0].source).toBeUndefined();
+    expect(getNotes('dead')).toEqual([]);
+    expect(getNotes('live-with-notes').map((n) => n.content)).toEqual([{ kind: 'plain', text: 'already here' }]);
+  });
+
+  it('does not notify when there is nothing to restore', () => {
+    const listener = vi.fn();
+    subscribeToNotepad(listener);
+    hydrateNotepadFromVolatile({ surfaces: [], stagedDeletions: {} }, ['live']);
+    hydrateNotepadFromVolatile(
+      {
+        surfaces: [{ surfaceId: 'live', surfaceTitle: '', surfaceKind: 'terminal', cwd: null, notes: [] }],
+        stagedDeletions: {},
+      },
+      ['live'],
+    );
+    expect(listener).not.toHaveBeenCalled();
+  });
+});
+
+it('mirrors and resumes a pending batch even after its last note is deleted', async () => {
+  const sync = vi.spyOn(adapter.notepadArchive, 'syncVolatile');
+  const noteId = addPlainNote('s1', 'original');
+  await flush();
+  sync.mockClear();
+  const batchId = pendingBatchId('s1');
+  await flush();
+  expect(sync).toHaveBeenCalledWith(expect.objectContaining({
+    surfaces: [expect.objectContaining({ pendingBatchId: batchId })],
+  }));
+  deleteNote('s1', noteId!);
+  const snapshot = buildVolatileSnapshot();
+  expect(snapshot.surfaces).toEqual([expect.objectContaining({ pendingBatchId: batchId, notes: [] })]);
+  clearAllNotepads();
+  hydrateNotepadFromVolatile(snapshot, ['s1']);
+  expect(pendingBatchId('s1')).toBe(batchId);
+  expect(buildVolatileSnapshot().surfaces[0].notes).toEqual([]);
+});
diff --git a/lib/src/lib/notepad/notepad-store.ts b/lib/src/lib/notepad/notepad-store.ts
new file mode 100644
index 00000000..40cfae43
--- /dev/null
+++ b/lib/src/lib/notepad/notepad-store.ts
@@ -0,0 +1,519 @@
+// The renderer's live notes, keyed by Surface id, with a
+// `useSyncExternalStore`-compatible subscription API. Notes live here and
+// nowhere else: they are never written to a session snapshot, Lath persistence,
+// `localStorage`, or webview state. The one mirror is `syncVolatile`, host
+// memory that exists so a VS Code webview re-resolved over live PTYs can get its
+// notes back (docs/specs/notepad.md).
+import { hasTerminal, type SurfaceKind } from 'dor/commands/types';
+import { getPlatformOrNull } from '../platform';
+import type { CwdState } from '../terminal-state';
+import { toArchivedNote } from './archive-model';
+import type {
+  LiveNote,
+  NotepadArchiveMutation,
+  NotepadArchivePort,
+  RichTextRun,
+  RuntimeTerminalSource,
+  VolatileNotepadSnapshot,
+  VolatileSurfaceNotes,
+} from './types';
+
+/** What the volatile mirror needs about a Surface that the notes themselves do
+ *  not carry. The Wall owns this; see `setNotepadSurfaceMetaResolver`. */
+export interface NotepadSurfaceMeta {
+  surfaceTitle: string;
+  surfaceKind: SurfaceKind;
+  cwd: CwdState | null;
+}
+
+export type NotepadSurfaceMetaResolver = (surfaceId: string) => NotepadSurfaceMeta | null;
+
+/** Shared identity for "this Surface has no notes", so `getNotes` stays stable
+ *  for the (common) empty case instead of handing React a new array each render. */
+const NO_NOTES: readonly LiveNote[] = Object.freeze([]);
+
+const notesBySurface = new Map<string, LiveNote[]>();
+const listeners = new Set<() => void>();
+let cachedSnapshot: Map<string, LiveNote[]> | null = null;
+
+/**
+ * Surfaces whose notes a closure has snapshotted and not yet finished writing
+ * (docs/specs/notepad.md → "Closure"). Counted, not flagged: two closures of one
+ * Surface can overlap, and the second finishing must not thaw the notes the
+ * first is still writing.
+ */
+const closingSurfaces = new Map<string, number>();
+
+/**
+ * The archive batch id each Surface's closure is using, remembered across that
+ * Surface's attempts and forgotten once one lands (docs/specs/notepad.md →
+ * "Model"). An attempt that reached the host and *then* reported failure has to
+ * be replaceable by the next one, which is only addressable by id.
+ */
+const pendingBatchIdBySurface = new Map<string, string>();
+
+/** The freeze's own listeners. It changes neither a note nor which panel is
+ *  open, so waking `listeners` for it would drop the snapshot, re-render every
+ *  Door, and post a volatile mirror that has not moved. */
+const closingListeners = new Set<() => void>();
+
+function notify(): void {
+  cachedSnapshot = null;
+  listeners.forEach((listener) => listener());
+  scheduleVolatileSync();
+}
+
+function notifyClosing(): void {
+  closingListeners.forEach((listener) => listener());
+}
+
+export function subscribeToNotepad(listener: () => void): () => void {
+  listeners.add(listener);
+  return () => {
+    listeners.delete(listener);
+  };
+}
+
+/** Subscribe to the freeze alone (`isSurfaceClosing`), which is what the panel's
+ *  read-only state reads. */
+export function subscribeToClosing(listener: () => void): () => void {
+  closingListeners.add(listener);
+  return () => {
+    closingListeners.delete(listener);
+  };
+}
+
+/** Stable snapshot reference (changes only on mutation) for `useSyncExternalStore`. */
+export function getNotepadSnapshot(): Map<string, LiveNote[]> {
+  if (cachedSnapshot) return cachedSnapshot;
+  cachedSnapshot = new Map(notesBySurface);
+  return cachedSnapshot;
+}
+
+export function getNotes(surfaceId: string): readonly LiveNote[] {
+  return notesBySurface.get(surfaceId) ?? NO_NOTES;
+}
+
+export function noteCount(surfaceId: string): number {
+  return notesBySurface.get(surfaceId)?.length ?? 0;
+}
+
+/** Whether a closure is holding this Surface's notes mid-write. Every content
+ *  mutation below refuses while it is true, and the panel goes read-only. */
+export function isSurfaceClosing(surfaceId: string): boolean {
+  return closingSurfaces.has(surfaceId);
+}
+
+/** The batch id this Surface's closure appends under, minted on the first
+ *  attempt and handed back unchanged to every retry, so a retry deletes and
+ *  re-appends the batch an earlier attempt may already have landed. */
+export function pendingBatchId(surfaceId: string): string {
+  const remembered = pendingBatchIdBySurface.get(surfaceId);
+  if (remembered) return remembered;
+  const minted = newNotepadId('batch');
+  pendingBatchIdBySurface.set(surfaceId, minted);
+  scheduleVolatileSync();
+  return minted;
+}
+
+/** The id this Surface's closure is already holding, or `undefined` — the
+ *  non-minting read. A closure with nothing left to append asks through here:
+ *  minting one there would append a batch id nobody ever stored. */
+export function peekPendingBatchId(surfaceId: string): string | undefined {
+  return pendingBatchIdBySurface.get(surfaceId);
+}
+
+/**
+ * Freeze these Surfaces' notes and hand back the release. The close coordinator
+ * calls this before it reads a single note, so the batches it builds and the
+ * notes nobody can touch are the same set; the release runs whether the write
+ * lands or rejects.
+ */
+export function beginClosing(surfaceIds: Iterable<string>): () => void {
+  const ids = [...surfaceIds];
+  for (const id of ids) closingSurfaces.set(id, (closingSurfaces.get(id) ?? 0) + 1);
+  if (ids.length > 0) notifyClosing();
+  let released = false;
+  return () => {
+    // Idempotent: a caller that releases twice must not thaw someone else's
+    // overlapping closure.
+    if (released) return;
+    released = true;
+    for (const id of ids) {
+      const remaining = (closingSurfaces.get(id) ?? 1) - 1;
+      if (remaining <= 0) closingSurfaces.delete(id);
+      else closingSurfaces.set(id, remaining);
+    }
+    if (ids.length > 0) notifyClosing();
+  };
+}
+
+let idCounter = 0;
+
+/** `crypto.randomUUID` everywhere it exists; the counter is for the odd
+ *  environment (an insecure origin, an older runtime) where it does not, since
+ *  a note or batch with no id cannot be addressed for edit, delete, or archive.
+ *  Shared with the close coordinator so notes and archive batches mint ids the
+ *  same way; `prefix` only labels the fallback form. */
+export function newNotepadId(prefix = 'note'): string {
+  const webCrypto = globalThis.crypto as Crypto | undefined;
+  if (webCrypto && typeof webCrypto.randomUUID === 'function') return webCrypto.randomUUID();
+  idCounter += 1;
+  return `${prefix}-${Date.now().toString(36)}-${idCounter.toString(36)}`;
+}
+
+function replaceNotes(surfaceId: string, next: LiveNote[]): void {
+  if (next.length === 0) notesBySurface.delete(surfaceId);
+  else notesBySurface.set(surfaceId, next);
+  notify();
+}
+
+function appendNote(surfaceId: string, note: LiveNote): string {
+  replaceNotes(surfaceId, [...(notesBySurface.get(surfaceId) ?? []), note]);
+  return note.id;
+}
+
+/** Add an empty (or pre-filled) plain note at the bottom. The panel focuses it;
+ *  an untouched one is removed again by `pruneEmptyNote`. `null` while the
+ *  Surface is closing — the note would be dropped unarchived, and the caller
+ *  must not go looking for it. */
+export function addPlainNote(surfaceId: string, text = ''): string | null {
+  if (isSurfaceClosing(surfaceId)) return null;
+  return appendNote(surfaceId, {
+    id: newNotepadId(),
+    createdAt: Date.now(),
+    content: { kind: 'plain', text },
+  });
+}
+
+/** Add a captured terminal selection. `source` is present only for
+ *  normal-buffer captures — it is what a pin resolves against. `null` while the
+ *  Surface is closing, the markers released here because no note will own them. */
+export function addTerminalNote(
+  surfaceId: string,
+  runs: RichTextRun[],
+  source?: RuntimeTerminalSource,
+): string | null {
+  if (isSurfaceClosing(surfaceId)) {
+    source?.startMarker.dispose();
+    source?.endMarker.dispose();
+    return null;
+  }
+  const note: LiveNote = {
+    id: newNotepadId(),
+    createdAt: Date.now(),
+    content: { kind: 'terminal', runs },
+  };
+  if (source) note.source = source;
+  return appendNote(surfaceId, note);
+}
+
+/**
+ * The one path that changes note text, and therefore the one place a rich note
+ * becomes plain. Conversion and the edit are a single transition: a caret moving
+ * through a rich note, or a read of its runs, changes nothing.
+ *
+ * The source link survives the conversion — it points at where the text came
+ * from, which an edit does not move.
+ */
+export function setNoteText(surfaceId: string, noteId: string, text: string): void {
+  // An edit landing mid-write would archive the pre-edit text and then be
+  // forgotten with the rest of the notepad.
+  if (isSurfaceClosing(surfaceId)) return;
+  const current = notesBySurface.get(surfaceId);
+  if (!current) return;
+  const index = current.findIndex((note) => note.id === noteId);
+  if (index === -1) return;
+  const note = current[index];
+  if (note.content.kind === 'plain' && note.content.text === text) return;
+  const next = current.slice();
+  next[index] = { ...note, content: { kind: 'plain', text } };
+  replaceNotes(surfaceId, next);
+}
+
+function disposeSource(note: LiveNote): void {
+  if (!note.source) return;
+  note.source.startMarker.dispose();
+  note.source.endMarker.dispose();
+}
+
+/** The note without its pin, markers released. The one shape of "this link can
+ *  never resolve again": a failed reveal, the terminal going away, and an
+ *  in-place replacement all end here. */
+function withoutSource(note: LiveNote): LiveNote {
+  disposeSource(note);
+  const { source: _dropped, ...rest } = note;
+  return rest;
+}
+
+export function deleteNote(surfaceId: string, noteId: string): void {
+  if (isSurfaceClosing(surfaceId)) return;
+  const current = notesBySurface.get(surfaceId);
+  if (!current) return;
+  const note = current.find((candidate) => candidate.id === noteId);
+  if (!note) return;
+  // The markers exist only to serve this note's pin; nothing else can reach
+  // them once it is gone.
+  disposeSource(note);
+  replaceNotes(
+    surfaceId,
+    current.filter((candidate) => candidate.id !== noteId),
+  );
+}
+
+/** An untouched Add New. Not a note the user wrote: it is pruned on blur, and a
+ *  closure never archives it — it would be a row nobody typed, and a Surface
+ *  holding only these closes as if it held none. */
+export function isEmptyPlainNote(note: LiveNote): boolean {
+  return note.content.kind === 'plain' && note.content.text === '';
+}
+
+/**
+ * Remove a note only if it is plain and empty — the blur/close rule for an
+ * Add New that was never typed into. A rich note or one with text is kept, so
+ * this is safe to call on every blur.
+ */
+export function pruneEmptyNote(surfaceId: string, noteId: string): boolean {
+  if (isSurfaceClosing(surfaceId)) return false;
+  const note = notesBySurface.get(surfaceId)?.find((candidate) => candidate.id === noteId);
+  if (!note) return false;
+  if (!isEmptyPlainNote(note)) return false;
+  deleteNote(surfaceId, noteId);
+  return true;
+}
+
+/** Drop one note's source link: the pin disappears, the note stays. Called when
+ *  a pin fails to resolve (disposed markers, trimmed scrollback, text mismatch). */
+export function dropSource(surfaceId: string, noteId: string): void {
+  if (isSurfaceClosing(surfaceId)) return;
+  const current = notesBySurface.get(surfaceId);
+  if (!current) return;
+  const index = current.findIndex((note) => note.id === noteId);
+  if (index === -1) return;
+  const note = current[index];
+  if (!note.source) return;
+  const next = current.slice();
+  next[index] = withoutSource(note);
+  replaceNotes(surfaceId, next);
+}
+
+/**
+ * Drop every pin pointing at a terminal that is being disposed, across all
+ * Surfaces. Markers belong to one xterm instance, so replacing or killing that
+ * instance invalidates them immediately; the notes themselves are untouched.
+ */
+export function dropSourcesForTerminal(terminalId: string): void {
+  let changed = false;
+  for (const [surfaceId, current] of notesBySurface) {
+    if (!current.some((note) => note.source?.terminalId === terminalId)) continue;
+    const next = current.map((note) => (
+      note.source?.terminalId === terminalId ? withoutSource(note) : note
+    ));
+    notesBySurface.set(surfaceId, next);
+    changed = true;
+  }
+  if (changed) notify();
+}
+
+/**
+ * Follow an in-place replacement (renderer swap, browser/terminal mode change,
+ * untouched-shell replace) to the new Surface id it mints. The notes move as
+ * they are; pins into the *old* terminal go, because that instance is being
+ * disposed as part of the replacement.
+ */
+export function transferNotepad(oldId: string, newId: string): void {
+  if (oldId === newId) return;
+  // Either end frozen means a closure is holding one of these notepads: moving
+  // notes out from under it would archive a batch for a Surface id that no
+  // longer owns them.
+  if (isSurfaceClosing(oldId) || isSurfaceClosing(newId)) return;
+  // Both before the empty-notepad early return: the old id stops existing either
+  // way, so an open panel pointing at it would be stranded on a Surface that is
+  // gone, and a pending batch id left behind could never be replaced.
+  if (openNotepadId === oldId) setOpenNotepadId(newId);
+  const pending = pendingBatchIdBySurface.get(oldId);
+  if (pending !== undefined) {
+    pendingBatchIdBySurface.set(newId, pending);
+    pendingBatchIdBySurface.delete(oldId);
+  }
+  const moving = notesBySurface.get(oldId);
+  if (!moving || moving.length === 0) return;
+  const carried = moving.map((note) => (
+    note.source?.terminalId === oldId ? withoutSource(note) : note
+  ));
+  notesBySurface.delete(oldId);
+  notesBySurface.set(newId, [...(notesBySurface.get(newId) ?? []), ...carried]);
+  notify();
+}
+
+/** Forget a Surface's notes (it closed; anything worth keeping was archived
+ *  before teardown). */
+export function removeSurface(surfaceId: string): void {
+  // The closure is over: whatever batch id it was holding has landed, and the
+  // next closure of this id is a new batch rather than a replacement.
+  pendingBatchIdBySurface.delete(surfaceId);
+  const current = notesBySurface.get(surfaceId);
+  if (!current) {
+    if (openNotepadId === surfaceId) setOpenNotepadId(null);
+    return;
+  }
+  current.forEach(disposeSource);
+  notesBySurface.delete(surfaceId);
+  if (openNotepadId === surfaceId) setOpenNotepadId(null);
+  notify();
+}
+
+/** Tests and Storybook: module state outlives components. */
+export function clearAllNotepads(): void {
+  for (const notes of notesBySurface.values()) notes.forEach(disposeSource);
+  notesBySurface.clear();
+  closingSurfaces.clear();
+  pendingBatchIdBySurface.clear();
+  metaResolver = null;
+  stagedDeletions = {};
+  setOpenNotepadId(null);
+  notify();
+  notifyClosing();
+}
+
+// --- Open panel ---
+//
+// Only one Surface notepad is open per Wall, so this is a single id rather than
+// per-Surface open state. Its own listener set: a note edit must not re-render
+// every header that only cares about which panel is open, and vice versa.
+
+let openNotepadId: string | null = null;
+const openListeners = new Set<() => void>();
+
+export function subscribeToOpenNotepad(listener: () => void): () => void {
+  openListeners.add(listener);
+  return () => {
+    openListeners.delete(listener);
+  };
+}
+
+export function getOpenNotepadId(): string | null {
+  return openNotepadId;
+}
+
+export function setOpenNotepadId(surfaceId: string | null): void {
+  if (openNotepadId === surfaceId) return;
+  openNotepadId = surfaceId;
+  openListeners.forEach((listener) => listener());
+}
+
+// --- Volatile mirror ---
+
+let metaResolver: NotepadSurfaceMetaResolver | null = null;
+let stagedDeletions: Pick<NotepadArchiveMutation, 'deleteBatchIds' | 'deleteNotes'> = {};
+
+/** The Wall installs this; until it does, the mirror carries empty metadata
+ *  rather than nothing, so notes still survive a live resume. */
+export function setNotepadSurfaceMetaResolver(resolver: NotepadSurfaceMetaResolver | null): void {
+  metaResolver = resolver;
+  scheduleVolatileSync();
+}
+
+/** One Surface's metadata as the Wall sees it right now, or `null` when no
+ *  resolver is installed. The volatile mirror and the close coordinator both
+ *  read through here, so a mirrored batch and an archived one describe the
+ *  Surface identically (docs/specs/notepad.md → "Closure"). */
+export function getNotepadSurfaceMeta(surfaceId: string): NotepadSurfaceMeta | null {
+  return metaResolver?.(surfaceId) ?? null;
+}
+
+/** Archive deletions staged in an open Archive view, mirrored so a host that
+ *  loses the webview can still commit them. */
+export function setStagedArchiveDeletions(
+  deletions: Pick<NotepadArchiveMutation, 'deleteBatchIds' | 'deleteNotes'>,
+): void {
+  stagedDeletions = deletions;
+  scheduleVolatileSync();
+}
+
+/** No platform installed yet simply means no mirror. */
+function archivePort(): NotepadArchivePort | undefined {
+  return getPlatformOrNull()?.notepadArchive;
+}
+
+/** Surfaces whose next closure must append notes or replace a possibly landed batch. */
+export function notepadSurfaceIds(): string[] {
+  return [...new Set([...notesBySurface.keys(), ...pendingBatchIdBySurface.keys()])];
+}
+
+/** Everything a close would archive for every Surface holding notes, minus the
+ *  markers (`toArchivedNote` strips them). */
+export function buildVolatileSnapshot(): VolatileNotepadSnapshot {
+  const surfaces: VolatileSurfaceNotes[] = [];
+  for (const surfaceId of notepadSurfaceIds()) {
+    const notes = getNotes(surfaceId);
+    const pendingBatchId = pendingBatchIdBySurface.get(surfaceId);
+    const meta = getNotepadSurfaceMeta(surfaceId);
+    surfaces.push({
+      surfaceId,
+      surfaceTitle: meta?.surfaceTitle ?? '',
+      surfaceKind: meta?.surfaceKind ?? 'terminal',
+      cwd: meta?.cwd ?? null,
+      // Only a terminal Surface has a PTY to ask about; its Surface id is
+      // also its PTY id, so the mirror carries it straight through
+      // (docs/specs/notepad.md → "VS Code lifecycle").
+      ...(meta && hasTerminal(meta.surfaceKind)
+        ? { terminalId: surfaceId }
+        : {}),
+      ...(pendingBatchId ? { pendingBatchId } : {}),
+      notes: notes.map(toArchivedNote),
+    });
+  }
+  return { surfaces, stagedDeletions };
+}
+
+let syncScheduled = false;
+
+/** One snapshot per burst: typing a line of text is one keystroke per change,
+ *  and the mirror only has to be right by the time control returns to the host. */
+function scheduleVolatileSync(): void {
+  if (syncScheduled) return;
+  syncScheduled = true;
+  queueMicrotask(() => {
+    syncScheduled = false;
+    const port = archivePort();
+    if (!port?.syncVolatile) return;
+    port.syncVolatile(buildVolatileSnapshot());
+  });
+}
+
+/**
+ * Restore mirrored notes on a live resume — a webview re-resolved over PTYs the
+ * host still owns. Only ids in `liveSurfaceIds` are restored, and only into
+ * Surfaces that have no notes yet, so this can never overwrite a live notepad
+ * or resurrect notes for a Surface that is gone. Sources are not restored: the
+ * markers died with the previous webview's xterm instances.
+ *
+ * `snapshot.stagedDeletions` is ignored by design. The disposal that produced
+ * this resume committed them, so nothing there is still pending; re-staging them
+ * would offer an Undo for deletions the archive has already taken
+ * (`takeStagedForRouter` in `vscode-ext/src/notepad-volatile.ts`).
+ */
+export function hydrateNotepadFromVolatile(
+  snapshot: VolatileNotepadSnapshot,
+  liveSurfaceIds: Iterable<string>,
+): void {
+  const live = new Set(liveSurfaceIds);
+  let changed = false;
+  for (const surface of snapshot.surfaces) {
+    if (!live.has(surface.surfaceId)) continue;
+    if ((notesBySurface.get(surface.surfaceId)?.length ?? 0) > 0) continue;
+    if (pendingBatchIdBySurface.has(surface.surfaceId)) continue;
+    if (surface.pendingBatchId) {
+      pendingBatchIdBySurface.set(surface.surfaceId, surface.pendingBatchId);
+      changed = true;
+    }
+    if (surface.notes.length === 0) continue;
+    notesBySurface.set(
+      surface.surfaceId,
+      surface.notes.map((note) => ({ id: note.id, createdAt: note.createdAt, content: note.content })),
+    );
+    changed = true;
+  }
+  if (changed) notify();
+}
diff --git a/lib/src/lib/notepad/pin.test.ts b/lib/src/lib/notepad/pin.test.ts
new file mode 100644
index 00000000..65cd20be
--- /dev/null
+++ b/lib/src/lib/notepad/pin.test.ts
@@ -0,0 +1,178 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import type { IMarker, Terminal } from '@xterm/xterm';
+
+const mocks = vi.hoisted(() => ({
+  getTerminalInstance: vi.fn<(id: string) => unknown>(),
+}));
+
+// Both `pin` and the `revealResolvedSource` it calls reach for the registry;
+// stub the barrel so neither boots xterm.
+vi.mock('../terminal-registry', () => ({ getTerminalInstance: mocks.getTerminalInstance }));
+
+import { __resetMouseSelectionForTests, getMouseSelectionState } from '../mouse-selection';
+import { FakePtyAdapter, setPlatform } from '../platform';
+import { addPlainNote, addTerminalNote, clearAllNotepads, getNotes } from './notepad-store';
+import { revealNoteSource } from './pin';
+import type { RuntimeTerminalSource } from './types';
+
+class FakeMarker {
+  isDisposed = false;
+  constructor(public line: number) {}
+  dispose(): void {
+    this.isDisposed = true;
+    this.line = -1;
+  }
+}
+
+const LINES = ['alpha one', 'bravo two', 'charlie three'];
+
+/** Satisfies both `resolveTerminalSource` (buffer reads) and
+ *  `revealResolvedSource` (viewport + scroll). */
+function makeTerminal(
+  lines: string[] = LINES,
+  opts: { viewportY?: number; baseY?: number; type?: 'normal' | 'alternate' } = {},
+) {
+  const cols = Math.max(1, ...lines.map((line) => line.length));
+  const scrollToLine = vi.fn<(line: number) => void>();
+  const terminal = {
+    cols,
+    rows: 24,
+    buffer: {
+      active: {
+        type: opts.type ?? ('normal' as const),
+        baseY: opts.baseY ?? 0,
+        viewportY: opts.viewportY ?? 0,
+        cursorY: 0,
+        length: lines.length,
+        getLine: (y: number) => (lines[y] === undefined ? undefined : {
+          translateToString: (_trim?: boolean, start = 0, end = cols) =>
+            lines[y].padEnd(cols, ' ').slice(start, end),
+        }),
+      },
+    },
+    scrollToLine,
+  };
+  return { terminal: terminal as unknown as Terminal, scrollToLine };
+}
+
+/** A pin over `alpha one\nbravo`, the text `LINES` reads back for rows 0..1. */
+function source(overrides: Partial<RuntimeTerminalSource> = {}): RuntimeTerminalSource {
+  return {
+    terminalId: 'term-1',
+    startMarker: new FakeMarker(0) as unknown as IMarker,
+    endMarker: new FakeMarker(1) as unknown as IMarker,
+    startColumn: 0,
+    endColumn: 4,
+    shape: 'linewise',
+    expectedRawText: 'alpha one\nbravo',
+    ...overrides,
+  };
+}
+
+/** The note whose pin every test below follows. */
+function pinnedNote(src = source()): { noteId: string; source: RuntimeTerminalSource } {
+  return { noteId: addTerminalNote('term-1', [{ text: 'alpha one\nbravo' }], src), source: src };
+}
+
+const markersOf = (src: RuntimeTerminalSource) =>
+  [src.startMarker, src.endMarker] as unknown as FakeMarker[];
+
+beforeEach(() => {
+  clearAllNotepads();
+  __resetMouseSelectionForTests();
+  mocks.getTerminalInstance.mockReset();
+  setPlatform(new FakePtyAdapter());
+});
+
+describe('revealNoteSource', () => {
+  it('reveals the range and keeps the pin', () => {
+    const { terminal, scrollToLine } = makeTerminal(LINES, { viewportY: 40, baseY: 40 });
+    mocks.getTerminalInstance.mockReturnValue(terminal);
+    const { noteId, source: src } = pinnedNote();
+
+    expect(revealNoteSource('term-1', noteId)).toEqual({ ok: true });
+    expect(scrollToLine).toHaveBeenCalledWith(0);
+    expect(getMouseSelectionState('term-1').selection).toMatchObject({
+      startRow: 0,
+      startCol: 0,
+      endRow: 1,
+      endCol: 4,
+      dragging: false,
+    });
+    expect(getNotes('term-1')[0].source).toBe(src);
+    expect(markersOf(src).every((marker) => !marker.isDisposed)).toBe(true);
+  });
+
+  it('reports a note that has no pin', () => {
+    const noteId = addPlainNote('term-1', 'typed by hand');
+    expect(revealNoteSource('term-1', noteId)).toEqual({ ok: false, reason: 'no-source', kept: false });
+  });
+
+  it('reports a note that is gone', () => {
+    expect(revealNoteSource('term-1', 'missing')).toEqual({ ok: false, reason: 'no-source', kept: false });
+  });
+
+  it('drops the pin when the terminal instance is gone', () => {
+    mocks.getTerminalInstance.mockReturnValue(null);
+    const { noteId, source: src } = pinnedNote();
+
+    expect(revealNoteSource('term-1', noteId)).toEqual({ ok: false, reason: 'no-terminal', kept: false });
+    expect(getNotes('term-1')[0].source).toBeUndefined();
+    // The markers belonged to that instance; dropping the pin releases them.
+    expect(markersOf(src).every((marker) => marker.isDisposed)).toBe(true);
+  });
+
+  it('drops the pin when the markers are disposed', () => {
+    mocks.getTerminalInstance.mockReturnValue(makeTerminal().terminal);
+    const src = source();
+    markersOf(src)[0].dispose();
+    const { noteId } = pinnedNote(src);
+
+    expect(revealNoteSource('term-1', noteId)).toEqual({ ok: false, reason: 'disposed', kept: false });
+    expect(getNotes('term-1')[0].source).toBeUndefined();
+  });
+
+  it('keeps the pin while a full-screen program owns the buffer', () => {
+    // The markers still name live normal-buffer rows; only the view is covered.
+    mocks.getTerminalInstance.mockReturnValue(makeTerminal(LINES, { type: 'alternate' }).terminal);
+    const { noteId, source: src } = pinnedNote();
+
+    expect(revealNoteSource('term-1', noteId)).toEqual({ ok: false, reason: 'alternate-buffer', kept: true });
+    expect(getNotes('term-1')[0].source).toBe(src);
+    expect(markersOf(src).every((marker) => !marker.isDisposed)).toBe(true);
+    expect(getMouseSelectionState('term-1').selection).toBeNull();
+  });
+
+  it('drops the pin when the rows are gone', () => {
+    mocks.getTerminalInstance.mockReturnValue(makeTerminal(['alpha one']).terminal);
+    const { noteId } = pinnedNote();
+
+    expect(revealNoteSource('term-1', noteId)).toEqual({ ok: false, reason: 'missing-rows', kept: false });
+    expect(getNotes('term-1')[0].source).toBeUndefined();
+  });
+
+  it('drops the pin when the rows read back differently', () => {
+    mocks.getTerminalInstance.mockReturnValue(
+      makeTerminal(['alpha one', 'BRAVO two', 'charlie three']).terminal,
+    );
+    const { noteId, source: src } = pinnedNote();
+
+    expect(revealNoteSource('term-1', noteId)).toEqual({ ok: false, reason: 'mismatch', kept: false });
+    expect(getNotes('term-1')[0].source).toBeUndefined();
+    expect(markersOf(src).every((marker) => marker.isDisposed)).toBe(true);
+    // The note itself survives every failure — only the link goes.
+    expect(getNotes('term-1')[0].content).toEqual({
+      kind: 'terminal',
+      runs: [{ text: 'alpha one\nbravo' }],
+    });
+  });
+
+  it('leaves the viewport alone when the range is already on screen', () => {
+    const { terminal, scrollToLine } = makeTerminal(LINES, { viewportY: 0, baseY: 10 });
+    mocks.getTerminalInstance.mockReturnValue(terminal);
+    const { noteId } = pinnedNote();
+
+    expect(revealNoteSource('term-1', noteId)).toEqual({ ok: true });
+    expect(scrollToLine).not.toHaveBeenCalled();
+  });
+});
diff --git a/lib/src/lib/notepad/pin.ts b/lib/src/lib/notepad/pin.ts
new file mode 100644
index 00000000..724fe941
--- /dev/null
+++ b/lib/src/lib/notepad/pin.ts
@@ -0,0 +1,65 @@
+// Following a note's source pin back to its scrollback (docs/specs/notepad.md
+// → Source links). Every failure but an active alternate buffer is terminal for
+// the pin: the markers are released and the link removed, so a pin the user can
+// see is one that resolved the last time it was asked — or one waiting for a
+// full-screen program to exit. The note itself is never touched.
+import { getTerminalInstance } from '../terminal-registry';
+import { dropSource, getNotes } from './notepad-store';
+import { resolveTerminalSource, revealResolvedSource } from './source-link';
+
+export type PinFailureReason =
+  | 'no-source'
+  | 'no-terminal'
+  | 'alternate-buffer'
+  | 'disposed'
+  | 'missing-rows'
+  | 'mismatch';
+
+export type PinOutcome =
+  | { ok: true }
+  | {
+      ok: false;
+      reason: PinFailureReason;
+      /** Whether the pin survived — true only for `alternate-buffer`, the one
+       *  failure that can resolve later. Everything downstream reads this
+       *  rather than the reason: dropping the source, and the notice a row
+       *  shows (`sourceNoticeFor` in `lib/src/components/NoteList.tsx`). */
+      kept: boolean;
+    };
+
+/** The single place a failure reason decides whether the pin lives. */
+function failed(reason: PinFailureReason): Extract<PinOutcome, { ok: false }> {
+  return { ok: false, reason, kept: reason === 'alternate-buffer' };
+}
+
+/** Resolve the note's pin against the live buffer; on success scroll the range
+ *  into view and restore the Dormouse selection (outline + finalized popup).
+ *  On failure the reason is returned, and the pin removed from the note unless
+ *  it can still resolve later. */
+export function revealNoteSource(surfaceId: string, noteId: string): PinOutcome {
+  // A missing note reads the same as a note without a pin: there is nothing to
+  // follow and nothing to clean up.
+  const source = getNotes(surfaceId).find((note) => note.id === noteId)?.source;
+  if (!source) return failed('no-source');
+
+  const terminal = getTerminalInstance(source.terminalId);
+  if (!terminal) {
+    // The instance the markers belong to is gone, so they can never resolve
+    // again — `dropSource` disposes them on the way out.
+    dropSource(surfaceId, noteId);
+    return failed('no-terminal');
+  }
+
+  const resolved = resolveTerminalSource(terminal, source);
+  if (!resolved.ok) {
+    const outcome = failed(resolved.reason);
+    // A full-screen program only covers the normal buffer the markers ride, so
+    // that pin is temporarily unavailable rather than dead: keep it and let the
+    // user try again once the program exits.
+    if (!outcome.kept) dropSource(surfaceId, noteId);
+    return outcome;
+  }
+
+  revealResolvedSource(source.terminalId, resolved.selection);
+  return { ok: true };
+}
diff --git a/lib/src/lib/notepad/rich-clipboard.test.ts b/lib/src/lib/notepad/rich-clipboard.test.ts
new file mode 100644
index 00000000..920fe4bd
--- /dev/null
+++ b/lib/src/lib/notepad/rich-clipboard.test.ts
@@ -0,0 +1,144 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import type { NoteContent } from './types';
+import { copyNoteToClipboard, noteToHtml, noteToPlainText } from './rich-clipboard';
+
+class FakeClipboardItem {
+  constructor(readonly data: Record<string, Blob>) {}
+}
+
+const write = vi.fn<(items: unknown[]) => Promise<void>>();
+const writeText = vi.fn<(text: string) => Promise<void>>();
+
+/** The one ClipboardItem the last `write` call carried. */
+function writtenItem(): FakeClipboardItem {
+  expect(write).toHaveBeenCalledTimes(1);
+  const [items] = write.mock.calls[0];
+  expect(items).toHaveLength(1);
+  return items[0] as FakeClipboardItem;
+}
+
+const RICH: NoteContent = {
+  kind: 'terminal',
+  runs: [
+    { text: 'error: ', bold: true, foreground: '#ff0000' },
+    { text: '<a & b>' },
+  ],
+};
+
+beforeEach(() => {
+  write.mockReset().mockResolvedValue(undefined);
+  writeText.mockReset().mockResolvedValue(undefined);
+  vi.stubGlobal('ClipboardItem', FakeClipboardItem);
+  vi.stubGlobal('navigator', { clipboard: { write, writeText } });
+});
+
+afterEach(() => {
+  vi.unstubAllGlobals();
+});
+
+describe('noteToPlainText', () => {
+  it('returns a plain note verbatim', () => {
+    expect(noteToPlainText({ kind: 'plain', text: 'a\nb' })).toBe('a\nb');
+  });
+
+  it('concatenates the runs of a terminal note', () => {
+    expect(noteToPlainText(RICH)).toBe('error: <a & b>');
+  });
+});
+
+describe('noteToHtml', () => {
+  it('wraps everything in a whitespace-preserving container', () => {
+    expect(noteToHtml({ kind: 'plain', text: 'x  y\nz' }))
+      .toBe('<pre style="white-space:pre-wrap">x  y\nz</pre>');
+  });
+
+  it('escapes the four dangerous characters in every chunk', () => {
+    const content: NoteContent = {
+      kind: 'terminal',
+      runs: [{ text: '<script>' }, { text: ' & "quoted"', bold: true }],
+    };
+    expect(noteToHtml(content)).toBe(
+      '<pre style="white-space:pre-wrap">&lt;script&gt;'
+      + '<span style="font-weight:bold"> &amp; &quot;quoted&quot;</span></pre>',
+    );
+  });
+
+  it('escapes an ampersand once, not twice', () => {
+    expect(noteToHtml({ kind: 'plain', text: '&lt;' }))
+      .toBe('<pre style="white-space:pre-wrap">&amp;lt;</pre>');
+  });
+
+  it('emits only the four supported attributes, in a fixed order', () => {
+    const content: NoteContent = {
+      kind: 'terminal',
+      runs: [{ text: 'x', bold: true, italic: true, foreground: '#0dbc79', background: '#1e1e1e' }],
+    };
+    expect(noteToHtml(content)).toBe(
+      '<pre style="white-space:pre-wrap"><span style="font-weight:bold;font-style:italic;'
+      + 'color:#0dbc79;background-color:#1e1e1e">x</span></pre>',
+    );
+  });
+
+  it('leaves an unstyled run as bare escaped text', () => {
+    expect(noteToHtml({ kind: 'terminal', runs: [{ text: 'plain' }] }))
+      .toBe('<pre style="white-space:pre-wrap">plain</pre>');
+  });
+
+  it.each([
+    'red',
+    '#FF0000',
+    '#f00',
+    '#ff000',
+    'rgb(255,0,0)',
+    '#ff0000; --evil: 1',
+    'url(javascript:alert(1))',
+  ])('drops a color that is not exactly #rrggbb (%s)', (color) => {
+    const html = noteToHtml({ kind: 'terminal', runs: [{ text: 'x', foreground: color }] });
+    expect(html).toBe('<pre style="white-space:pre-wrap">x</pre>');
+  });
+});
+
+describe('copyNoteToClipboard', () => {
+  it('writes both flavors for a terminal note', async () => {
+    await copyNoteToClipboard(RICH);
+
+    const item = writtenItem();
+    expect(Object.keys(item.data)).toEqual(['text/plain', 'text/html']);
+    await expect(item.data['text/plain'].text()).resolves.toBe('error: <a & b>');
+    await expect(item.data['text/html'].text()).resolves.toBe(noteToHtml(RICH));
+    expect(item.data['text/html'].type).toBe('text/html');
+    expect(writeText).not.toHaveBeenCalled();
+  });
+
+  it('writes plain text only for a plain note', async () => {
+    await copyNoteToClipboard({ kind: 'plain', text: 'just words' });
+    expect(write).not.toHaveBeenCalled();
+    expect(writeText).toHaveBeenCalledWith('just words');
+  });
+
+  it('falls back to plain text when ClipboardItem is unavailable', async () => {
+    vi.stubGlobal('ClipboardItem', undefined);
+    await copyNoteToClipboard(RICH);
+    expect(write).not.toHaveBeenCalled();
+    expect(writeText).toHaveBeenCalledWith('error: <a & b>');
+  });
+
+  it('falls back to plain text when the clipboard has no write()', async () => {
+    vi.stubGlobal('navigator', { clipboard: { writeText } });
+    await copyNoteToClipboard(RICH);
+    expect(writeText).toHaveBeenCalledWith('error: <a & b>');
+  });
+
+  it('falls back to plain text when the rich write is rejected', async () => {
+    write.mockRejectedValue(new Error('not allowed'));
+    await copyNoteToClipboard(RICH);
+    expect(write).toHaveBeenCalledTimes(1);
+    expect(writeText).toHaveBeenCalledWith('error: <a & b>');
+  });
+
+  it('swallows a failing fallback rather than throwing at the caller', async () => {
+    vi.stubGlobal('ClipboardItem', undefined);
+    writeText.mockRejectedValue(new Error('document not focused'));
+    await expect(copyNoteToClipboard(RICH)).resolves.toBeUndefined();
+  });
+});
diff --git a/lib/src/lib/notepad/rich-clipboard.ts b/lib/src/lib/notepad/rich-clipboard.ts
new file mode 100644
index 00000000..e8a4f697
--- /dev/null
+++ b/lib/src/lib/notepad/rich-clipboard.ts
@@ -0,0 +1,78 @@
+// Exporting a note to the system clipboard (docs/specs/notepad.md). The HTML
+// flavor is generated here rather than by serializing rendered DOM, so the only
+// thing that can reach the clipboard is escaped text plus the four attributes
+// `RichTextRun` carries.
+import { writeTextToClipboard } from '../clipboard';
+import type { NoteContent, RichTextRun } from './types';
+
+/** The archive is a file on disk a user can edit, so a color is re-checked on
+ *  the way out and dropped unless it is exactly a normalized `#rrggbb`. */
+const HEX_COLOR = /^#[0-9a-f]{6}$/;
+
+export function noteToPlainText(content: NoteContent): string {
+  if (content.kind === 'plain') return content.text;
+  return content.runs.map((run) => run.text).join('');
+}
+
+function escapeHtml(text: string): string {
+  return text
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;');
+}
+
+function runStyle(run: RichTextRun): string {
+  const parts: string[] = [];
+  if (run.bold) parts.push('font-weight:bold');
+  if (run.italic) parts.push('font-style:italic');
+  if (run.foreground && HEX_COLOR.test(run.foreground)) parts.push(`color:${run.foreground}`);
+  if (run.background && HEX_COLOR.test(run.background)) parts.push(`background-color:${run.background}`);
+  return parts.join(';');
+}
+
+/**
+ * The `text/html` flavor: a whitespace-preserving container of escaped spans.
+ * `pre-wrap` rather than `pre` because the receiving editor decides the width —
+ * a captured excerpt should reflow there, not run off the page.
+ */
+export function noteToHtml(content: NoteContent): string {
+  const body = content.kind === 'plain'
+    ? escapeHtml(content.text)
+    : content.runs.map((run) => {
+      const text = escapeHtml(run.text);
+      const style = runStyle(run);
+      return style ? `<span style="${style}">${text}</span>` : text;
+    }).join('');
+  return `<pre style="white-space:pre-wrap">${body}</pre>`;
+}
+
+function canWriteRichClipboard(): boolean {
+  return typeof ClipboardItem !== 'undefined'
+    && typeof navigator !== 'undefined'
+    && typeof navigator.clipboard?.write === 'function';
+}
+
+/**
+ * Copy a note. `text/plain` is always written; a terminal note adds `text/html`
+ * so the styling survives into a rich destination. Anything the async clipboard
+ * refuses — no `ClipboardItem`, a webview without focus, a permission denial —
+ * falls back to the plain-text write, which is best effort by contract.
+ */
+export async function copyNoteToClipboard(content: NoteContent): Promise<void> {
+  const text = noteToPlainText(content);
+  if (content.kind === 'terminal' && canWriteRichClipboard()) {
+    try {
+      await navigator.clipboard.write([
+        new ClipboardItem({
+          'text/plain': new Blob([text], { type: 'text/plain' }),
+          'text/html': new Blob([noteToHtml(content)], { type: 'text/html' }),
+        }),
+      ]);
+      return;
+    } catch {
+      // Fall through to the plain-text write below.
+    }
+  }
+  await writeTextToClipboard(text);
+}
diff --git a/lib/src/lib/notepad/rich-extract.test.ts b/lib/src/lib/notepad/rich-extract.test.ts
new file mode 100644
index 00000000..9c78326e
--- /dev/null
+++ b/lib/src/lib/notepad/rich-extract.test.ts
@@ -0,0 +1,423 @@
+import { describe, expect, it } from 'vitest';
+import type { Terminal } from '@xterm/xterm';
+import type { Selection } from '../mouse-selection';
+import { extractSelectionText } from '../selection-text';
+import { extractRichRuns, type CellLike, type TerminalLike, type TerminalPalette } from './rich-extract';
+
+const THEME: TerminalPalette = {
+  foreground: '#cccccc',
+  background: '#1e1e1e',
+  black: '#000000',
+  red: '#cd3131',
+  green: '#0dbc79',
+  yellow: '#e5e510',
+  blue: '#2472c8',
+  magenta: '#bc3fbc',
+  cyan: '#11a8cd',
+  white: '#e5e5e5',
+  brightBlack: '#666666',
+  brightRed: '#f14c4c',
+  brightGreen: '#23d18b',
+  brightYellow: '#f5f543',
+  brightBlue: '#3b8eea',
+  brightMagenta: '#d670d6',
+  brightCyan: '#29b8db',
+  brightWhite: '#ffffff',
+};
+
+type Color = { palette: number } | { rgb: number };
+
+interface Attrs {
+  bold?: boolean;
+  italic?: boolean;
+  inverse?: boolean;
+  fg?: Color;
+  bg?: Color;
+  /** Cell width; 2 marks a wide character, whose continuation cell is added automatically. */
+  width?: number;
+}
+
+function makeCell(chars: string, attrs: Attrs = {}, width = attrs.width ?? 1): CellLike {
+  const { fg, bg } = attrs;
+  return {
+    getChars: () => chars,
+    getWidth: () => width,
+    isBold: () => (attrs.bold ? 1 : 0),
+    isItalic: () => (attrs.italic ? 1 : 0),
+    isInverse: () => (attrs.inverse ? 1 : 0),
+    isFgDefault: () => fg === undefined,
+    isFgPalette: () => !!fg && 'palette' in fg,
+    isFgRGB: () => !!fg && 'rgb' in fg,
+    getFgColor: () => (fg ? ('palette' in fg ? fg.palette : fg.rgb) : 0),
+    isBgDefault: () => bg === undefined,
+    isBgPalette: () => !!bg && 'palette' in bg,
+    isBgRGB: () => !!bg && 'rgb' in bg,
+    getBgColor: () => (bg ? ('palette' in bg ? bg.palette : bg.rgb) : 0),
+  };
+}
+
+/** One cell per character of `text`, all sharing `attrs`. */
+function styled(text: string, attrs: Attrs = {}): CellLike[] {
+  const cells: CellLike[] = [];
+  for (const ch of text) {
+    cells.push(makeCell(ch, attrs, attrs.width ?? 1));
+    // xterm follows a width-2 cell with a width-0 continuation carrying no chars.
+    if (attrs.width === 2) cells.push(makeCell('', attrs, 0));
+  }
+  return cells;
+}
+
+interface RowSpec {
+  cells: CellLike[];
+  wrapped?: boolean;
+}
+
+function row(cells: CellLike[], wrapped = false): RowSpec {
+  return { cells, wrapped };
+}
+
+/** A terminal whose `translateToString` is derived from the same cells the rich
+ *  walk reads, so `rawText` and the runs cannot disagree for spurious reasons. */
+function makeTerminal(rows: RowSpec[], cols: number): TerminalLike {
+  const lines = rows.map((spec) => {
+    // xterm allocates every line to `cols`; the tail is unwritten cells.
+    const cells = spec.cells.slice(0, cols);
+    while (cells.length < cols) cells.push(makeCell('', {}));
+    return {
+      isWrapped: spec.wrapped ?? false,
+      length: cells.length,
+      getCell: (x: number) => cells[x],
+      translateToString: (_trimRight?: boolean, start = 0, end = cells.length) => {
+        let out = '';
+        for (let x = Math.max(0, start); x < Math.min(end, cells.length); x += 1) {
+          const cell = cells[x];
+          if (cell.getWidth() === 0) continue;
+          const chars = cell.getChars();
+          out += chars === '' ? ' ' : chars;
+        }
+        return out;
+      },
+    };
+  });
+  return { cols, buffer: { active: { getLine: (y: number) => lines[y] } } };
+}
+
+function sel(overrides: Partial<Selection>): Selection {
+  return {
+    startRow: 0,
+    startCol: 0,
+    endRow: 0,
+    endCol: 0,
+    shape: 'linewise',
+    dragging: false,
+    startedInScrollback: false,
+    ...overrides,
+  };
+}
+
+/** Whole first row of a one-row terminal sized to the content. */
+function wholeRow(cells: CellLike[]): { terminal: TerminalLike; selection: Selection } {
+  const cols = cells.length;
+  return {
+    terminal: makeTerminal([row(cells)], cols),
+    selection: sel({ endCol: cols - 1 }),
+  };
+}
+
+describe('extractRichRuns styling', () => {
+  it('emits one unstyled run for plain text', () => {
+    const { terminal, selection } = wholeRow(styled('hello'));
+    expect(extractRichRuns(terminal, selection, THEME).runs).toEqual([{ text: 'hello' }]);
+  });
+
+  it('carries bold and italic', () => {
+    const { terminal, selection } = wholeRow([
+      ...styled('bo', { bold: true }),
+      ...styled('it', { italic: true }),
+      ...styled('bi', { bold: true, italic: true }),
+    ]);
+    expect(extractRichRuns(terminal, selection, THEME).runs).toEqual([
+      { text: 'bo', bold: true },
+      { text: 'it', italic: true },
+      { text: 'bi', bold: true, italic: true },
+    ]);
+  });
+
+  it('resolves palette 0-15 through the theme, foreground and background', () => {
+    const { terminal, selection } = wholeRow(
+      styled('warn', { fg: { palette: 1 }, bg: { palette: 4 } }),
+    );
+    expect(extractRichRuns(terminal, selection, THEME).runs).toEqual([
+      { text: 'warn', foreground: '#cd3131', background: '#2472c8' },
+    ]);
+  });
+
+  it('unpacks 24-bit RGB colors', () => {
+    const { terminal, selection } = wholeRow(
+      styled('rgb', { fg: { rgb: 0x1234ab }, bg: { rgb: 0x00ff00 } }),
+    );
+    expect(extractRichRuns(terminal, selection, THEME).runs).toEqual([
+      { text: 'rgb', foreground: '#1234ab', background: '#00ff00' },
+    ]);
+  });
+
+  it('computes the 256-color cube and gray ramp', () => {
+    const { terminal, selection } = wholeRow([
+      ...styled('a', { fg: { palette: 196 } }),
+      ...styled('b', { fg: { palette: 232 } }),
+      ...styled('c', { fg: { palette: 255 } }),
+      ...styled('d', { fg: { palette: 16 } }),
+      ...styled('e', { fg: { palette: 231 } }),
+      ...styled('f', { fg: { palette: 33 } }),
+    ]);
+    expect(extractRichRuns(terminal, selection, THEME).runs).toEqual([
+      { text: 'a', foreground: '#ff0000' },
+      { text: 'b', foreground: '#080808' },
+      { text: 'c', foreground: '#eeeeee' },
+      { text: 'd', foreground: '#000000' },
+      { text: 'e', foreground: '#ffffff' },
+      { text: 'f', foreground: '#0087ff' },
+    ]);
+  });
+
+  it('omits defaulted colors entirely', () => {
+    const { terminal, selection } = wholeRow(styled('x', { bold: true }));
+    const [run] = extractRichRuns(terminal, selection, THEME).runs;
+    expect(run).toEqual({ text: 'x', bold: true });
+    expect('foreground' in run).toBe(false);
+    expect('background' in run).toBe(false);
+  });
+
+  it('swaps explicit colors on an inverse cell', () => {
+    const { terminal, selection } = wholeRow(
+      styled('inv', { inverse: true, fg: { palette: 2 }, bg: { rgb: 0x112233 } }),
+    );
+    expect(extractRichRuns(terminal, selection, THEME).runs).toEqual([
+      { text: 'inv', foreground: '#112233', background: '#0dbc79' },
+    ]);
+  });
+
+  it('makes the theme defaults explicit on an inverse cell that had none', () => {
+    const { terminal, selection } = wholeRow(styled('inv', { inverse: true }));
+    expect(extractRichRuns(terminal, selection, THEME).runs).toEqual([
+      { text: 'inv', foreground: THEME.background, background: THEME.foreground },
+    ]);
+  });
+
+  it('normalizes theme colors that are not already #rrggbb', () => {
+    const loose: TerminalPalette = { ...THEME, red: 'rgb(255, 0, 8)', background: '#ABC' };
+    const { terminal, selection } = wholeRow([
+      ...styled('r', { fg: { palette: 1 } }),
+      ...styled('i', { inverse: true }),
+    ]);
+    expect(extractRichRuns(terminal, selection, loose).runs).toEqual([
+      { text: 'r', foreground: '#ff0008' },
+      { text: 'i', foreground: '#aabbcc', background: '#cccccc' },
+    ]);
+  });
+
+  it('drops a color the theme cannot supply', () => {
+    const broken: TerminalPalette = { ...THEME, cyan: 'var(--nope)' };
+    const { terminal, selection } = wholeRow(styled('c', { fg: { palette: 6 } }));
+    expect(extractRichRuns(terminal, selection, broken).runs).toEqual([{ text: 'c' }]);
+  });
+});
+
+describe('extractRichRuns bold-in-bright mapping', () => {
+  const { terminal, selection } = wholeRow(styled('hot', { bold: true, fg: { palette: 1 } }));
+
+  it('promotes palette 0-7 to the bright half by default', () => {
+    expect(extractRichRuns(terminal, selection, THEME).runs).toEqual([
+      { text: 'hot', bold: true, foreground: '#f14c4c' },
+    ]);
+  });
+
+  it('leaves the palette alone when the terminal has the option off', () => {
+    const opts = { drawBoldTextInBrightColors: false };
+    expect(extractRichRuns(terminal, selection, THEME, opts).runs).toEqual([
+      { text: 'hot', bold: true, foreground: '#cd3131' },
+    ]);
+  });
+
+  it('never promotes a bright entry, a 256-color entry, or a background', () => {
+    const wide = wholeRow([
+      ...styled('a', { bold: true, fg: { palette: 9 } }),
+      ...styled('b', { bold: true, fg: { palette: 196 } }),
+      ...styled('c', { bold: true, bg: { palette: 1 } }),
+    ]);
+    expect(extractRichRuns(wide.terminal, wide.selection, THEME).runs).toEqual([
+      { text: 'a', bold: true, foreground: '#f14c4c' },
+      { text: 'b', bold: true, foreground: '#ff0000' },
+      { text: 'c', bold: true, background: '#cd3131' },
+    ]);
+  });
+});
+
+describe('extractRichRuns cell walking', () => {
+  it('includes a wide character once, with its own styling', () => {
+    const { terminal, selection } = wholeRow([
+      ...styled('a'),
+      ...styled('日本', { width: 2, bold: true }),
+      ...styled('b'),
+    ]);
+    const { runs, rawText } = extractRichRuns(terminal, selection, THEME);
+    expect(runs).toEqual([
+      { text: 'a' },
+      { text: '日本', bold: true },
+      { text: 'b' },
+    ]);
+    expect(rawText).toBe('a日本b');
+  });
+
+  it('reads an unwritten cell inside the range as a space', () => {
+    const terminal = makeTerminal([row([...styled('ab'), makeCell('', {}), ...styled('cd')])], 5);
+    const runs = extractRichRuns(terminal, sel({ endCol: 4 }), THEME).runs;
+    expect(runs).toEqual([{ text: 'ab cd' }]);
+  });
+
+  it('normalizes a reversed selection', () => {
+    const terminal = makeTerminal([row(styled('The quick brown fox'))], 19);
+    const forward = sel({ startCol: 4, endCol: 8 });
+    const reversed = sel({ startCol: 8, endCol: 4 });
+    expect(extractRichRuns(terminal, reversed, THEME).runs).toEqual([{ text: 'quick' }]);
+    expect(extractRichRuns(terminal, reversed, THEME)).toEqual(extractRichRuns(terminal, forward, THEME));
+  });
+
+  it('normalizes a reversed multi-row selection', () => {
+    const terminal = makeTerminal([row(styled('alpha')), row(styled('beta'))], 5);
+    const reversed = sel({ startRow: 1, startCol: 3, endRow: 0, endCol: 1 });
+    expect(extractRichRuns(terminal, reversed, THEME).runs).toEqual([{ text: 'lpha\nbeta' }]);
+  });
+});
+
+describe('extractRichRuns row joining', () => {
+  it('joins a soft-wrapped row with no separator and keeps its trailing spaces', () => {
+    const terminal = makeTerminal([
+      row([...styled('long line '), ...styled('')]),
+      row(styled('continues'), true),
+    ], 10);
+    const s = sel({ startRow: 0, startCol: 0, endRow: 1, endCol: 8 });
+    expect(extractRichRuns(terminal, s, THEME).runs).toEqual([{ text: 'long line continues' }]);
+  });
+
+  it('keeps a hard break and trims the trailing whitespace before it', () => {
+    const terminal = makeTerminal([row(styled('one')), row(styled('two'))], 10);
+    const s = sel({ startRow: 0, startCol: 0, endRow: 1, endCol: 9 });
+    expect(extractRichRuns(terminal, s, THEME).runs).toEqual([{ text: 'one\ntwo' }]);
+  });
+
+  it('trims trailing whitespace off the last row too', () => {
+    const terminal = makeTerminal([row(styled('tail   '))], 10);
+    const s = sel({ startRow: 0, startCol: 0, endRow: 0, endCol: 9 });
+    expect(extractRichRuns(terminal, s, THEME).runs).toEqual([{ text: 'tail' }]);
+  });
+
+  it('trims into a styled run without disturbing the style', () => {
+    const terminal = makeTerminal([row([...styled('ok'), ...styled('  ', { bold: true })])], 6);
+    const s = sel({ startRow: 0, startCol: 0, endRow: 0, endCol: 5 });
+    expect(extractRichRuns(terminal, s, THEME).runs).toEqual([{ text: 'ok' }]);
+  });
+
+  it('emits the break unstyled so a background does not bleed across rows', () => {
+    const terminal = makeTerminal([
+      row(styled('aa', { bg: { palette: 4 } })),
+      row(styled('bb', { bg: { palette: 4 } })),
+    ], 2);
+    const s = sel({ startRow: 0, startCol: 0, endRow: 1, endCol: 1 });
+    expect(extractRichRuns(terminal, s, THEME).runs).toEqual([
+      { text: 'aa', background: '#2472c8' },
+      { text: '\n' },
+      { text: 'bb', background: '#2472c8' },
+    ]);
+  });
+
+  it('treats every row of a block selection as a hard break, wrapped or not', () => {
+    const terminal = makeTerminal([
+      row(styled('The quick brown fox')),
+      row(styled('jumps over the lazy'), true),
+      row(styled('dog and runs away.,'), true),
+    ], 19);
+    const s = sel({ startRow: 0, startCol: 4, endRow: 2, endCol: 8, shape: 'block' });
+    expect(extractRichRuns(terminal, s, THEME).runs).toEqual([{ text: 'quick\ns ove\nand r' }]);
+  });
+
+  it('skips a missing row without leaving a separator behind, as the raw read does', () => {
+    const terminal = makeTerminal([row(styled('one')), row(styled('two'))], 3);
+    const s = sel({ startRow: 0, startCol: 0, endRow: 4, endCol: 2 });
+    expect(extractRichRuns(terminal, s, THEME).runs).toEqual([{ text: 'one\ntwo' }]);
+  });
+});
+
+describe('extractRichRuns run merging', () => {
+  it('merges adjacent cells with identical supported styling', () => {
+    const { terminal, selection } = wholeRow([
+      ...styled('aaa', { bold: true, fg: { palette: 2 } }),
+      ...styled('bbb', { bold: true, fg: { palette: 2 } }),
+    ]);
+    expect(extractRichRuns(terminal, selection, THEME).runs).toEqual([
+      { text: 'aaabbb', bold: true, foreground: '#23d18b' },
+    ]);
+  });
+
+  it('merges two palettes that resolve to the same color', () => {
+    // palette 15 and 231 are both #ffffff in this theme.
+    const { terminal, selection } = wholeRow([
+      ...styled('x', { fg: { palette: 15 } }),
+      ...styled('y', { fg: { palette: 231 } }),
+    ]);
+    expect(extractRichRuns(terminal, selection, THEME).runs).toEqual([
+      { text: 'xy', foreground: '#ffffff' },
+    ]);
+  });
+
+  it('does not merge across a foreground change', () => {
+    const { terminal, selection } = wholeRow([
+      ...styled('r', { fg: { palette: 1 } }),
+      ...styled('g', { fg: { palette: 2 } }),
+    ]);
+    expect(extractRichRuns(terminal, selection, THEME).runs).toHaveLength(2);
+  });
+
+  it('never emits an empty run', () => {
+    const terminal = makeTerminal([row(styled('  ')), row(styled('x'))], 2);
+    const s = sel({ startRow: 0, startCol: 0, endRow: 1, endCol: 1 });
+    const runs = extractRichRuns(terminal, s, THEME).runs;
+    expect(runs.every((run) => run.text.length > 0)).toBe(true);
+    expect(runs).toEqual([{ text: '\nx' }]);
+  });
+
+  it('returns nothing for a selection with no content', () => {
+    const terminal = makeTerminal([row(styled('   '))], 3);
+    const s = sel({ startRow: 0, startCol: 0, endRow: 0, endCol: 2 });
+    expect(extractRichRuns(terminal, s, THEME).runs).toEqual([]);
+  });
+});
+
+describe('extractRichRuns rawText', () => {
+  const terminal = makeTerminal([
+    row([...styled('The quick', { bold: true }), ...styled(' brown fox')]),
+    row(styled('jumps over the lazy'), true),
+    row(styled('dog and runs away.')),
+  ], 19);
+
+  const cases: Array<[string, Selection]> = [
+    ['single row', sel({ startCol: 4, endCol: 8 })],
+    ['multi row', sel({ startRow: 0, startCol: 10, endRow: 2, endCol: 2 })],
+    ['reversed', sel({ startRow: 2, startCol: 2, endRow: 0, endCol: 10 })],
+    ['block', sel({ startRow: 0, startCol: 4, endRow: 2, endCol: 8, shape: 'block' })],
+    ['whole buffer', sel({ startRow: 0, startCol: 0, endRow: 2, endCol: 18 })],
+  ];
+
+  it.each(cases)('matches extractSelectionText exactly (%s)', (_name, s) => {
+    expect(extractRichRuns(terminal, s, THEME).rawText)
+      .toBe(extractSelectionText(terminal as Terminal, s));
+  });
+
+  it('differs from the run text where a soft wrap was rejoined', () => {
+    const s = sel({ startRow: 0, startCol: 0, endRow: 1, endCol: 18 });
+    const { runs, rawText } = extractRichRuns(terminal, s, THEME);
+    const runText = runs.map((run) => run.text).join('');
+    expect(rawText).toBe('The quick brown fox\njumps over the lazy');
+    expect(runText).toBe('The quick brown foxjumps over the lazy');
+  });
+});
diff --git a/lib/src/lib/notepad/rich-extract.ts b/lib/src/lib/notepad/rich-extract.ts
new file mode 100644
index 00000000..dd76b203
--- /dev/null
+++ b/lib/src/lib/notepad/rich-extract.ts
@@ -0,0 +1,287 @@
+// Capturing a terminal selection as styled runs (docs/specs/notepad.md).
+// Deliberately *not* Copy Rewrapped: soft-wrapped rows rejoin, every hard break
+// survives, and nothing is stripped — a captured excerpt has to read like what
+// was on the screen. Only the four attributes `RichTextRun` carries survive;
+// xterm exposes more, but underline/dim/blink/strike/hyperlinks have no place
+// in a note the user can edit into plain text.
+import type { Terminal } from '@xterm/xterm';
+import { parseColor, toHex } from '../css-color';
+import type { Selection } from '../mouse-selection';
+import { extractSelectionText, normalizeSelection } from '../selection-text';
+import { getTerminalTheme } from '../terminal-theme';
+import type { RichTextRun } from './types';
+
+/** Minimal slice of an xterm.js `IBufferCell`, kept tiny so this is unit-testable. */
+export interface CellLike {
+  getChars(): string;
+  getWidth(): number;
+  isBold(): number;
+  isItalic(): number;
+  isInverse(): number;
+  isFgDefault(): boolean;
+  isFgPalette(): boolean;
+  isFgRGB(): boolean;
+  getFgColor(): number;
+  isBgDefault(): boolean;
+  isBgPalette(): boolean;
+  isBgRGB(): boolean;
+  getBgColor(): number;
+}
+
+/** Minimal slice of an xterm.js `IBufferLine`. */
+export interface LineLike {
+  readonly isWrapped: boolean;
+  readonly length: number;
+  getCell(x: number): CellLike | undefined;
+  translateToString(trimRight?: boolean, startColumn?: number, endColumn?: number): string;
+}
+
+/** Minimal slice of an xterm.js `IBuffer`. */
+export interface BufferLike {
+  getLine(y: number): LineLike | undefined;
+}
+
+/** Minimal slice of an xterm.js `Terminal`. A real `Terminal` satisfies it
+ *  structurally, so the live wrapper below passes one straight through. */
+export interface TerminalLike {
+  readonly cols: number;
+  readonly buffer: { readonly active: BufferLike };
+}
+
+/** ANSI palette entries 0–15 in index order, named as `getTerminalTheme()` names them. */
+const ANSI_NAMES = [
+  'black', 'red', 'green', 'yellow', 'blue', 'magenta', 'cyan', 'white',
+  'brightBlack', 'brightRed', 'brightGreen', 'brightYellow',
+  'brightBlue', 'brightMagenta', 'brightCyan', 'brightWhite',
+] as const;
+
+export type AnsiColorName = (typeof ANSI_NAMES)[number];
+
+/**
+ * The colors a capture needs from the live theme: the 16 ANSI entries plus the
+ * two defaults an inverse cell swaps in. Values are whatever CSS the host's
+ * tokens hold — `rgb()`, `#rgb`, or a hex with alpha — and are normalized here,
+ * so a capture never carries a color string a renderer cannot read.
+ */
+export type TerminalPalette = Record<AnsiColorName | 'foreground' | 'background', string>;
+
+const PALETTE_KEYS: readonly (keyof TerminalPalette)[] = ['foreground', 'background', ...ANSI_NAMES];
+
+export interface RichExtractOptions {
+  /** Mirrors `terminal.options.drawBoldTextInBrightColors`; xterm defaults it to true. */
+  drawBoldTextInBrightColors?: boolean;
+}
+
+export interface RichCapture {
+  runs: RichTextRun[];
+  /** `extractSelectionText` over the same selection — the source-pin validation
+   *  key, so it is read from the buffer rather than rebuilt from `runs`. */
+  rawText: string;
+}
+
+/** Project the live terminal theme onto the palette this module consumes. */
+function currentTerminalPalette(): TerminalPalette {
+  const theme = getTerminalTheme();
+  const palette: Record<string, string> = {};
+  for (const key of PALETTE_KEYS) palette[key] = theme[key] ?? '';
+  return palette as TerminalPalette;
+}
+
+/** Normalize a theme color to lowercase `#rrggbb`; alpha is dropped, and an
+ *  unparseable token becomes "no color" so the note falls back to the default. */
+function normalizeHex(value: string | undefined): string | undefined {
+  if (!value) return undefined;
+  const rgba = parseColor(value);
+  return rgba ? toHex(rgba) : undefined;
+}
+
+/** The packed 0xRRGGBB an RGB-mode cell reports. */
+function unpackRgb(packed: number): string {
+  return toHex({ r: (packed >> 16) & 0xff, g: (packed >> 8) & 0xff, b: packed & 0xff, a: 1 });
+}
+
+/** xterm's 256-color table above the themed 16: a 6×6×6 cube at 16–231 and a
+ *  24-step gray ramp at 232–255. Computed, because the table is a formula. */
+function xterm256(index: number): string {
+  if (index >= 232) {
+    const level = (index - 232) * 10 + 8;
+    return toHex({ r: level, g: level, b: level, a: 1 });
+  }
+  const offset = index - 16;
+  const channel = (n: number) => (n === 0 ? 0 : 55 + n * 40);
+  return toHex({
+    r: channel(Math.floor(offset / 36)),
+    g: channel(Math.floor(offset / 6) % 6),
+    b: channel(offset % 6),
+    a: 1,
+  });
+}
+
+function paletteHex(index: number, theme: TerminalPalette): string | undefined {
+  if (!Number.isInteger(index) || index < 0 || index > 255) return undefined;
+  // 0–15 are the user's theme, not fixed values — a capture stays recognizable
+  // next to the terminal it came from.
+  return index < 16 ? normalizeHex(theme[ANSI_NAMES[index]]) : xterm256(index);
+}
+
+/** The subset of `RichTextRun` that is styling; `text` is carried separately. */
+type CellStyle = Omit<RichTextRun, 'text'>;
+
+function styleOf(cell: CellLike, theme: TerminalPalette, boldIsBright: boolean): CellStyle {
+  const bold = cell.isBold() !== 0;
+  const italic = cell.isItalic() !== 0;
+
+  let fg: string | undefined;
+  if (!cell.isFgDefault()) {
+    if (cell.isFgRGB()) {
+      fg = unpackRgb(cell.getFgColor());
+    } else if (cell.isFgPalette()) {
+      let index = cell.getFgColor();
+      // xterm draws bold text from the bright half of the low palette while
+      // `drawBoldTextInBrightColors` is on, and a note records what was drawn.
+      if (bold && boldIsBright && index < 8) index += 8;
+      fg = paletteHex(index, theme);
+    }
+  }
+
+  let bg: string | undefined;
+  if (!cell.isBgDefault()) {
+    if (cell.isBgRGB()) bg = unpackRgb(cell.getBgColor());
+    else if (cell.isBgPalette()) bg = paletteHex(cell.getBgColor(), theme);
+  }
+
+  if (cell.isInverse() !== 0) {
+    // The swap has to make a defaulted side explicit, or inverting a cell that
+    // relied on the defaults would read back as ordinary unstyled text.
+    const swappedFg = bg ?? normalizeHex(theme.background);
+    const swappedBg = fg ?? normalizeHex(theme.foreground);
+    fg = swappedFg;
+    bg = swappedBg;
+  }
+
+  const style: CellStyle = {};
+  if (bold) style.bold = true;
+  if (italic) style.italic = true;
+  if (fg) style.foreground = fg;
+  if (bg) style.background = bg;
+  return style;
+}
+
+interface Piece {
+  text: string;
+  style: CellStyle;
+}
+
+function readRow(
+  line: LineLike,
+  c0: number,
+  c1: number,
+  theme: TerminalPalette,
+  boldIsBright: boolean,
+): Piece[] {
+  const pieces: Piece[] = [];
+  const end = Math.min(c1, line.length);
+  for (let x = Math.max(0, c0); x < end; x += 1) {
+    const cell = line.getCell(x);
+    if (!cell) break;
+    // Width 0 is the trailing half of a wide character, already emitted whole
+    // by its width-2 cell.
+    if (cell.getWidth() === 0) continue;
+    const chars = cell.getChars();
+    // An unwritten cell inside the range is a space, matching how
+    // `translateToString` renders it.
+    pieces.push({ text: chars === '' ? ' ' : chars, style: styleOf(cell, theme, boldIsBright) });
+  }
+  return pieces;
+}
+
+/** Drop trailing whitespace exactly as `extractSelectionText`'s `/\s+$/` does,
+ *  keeping the styling of whatever survives. */
+function trimTrailing(pieces: Piece[]): Piece[] {
+  const text = pieces.map((p) => p.text).join('');
+  const trimmed = text.replace(/\s+$/, '');
+  if (trimmed.length === text.length) return pieces;
+  const out: Piece[] = [];
+  let kept = 0;
+  for (const piece of pieces) {
+    const room = trimmed.length - kept;
+    if (room <= 0) break;
+    out.push(room >= piece.text.length ? piece : { ...piece, text: piece.text.slice(0, room) });
+    kept += piece.text.length;
+  }
+  return out;
+}
+
+function sameStyle(a: CellStyle, b: CellStyle): boolean {
+  return a.bold === b.bold
+    && a.italic === b.italic
+    && a.foreground === b.foreground
+    && a.background === b.background;
+}
+
+/**
+ * Walk the cells under `sel` and return them as merged style runs plus the raw
+ * selected text. Rows join with nothing when the row that follows is a soft
+ * wrap (xterm's `isWrapped`) and with `\n` otherwise; block shapes are
+ * rectangular slabs, so every one of their rows ends hard. Trailing whitespace
+ * is trimmed only on a row that ends hard — a soft-wrapped row is full by
+ * definition, and its trailing spaces are content.
+ */
+export function extractRichRuns(
+  terminal: TerminalLike,
+  sel: Selection,
+  theme: TerminalPalette,
+  options: RichExtractOptions = {},
+): RichCapture {
+  const boldIsBright = options.drawBoldTextInBrightColors ?? true;
+  const n = normalizeSelection(sel);
+  const buf = terminal.buffer.active;
+  const block = sel.shape === 'block';
+
+  const rows: Array<{ index: number; pieces: Piece[] }> = [];
+  for (let r = n.r0; r <= n.r1; r += 1) {
+    const line = buf.getLine(r);
+    // `extractSelectionText` drops a missing row without a separator; stay in
+    // step with it so the two views of one selection cannot disagree.
+    if (!line) continue;
+    const c0 = block || r === n.r0 ? n.c0 : 0;
+    const c1 = block || r === n.r1 ? n.c1 + 1 : terminal.cols;
+    rows.push({ index: r, pieces: readRow(line, c0, c1, theme, boldIsBright) });
+  }
+
+  const pieces: Piece[] = [];
+  for (let i = 0; i < rows.length; i += 1) {
+    const next = rows[i + 1];
+    const soft = !block && next !== undefined && buf.getLine(next.index)?.isWrapped === true;
+    pieces.push(...(soft ? rows[i].pieces : trimTrailing(rows[i].pieces)));
+    // The break itself carries no styling: a colored newline is a rendering
+    // artifact, not content.
+    if (next && !soft) pieces.push({ text: '\n', style: {} });
+  }
+
+  const runs: RichTextRun[] = [];
+  for (const piece of pieces) {
+    if (!piece.text) continue;
+    const last = runs[runs.length - 1];
+    if (last && sameStyle(last, piece.style)) {
+      last.text += piece.text;
+      continue;
+    }
+    runs.push({ text: piece.text, ...piece.style });
+  }
+
+  return {
+    runs,
+    // Read from the buffer rather than rebuilt from `runs`: a source pin
+    // resolves by comparing this byte for byte with a later read of the same
+    // range, and the run text joins rows differently.
+    rawText: extractSelectionText(terminal as Terminal, sel),
+  };
+}
+
+/** `extractRichRuns` against the live theme and the terminal's own bold/bright setting. */
+export function captureRichSelection(terminal: Terminal, sel: Selection): RichCapture {
+  return extractRichRuns(terminal, sel, currentTerminalPalette(), {
+    drawBoldTextInBrightColors: terminal.options.drawBoldTextInBrightColors,
+  });
+}
diff --git a/lib/src/lib/notepad/source-link.test.ts b/lib/src/lib/notepad/source-link.test.ts
new file mode 100644
index 00000000..9def01a8
--- /dev/null
+++ b/lib/src/lib/notepad/source-link.test.ts
@@ -0,0 +1,376 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import type { IMarker } from '@xterm/xterm';
+import type { Selection } from '../mouse-selection';
+import type { RuntimeTerminalSource } from './types';
+
+const mocks = vi.hoisted(() => ({
+  getTerminalInstance: vi.fn<(id: string) => unknown>(),
+  setTerminalSelectionBaseline: vi.fn<(id: string, baseline: string | null) => void>(),
+}));
+
+// The registry barrel drags in the whole terminal lifecycle; only
+// `revealResolvedSource` needs it, so stub it rather than boot xterm here.
+vi.mock('../terminal-registry', () => ({ getTerminalInstance: mocks.getTerminalInstance }));
+// The baseline lands on the live registry entry; stub the store so the reveal
+// tests can see the call without one.
+vi.mock('../terminal-store', () => ({
+  setTerminalSelectionBaseline: mocks.setTerminalSelectionBaseline,
+}));
+
+import { getMouseSelectionState, setSelection } from '../mouse-selection';
+import { extractSelectionText } from '../selection-text';
+import {
+  disposeTerminalSource,
+  registerTerminalSource,
+  resolveTerminalSource,
+  revealResolvedSource,
+  type SourceTerminalLike,
+} from './source-link';
+
+class FakeMarker {
+  isDisposed = false;
+  constructor(public line: number) {}
+  dispose(): void {
+    if (this.isDisposed) return;
+    this.isDisposed = true;
+    // xterm reports -1 once a marker is gone.
+    this.line = -1;
+  }
+}
+
+const asMarker = (marker: FakeMarker) => marker as unknown as IMarker;
+
+interface FakeTerminalOptions {
+  type?: 'normal' | 'alternate';
+  baseY?: number;
+  cursorY?: number;
+  cols?: number;
+  /** Override marker creation to exercise the failure paths. */
+  registerMarker?: (offset: number) => IMarker | undefined;
+}
+
+interface FakeTerminal {
+  terminal: SourceTerminalLike;
+  markers: FakeMarker[];
+}
+
+function makeTerminal(lines: string[], opts: FakeTerminalOptions = {}): FakeTerminal {
+  const cols = opts.cols ?? Math.max(1, ...lines.map((l) => l.length));
+  const baseY = opts.baseY ?? 0;
+  const cursorY = opts.cursorY ?? 0;
+  const markers: FakeMarker[] = [];
+  const terminal: SourceTerminalLike = {
+    cols,
+    buffer: {
+      active: {
+        type: opts.type ?? 'normal',
+        baseY,
+        cursorY,
+        length: lines.length,
+        getLine: (y: number) => (lines[y] === undefined ? undefined : {
+          translateToString: (_trim?: boolean, start = 0, end = cols) => lines[y].slice(start, end),
+        }),
+      },
+    },
+    registerMarker: (offset = 0) => {
+      if (opts.registerMarker) return opts.registerMarker(offset);
+      const marker = new FakeMarker(baseY + cursorY + offset);
+      markers.push(marker);
+      return asMarker(marker);
+    },
+  };
+  return { terminal, markers };
+}
+
+function sel(overrides: Partial<Selection>): Selection {
+  return {
+    startRow: 0,
+    startCol: 0,
+    endRow: 0,
+    endCol: 0,
+    shape: 'linewise',
+    dragging: false,
+    startedInScrollback: false,
+    ...overrides,
+  };
+}
+
+/** Register the way a capture does: the raw text is whatever the buffer reads now. */
+function capture(fake: FakeTerminal, selection: Selection, id = 't1'): RuntimeTerminalSource {
+  const raw = extractSelectionText(fake.terminal as never, selection);
+  const source = registerTerminalSource(fake.terminal, id, selection, raw);
+  if (!source) throw new Error('expected a source');
+  return source;
+}
+
+const LINES = ['alpha one', 'bravo two', 'charlie three'];
+
+describe('registerTerminalSource', () => {
+  it('pins the normalized endpoints with cursor-relative markers', () => {
+    // baseY 5 + cursorY 2 puts the cursor at absolute row 7, so a capture of
+    // rows 2..4 has to register negative offsets to reach back into scrollback.
+    const fake = makeTerminal(['a', 'b', 'alpha', 'bravo', 'charlie', 'd', 'e', 'f'], {
+      baseY: 5,
+      cursorY: 2,
+    });
+    const source = capture(fake, sel({ startRow: 2, startCol: 1, endRow: 4, endCol: 3 }));
+
+    expect(source.terminalId).toBe('t1');
+    expect(source.startMarker.line).toBe(2);
+    expect(source.endMarker.line).toBe(4);
+    expect(source.startColumn).toBe(1);
+    expect(source.endColumn).toBe(3);
+    expect(source.shape).toBe('linewise');
+    expect(source.expectedRawText).toBe('lpha\nbravo\nchar');
+  });
+
+  it('normalizes a reversed selection before pinning it', () => {
+    const fake = makeTerminal(LINES);
+    const forward = sel({ startRow: 0, startCol: 2, endRow: 2, endCol: 6 });
+    const reversed = sel({ startRow: 2, startCol: 6, endRow: 0, endCol: 2 });
+    const source = capture(fake, reversed);
+
+    expect(source.startMarker.line).toBe(0);
+    expect(source.endMarker.line).toBe(2);
+    expect(source.startColumn).toBe(2);
+    expect(source.endColumn).toBe(6);
+    expect(source.expectedRawText).toBe(extractSelectionText(fake.terminal as never, forward));
+  });
+
+  it('keeps a block shape', () => {
+    const fake = makeTerminal(LINES);
+    const source = capture(fake, sel({ startRow: 0, startCol: 2, endRow: 2, endCol: 5, shape: 'block' }));
+    expect(source.shape).toBe('block');
+    expect(source.expectedRawText).toBe('pha\navo\narli');
+  });
+
+  it('refuses an alternate-buffer capture and registers nothing', () => {
+    const fake = makeTerminal(LINES, { type: 'alternate' });
+    const selection = sel({ startRow: 0, startCol: 0, endRow: 1, endCol: 4 });
+    expect(registerTerminalSource(fake.terminal, 't1', selection, 'alpha')).toBeNull();
+    expect(fake.markers).toHaveLength(0);
+  });
+
+  it('gives up and disposes the first marker when the second cannot be made', () => {
+    const made: FakeMarker[] = [];
+    const fake = makeTerminal(LINES, {
+      registerMarker: (offset) => {
+        if (made.length > 0) return undefined;
+        const marker = new FakeMarker(offset);
+        made.push(marker);
+        return asMarker(marker);
+      },
+    });
+    const selection = sel({ startRow: 0, startCol: 0, endRow: 2, endCol: 4 });
+
+    expect(registerTerminalSource(fake.terminal, 't1', selection, 'x')).toBeNull();
+    expect(made[0].isDisposed).toBe(true);
+  });
+
+  it('rejects a marker that arrives already disposed', () => {
+    const dead = new FakeMarker(0);
+    dead.dispose();
+    const fake = makeTerminal(LINES, { registerMarker: () => asMarker(dead) });
+    const selection = sel({ startRow: 0, startCol: 0, endRow: 0, endCol: 4 });
+    expect(registerTerminalSource(fake.terminal, 't1', selection, 'alpha')).toBeNull();
+  });
+});
+
+describe('resolveTerminalSource', () => {
+  it('rebuilds the range and reports it as a finalized selection', () => {
+    const fake = makeTerminal(LINES, { baseY: 2 });
+    const source = capture(fake, sel({ startRow: 1, startCol: 2, endRow: 2, endCol: 6 }));
+
+    const result = resolveTerminalSource(fake.terminal, source);
+    expect(result).toEqual({
+      ok: true,
+      selection: {
+        startRow: 1,
+        startCol: 2,
+        endRow: 2,
+        endCol: 6,
+        shape: 'linewise',
+        dragging: false,
+        // Row 1 sits above baseY 2, so the range starts in scrollback.
+        startedInScrollback: true,
+      },
+    });
+  });
+
+  it('follows the markers when the buffer has scrolled', () => {
+    const fake = makeTerminal(['x', 'alpha one', 'bravo two'], { baseY: 0 });
+    const source = capture(fake, sel({ startRow: 1, startCol: 0, endRow: 1, endCol: 4 }));
+    // Scrollback trimming shifts every line up by one; the markers move with it.
+    const scrolled = makeTerminal(['alpha one', 'bravo two']);
+    (source.startMarker as unknown as FakeMarker).line = 0;
+    (source.endMarker as unknown as FakeMarker).line = 0;
+
+    expect(resolveTerminalSource(scrolled.terminal, source)).toEqual({
+      ok: true,
+      selection: expect.objectContaining({ startRow: 0, endRow: 0, startedInScrollback: false }),
+    });
+  });
+
+  it('reports a disposed marker', () => {
+    const fake = makeTerminal(LINES);
+    const source = capture(fake, sel({ startRow: 0, startCol: 0, endRow: 1, endCol: 4 }));
+    disposeTerminalSource(source);
+
+    expect(resolveTerminalSource(fake.terminal, source)).toEqual({ ok: false, reason: 'disposed' });
+  });
+
+  it('reports rows the buffer no longer has', () => {
+    const fake = makeTerminal(LINES);
+    const source = capture(fake, sel({ startRow: 0, startCol: 0, endRow: 2, endCol: 4 }));
+    // The terminal was cleared; the markers still name rows past its end.
+    const shrunk = makeTerminal(['alpha one']);
+
+    expect(resolveTerminalSource(shrunk.terminal, source)).toEqual({
+      ok: false,
+      reason: 'missing-rows',
+    });
+  });
+
+  it('reports a text mismatch when the rows were overwritten', () => {
+    const fake = makeTerminal(LINES);
+    const source = capture(fake, sel({ startRow: 0, startCol: 0, endRow: 1, endCol: 8 }));
+    const rewritten = makeTerminal(['alpha one', 'BRAVO two', 'charlie three']);
+
+    expect(resolveTerminalSource(rewritten.terminal, source)).toEqual({
+      ok: false,
+      reason: 'mismatch',
+    });
+  });
+
+  it('still resolves after a resize that did not reflow the captured rows', () => {
+    const narrow = makeTerminal(LINES, { cols: 13 });
+    const source = capture(narrow, sel({ startRow: 0, startCol: 0, endRow: 2, endCol: 12 }));
+    const wide = makeTerminal(LINES, { cols: 40 });
+
+    expect(resolveTerminalSource(wide.terminal, source)).toMatchObject({ ok: true });
+  });
+
+  it('refuses when a resize rewrapped the captured text across different rows', () => {
+    const narrow = makeTerminal(['alpha one br', 'avo two'], { cols: 12 });
+    const source = capture(narrow, sel({ startRow: 0, startCol: 0, endRow: 1, endCol: 6 }));
+    expect(source.expectedRawText).toBe('alpha one br\navo two');
+
+    // Same characters, redistributed by a wider terminal: the equality check is
+    // what stops a pin from navigating to plausible-looking wrong output.
+    const wide = makeTerminal(['alpha one bravo two', ''], { cols: 19 });
+    expect(resolveTerminalSource(wide.terminal, source)).toEqual({
+      ok: false,
+      reason: 'mismatch',
+    });
+  });
+
+  it('reports the alternate buffer as a failure of its own and keeps the markers', () => {
+    const fake = makeTerminal(LINES);
+    const source = capture(fake, sel({ startRow: 0, startCol: 0, endRow: 2, endCol: 4 }));
+    const alt = makeTerminal(['full screen app'], { type: 'alternate' });
+
+    expect(resolveTerminalSource(alt.terminal, source)).toEqual({
+      ok: false,
+      reason: 'alternate-buffer',
+    });
+    // The markers ride the normal buffer, which the program only covered.
+    expect(source.startMarker.isDisposed).toBe(false);
+    expect(source.endMarker.isDisposed).toBe(false);
+  });
+});
+
+describe('disposeTerminalSource', () => {
+  it('releases both markers and is safe to repeat', () => {
+    const fake = makeTerminal(LINES);
+    const source = capture(fake, sel({ startRow: 0, startCol: 0, endRow: 2, endCol: 4 }));
+
+    disposeTerminalSource(source);
+    disposeTerminalSource(source);
+
+    expect(source.startMarker.isDisposed).toBe(true);
+    expect(source.endMarker.isDisposed).toBe(true);
+  });
+});
+
+describe('revealResolvedSource', () => {
+  const scrollToLine = vi.fn<(line: number) => void>();
+
+  /** The reveal reads the rows back for the baseline, so the fake needs lines
+   *  as well as a viewport. */
+  function liveTerminal(opts: { viewportY: number; baseY: number; rows: number; lines?: string[] }) {
+    const lines = opts.lines ?? LINES;
+    const cols = Math.max(1, ...lines.map((line) => line.length));
+    return {
+      cols,
+      rows: opts.rows,
+      buffer: {
+        active: {
+          viewportY: opts.viewportY,
+          baseY: opts.baseY,
+          getLine: (y: number) => (lines[y] === undefined ? undefined : {
+            translateToString: (_trim?: boolean, start = 0, end = cols) => lines[y].slice(start, end),
+          }),
+        },
+      },
+      scrollToLine,
+    };
+  }
+
+  beforeEach(() => {
+    scrollToLine.mockClear();
+    mocks.getTerminalInstance.mockReset();
+    mocks.setTerminalSelectionBaseline.mockReset();
+    setSelection('reveal', null);
+  });
+
+  it('scrolls an off-screen range into view and sets the selection', () => {
+    mocks.getTerminalInstance.mockReturnValue(liveTerminal({ viewportY: 100, baseY: 100, rows: 24 }));
+    const selection = sel({ startRow: 8, startCol: 0, endRow: 9, endCol: 4 });
+
+    revealResolvedSource('reveal', selection);
+
+    expect(scrollToLine).toHaveBeenCalledWith(8);
+    expect(getMouseSelectionState('reveal').selection).toBe(selection);
+  });
+
+  it('arms render-tick invalidation with the text it just restored', () => {
+    mocks.getTerminalInstance.mockReturnValue(liveTerminal({ viewportY: 0, baseY: 0, rows: 24 }));
+    const selection = sel({ startRow: 0, startCol: 0, endRow: 1, endCol: 5 });
+
+    revealResolvedSource('reveal', selection);
+
+    // The same text the resolve step proved equal to the pin's raw text; without
+    // it the render handler never watches a restored selection.
+    expect(mocks.setTerminalSelectionBaseline).toHaveBeenCalledWith('reveal', 'alpha one\nbravo');
+  });
+
+  it('leaves the baseline alone when the terminal instance is gone', () => {
+    mocks.getTerminalInstance.mockReturnValue(null);
+    revealResolvedSource('reveal', sel({ startRow: 0, startCol: 0, endRow: 0, endCol: 4 }));
+
+    expect(mocks.setTerminalSelectionBaseline).not.toHaveBeenCalled();
+  });
+
+  it('leaves the viewport alone when the range is already on screen', () => {
+    mocks.getTerminalInstance.mockReturnValue(liveTerminal({ viewportY: 0, baseY: 40, rows: 24 }));
+    revealResolvedSource('reveal', sel({ startRow: 3, startCol: 0, endRow: 3, endCol: 4 }));
+
+    expect(scrollToLine).not.toHaveBeenCalled();
+    expect(getMouseSelectionState('reveal').selection).not.toBeNull();
+  });
+
+  it('clamps the scroll target to the last scrollable line', () => {
+    mocks.getTerminalInstance.mockReturnValue(liveTerminal({ viewportY: 0, baseY: 10, rows: 5 }));
+    revealResolvedSource('reveal', sel({ startRow: 40, startCol: 0, endRow: 40, endCol: 4 }));
+
+    expect(scrollToLine).toHaveBeenCalledWith(10);
+  });
+
+  it('does nothing when the terminal instance is gone', () => {
+    mocks.getTerminalInstance.mockReturnValue(null);
+    revealResolvedSource('reveal', sel({ startRow: 1, startCol: 0, endRow: 1, endCol: 4 }));
+
+    expect(scrollToLine).not.toHaveBeenCalled();
+    expect(getMouseSelectionState('reveal').selection).toBeNull();
+  });
+});
diff --git a/lib/src/lib/notepad/source-link.ts b/lib/src/lib/notepad/source-link.ts
new file mode 100644
index 00000000..e50a1b91
--- /dev/null
+++ b/lib/src/lib/notepad/source-link.ts
@@ -0,0 +1,149 @@
+// Terminal source pins (docs/specs/notepad.md): the runtime-only link from a
+// captured note back to the scrollback it came from. Two xterm markers ride the
+// buffer as it scrolls, and the raw text captured alongside them is the proof —
+// column restoration after a resize is best effort, so a pin resolves only when
+// the rebuilt range reads back byte for byte.
+import type { IMarker, Terminal } from '@xterm/xterm';
+import { setSelection, type Selection } from '../mouse-selection';
+import { extractSelectionText, normalizeSelection } from '../selection-text';
+import { getTerminalInstance } from '../terminal-registry';
+import { setTerminalSelectionBaseline } from '../terminal-store';
+import type { RuntimeTerminalSource } from './types';
+
+/** Minimal slice of an xterm.js `IBufferLine`. */
+export interface SourceLineLike {
+  translateToString(trimRight?: boolean, startColumn?: number, endColumn?: number): string;
+}
+
+/** Minimal slice of an xterm.js `IBuffer`. */
+export interface SourceBufferLike {
+  readonly type: 'normal' | 'alternate';
+  readonly baseY: number;
+  readonly cursorY: number;
+  readonly length: number;
+  getLine(y: number): SourceLineLike | undefined;
+}
+
+/** Minimal slice of an xterm.js `Terminal`; a real `Terminal` satisfies it. */
+export interface SourceTerminalLike {
+  readonly cols: number;
+  readonly buffer: { readonly active: SourceBufferLike };
+  registerMarker(cursorYOffset?: number): IMarker | undefined;
+}
+
+export type ResolvedSource =
+  | { ok: true; selection: Selection }
+  | { ok: false; reason: 'alternate-buffer' | 'disposed' | 'missing-rows' | 'mismatch' };
+
+/**
+ * Pin a capture to its place in the normal buffer. Returns `null` for an
+ * alternate-buffer capture: xterm registers markers on the normal buffer only,
+ * and a full-screen program's grid is rewritten in place, so there is nothing
+ * stable to point at.
+ */
+export function registerTerminalSource(
+  terminal: SourceTerminalLike,
+  terminalId: string,
+  sel: Selection,
+  rawText: string,
+): RuntimeTerminalSource | null {
+  const buf = terminal.buffer.active;
+  if (buf.type === 'alternate') return null;
+
+  const n = normalizeSelection(sel);
+  // Markers are registered cursor-relative; a negative offset reaches back into
+  // scrollback, which is where most captures live.
+  const cursorRow = buf.baseY + buf.cursorY;
+  const startMarker = terminal.registerMarker(n.r0 - cursorRow);
+  if (!startMarker || startMarker.isDisposed) return null;
+  const endMarker = terminal.registerMarker(n.r1 - cursorRow);
+  if (!endMarker || endMarker.isDisposed) {
+    startMarker.dispose();
+    endMarker?.dispose();
+    return null;
+  }
+
+  return {
+    terminalId,
+    startMarker,
+    endMarker,
+    startColumn: n.c0,
+    endColumn: n.c1,
+    shape: sel.shape,
+    expectedRawText: rawText,
+  };
+}
+
+/**
+ * Rebuild the captured range from the markers' current lines and the stored
+ * columns, then prove it: the candidate range must read back exactly the text
+ * captured with it. A resize that reflowed the output, scrollback that trimmed
+ * away, or a program that overwrote the rows all surface here rather than
+ * scrolling the user to the wrong place.
+ */
+export function resolveTerminalSource(
+  terminal: SourceTerminalLike,
+  source: RuntimeTerminalSource,
+): ResolvedSource {
+  const buf = terminal.buffer.active;
+  // The markers belong to the normal buffer, which a full-screen program hides
+  // rather than rewrites: reading the alternate grid would compare against
+  // foreign content, so report the range as covered and leave the pin alone.
+  if (buf.type === 'alternate') return { ok: false, reason: 'alternate-buffer' };
+
+  const { startMarker, endMarker } = source;
+  if (startMarker.isDisposed || endMarker.isDisposed) return { ok: false, reason: 'disposed' };
+
+  const startRow = startMarker.line;
+  const endRow = endMarker.line;
+  // A disposed marker reports -1, and trimmed scrollback leaves the rows out of
+  // range — both land here rather than reading foreign content.
+  if (startRow < 0 || endRow < startRow || endRow >= buf.length) {
+    return { ok: false, reason: 'missing-rows' };
+  }
+  if (!buf.getLine(startRow) || !buf.getLine(endRow)) return { ok: false, reason: 'missing-rows' };
+
+  const selection: Selection = {
+    startRow,
+    startCol: source.startColumn,
+    endRow,
+    endCol: source.endColumn,
+    shape: source.shape,
+    dragging: false,
+    startedInScrollback: startRow < buf.baseY,
+  };
+  if (extractSelectionText(terminal as Terminal, selection) !== source.expectedRawText) {
+    return { ok: false, reason: 'mismatch' };
+  }
+  return { ok: true, selection };
+}
+
+/** Release both markers. Called when the pin is removed, the note is deleted,
+ *  or the terminal instance goes away. */
+export function disposeTerminalSource(source: RuntimeTerminalSource): void {
+  source.startMarker.dispose();
+  source.endMarker.dispose();
+}
+
+/**
+ * Show a resolved range: scroll it into view if it is off screen, then set the
+ * Dormouse selection, which is what draws the outline and raises the finalized
+ * selection popup, and give it the baseline that has it dropped once the rows
+ * change under it.
+ */
+export function revealResolvedSource(terminalId: string, selection: Selection): void {
+  const terminal = getTerminalInstance(terminalId);
+  if (!terminal) return;
+  const buf = terminal.buffer.active;
+  const top = normalizeSelection(selection).r0;
+  if (top < buf.viewportY || top > buf.viewportY + terminal.rows - 1) {
+    // `baseY` is the furthest the viewport can scroll; without the clamp a
+    // range near the bottom would ask for a scroll position that does not exist.
+    terminal.scrollToLine(Math.max(0, Math.min(top, buf.baseY)));
+  }
+  setSelection(terminalId, selection);
+  // Render-tick invalidation applies to a restored selection as to a dragged
+  // one, and it only watches a selection with a baseline. The resolve step just
+  // proved this text equals the pin's, so read it back rather than thread it in.
+  setTerminalSelectionBaseline(terminalId, extractSelectionText(terminal, selection));
+}
diff --git a/lib/src/lib/notepad/types.ts b/lib/src/lib/notepad/types.ts
new file mode 100644
index 00000000..5fa6e624
--- /dev/null
+++ b/lib/src/lib/notepad/types.ts
@@ -0,0 +1,126 @@
+// The notepad model (docs/specs/notepad.md). Bare TypeScript on purpose: the
+// archive half is shared with the VS Code extension host, which applies
+// mutations on the webview's behalf, so nothing here may reach for the DOM.
+import type { IMarker } from '@xterm/xterm';
+import type { SurfaceKind } from 'dor/commands/types';
+import type { CwdState } from '../terminal-state';
+
+/** One styled span of captured terminal text. Colors are normalized `#rrggbb`
+ *  (lowercase); a missing color means the theme default, so a rich note stays
+ *  theme-adaptive where the terminal was. Only these four attributes are kept —
+ *  underline, dim, blink, strike-through, and hyperlinks are dropped at capture. */
+export interface RichTextRun {
+  text: string;
+  bold?: true;
+  italic?: true;
+  foreground?: string;
+  background?: string;
+}
+
+export type NoteContent =
+  | { kind: 'plain'; text: string }
+  | { kind: 'terminal'; runs: RichTextRun[] };
+
+/** Runtime-only link from a captured note back to the scrollback it came from.
+ *  Never serialized: markers belong to one live xterm instance. */
+export interface RuntimeTerminalSource {
+  terminalId: string;
+  startMarker: IMarker;
+  endMarker: IMarker;
+  /** Normalized endpoint columns (start inclusive, end inclusive), so the range
+   *  can be rebuilt from the markers' current lines. */
+  startColumn: number;
+  endColumn: number;
+  shape: 'linewise' | 'block';
+  /** `extractSelectionText` output at capture; a pin resolves only when the
+   *  rebuilt range reads back exactly this. */
+  expectedRawText: string;
+}
+
+export interface LiveNote {
+  id: string;
+  createdAt: number;
+  content: NoteContent;
+  source?: RuntimeTerminalSource;
+}
+
+export type ArchivedNote = Omit<LiveNote, 'source'>;
+
+export interface ArchiveBatch {
+  id: string;
+  closedAt: number;
+  surfaceTitle: string;
+  surfaceKind: SurfaceKind;
+  /** The Session's last known CWD at teardown, whole; `null` for browser
+   *  Surfaces and terminals that never reported one. */
+  cwd: CwdState | null;
+  notes: ArchivedNote[];
+}
+
+export interface NotepadArchiveV1 {
+  version: 1;
+  batches: ArchiveBatch[];
+}
+
+/** Idempotent by batch and note id: appending a batch already present is a
+ *  no-op, deleting something already gone is a no-op. Deletes apply before
+ *  appends, so deleting and re-appending one id replaces that batch; a batch
+ *  left with no notes is dropped. */
+export interface NotepadArchiveMutation {
+  append?: ArchiveBatch[];
+  deleteBatchIds?: string[];
+  deleteNotes?: Array<{ batchId: string; noteId: string }>;
+}
+
+/** What the VS Code extension host mirrors in memory for one live Surface:
+ *  everything a close would archive, minus the markers, plus the PTY id a
+ *  teardown needs to ask where the process is. */
+export interface VolatileSurfaceNotes {
+  surfaceId: string;
+  surfaceTitle: string;
+  surfaceKind: SurfaceKind;
+  cwd: CwdState | null;
+  /** The Session's PTY id, for a terminal Surface only. Mirror-only: it is what
+   *  a teardown passes to `ptyManager.getCwd` while the PTY is still alive, and
+   *  `batchFromVolatile` never writes it into a batch. */
+  terminalId?: string;
+  /** Batch an earlier close may have stored; teardown replaces it, even when notes are empty. */
+  pendingBatchId?: string;
+  notes: ArchivedNote[];
+}
+
+export interface VolatileNotepadSnapshot {
+  surfaces: VolatileSurfaceNotes[];
+  /** Archive deletions staged in an open Archive view, committed by the host
+   *  if the webview is disposed before the view closes. */
+  stagedDeletions: Pick<NotepadArchiveMutation, 'deleteBatchIds' | 'deleteNotes'>;
+}
+
+export interface NotepadArchiveLoadResult {
+  /** Whatever the host stored — validated by `readNotepadArchive`. */
+  raw: unknown;
+  /** Opaque token naming the stored version; `save` is refused when it moved. */
+  revision: string;
+}
+
+/**
+ * The host side of the archive. Hosts store bytes and a revision; the shared
+ * layer (`archive-service.ts`) does the read-modify-write with
+ * `applyArchiveMutation`, retrying on `'conflict'`. One store per host, never
+ * shared across hosts (docs/specs/notepad.md).
+ */
+export interface NotepadArchivePort {
+  /** `null` when nothing has ever been archived. */
+  load(): Promise<NotepadArchiveLoadResult | null>;
+  /** Replace the stored archive iff it is still at `baseRevision` (`null` =
+   *  nothing stored). Atomic and owner-only on disk. */
+  save(archive: NotepadArchiveV1, baseRevision: string | null): Promise<'ok' | 'conflict'>;
+  /** User-initiated only: move unreadable stored data aside (never delete it)
+   *  so the next `load` returns `null`. */
+  resetUnreadable(): Promise<void>;
+  /** Mirror live notes into host memory (VS Code). Never written to disk. */
+  syncVolatile?(snapshot: VolatileNotepadSnapshot): void;
+  /** The mirror a resumed webview was booted with, consumed by a live resume
+   *  only — never by a cold restore. */
+  loadVolatile?(): VolatileNotepadSnapshot | null;
+}
diff --git a/lib/src/lib/platform/fake-adapter.ts b/lib/src/lib/platform/fake-adapter.ts
index 50d516af..dc201b9f 100644
--- a/lib/src/lib/platform/fake-adapter.ts
+++ b/lib/src/lib/platform/fake-adapter.ts
@@ -4,6 +4,10 @@ import { AlertManager } from '../alert-manager';
 import type { AwaitHandle, AwaitOptions } from '../alert-manager';
 import type { AlertSettings } from '../alert-settings';
 import { normalizeExternalUri } from '../external-links';
+import {
+  createMemoryNotepadArchivePort,
+  type MemoryNotepadArchivePort,
+} from '../notepad/memory-archive-port';
 import {
   applyTerminalProtocolEvents,
   collectTerminalSemanticEvents,
@@ -68,6 +72,18 @@ export class FakePtyAdapter implements PlatformAdapter {
   // for the stories that are *about* that section.
   burrow?: BurrowLink;
 
+  /**
+   * The notepad archive as memory — the website demo's real implementation and
+   * what tests and stories archive into. Public and concrete (not the narrower
+   * port type) so a caller can `seed`, `corrupt`, or `clear` it directly.
+   */
+  notepadArchive: MemoryNotepadArchivePort = createMemoryNotepadArchivePort();
+
+  /** Mutable and public for the same reason as the capability flags above: the
+   *  website playground sets it because a browser tab cannot take Cmd/Ctrl+N,
+   *  and the selection-popup stories toggle it per story. */
+  browserReservesNotepadChord?: boolean;
+
   constructor() {
     this.alertManager.onStateChange((id, state) => {
       for (const handler of this.alertStateHandlers) {
diff --git a/lib/src/lib/platform/index.ts b/lib/src/lib/platform/index.ts
index ae40e02f..3d7b2998 100644
--- a/lib/src/lib/platform/index.ts
+++ b/lib/src/lib/platform/index.ts
@@ -52,6 +52,13 @@ export function getPlatform(): PlatformAdapter {
   return adapter;
 }
 
+/** The adapter, or `null` when none is installed. For the readers that treat
+ *  "no platform yet" as an ordinary answer — unit tests and the boot frames
+ *  before `initPlatform()` — rather than as an error worth surfacing. */
+export function getPlatformOrNull(): PlatformAdapter | null {
+  return adapter;
+}
+
 export function initPlatform(override: 'fake'): FakePtyAdapter;
 export function initPlatform(): PlatformAdapter;
 export function initPlatform(override?: 'fake'): PlatformAdapter {
diff --git a/lib/src/lib/platform/types.ts b/lib/src/lib/platform/types.ts
index 6db387e4..9476be67 100644
--- a/lib/src/lib/platform/types.ts
+++ b/lib/src/lib/platform/types.ts
@@ -6,6 +6,7 @@ import type { ShellEntry } from '../shell-defaults';
 // Defined in its own dependency-free file so the Node proxy in lib/src/host can
 // share it without pulling this browser-typed module into a Node tsconfig.
 import type { IframeProxyResult } from './iframe-proxy-types';
+import type { NotepadArchivePort } from '../notepad/types';
 
 export interface PtyInfo {
   helper?: HelperIdentity;
@@ -377,4 +378,21 @@ export interface PlatformAdapter {
   // State persistence
   saveState(state: unknown): void;
   getState(): unknown;
+
+  /**
+   * The Surface notepad's archive store (docs/specs/notepad.md). Present on
+   * every host that has a notepad — standalone (owner-only JSON under app
+   * data), VS Code (`globalState`), the website demo (memory). Absent means no
+   * notepad at all: Pocket omits it and the header icon, popup action, and
+   * Settings entry all stay hidden.
+   */
+  notepadArchive?: NotepadArchivePort;
+
+  /**
+   * Whether the browser hosting this webview reserves the notepad chord
+   * (Cmd/Ctrl+N opens a new window, unpreventable), so Dormouse shows no
+   * shortcut and binds none. Absent reads as `false`; the website's demo
+   * adapter sets it `true`.
+   */
+  browserReservesNotepadChord?: boolean;
 }
diff --git a/lib/src/lib/platform/vscode-adapter.test.ts b/lib/src/lib/platform/vscode-adapter.test.ts
index 64fd8492..4dd75f39 100644
--- a/lib/src/lib/platform/vscode-adapter.test.ts
+++ b/lib/src/lib/platform/vscode-adapter.test.ts
@@ -32,6 +32,8 @@ import {
   TerminalProtocolParser,
 } from '../terminal-protocol';
 import { HOST_MESSAGE_TOKEN_FIELD, HOST_MESSAGE_TOKEN_GLOBAL } from '../vscode-message-token';
+import { NOTEPAD_VOLATILE_GLOBAL } from '../vscode-notepad-global';
+import type { NotepadArchiveV1, VolatileNotepadSnapshot } from '../notepad/types';
 import { VSCodeAdapter } from './vscode-adapter';
 
 /** Stand-in for the per-boot token the extension host injects at webview boot. */
@@ -445,6 +447,130 @@ describe('VSCodeAdapter PTY exit handling', () => {
 });
 
 
+// The archive lives in the extension host's `globalState` — nothing in the
+// webview can reach it — so the port is a request/response bridge
+// (docs/specs/notepad.md). What is covered here is what this transport adds: the
+// compare-and-swap shape on the wire, failures that reject rather than resolve,
+// and the boot mirror being consumable exactly once.
+describe('VSCodeAdapter notepad archive', () => {
+  beforeEach(stubWebviewEnv);
+
+  afterEach(() => {
+    vi.unstubAllGlobals();
+    vi.clearAllMocks();
+  });
+
+  const EMPTY: NotepadArchiveV1 = { version: 1, batches: [] };
+
+  /** The last archive request posted, whatever its type. */
+  function lastRequest(): { type: string; requestId: string; [key: string]: unknown } {
+    const posted = postMessage.mock.calls.map((call) => call[0]);
+    const request = [...posted].reverse().find((message) => String(message.type).startsWith('notepad:'));
+    if (!request) throw new Error('no notepad request was posted');
+    return request;
+  }
+
+  function answer(ok: boolean, extra: Record<string, unknown> = {}): void {
+    windowTarget.dispatchEvent(hostMessage({
+      type: 'notepad:result', requestId: lastRequest().requestId, ok, ...extra,
+    }));
+  }
+
+  it('loads the stored archive with the revision that names it', async () => {
+    const adapter = new VSCodeAdapter();
+    const pending = adapter.notepadArchive!.load();
+
+    expect(lastRequest()).toMatchObject({ type: 'notepad:load' });
+    answer(true, { result: { raw: JSON.stringify(EMPTY), revision: 'r3' } });
+
+    expect(await pending).toEqual({ raw: JSON.stringify(EMPTY), revision: 'r3' });
+  });
+
+  it('sends the whole archive and the revision it was built on', async () => {
+    const adapter = new VSCodeAdapter();
+    const pending = adapter.notepadArchive!.save(EMPTY, 'r3');
+
+    // The host stores bytes and compares revisions; it never parses or merges.
+    expect(lastRequest()).toMatchObject({
+      type: 'notepad:save', state: JSON.stringify(EMPTY), baseRevision: 'r3',
+    });
+    answer(true, { result: 'conflict' });
+
+    // A conflict is an outcome, not a failure — the shared service re-reads and retries.
+    expect(await pending).toBe('conflict');
+  });
+
+  it('rejects a failed request rather than resolving it as an empty archive', async () => {
+    // `null` legitimately means "nothing archived yet", so a failure that
+    // resolved like one would let the next save overwrite an archive nobody read.
+    const adapter = new VSCodeAdapter();
+    const pending = adapter.notepadArchive!.load();
+    answer(false, { error: 'globalState is gone' });
+    await expect(pending).rejects.toThrow('globalState is gone');
+  });
+
+  it('rejects rather than hanging when the host never answers', async () => {
+    const adapter = new VSCodeAdapter();
+    vi.useFakeTimers();
+    try {
+      const pending = adapter.notepadArchive!.load();
+      const rejected = expect(pending).rejects.toThrow(/timed out/);
+      await vi.advanceTimersByTimeAsync(10_000);
+      await rejected;
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
+  it('asks the host to move an unreadable archive aside', async () => {
+    const adapter = new VSCodeAdapter();
+    const pending = adapter.notepadArchive!.resetUnreadable();
+    expect(lastRequest()).toMatchObject({ type: 'notepad:reset' });
+    answer(true, {});
+    await expect(pending).resolves.toBeUndefined();
+  });
+
+  it('mirrors live notes to the extension host without waiting on it', () => {
+    // Fire and forget: the mirror is what lets a teardown archive from a webview
+    // VS Code has already destroyed.
+    const adapter = new VSCodeAdapter();
+    const snapshot: VolatileNotepadSnapshot = {
+      surfaces: [{
+        surfaceId: 'pane-1', surfaceTitle: 'zsh', surfaceKind: 'terminal', cwd: null,
+        notes: [{ id: 'n1', createdAt: 1, content: { kind: 'plain', text: 'hi' } }],
+      }],
+      stagedDeletions: { deleteBatchIds: [], deleteNotes: [] },
+    };
+
+    adapter.notepadArchive!.syncVolatile!(snapshot);
+
+    expect(postMessage).toHaveBeenCalledWith({ type: 'notepad:volatile', snapshot });
+  });
+
+  it('hands the boot mirror over exactly once', () => {
+    const snapshot: VolatileNotepadSnapshot = {
+      surfaces: [{
+        surfaceId: 'pane-1', surfaceTitle: 'zsh', surfaceKind: 'terminal', cwd: null,
+        notes: [{ id: 'n1', createdAt: 1, content: { kind: 'plain', text: 'hi' } }],
+      }],
+      stagedDeletions: { deleteBatchIds: [], deleteNotes: [] },
+    };
+    vi.stubGlobal(NOTEPAD_VOLATILE_GLOBAL, snapshot);
+
+    const adapter = new VSCodeAdapter();
+    expect(adapter.notepadArchive!.loadVolatile!()).toEqual(snapshot);
+    // A second read would be a later restore's, and a restore must never
+    // hydrate live notes.
+    expect(adapter.notepadArchive!.loadVolatile!()).toBeNull();
+  });
+
+  it('gives a cold restore no mirror at all', () => {
+    // The global is absent on every boot but a live resume.
+    const adapter = new VSCodeAdapter();
+    expect(adapter.notepadArchive!.loadVolatile!()).toBeNull();
+  });
+});
+
 // The Burrow lives in the extension host, in whichever VS Code window won
 // the bind (vscode-ext/src/burrow.ts). This is the webview's end of that
 // bridge; the contract is lib/src/host/remote/service-protocol.ts.
diff --git a/lib/src/lib/platform/vscode-adapter.ts b/lib/src/lib/platform/vscode-adapter.ts
index 7f55428c..00fbf031 100644
--- a/lib/src/lib/platform/vscode-adapter.ts
+++ b/lib/src/lib/platform/vscode-adapter.ts
@@ -4,7 +4,14 @@ import { OPEN_PORT_TIMEOUT_MS } from './types';
 import { createBurrowLinkClient } from '../../host/remote/link-client';
 import type { AwaitHandle, AwaitOptions, AwaitOutcome } from '../alert-manager';
 import type { AlertSettings } from '../alert-settings';
+import type {
+  NotepadArchiveLoadResult,
+  NotepadArchivePort,
+  NotepadArchiveV1,
+  VolatileNotepadSnapshot,
+} from '../notepad/types';
 import { readInjectedRecoveryCommands } from '../vscode-recovery-global';
+import { readInjectedVolatileNotepad } from '../vscode-notepad-global';
 import { setDefaultShellOpts } from '../shell-defaults';
 import { embedderOrigins } from '../embedder-origins';
 import {
@@ -69,6 +76,45 @@ export class VSCodeAdapter implements PlatformAdapter {
 
   readonly burrow: BurrowLink = this.burrowClient.link;
 
+  /**
+   * The mirror this webview booted with, consumed once by `loadVolatile()`.
+   * Captured at construction like every other boot global, so a later
+   * same-document write cannot move the goalposts.
+   */
+  private bootNotepadVolatile: VolatileNotepadSnapshot | null = readInjectedVolatileNotepad();
+
+  /**
+   * The archive lives in the extension host's `globalState` — nothing in the
+   * webview can reach it — so every call is a request/response round trip
+   * (docs/specs/notepad.md). The port is compare-and-swap: this side only ships
+   * bytes and the revision it read them at, and the shared service retries a
+   * `'conflict'`, so a second webview's concurrent append is never lost.
+   */
+  readonly notepadArchive: NotepadArchivePort = {
+    load: () => this.notepadRequest<NotepadArchiveLoadResult | null>('notepad:load', {}),
+    save: (archive: NotepadArchiveV1, baseRevision: string | null) =>
+      this.notepadRequest<'ok' | 'conflict'>('notepad:save', {
+        state: JSON.stringify(archive),
+        baseRevision,
+      }),
+    resetUnreadable: async () => {
+      await this.notepadRequest<void>('notepad:reset', {});
+    },
+    // Fire and forget: nothing waits on the mirror, and the next snapshot
+    // supersedes this one. It is what lets a teardown archive notes from a
+    // webview VS Code has already destroyed.
+    syncVolatile: (snapshot: VolatileNotepadSnapshot) => {
+      this.vscode.postMessage({ type: 'notepad:volatile', snapshot });
+    },
+    // Exactly once: a second read is a cold restore's read, and a cold restore
+    // must never hydrate live notes (docs/specs/notepad.md).
+    loadVolatile: () => {
+      const snapshot = this.bootNotepadVolatile;
+      this.bootNotepadVolatile = null;
+      return snapshot;
+    },
+  };
+
   constructor() {
     this.vscode = acquireVsCodeApi();
 
@@ -211,6 +257,27 @@ export class VSCodeAdapter implements PlatformAdapter {
     });
   }
 
+  /**
+   * One archive round trip. Unlike `requestResponse` this *rejects* rather than
+   * resolving `null`: a `null` load legitimately means "nothing archived yet", so
+   * a timeout that looked like one would let the next save overwrite an archive
+   * nobody managed to read. The shared service turns a rejection into the
+   * unavailable/closure-failure paths (docs/specs/notepad.md → Archive).
+   */
+  private async notepadRequest<T>(
+    type: 'notepad:load' | 'notepad:save' | 'notepad:reset',
+    data: Record<string, unknown>,
+  ): Promise<T> {
+    // The reply object is never `null` on its own, so `requestResponse`'s `null`
+    // here can only be its timeout.
+    const reply = await this.requestResponse<{ ok: boolean; result?: unknown; error?: string }>(
+      type, 'notepad:result', data, (msg) => msg, 5000,
+    );
+    if (!reply) throw new Error(`${type} timed out`);
+    if (!reply.ok) throw new Error(reply.error || `${type} failed`);
+    return reply.result as T;
+  }
+
   /**
    * One-shot listener for the host reply correlated by `requestId`. `detach`
    * stops listening and settles the promise with `DETACHED` (a caller's own
diff --git a/lib/src/lib/reconnect.test.ts b/lib/src/lib/reconnect.test.ts
index a91045dc..99b5db82 100644
--- a/lib/src/lib/reconnect.test.ts
+++ b/lib/src/lib/reconnect.test.ts
@@ -6,15 +6,19 @@ const terminalRegistryMocks = vi.hoisted(() => ({
   restoreBrowserSurfaceTodo: vi.fn(),
   resumeTerminal: vi.fn(),
   restoreTerminal: vi.fn(),
+  getDefaultShellOpts: vi.fn(() => null),
 }));
 
 vi.mock('./terminal-registry', () => ({
   restoreBrowserSurfaceTodo: terminalRegistryMocks.restoreBrowserSurfaceTodo,
   resumeTerminal: terminalRegistryMocks.resumeTerminal,
   restoreTerminal: terminalRegistryMocks.restoreTerminal,
+  getDefaultShellOpts: terminalRegistryMocks.getDefaultShellOpts,
 }));
 
 import { resumeOrRestore } from './reconnect';
+import { addPlainNote, buildVolatileSnapshot, clearAllNotepads, getNotes } from './notepad/notepad-store';
+import type { VolatileNotepadSnapshot } from './notepad/types';
 import { getHelper, forgetHelper } from './helper-terminal';
 import type { LathNode } from './lath/model';
 
@@ -440,3 +444,128 @@ describe('resumeOrRestore', () => {
     });
   });
 });
+
+/**
+ * The mirror the VS Code extension host boots a re-resolved webview with. It
+ * hydrates a live resume and nothing else (docs/specs/notepad.md → "Live
+ * resume"): a cold restore is a different Session over PTYs that no longer
+ * exist, so notes must not reappear there.
+ */
+describe('notepad hydration', () => {
+  const snapshot: VolatileNotepadSnapshot = {
+    surfaces: [
+      {
+        surfaceId: 'pane-a',
+        surfaceTitle: 'pnpm dev',
+        surfaceKind: 'terminal',
+        cwd: null,
+        notes: [{ id: 'n1', createdAt: 1, content: { kind: 'plain', text: 'mirrored' } }],
+      },
+      {
+        surfaceId: 'door-b',
+        surfaceTitle: 'zsh',
+        surfaceKind: 'terminal',
+        cwd: null,
+        notes: [{ id: 'n2', createdAt: 2, content: { kind: 'plain', text: 'minimized too' } }],
+      },
+    ],
+    stagedDeletions: {},
+  };
+
+  /** Attach an archive port that only ever answers `loadVolatile` — the one
+   *  member this path touches. */
+  function withMirror(platform: PlatformAdapter): ReturnType<typeof vi.fn> {
+    const loadVolatile = vi.fn(() => snapshot);
+    (platform as { notepadArchive?: unknown }).notepadArchive = { loadVolatile };
+    return loadVolatile;
+  }
+
+  beforeEach(() => {
+    clearAllNotepads();
+  });
+
+  it('restores mirrored notes for every live Surface on a resume, doors included', async () => {
+    const saved: PersistedSession = {
+      version: 3,
+      lathLayout: lathLayoutFor('pane-a'),
+      doors: [{ id: 'door-b', title: 'zsh' }],
+      panes: [
+        { id: 'pane-a', title: 'Pane A', cwd: null },
+        { id: 'door-b', title: 'zsh', cwd: null },
+      ],
+    };
+    const platform = createPlatform([
+      { id: 'pane-a', alive: true },
+      { id: 'door-b', alive: true },
+    ], saved);
+    const loadVolatile = withMirror(platform);
+
+    await resumeOrRestore(platform);
+
+    expect(loadVolatile).toHaveBeenCalledTimes(1);
+    expect(getNotes('pane-a').map((note) => note.content)).toEqual([{ kind: 'plain', text: 'mirrored' }]);
+    expect(getNotes('door-b').map((note) => note.content)).toEqual([{ kind: 'plain', text: 'minimized too' }]);
+  });
+
+  it('restores mirrored notes on a resume with no saved plan to match', async () => {
+    const platform = createPlatform([{ id: 'pane-a', alive: true }], null);
+    withMirror(platform);
+
+    await resumeOrRestore(platform);
+
+    expect(getNotes('pane-a')).toHaveLength(1);
+  });
+
+  it('never reads the mirror on a cold restore', async () => {
+    const saved: PersistedSession = {
+      version: 3,
+      lathLayout: lathLayoutFor('pane-a'),
+      panes: [{ id: 'pane-a', title: 'Pane A', cwd: null }],
+    };
+    // No live PTYs: `resumeOrRestore` falls through to the saved session.
+    const platform = createPlatform([], saved);
+    const loadVolatile = withMirror(platform);
+
+    const result = await resumeOrRestore(platform);
+
+    expect(result.paneIds).toEqual(['pane-a']);
+    expect(loadVolatile).not.toHaveBeenCalled();
+    expect(getNotes('pane-a')).toEqual([]);
+  });
+});
+
+describe('browser-only notepad resume', () => {
+  beforeEach(() => { clearAllNotepads(); });
+  it.each([true, false])('hydrates browser notes only with a same-host mirror (present: %s)', async (sameHost) => {
+    const saved: PersistedSession = {
+      version: 3,
+      lathLayout: lathLayoutFor('web'),
+      doors: [{ id: 'door-web', title: 'Browser door', component: 'browser' }],
+      panes: [
+        { id: 'web', title: 'Browser', cwd: null, surfaceType: 'browser' },
+        { id: 'door-web', title: 'Browser door', cwd: null, surfaceType: 'browser' },
+      ],
+    };
+    const snapshot: VolatileNotepadSnapshot = {
+      surfaces: ['web', 'door-web'].map((id) => ({
+        surfaceId: id, surfaceTitle: id, surfaceKind: 'browser', cwd: null,
+        notes: [{ id: `${id}-note`, createdAt: 1, content: { kind: 'plain', text: `keep ${id}` } }],
+      })),
+      stagedDeletions: {},
+    };
+    const platform = createPlatform([], saved);
+    const loadVolatile = vi.fn(() => sameHost ? snapshot : null);
+    (platform as { notepadArchive?: unknown }).notepadArchive = { loadVolatile };
+    const result = await resumeOrRestore(platform);
+    expect(result.paneIds).toEqual(['web']);
+    expect(result.doors?.map((door) => door.id)).toEqual(['door-web']);
+    expect(loadVolatile).toHaveBeenCalledTimes(1);
+    for (const surface of snapshot.surfaces) {
+      expect(getNotes(surface.surfaceId)).toEqual(sameHost ? surface.notes : []);
+    }
+    addPlainNote('web', 'new note');
+    expect(buildVolatileSnapshot().surfaces.find((surface) => surface.surfaceId === 'web')?.notes)
+      .toHaveLength(sameHost ? 2 : 1);
+    expect(platform.spawnPty).not.toHaveBeenCalled();
+  });
+});
diff --git a/lib/src/lib/reconnect.ts b/lib/src/lib/reconnect.ts
index 74924265..efb55e4e 100644
--- a/lib/src/lib/reconnect.ts
+++ b/lib/src/lib/reconnect.ts
@@ -1,6 +1,7 @@
-import { restoreHelper } from './helper-terminal';
+import { adoptOrphanedHelper, restoreHelper } from './helper-terminal';
 import type { LathPersistedLayout } from './lath/persistence';
 import type { PlatformAdapter, PtyInfo } from './platform/types';
+import { hydrateNotepadFromVolatile } from './notepad/notepad-store';
 import { restoreBrowserSurfaceTodo, resumeTerminal } from './terminal-registry';
 import { carrySurfaceRefs, readPersistedSession, type PersistedDoor, type PersistedSurfaceRefs } from './session-types';
 import { persistedLathLayout, restoreSession } from './session-restore';
@@ -32,7 +33,16 @@ export async function resumeOrRestore(platform: PlatformAdapter): Promise<Reconn
   if (liveResult) return liveResult;
 
   const restored = await restoreSession(platform);
-  if (restored) return restored;
+  if (restored) {
+    const saved = readPersistedSession(platform.getState());
+    // Browser-only views have no PTY with which to prove a live resume. Their
+    // host-memory mirror is that proof; an extension restart supplies null.
+    // Rebuild their layout first, then hydrate only those surviving Surfaces.
+    if (saved?.panes.length && saved.panes.every((pane) => pane.surfaceType === 'browser')) {
+      return hydrateNotepad(platform, restored);
+    }
+    return restored;
+  }
 
   return { paneIds: [] };
 }
@@ -74,6 +84,7 @@ function resumeLiveSessions(platform: PlatformAdapter): Promise<ReconnectResult
       const savedState = platform.getState();
       const savedResumeInfo = getSavedPaneResumeInfo(savedState, ptyList.map((pty) => pty.id));
       const ids: string[] = [];
+      const ptyById = new Map(ptyList.map((pty) => [pty.id, pty]));
       for (const pty of ptyList) {
         const resumeInfo: { alive: boolean; exitCode?: number; shell?: string; title?: string; untouched?: boolean; helper?: PtyInfo['helper'] } = {
           alive: pty.alive,
@@ -83,27 +94,31 @@ function resumeLiveSessions(platform: PlatformAdapter): Promise<ReconnectResult
         const savedInfo = savedResumeInfo.get(pty.id);
         if (savedInfo?.title !== undefined) resumeInfo.title = savedInfo.title;
         if (savedInfo?.untouched) resumeInfo.untouched = true;
-        const parentPresent = pty.helper && ptyList.some(parent => parent.id === pty.helper?.parentId && !parent.helper);
-        if (parentPresent) resumeInfo.helper = pty.helper;
+        // A helper stays one only while its source is also live; helpers cannot
+        // have helpers.
+        const parent = pty.helper && ptyById.get(pty.helper.parentId);
+        const helper = parent && !parent.helper ? pty.helper : undefined;
+        if (helper) resumeInfo.helper = helper;
         resumeTerminal(pty.id, replayBuffer.get(pty.id) ?? null, resumeInfo);
-        if (parentPresent && pty.helper) restoreHelper(pty.id, pty.helper);
-        else { ids.push(pty.id); if (pty.helper) void platform.terminalContext?.({ op: 'promote', id: pty.id }); }
+        if (helper) { restoreHelper(pty.id, helper); continue; }
+        ids.push(pty.id);
+        if (pty.helper) adoptOrphanedHelper(pty.id);
       }
       // Pull saved visible/doors state so a resume (e.g. after panel
       // close/reopen) restores splits and doors instead of stacking every live
       // PTY into one tab group.
       const savedPlan = getSavedResumePlan(savedState, ids);
       if (savedPlan) {
-        resolve(savedPlan);
+        resolve(hydrateNotepad(platform, savedPlan));
         return;
       }
 
       const saved = readPersistedSession(savedState);
-      resolve({
+      resolve(hydrateNotepad(platform, {
         paneIds: ids,
         doors: [],
         ...carrySurfaceRefs(saved),
-      });
+      }));
     }
 
     platform.onPtyList(handleList);
@@ -112,6 +127,22 @@ function resumeLiveSessions(platform: PlatformAdapter): Promise<ReconnectResult
   });
 }
 
+/**
+ * Give a resumed webview back the notes the host mirrored for it
+ * (docs/specs/notepad.md → "Live resume"). Only reachable from the live-PTY
+ * branch or a browser-only view with a same-host mirror: a cold restore is
+ * a different Session over a different set of PTYs,
+ * and mirrored notes must never surface there. Live Surfaces are the resume
+ * plan's panes plus its doors — a minimized Surface keeps its notes.
+ */
+function hydrateNotepad(platform: PlatformAdapter, result: ReconnectResult): ReconnectResult {
+  const snapshot = platform.notepadArchive?.loadVolatile?.();
+  if (snapshot) {
+    hydrateNotepadFromVolatile(snapshot, [...result.paneIds, ...(result.doors ?? []).map((door) => door.id)]);
+  }
+  return result;
+}
+
 function getSavedPaneResumeInfo(savedState: unknown, liveIds: string[]): Map<string, { title: string; untouched: boolean }> {
   const saved = readPersistedSession(savedState);
   if (!saved || !Array.isArray(saved.panes)) return new Map();
diff --git a/lib/src/lib/settle-within.test.ts b/lib/src/lib/settle-within.test.ts
new file mode 100644
index 00000000..c22cdb33
--- /dev/null
+++ b/lib/src/lib/settle-within.test.ts
@@ -0,0 +1,52 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { settleAllWithin } from './settle-within';
+
+describe('settleAllWithin', () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+    vi.useRealTimers();
+  });
+
+  it('falls back only for the entries that miss the deadline', async () => {
+    vi.useFakeTimers();
+
+    const settled = settleAllWithin<string>(
+      [Promise.resolve('here'), new Promise<string>(() => {}), Promise.resolve('also here')],
+      1000,
+      'missing',
+    );
+    await vi.advanceTimersByTimeAsync(1000);
+
+    await expect(settled).resolves.toEqual(['here', 'missing', 'also here']);
+  });
+
+  it('falls back for a rejection without failing the batch', async () => {
+    await expect(settleAllWithin<string | null>(
+      [Promise.reject(new Error('the PTY is gone')), Promise.resolve('kept')],
+      1000,
+      null,
+    )).resolves.toEqual([null, 'kept']);
+  });
+
+  it('arms one timer for the whole batch and clears it once they settle', async () => {
+    const armed = vi.spyOn(globalThis, 'setTimeout');
+    const cleared = vi.spyOn(globalThis, 'clearTimeout');
+
+    await expect(settleAllWithin(
+      [Promise.resolve(1), Promise.resolve(2), Promise.resolve(3)],
+      60_000,
+      0,
+    )).resolves.toEqual([1, 2, 3]);
+
+    expect(armed).toHaveBeenCalledTimes(1);
+    expect(cleared).toHaveBeenCalledTimes(1);
+  });
+
+  it('arms no timer at all for an empty batch', async () => {
+    const armed = vi.spyOn(globalThis, 'setTimeout');
+
+    await expect(settleAllWithin<string | null>([], 1000, null)).resolves.toEqual([]);
+
+    expect(armed).not.toHaveBeenCalled();
+  });
+});
diff --git a/lib/src/lib/settle-within.ts b/lib/src/lib/settle-within.ts
new file mode 100644
index 00000000..dd322663
--- /dev/null
+++ b/lib/src/lib/settle-within.ts
@@ -0,0 +1,28 @@
+/**
+ * Settle a batch of best-effort answers under one shared deadline.
+ *
+ * Every entry is raced against the *same* timer rather than arming one apiece,
+ * so a close waiting on twenty PTYs waits once. An entry that rejects or does
+ * not arrive in time yields `fallback` and nothing else: the answers that did
+ * arrive are kept, in input order. The timer is cleared as soon as the batch
+ * settles, so an early completion leaves nothing pending behind it.
+ *
+ * Every caller here is asking a host something it would rather have than not —
+ * a live process's working directory — where a missing answer is a fallback,
+ * never a failure.
+ */
+export function settleAllWithin<T>(
+  works: readonly Promise<T>[],
+  ms: number,
+  fallback: T,
+): Promise<T[]> {
+  if (works.length === 0) return Promise.resolve([]);
+  let expire: (value: T) => void = () => {};
+  const deadline = new Promise<T>((resolve) => {
+    expire = resolve;
+  });
+  const timer = setTimeout(() => expire(fallback), ms);
+  return Promise.all(
+    works.map((work) => Promise.race([work.catch(() => fallback), deadline])),
+  ).finally(() => clearTimeout(timer));
+}
diff --git a/lib/src/lib/terminal-lifecycle.ts b/lib/src/lib/terminal-lifecycle.ts
index a04673f8..5c94542d 100644
--- a/lib/src/lib/terminal-lifecycle.ts
+++ b/lib/src/lib/terminal-lifecycle.ts
@@ -6,6 +6,7 @@ import { WebglAddon } from '@xterm/addon-webgl';
 import { shellCommandKind, type ShellCommandKind } from 'dor/commands/shell-quote';
 import { getPlatform, IS_MAC, IS_WINDOWS, PLATFORM_STRING } from './platform';
 import type { PtyDataDetail } from './platform/types';
+import type { HelperIdentity } from './terminal-context-types';
 import { DIM, RESET } from './ansi';
 import { cfg } from '../cfg';
 import { requestExternalLinkConfirmation } from './external-link-confirmation';
@@ -17,6 +18,7 @@ import {
   removeMouseSelectionState,
   setSelection as setMouseSelection,
 } from './mouse-selection';
+import { dropSourcesForTerminal } from './notepad/notepad-store';
 import { extractSelectionText } from './selection-text';
 import { normalizeResumeCommand } from './resume-patterns';
 import {
@@ -340,9 +342,14 @@ function wireXtermHandlers(
   };
 }
 
-function setupTerminalEntry(id: string, options: { shell?: string; untouched?: boolean; helper?: import('./terminal-context-types').HelperIdentity } = {}): TerminalEntry {
+function setupTerminalEntry(id: string, options: { shell?: string; untouched?: boolean; helper?: HelperIdentity } = {}): TerminalEntry {
   const { terminal, fit, element } = createXtermHost();
   const selectionBaselineRef = { current: null as string | null };
+  // Every module that finalizes a selection arms the render handler through
+  // this one setter: the mouse router at drag end, a note's pin on reveal.
+  const setSelectionBaseline = (baseline: string | null) => {
+    selectionBaselineRef.current = baseline;
+  };
 
   const disposePty = wirePtyEvents(id, terminal);
   const disposeXterm = wireXtermHandlers(id, terminal, selectionBaselineRef);
@@ -355,9 +362,7 @@ function setupTerminalEntry(id: string, options: { shell?: string; untouched?: b
     terminal,
     element,
     getOverlayDims: getTerminalOverlayDims,
-    setSelectionBaseline: (baseline) => {
-      selectionBaselineRef.current = baseline;
-    },
+    setSelectionBaseline,
   });
 
   const cleanup = () => {
@@ -375,6 +380,7 @@ function setupTerminalEntry(id: string, options: { shell?: string; untouched?: b
     fit,
     element,
     cleanup,
+    setSelectionBaseline,
     isReplaying: false,
     untouched: options.untouched ?? false,
   };
@@ -484,7 +490,7 @@ export function getOrCreateTerminal(id: string): TerminalEntry {
 export function resumeTerminal(
   id: string,
   replayData: string | null,
-  exitInfo?: { alive: boolean; exitCode?: number; shell?: string; title?: string | null; untouched?: boolean; helper?: import('./terminal-context-types').HelperIdentity },
+  exitInfo?: { alive: boolean; exitCode?: number; shell?: string; title?: string | null; untouched?: boolean; helper?: HelperIdentity },
 ): TerminalEntry {
   const existing = registry.get(id);
   if (existing) return existing;
@@ -580,14 +586,34 @@ export function mountElement(id: string, container: HTMLElement): void {
   requestAnimationFrame(() => entry.fit.fit());
 }
 
+/** Where a hidden helper's xterm element waits between reveals: still in the
+ *  document, so its renderer and scrollback survive
+ *  (docs/specs/terminal-context.md → Helper lifecycle). */
+let helperParking: HTMLElement | null = null;
+
+/** Park a helper Session's element out of sight without terminating anything;
+ *  the next `mountElement` reveals the same element. */
+export function parkElement(id: string): void {
+  const entry = registry.get(id);
+  if (!entry) return;
+  // Revalidated, not just cached: a host that replaces the body (a docs iframe,
+  // a test teardown) would otherwise park every helper in a detached subtree.
+  if (!helperParking?.isConnected) {
+    helperParking = document.createElement('div');
+    helperParking.hidden = true;
+    document.body.appendChild(helperParking);
+  }
+  helperParking.appendChild(entry.element);
+}
+
+/** Detach a Session's element from its pane. With `container`, only when it is
+ *  still mounted there: cleanup from an older mount cannot detach a newer one.
+ *  A helper's element is parked rather than removed. */
 export function unmountElement(id: string, container?: HTMLElement): void {
   const entry = registry.get(id);
   if (!entry || (container && entry.element.parentElement !== container)) return;
-  if (entry.helper) {
-    let parking = document.getElementById('helper-terminal-parking');
-    if (!parking) { parking = document.createElement('div'); parking.id = 'helper-terminal-parking'; parking.hidden = true; document.body.appendChild(parking); }
-    parking.appendChild(entry.element);
-  } else entry.element.remove();
+  if (entry.helper) parkElement(id);
+  else entry.element.remove();
 }
 
 export function disposeAllSessions(): void {
@@ -600,6 +626,9 @@ export function disposeSession(id: string): void {
   const entry = registry.get(id);
   if (!entry) return;
   getPlatform().alertRemove(id);
+  // Before the xterm instance goes: its markers are what notepad pins hold, and
+  // a disposed marker cannot be dropped cleanly afterwards. The notes stay.
+  dropSourcesForTerminal(id);
   entry.cleanup();
   getPlatform().killPty(id);
   entry.element.remove();
diff --git a/lib/src/lib/terminal-state-store.ts b/lib/src/lib/terminal-state-store.ts
index 11d0bb6e..f29d35f9 100644
--- a/lib/src/lib/terminal-state-store.ts
+++ b/lib/src/lib/terminal-state-store.ts
@@ -5,6 +5,7 @@ import {
   cwdFromManualPath,
   cwdFromProcessPath,
   DEFAULT_IDLE_TITLE,
+  processCwdMayReplace,
   reduceTerminalState,
   type CwdState,
   type TerminalPaneState,
@@ -310,8 +311,7 @@ export function fillTerminalProcessCwd(id: string, path: string | null | undefin
 function updateCwdIfAllowed(id: string, cwd: CwdState): void {
   const current = paneStates.get(id);
   if (!current) return;
-  const currentSource = current.cwd?.source;
-  if (currentSource && currentSource !== 'manual' && currentSource !== 'process') return;
+  if (!processCwdMayReplace(current.cwd?.source)) return;
   paneStates.set(id, { ...current, cwd });
   notifyTerminalPaneStateListeners();
 }
diff --git a/lib/src/lib/terminal-state.ts b/lib/src/lib/terminal-state.ts
index 4e574d1d..db2e7f7a 100644
--- a/lib/src/lib/terminal-state.ts
+++ b/lib/src/lib/terminal-state.ts
@@ -314,6 +314,14 @@ export function cwdFromManualPath(rawPath: string, now = Date.now()): CwdState |
   return cwdFromDecodedPath(rawPath, 'manual', now);
 }
 
+/** Whether inspecting the live process may replace a CWD from this source. A
+ *  shell integration escape is the shell's own answer and always wins; nothing
+ *  reported, an earlier inspection, and a launch-time seed are all fillable.
+ *  The one rule for it, so a caller can also decline to *ask*. */
+export function processCwdMayReplace(source: CwdSource | undefined): boolean {
+  return source === undefined || source === 'process' || source === 'manual';
+}
+
 export function cwdIdentity(cwd: CwdState): string {
   const scheme = cwd.scheme ?? 'path';
   const host = cwd.host ?? '';
diff --git a/lib/src/lib/terminal-store.ts b/lib/src/lib/terminal-store.ts
index e806a447..5a559e5d 100644
--- a/lib/src/lib/terminal-store.ts
+++ b/lib/src/lib/terminal-store.ts
@@ -15,6 +15,9 @@ export interface TerminalEntry {
   fit: FitAddon;
   element: HTMLDivElement;
   cleanup: () => void;
+  /** Replace the text snapshot the render handler compares a finalized Dormouse
+   *  selection against; `null` stops it watching. */
+  setSelectionBaseline: (baseline: string | null) => void;
   isReplaying: boolean;
   untouched: boolean;
   /**
@@ -67,3 +70,8 @@ export const registry = new Map<string, TerminalEntry>();
 /** Helper Sessions are private to their source: excluded from alerts, `dor`, remote projections, and cross-pane derivations. */
 export const isHelperSession = (id: string): boolean => !!registry.get(id)?.helper;
 export const pendingShellOpts = new Map<string, PendingShellOpts>();
+/** Arm render-tick invalidation for a selection some other module just set, so
+ *  it is dropped when the text under it changes (a pin's restored range). */
+export function setTerminalSelectionBaseline(id: string, baseline: string | null): void {
+  registry.get(id)?.setSelectionBaseline(baseline);
+}
diff --git a/lib/src/lib/vscode-notepad-global.test.ts b/lib/src/lib/vscode-notepad-global.test.ts
new file mode 100644
index 00000000..79ae82a5
--- /dev/null
+++ b/lib/src/lib/vscode-notepad-global.test.ts
@@ -0,0 +1,130 @@
+/**
+ * The boot global carrying the VS Code volatile notepad mirror. The host wrote
+ * it, but what comes out reaches the live notepad store and from there the
+ * archive, so this is the boundary check: anything that would not read back
+ * through the archive validator degrades to no mirror rather than to entries
+ * nobody validated (`docs/specs/notepad.md` → "Live resume").
+ */
+import { afterEach, describe, expect, it } from 'vitest';
+import type { CwdState } from './terminal-state';
+import { NOTEPAD_VOLATILE_GLOBAL, readInjectedVolatileNotepad } from './vscode-notepad-global';
+
+const CWD: CwdState = {
+  path: '/srv/app',
+  pathKind: 'posix',
+  isRemote: false,
+  source: 'osc7',
+  updatedAt: 5,
+};
+
+function inject(value: unknown): void {
+  (globalThis as unknown as Record<string, unknown>)[NOTEPAD_VOLATILE_GLOBAL] = value;
+}
+
+function surface(overrides: Record<string, unknown> = {}): Record<string, unknown> {
+  return {
+    surfaceId: 'pane-1',
+    surfaceTitle: 'zsh',
+    surfaceKind: 'terminal',
+    cwd: CWD,
+    notes: [{ id: 'n1', createdAt: 1, content: { kind: 'plain', text: 'remember this' } }],
+    ...overrides,
+  };
+}
+
+afterEach(() => {
+  delete (globalThis as unknown as Record<string, unknown>)[NOTEPAD_VOLATILE_GLOBAL];
+});
+
+describe('readInjectedVolatileNotepad', () => {
+  it('is null on a boot that is not a live resume', () => {
+    expect(readInjectedVolatileNotepad()).toBeNull();
+    inject('not an object');
+    expect(readInjectedVolatileNotepad()).toBeNull();
+  });
+
+  it('reads a well-formed mirror whole, cwd included', () => {
+    inject({ surfaces: [surface()], stagedDeletions: { deleteBatchIds: [], deleteNotes: [] } });
+
+    const mirror = readInjectedVolatileNotepad();
+    expect(mirror!.surfaces).toEqual([{
+      surfaceId: 'pane-1',
+      surfaceTitle: 'zsh',
+      surfaceKind: 'terminal',
+      cwd: CWD,
+      notes: [{ id: 'n1', createdAt: 1, content: { kind: 'plain', text: 'remember this' } }],
+    }]);
+  });
+
+  it('round-trips the PTY id, and drops one that is not a string', () => {
+    inject({ surfaces: [surface({ terminalId: 'pty-9' })] });
+    expect(readInjectedVolatileNotepad()!.surfaces[0].terminalId).toBe('pty-9');
+
+    // Same tolerance as the CWD: it is metadata for a teardown that has not
+    // happened, and a resuming webview derives its own anyway.
+    inject({ surfaces: [surface({ terminalId: 7 })] });
+    const [read] = readInjectedVolatileNotepad()!.surfaces;
+    expect(read.terminalId).toBeUndefined();
+    expect(read.notes).toHaveLength(1);
+  });
+
+  it('drops a Surface whose kind is not one of the known kinds', () => {
+    inject({ surfaces: [surface({ surfaceKind: 'spreadsheet' }), surface({ surfaceId: 'pane-2' })] });
+    expect(readInjectedVolatileNotepad()!.surfaces.map((s) => s.surfaceId)).toEqual(['pane-2']);
+  });
+
+  it('drops a Surface whole when any one of its notes is invalid', () => {
+    // Half a notepad is worse than none: the missing notes would look deleted,
+    // and the ones that survived would be archived as the whole thing.
+    inject({
+      surfaces: [
+        surface({
+          notes: [
+            { id: 'n1', createdAt: 1, content: { kind: 'plain', text: 'good' } },
+            { id: 'n2', createdAt: 'yesterday', content: { kind: 'plain', text: 'bad' } },
+          ],
+        }),
+        surface({ surfaceId: 'pane-2' }),
+      ],
+    });
+    expect(readInjectedVolatileNotepad()!.surfaces.map((s) => s.surfaceId)).toEqual(['pane-2']);
+  });
+
+  it('drops a run colour the archive would reject, with its Surface', () => {
+    inject({
+      surfaces: [surface({
+        notes: [{ id: 'n1', createdAt: 1, content: { kind: 'terminal', runs: [{ text: 'x', foreground: 'red' }] } }],
+      })],
+    });
+    expect(readInjectedVolatileNotepad()!.surfaces).toEqual([]);
+  });
+
+  it('keeps a Surface whose cwd is malformed, with no cwd', () => {
+    // The CWD is metadata for a batch this Surface has not written yet, so a bad
+    // one is dropped rather than costing the user their notes.
+    inject({ surfaces: [surface({ cwd: { path: '/srv/app', pathKind: 'martian' } })] });
+    const [read] = readInjectedVolatileNotepad()!.surfaces;
+    expect(read.cwd).toBeNull();
+    expect(read.notes).toHaveLength(1);
+
+    // A field outside `CwdState` is malformed too, for the same reason the
+    // archive refuses one: the batch this Surface writes would drop it.
+    inject({ surfaces: [surface({ cwd: { ...CWD, drive: 'C:' } })] });
+    expect(readInjectedVolatileNotepad()!.surfaces[0].cwd).toBeNull();
+  });
+
+  it('drops a Surface whose note carries a field the archive does not know', () => {
+    inject({
+      surfaces: [
+        surface({ notes: [{ id: 'n1', createdAt: 1, source: { terminalId: 't1' }, content: { kind: 'plain', text: 'x' } }] }),
+        surface({ surfaceId: 'pane-2' }),
+      ],
+    });
+    expect(readInjectedVolatileNotepad()!.surfaces.map((s) => s.surfaceId)).toEqual(['pane-2']);
+  });
+});
+
+it('retains a pending batch identity even when all its notes were deleted', () => {
+  inject({ surfaces: [surface({ notes: [], pendingBatchId: 'pending' })], stagedDeletions: {} });
+  expect(readInjectedVolatileNotepad()?.surfaces[0]).toMatchObject({ notes: [], pendingBatchId: 'pending' });
+});
diff --git a/lib/src/lib/vscode-notepad-global.ts b/lib/src/lib/vscode-notepad-global.ts
new file mode 100644
index 00000000..517c4b74
--- /dev/null
+++ b/lib/src/lib/vscode-notepad-global.ts
@@ -0,0 +1,97 @@
+/**
+ * The boot global carrying the VS Code extension host's volatile notepad mirror
+ * into a *live resume* — a webview re-resolved over PTYs the extension host
+ * still owns (`docs/specs/notepad.md` → Archive and Lifecycle).
+ *
+ * The name and the read live here, together, for the same reason
+ * `vscode-recovery-global.ts` does it: the writer
+ * (`vscode-ext/src/webview-html.ts`) and the reader
+ * (`lib/src/lib/platform/vscode-adapter.ts`) sit in different packages, and a
+ * string duplicated across that boundary fails *silently* — nothing errors, the
+ * notes simply never come back. Sharing the constant makes a mismatch a compile
+ * error instead.
+ */
+import { SURFACE_KINDS, type SurfaceKind } from 'dor/commands/types';
+import { readArchivedNote, readCwdState, readMirrorTerminalId } from './notepad/archive-model';
+import type { ArchivedNote, VolatileNotepadSnapshot, VolatileSurfaceNotes } from './notepad/types';
+
+/** Global the host injects the mirror into; `null` on every other boot. */
+export const NOTEPAD_VOLATILE_GLOBAL = '__DORMOUSE_NOTEPAD_VOLATILE__';
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+
+function readSurface(value: unknown): VolatileSurfaceNotes | null {
+  if (!isRecord(value)) return null;
+  if (typeof value.surfaceId !== 'string' || !value.surfaceId) return null;
+  if (typeof value.surfaceTitle !== 'string') return null;
+  if (typeof value.surfaceKind !== 'string' || !SURFACE_KINDS.includes(value.surfaceKind as SurfaceKind)) return null;
+  if (!Array.isArray(value.notes)) return null;
+  const notes: ArchivedNote[] = [];
+  for (const raw of value.notes) {
+    const note = readArchivedNote(raw);
+    // One bad note drops the whole Surface: these go into the live store and
+    // from there into the archive, so a half-read notepad would silently lose
+    // notes rather than fail to restore them.
+    if (!note) return null;
+    notes.push(note);
+  }
+  const terminalId = readMirrorTerminalId(value.terminalId);
+  return {
+    surfaceId: value.surfaceId,
+    surfaceTitle: value.surfaceTitle,
+    surfaceKind: value.surfaceKind as SurfaceKind,
+    // A CWD that does not read back is dropped, not fatal — it is metadata for
+    // a batch this Surface has not written yet. The PTY id beside it is the
+    // same: the resuming webview re-derives its own.
+    cwd: readCwdState(value.cwd),
+    ...(terminalId ? { terminalId } : {}),
+    ...(typeof value.pendingBatchId === 'string' && value.pendingBatchId
+      ? { pendingBatchId: value.pendingBatchId } : {}),
+    notes,
+  };
+}
+
+function readIdList(value: unknown): string[] {
+  if (!Array.isArray(value)) return [];
+  return value.filter((id): id is string => typeof id === 'string' && id.length > 0);
+}
+
+function readNoteRefs(value: unknown): Array<{ batchId: string; noteId: string }> {
+  if (!Array.isArray(value)) return [];
+  const refs: Array<{ batchId: string; noteId: string }> = [];
+  for (const entry of value) {
+    if (!isRecord(entry)) continue;
+    if (typeof entry.batchId !== 'string' || typeof entry.noteId !== 'string') continue;
+    refs.push({ batchId: entry.batchId, noteId: entry.noteId });
+  }
+  return refs;
+}
+
+/**
+ * Read the injected mirror, or `null` when this boot is not a live resume.
+ *
+ * Validated rather than trusted, like the recovery commands: the host wrote it,
+ * but the notes reach the live notepad store and from there the archive, so a
+ * payload that does not fit degrades to "no mirror" rather than to entries
+ * nobody checked. It runs the archive validator's own readers rather than a
+ * second copy of the schema — one bad note drops its Surface whole.
+ */
+export function readInjectedVolatileNotepad(): VolatileNotepadSnapshot | null {
+  const raw = (globalThis as unknown as Record<string, unknown>)[NOTEPAD_VOLATILE_GLOBAL];
+  if (!isRecord(raw) || !Array.isArray(raw.surfaces)) return null;
+  const surfaces: VolatileSurfaceNotes[] = [];
+  for (const entry of raw.surfaces) {
+    const surface = readSurface(entry);
+    if (surface) surfaces.push(surface);
+  }
+  const staged = isRecord(raw.stagedDeletions) ? raw.stagedDeletions : {};
+  return {
+    surfaces,
+    stagedDeletions: {
+      deleteBatchIds: readIdList(staged.deleteBatchIds),
+      deleteNotes: readNoteRefs(staged.deleteNotes),
+    },
+  };
+}
diff --git a/lib/src/remote/burrow/RemotePairingModalHost.tsx b/lib/src/remote/burrow/RemotePairingModalHost.tsx
index d767865b..24d3f215 100644
--- a/lib/src/remote/burrow/RemotePairingModalHost.tsx
+++ b/lib/src/remote/burrow/RemotePairingModalHost.tsx
@@ -5,6 +5,7 @@ import {
   subscribePairingApproval,
 } from './pairing-approval';
 import { installBurrowConsoleHook } from './activation';
+import { useDialogKeyboardOwner } from '../../components/wall/wall-context';
 
 /**
  * Renders the head of the pairing-approval queue and, on mount, wires this
@@ -12,21 +13,14 @@ import { installBurrowConsoleHook } from './activation';
  * other modal hosts in the wall — additive, and inert unless the user has
  * enrolled a Burrow.
  */
-export function RemotePairingModalHost({
-  onKeyboardActiveChange,
-}: {
-  onKeyboardActiveChange?: (active: boolean) => void;
-}) {
+export function RemotePairingModalHost() {
   const pending = useSyncExternalStore(subscribePairingApproval, getPairingApprovalSnapshot);
   const head = pending[0] ?? null;
 
   // Idempotent, because StrictMode mounts this twice.
   useEffect(() => installBurrowConsoleHook(), []);
 
-  useEffect(() => {
-    onKeyboardActiveChange?.(head !== null);
-    return () => onKeyboardActiveChange?.(false);
-  }, [onKeyboardActiveChange, head]);
+  useDialogKeyboardOwner(head !== null);
 
   if (!head) return null;
 
diff --git a/lib/src/stories/Door.stories.tsx b/lib/src/stories/Door.stories.tsx
index 8f4b4b6e..83e6b162 100644
--- a/lib/src/stories/Door.stories.tsx
+++ b/lib/src/stories/Door.stories.tsx
@@ -1,5 +1,11 @@
+import { useEffect } from 'react';
 import type { Meta, StoryObj } from '@storybook/react';
 import { Door } from '../components/Door';
+import { Baseboard } from '../components/Baseboard';
+import { addPlainNote, clearAllNotepads } from '../lib/notepad/notepad-store';
+import { requireElement } from './settle-terminals';
+
+const NOTED_DOOR_ID = 'door-story';
 
 function DoorStory({
   width = 260,
@@ -21,6 +27,33 @@ function DoorStory({
   );
 }
 
+/** The real baseboard, because the popover is the Baseboard's to open — the
+ *  Door only asks. */
+function NotedDoorStory({ noteCount = 2 }: { noteCount?: number }) {
+  useEffect(() => {
+    for (let i = 0; i < noteCount; i++) addPlainNote(NOTED_DOOR_ID, `note ${i + 1}`);
+    return () => clearAllNotepads();
+  }, [noteCount]);
+
+  return (
+    <div className="bg-app-bg flex h-40 flex-col justify-end" style={{ width: 520 }}>
+      <Baseboard
+        items={[{ id: NOTED_DOOR_ID, kind: 'terminal', title: 'build-server' }]}
+        onReattach={() => {}}
+      />
+    </div>
+  );
+}
+
+async function openDoorNotepad() {
+  const button = await requireElement<HTMLButtonElement>(
+    `[data-door-notepad-for="${NOTED_DOOR_ID}"]`,
+    'Door notepad button',
+  );
+  button.click();
+  await requireElement(`[data-notepad-popover-for="${NOTED_DOOR_ID}"]`, 'Door notepad popover');
+}
+
 const meta: Meta<typeof DoorStory> = {
   title: 'Components/Door',
   component: DoorStory,
@@ -65,3 +98,18 @@ export const LongTitleWithIndicators: Story = {
     status: 'NOTHING_TO_SHOW',
   },
 };
+
+/** A Door carrying notes: a second button, filled, that never reattaches. */
+export const WithNotes: Story = {
+  args: { noteCount: 3, status: 'NOTHING_TO_SHOW' },
+};
+
+export const WithNotesAndIndicators: Story = {
+  args: { noteCount: 1, todo: true, status: 'ALERT_RINGING' },
+};
+
+export const NotepadPopover: StoryObj<typeof NotedDoorStory> = {
+  render: (args) => <NotedDoorStory {...args} />,
+  args: { noteCount: 2 },
+  play: openDoorNotepad,
+};
diff --git a/lib/src/stories/NotepadArchiveView.stories.tsx b/lib/src/stories/NotepadArchiveView.stories.tsx
new file mode 100644
index 00000000..e9dcd400
--- /dev/null
+++ b/lib/src/stories/NotepadArchiveView.stories.tsx
@@ -0,0 +1,198 @@
+import { useLayoutEffect } from 'react';
+import type { Meta, StoryObj } from '@storybook/react';
+import { userEvent, within } from 'storybook/test';
+import { NotepadArchiveView } from '../components/NotepadArchiveView';
+import { getPlatform } from '../lib/platform';
+import type { FakePtyAdapter } from '../lib/platform/fake-adapter';
+import { refreshArchive } from '../lib/notepad/archive-service';
+import type { ArchiveBatch, NotepadArchiveV1 } from '../lib/notepad/types';
+import type { CwdState } from '../lib/terminal-state';
+
+/**
+ * Batch times are frozen literals rather than offsets from `Date.now()`: the
+ * header renders an absolute date, so a live clock would make every snapshot a
+ * diff.
+ */
+const MORNING = Date.parse('2026-03-04T09:12:00Z');
+const YESTERDAY = Date.parse('2026-03-03T17:41:00Z');
+const LAST_WEEK = Date.parse('2026-02-26T11:05:00Z');
+
+const LOCAL_CWD: CwdState = {
+  path: '/Users/ned/projects/dormouse/lib/src/components',
+  pathKind: 'posix',
+  isRemote: false,
+  source: 'osc7',
+  updatedAt: MORNING,
+};
+
+/** A remote CWD renders its host, because `/srv/app` on the build box and
+ *  `/srv/app` here are not the same directory. */
+const REMOTE_CWD: CwdState = {
+  path: '/srv/build/dormouse',
+  host: 'build-box.tailnet.ts.net',
+  scheme: 'file',
+  pathKind: 'posix',
+  isRemote: true,
+  source: 'osc7',
+  updatedAt: YESTERDAY,
+};
+
+/** A captured terminal excerpt: the four attributes capture keeps, and nothing
+ *  else. Colors are the terminal's own resolved values, so they are literal
+ *  here in a way no chrome would be. */
+const FAILING_TEST: ArchiveBatch = {
+  id: 'batch-local',
+  closedAt: MORNING,
+  surfaceTitle: 'pnpm test',
+  surfaceKind: 'terminal',
+  cwd: LOCAL_CWD,
+  notes: [
+    {
+      id: 'note-rich',
+      createdAt: MORNING,
+      content: {
+        kind: 'terminal',
+        runs: [
+          { text: ' FAIL ', bold: true, foreground: '#ffffff', background: '#c4314b' },
+          { text: '  src/components/design.test.ts\n' },
+          { text: '    ✕ ', foreground: '#c4314b' },
+          { text: 'popover cap matches the viewport margin', italic: true },
+          { text: '\n    → expected ' },
+          { text: '24px', bold: true, foreground: '#4f9153' },
+          { text: ' but got ' },
+          { text: '16px', bold: true, foreground: '#c4314b' },
+        ],
+      },
+    },
+    {
+      id: 'note-plain',
+      createdAt: MORNING + 60_000,
+      content: {
+        kind: 'plain',
+        text: 'the popover budget moved when OVERLAY_MAX_HEIGHT landed — check design.test.ts before touching the margin again',
+      },
+    },
+  ],
+};
+
+const REMOTE_BUILD: ArchiveBatch = {
+  id: 'batch-remote',
+  closedAt: YESTERDAY,
+  surfaceTitle: 'cargo build --release',
+  surfaceKind: 'terminal',
+  cwd: REMOTE_CWD,
+  notes: [
+    {
+      id: 'note-remote',
+      createdAt: YESTERDAY,
+      content: {
+        kind: 'terminal',
+        runs: [
+          { text: 'warning', bold: true, foreground: '#b08800' },
+          { text: ': unused variable: ' },
+          { text: '`quit_progress`', bold: true },
+        ],
+      },
+    },
+  ],
+};
+
+/** A browser Surface has no CWD at all — the header has to read as complete
+ *  without one rather than leaving a hole where the path goes. */
+const BROWSER_BATCH: ArchiveBatch = {
+  id: 'batch-browser',
+  closedAt: LAST_WEEK,
+  surfaceTitle: 'xterm.js API — IBufferCell',
+  surfaceKind: 'browser',
+  cwd: null,
+  notes: [
+    {
+      id: 'note-browser',
+      createdAt: LAST_WEEK,
+      content: {
+        kind: 'plain',
+        text: 'getFgColorMode() returns the palette mode; bold + palette 0-7 resolves bright while drawBoldTextInBrightColors is on.',
+      },
+    },
+  ],
+};
+
+const POPULATED: NotepadArchiveV1 = {
+  version: 1,
+  // Deliberately not in closure order: the view sorts, nothing else does.
+  batches: [REMOTE_BUILD, BROWSER_BATCH, FAILING_TEST],
+};
+
+/**
+ * Install the story's archive into the fake platform's memory port and re-read
+ * it. Both are module-global — one platform, one archive store, shared by every
+ * story — so each story seeds what it wants and clears what the last one left.
+ * A layout effect, so the seed lands before the view's own mount load runs.
+ */
+function ArchiveStory({ seed, corrupt }: { seed?: NotepadArchiveV1; corrupt?: boolean }) {
+  useLayoutEffect(() => {
+    const platform = getPlatform() as FakePtyAdapter;
+    platform.notepadArchive.clear();
+    if (corrupt) platform.notepadArchive.corrupt();
+    else if (seed) platform.notepadArchive.seed(seed);
+    void refreshArchive();
+  }, [seed, corrupt]);
+
+  return <NotepadArchiveView onBack={() => {}} onClose={() => {}} />;
+}
+
+const meta: Meta<typeof ArchiveStory> = {
+  title: 'Modals/NotepadArchiveView',
+  component: ArchiveStory,
+};
+
+export default meta;
+type Story = StoryObj<typeof ArchiveStory>;
+
+/**
+ * The populated archive: a local terminal batch with a rich capture and a plain
+ * note, a remote one whose header carries its host, and a browser batch with no
+ * CWD. Newest first.
+ */
+export const Populated: Story = {
+  args: { seed: POPULATED },
+  play: async ({ canvasElement }) => {
+    await within(canvasElement).findByText('pnpm test');
+  },
+};
+
+/**
+ * Mid-deletion: one note staged, so the irreversibility bar and its Undo are
+ * up. Nothing has been written yet — leaving the view is what commits it.
+ */
+export const StagedDeletion: Story = {
+  args: { seed: POPULATED },
+  play: async ({ canvasElement }) => {
+    const canvas = within(canvasElement);
+    await canvas.findByText('pnpm test');
+    const deletes = await canvas.findAllByLabelText('Delete note');
+    await userEvent.click(deletes[0]!);
+    await canvas.findByText(/Deletion is irreversible/);
+  },
+};
+
+/** Nothing has ever been archived. It has to explain where batches come from,
+ *  because nothing in this view can create one. */
+export const EmptyArchive: Story = {
+  args: { seed: { version: 1, batches: [] } },
+  play: async ({ canvasElement }) => {
+    await within(canvasElement).findByText(/Nothing archived yet/);
+  },
+};
+
+/**
+ * Stored data the validator rejected. The copy's job is to say that nothing was
+ * replaced: the button below it is the only thing in the app that ever moves an
+ * archive aside, and it keeps a copy when it does.
+ */
+export const Unreadable: Story = {
+  args: { corrupt: true },
+  play: async ({ canvasElement }) => {
+    await within(canvasElement).findByText(/could not be read/);
+  },
+};
diff --git a/lib/src/stories/NotepadPanel.stories.tsx b/lib/src/stories/NotepadPanel.stories.tsx
new file mode 100644
index 00000000..7350d8ef
--- /dev/null
+++ b/lib/src/stories/NotepadPanel.stories.tsx
@@ -0,0 +1,132 @@
+import { useEffect } from 'react';
+import type { Meta, StoryObj } from '@storybook/react';
+import { NotepadPanel } from '../components/NotepadPanel';
+import {
+  addPlainNote,
+  addTerminalNote,
+  clearAllNotepads,
+  setOpenNotepadId,
+} from '../lib/notepad/notepad-store';
+import type { RichTextRun, RuntimeTerminalSource } from '../lib/notepad/types';
+import { requireElement } from './settle-terminals';
+
+const SURFACE_ID = 'notepad-story';
+
+type Seed =
+  | { kind: 'plain'; text: string }
+  | { kind: 'terminal'; runs: RichTextRun[]; pinned?: boolean };
+
+/**
+ * A source link with inert markers. The pin's own resolution is the capture
+ * work's; what these stories show is the affordance and its failure message.
+ */
+function stubSource(): RuntimeTerminalSource {
+  const marker = { id: 0, line: 0, isDisposed: false, dispose() {}, onDispose: () => ({ dispose() {} }) };
+  return {
+    terminalId: SURFACE_ID,
+    startMarker: marker,
+    endMarker: marker,
+    startColumn: 0,
+    endColumn: 40,
+    shape: 'linewise',
+    expectedRawText: '',
+  } as unknown as RuntimeTerminalSource;
+}
+
+/**
+ * The attached notepad over a stand-in Surface body — the panel corners itself
+ * in it at three quarters of its width and height.
+ */
+function NotepadPanelStory({
+  notes = [],
+  width = 720,
+  height = 420,
+}: {
+  notes?: Seed[];
+  width?: number;
+  height?: number;
+}) {
+  useEffect(() => {
+    clearAllNotepads();
+    for (const note of notes) {
+      if (note.kind === 'plain') addPlainNote(SURFACE_ID, note.text);
+      else addTerminalNote(SURFACE_ID, note.runs, note.pinned ? stubSource() : undefined);
+    }
+    setOpenNotepadId(SURFACE_ID);
+    return () => clearAllNotepads();
+  }, [notes]);
+
+  return (
+    <div className="relative overflow-hidden rounded-lg bg-terminal-bg" style={{ width, height }}>
+      <NotepadPanel surfaceId={SURFACE_ID} />
+    </div>
+  );
+}
+
+/** Follow a pin that cannot resolve: the panel comes back saying so. */
+async function clickUnavailablePin() {
+  const pin = await requireElement<HTMLButtonElement>('[aria-label="Show source"]', 'source pin');
+  pin.click();
+  await requireElement('[role="status"]', 'source-unavailable message');
+}
+
+const meta: Meta<typeof NotepadPanelStory> = {
+  title: 'Components/NotepadPanel',
+  component: NotepadPanelStory,
+  argTypes: {
+    width: { control: 'number' },
+    height: { control: 'number' },
+  },
+};
+
+export default meta;
+type Story = StoryObj<typeof NotepadPanelStory>;
+
+export const Empty: Story = {
+  args: { notes: [] },
+};
+
+export const PlainNotes: Story = {
+  args: {
+    notes: [
+      { kind: 'plain', text: 'ask about the flaky resize test' },
+      { kind: 'plain', text: 'PORT=5173\nDEBUG=dormouse:*' },
+    ],
+  },
+};
+
+export const TerminalNotes: Story = {
+  args: {
+    notes: [
+      {
+        kind: 'terminal',
+        runs: [
+          { text: 'FAIL ', bold: true, foreground: '#ff5f56' },
+          { text: 'src/components/Wall.test.tsx' },
+        ],
+      },
+      {
+        kind: 'terminal',
+        runs: [
+          { text: '  ✓ ', foreground: '#27c93f' },
+          { text: 'restores a door ', italic: true },
+          { text: '12ms', foreground: '#8a8a8a', background: '#1f1f1f' },
+        ],
+      },
+      { kind: 'plain', text: 'both from the same run' },
+    ],
+  },
+};
+
+export const SourceNoLongerAvailable: Story = {
+  args: {
+    notes: [
+      {
+        kind: 'terminal',
+        runs: [{ text: 'error[E0308]: mismatched types', bold: true, foreground: '#ff5f56' }],
+        pinned: true,
+      },
+    ],
+  },
+  play: clickUnavailablePin,
+};
diff --git a/lib/src/stories/QuitConfirmModal.stories.tsx b/lib/src/stories/QuitConfirmModal.stories.tsx
index acbdd5e5..e481cd6b 100644
--- a/lib/src/stories/QuitConfirmModal.stories.tsx
+++ b/lib/src/stories/QuitConfirmModal.stories.tsx
@@ -16,14 +16,14 @@ function runningPanes(count: number) {
   };
 }
 
-function QuitConfirmModalStory({ confirming }: { confirming: boolean }) {
+function QuitConfirmModalStory({ confirming, archiveError }: { confirming: boolean; archiveError?: string | null }) {
   // Cancel/Quit call the quit-confirm store's actions, which no-op without an
   // active quit context — the buttons are safely inert here.
   return (
     <div className="relative h-[420px] w-[720px] overflow-hidden rounded bg-app-bg p-4 font-mono text-sm text-terminal-fg">
       <div>dev@dormouse:~/repo$ pnpm test --watch</div>
       <div className="text-muted">RUN v4.1.9 …</div>
-      <QuitConfirmModal confirming={confirming} />
+      <QuitConfirmModal confirming={confirming} archiveError={archiveError} />
     </div>
   );
 }
@@ -62,3 +62,14 @@ export const Quitting: Story = {
   args: { confirming: true },
   parameters: { primedTerminalState: runningPanes(2) },
 };
+
+// The archive gate refused the quit (docs/specs/notepad.md → "Standalone
+// quit"): the running-command decision is already made, so the dialog now asks
+// only whether to lose the notes. Cancel is the default action.
+export const ArchiveFailed: Story = {
+  args: {
+    confirming: false,
+    archiveError: 'The notepad archive could not be written: no space left on device.',
+  },
+  parameters: { primedTerminalState: runningPanes(2) },
+};
diff --git a/lib/src/stories/SelectionPopup.stories.tsx b/lib/src/stories/SelectionPopup.stories.tsx
index aa9863cc..be3876a4 100644
--- a/lib/src/stories/SelectionPopup.stories.tsx
+++ b/lib/src/stories/SelectionPopup.stories.tsx
@@ -10,7 +10,7 @@ import {
   refitSession,
   unmountElement,
 } from '../lib/terminal-registry';
-import { flattenScenario, SCENARIO_LS_OUTPUT } from '../lib/platform';
+import { flattenScenario, getPlatform, SCENARIO_LS_OUTPUT } from '../lib/platform';
 import { getMouseSelectionState, setSelection, type Selection } from '../lib/mouse-selection';
 import { TERMINAL_BOTTOM_RADIUS_CLASS } from '../components/design';
 import { TouchUiContext } from '../components/touch-ui-context';
@@ -20,13 +20,24 @@ function SelectionPopupStory({
   id,
   selection,
   touch = false,
+  reservesChord = false,
 }: {
   id: string;
   selection: Omit<Selection, 'startedInScrollback'>;
   touch?: boolean;
+  /** Stand in for the website demo's adapter, whose browser has already claimed
+   *  Cmd/Ctrl+N. Set during render because the popup reads it during render;
+   *  cleared on unmount so it cannot leak into the next story. */
+  reservesChord?: boolean;
 }) {
   const terminalHostRef = useRef<HTMLDivElement>(null);
 
+  const platform = getPlatform() as { browserReservesNotepadChord?: boolean };
+  platform.browserReservesNotepadChord = reservesChord || undefined;
+  useEffect(() => () => {
+    platform.browserReservesNotepadChord = undefined;
+  }, [platform]);
+
   useEffect(() => {
     const terminalHost = terminalHostRef.current;
     if (!terminalHost) return;
@@ -100,19 +111,32 @@ const meta: Meta<typeof SelectionPopupStory> = {
 export default meta;
 type Story = StoryObj<typeof SelectionPopupStory>;
 
-// Desktop: copy buttons carry their keyboard shortcuts and, for a downward drag,
-// sit below the selection.
+const SELECTION: Omit<Selection, 'startedInScrollback'> = {
+  startRow: 2,
+  startCol: 5,
+  endRow: 6,
+  endCol: 24,
+  shape: 'linewise',
+  dragging: false,
+};
+
+// Desktop: all three buttons carry their keyboard shortcuts and, for a downward
+// drag, sit below the selection. The fake adapter has an in-memory notepad
+// archive, so Add to notepad is present here as it is in every real desktop host.
 export const Desktop: Story = {
   args: {
     id: 'selection-popup-desktop',
-    selection: {
-      startRow: 2,
-      startCol: 5,
-      endRow: 6,
-      endCol: 24,
-      shape: 'linewise',
-      dragging: false,
-    },
+    selection: SELECTION,
+  },
+};
+
+// The website demo: the notepad is there, but the browser owns Cmd/Ctrl+N, so
+// the third button shows no shortcut while the two copy chords keep theirs.
+export const ChordReservedByBrowser: Story = {
+  args: {
+    id: 'selection-popup-reserved-chord',
+    reservesChord: true,
+    selection: SELECTION,
   },
 };
 
@@ -122,13 +146,6 @@ export const Mobile: Story = {
   args: {
     id: 'selection-popup-mobile',
     touch: true,
-    selection: {
-      startRow: 2,
-      startCol: 5,
-      endRow: 6,
-      endCol: 24,
-      shape: 'linewise',
-      dragging: false,
-    },
+    selection: SELECTION,
   },
 };
diff --git a/lib/src/stories/SettingsDialog.stories.tsx b/lib/src/stories/SettingsDialog.stories.tsx
index 0db97605..d8b8ef74 100644
--- a/lib/src/stories/SettingsDialog.stories.tsx
+++ b/lib/src/stories/SettingsDialog.stories.tsx
@@ -178,6 +178,27 @@ export const ManyRules: Story = {
   },
 };
 
+/**
+ * The Notepad archive entry, last in the dialog. Every host but Pocket has an
+ * archive port, so the entry is present in every story here — this one is the
+ * one that scrolls to it and proves it opens the Archive view in place rather
+ * than stacking a second modal (`NotepadArchiveView.stories.tsx` covers the
+ * view itself).
+ */
+export const NotepadArchiveEntry: Story = {
+  parameters: {
+    primedWatchedCommands: ['claude'],
+    primedAlertSettings: {},
+  },
+  play: async ({ canvasElement }) => {
+    const canvas = within(canvasElement);
+    const open = await canvas.findByRole('button', { name: 'Open archive' });
+    open.scrollIntoView();
+    await userEvent.click(open);
+    await canvas.findByRole('button', { name: /Back to Settings/ });
+  },
+};
+
 /** Opens the picker whose trigger matches `name`.
  *
  *  Storybook's `play` runs before the snapshot, but the menu positions itself
diff --git a/lib/src/stories/TerminalContext.stories.tsx b/lib/src/stories/TerminalContext.stories.tsx
index 9430d284..a1aeb0fe 100644
--- a/lib/src/stories/TerminalContext.stories.tsx
+++ b/lib/src/stories/TerminalContext.stories.tsx
@@ -2,10 +2,12 @@ import { useState, type ReactNode } from 'react';
 import type { Meta, StoryObj } from '@storybook/react';
 import { BellIcon, FrameCornersIcon, XIcon } from '@phosphor-icons/react';
 import { PANE_HEADER_HEIGHT_PX } from '../components/design';
+import { NotepadHeaderButton } from '../components/wall/NotepadHeaderButton';
+import { NotepadPanel } from '../components/NotepadPanel';
 import { TerminalContextView } from '../components/wall/TerminalContextView';
 
-// Presentation only: no PTYs, platform calls, persistence, or production menu
-// wiring. Local state switches fixtures and opens visual detail treatments.
+// Sample terminal output with the shared context presentation and notepad UI.
+// Local state switches fixtures and opens visual detail treatments.
 type Scenario = 'fresh' | 'noPorts' | 'running' | 'preserved' | 'editor' | 'differentDirectory' | 'multiplePorts' | 'notification' | 'autorunOff' | 'scanFailed';
 const SCENARIOS: { id: Scenario; label: string }[] = [
   { id: 'fresh', label: 'Common case' },
@@ -101,6 +103,7 @@ function ContextPrototype({ scenario, initialDetail = null, paneWidth }: { scena
         argv0="pnpm" watching={watching} todo={todo} notification={scenario === 'notification' ? { title: 'Tests complete', body: '341 passed, 0 failed' } : null}
         status={preserved ? 'preserved' : scenario === 'running' ? 'running' : scenario === 'autorunOff' ? 'off' : 'completed'} command={command}
         explorerLabel="Open in Finder" canExplore canAgent canIframe initialDetail={initialDetail}
+        notepadAction={<NotepadHeaderButton surfaceId="context-gallery" />} notepadPanel={<NotepadPanel surfaceId="context-gallery" pins={false} />}
         onClose={() => {}} onCopyRef={() => {}} onCopyPath={() => {}} onExplore={() => {}} onPort={() => {}}
         onWatch={() => setWatching(!watching)} onTodo={() => setTodo(!todo)} onModify={async value => setCommand(value)} onReset={async () => {}} onPromote={async () => {}}>
         <div className="h-full overflow-auto px-3 py-2" style={{ fontSize: 13, lineHeight: '20px', whiteSpace: 'pre-wrap' }}><TerminalOutput scenario={scenario} /></div>
diff --git a/lib/src/stories/TerminalPaneHeader.stories.tsx b/lib/src/stories/TerminalPaneHeader.stories.tsx
index bee14e1c..22da10eb 100644
--- a/lib/src/stories/TerminalPaneHeader.stories.tsx
+++ b/lib/src/stories/TerminalPaneHeader.stories.tsx
@@ -13,6 +13,7 @@ import {
 import type { ActivityNotification } from '../lib/alert-manager';
 import { summarizeCommandLine, type SetTerminalUserTitleResult } from '../lib/terminal-registry';
 import { removeMouseSelectionState, setMouseReporting, setOverride } from '../lib/mouse-selection';
+import { addPlainNote, clearAllNotepads } from '../lib/notepad/notepad-store';
 import { requireElement, settleTerminals, waitForCondition, waitForPrimedState } from './settle-terminals';
 
 const SESSION_ID = 'tab-story';
@@ -97,6 +98,7 @@ function TabStory({
   width = 360,
   reducedMotion = false,
   mouseCaptured = false,
+  noteCount = 0,
   actions = noopActions,
 }: {
   title?: string;
@@ -107,6 +109,8 @@ function TabStory({
   reducedMotion?: boolean;
   /** Simulate a TUI capturing the mouse, which surfaces the mouse-override icon. */
   mouseCaptured?: boolean;
+  /** Notes on this Surface — the notepad icon fills, and survives the minimal tier. */
+  noteCount?: number;
   actions?: WallActions;
 }) {
   useEffect(() => {
@@ -116,6 +120,11 @@ function TabStory({
     return () => removeMouseSelectionState(SESSION_ID);
   }, [mouseCaptured]);
 
+  useEffect(() => {
+    for (let i = 0; i < noteCount; i++) addPlainNote(SESSION_ID, `note ${i + 1}`);
+    return () => clearAllNotepads();
+  }, [noteCount]);
+
   return (
     <ModeContext.Provider value={mode}>
       <SelectedIdContext.Provider value={isSelected ? SESSION_ID : null}>
@@ -338,6 +347,7 @@ const meta: Meta<typeof TabStory> = {
     width: { control: 'number' },
     reducedMotion: { control: 'boolean' },
     mouseCaptured: { control: 'boolean' },
+    noteCount: { control: 'number' },
   },
   args: {
     title: 'build-server',
@@ -347,6 +357,7 @@ const meta: Meta<typeof TabStory> = {
     width: 360,
     reducedMotion: false,
     mouseCaptured: false,
+    noteCount: 0,
   },
 };
 
@@ -620,6 +631,35 @@ export const NarrowWithMouseCaptureControlsVisible: Story = {
   play: assertControlsVisible,
 };
 
+// --- Notepad icon across the tiers -----------------------------------------
+//
+// Present at `full` and `compact`; at `minimal` an empty notepad yields its
+// 20px to the title, and one with notes keeps it (`docs/specs/notepad.md`).
+
+export const NotepadEmpty: Story = {
+  parameters: primedState({ status: 'NOTHING_TO_SHOW', todo: false }),
+};
+
+export const NotepadWithNotes: Story = {
+  args: { noteCount: 3 },
+  parameters: primedState({ status: 'NOTHING_TO_SHOW', todo: false }),
+};
+
+export const NotepadCompactWidth: Story = {
+  args: { width: 220, noteCount: 3 },
+  parameters: primedState({ status: 'NOTHING_TO_SHOW', todo: false }),
+};
+
+export const NotepadMinimalWidthEmpty: Story = {
+  args: { width: 150 },
+  parameters: primedState({ status: 'NOTHING_TO_SHOW', todo: false }),
+};
+
+export const NotepadMinimalWidthWithNotes: Story = {
+  args: { width: 150, noteCount: 2 },
+  parameters: primedState({ status: 'NOTHING_TO_SHOW', todo: false }),
+};
+
 export const NarrowLongTitleControlsVisible: Story = {
   args: {
     title: 'my-extremely-long-running-background-process-with-a-very-descriptive-name',
diff --git a/scripts/spec-word-budgets.json b/scripts/spec-word-budgets.json
index f2e729a6..63d729b7 100644
--- a/scripts/spec-word-budgets.json
+++ b/scripts/spec-word-budgets.json
@@ -1,5 +1,5 @@
 {
-  "AGENTS.md": 3200,
+  "AGENTS.md": 3250,
   "SECURITY.md": 200,
   "SELF_HOST.md": 6000,
   "docs/specs/alert.md": 6550,
@@ -9,29 +9,30 @@
   "docs/specs/dor-cli.md": 4850,
   "docs/specs/dor-tool.md": 2100,
   "docs/specs/glossary.md": 2850,
-  "docs/specs/layout.md": 7800,
+  "docs/specs/layout.md": 8000,
   "docs/specs/mobile-terminal-ui.md": 1950,
-  "docs/specs/mouse-and-clipboard.md": 3700,
+  "docs/specs/mouse-and-clipboard.md": 3750,
+  "docs/specs/notepad.md": 3700,
   "docs/specs/pocket-app.md": 4050,
   "docs/specs/relay.md": 9950,
   "docs/specs/remote-api.md": 3600,
   "docs/specs/remote-security-model.md": 4200,
   "docs/specs/security-audit.md": 1750,
   "docs/specs/security-ci.md": 2500,
-  "docs/specs/security-local.md": 2350,
+  "docs/specs/security-local.md": 2550,
   "docs/specs/security-remote.md": 4900,
   "docs/specs/security-supply-chain.md": 1150,
   "docs/specs/security.md": 1900,
   "docs/specs/shortcuts.md": 1000,
-  "docs/specs/standalone.md": 4150,
-  "docs/specs/terminal-context.md": 2100,
+  "docs/specs/standalone.md": 4300,
+  "docs/specs/terminal-context.md": 900,
   "docs/specs/terminal-escapes.md": 3750,
   "docs/specs/terminal-state.md": 2300,
   "docs/specs/theme.md": 2150,
   "docs/specs/tiling-engine.md": 4500,
-  "docs/specs/transport.md": 4250,
+  "docs/specs/transport.md": 4350,
   "docs/specs/tutorial.md": 1900,
-  "docs/specs/vscode.md": 7150,
+  "docs/specs/vscode.md": 7350,
   "docs/specs/webgl-text.md": 1200,
   "docs/specs/website-docs.md": 5050
 }
diff --git a/standalone/src-tauri/src/lib.rs b/standalone/src-tauri/src/lib.rs
index 5021eff4..83a4e2ee 100644
--- a/standalone/src-tauri/src/lib.rs
+++ b/standalone/src-tauri/src/lib.rs
@@ -11,7 +11,7 @@ use std::{
     process::Stdio,
     sync::atomic::{AtomicBool, AtomicU64, Ordering},
     sync::mpsc,
-    sync::{Arc, Mutex, OnceLock},
+    sync::{Arc, Mutex, MutexGuard, OnceLock},
     time::{Duration, SystemTime, UNIX_EPOCH},
 };
 use tauri::{
@@ -747,12 +747,14 @@ fn read_update_log() -> Result<String, String> {
 // so the frontend stays window-agnostic and a second window (`win-2`, …) persists
 // to its own file without ever rewriting the first window's blob.
 
-fn sessions_dir(app: &AppHandle) -> Result<PathBuf, String> {
-    Ok(app
-        .path()
+fn app_data_dir(app: &AppHandle) -> Result<PathBuf, String> {
+    app.path()
         .app_data_dir()
-        .map_err(|e| format!("app_data_dir unavailable: {e}"))?
-        .join("sessions"))
+        .map_err(|e| format!("app_data_dir unavailable: {e}"))
+}
+
+fn sessions_dir(app: &AppHandle) -> Result<PathBuf, String> {
+    Ok(app_data_dir(app)?.join("sessions"))
 }
 
 // Window labels are app-controlled (e.g. "main"), but sanitize defensively so a
@@ -920,33 +922,62 @@ fn restrict_to_owner(_path: &Path, _mode: u32) -> Result<(), String> {
     Ok(())
 }
 
-fn write_session_to(dir: &Path, label: &str, state: &str) -> Result<(), String> {
-    write_session_with_permissions(dir, label, state, restrict_to_owner)
+/// The sibling this file is written through before being renamed into place.
+/// Also what a crash before that rename leaves behind, which is why the clearing
+/// paths look for it by the same name.
+fn temp_write_path(path: &Path) -> PathBuf {
+    let mut name = path.file_name().unwrap_or_default().to_os_string();
+    name.push(".tmp");
+    path.with_file_name(name)
 }
 
-fn write_session_with_permissions(
-    dir: &Path,
-    label: &str,
-    state: &str,
+/// The directory `path` is written into, created and tightened to owner-only
+/// by `restrict` (`restrict_to_owner` outside tests).
+fn ensure_parent_with(
+    path: &Path,
     restrict: impl Fn(&Path, u32) -> Result<(), String>,
-) -> Result<(), String> {
-    create_dir_all(dir).map_err(|e| format!("create sessions dir: {e}"))?;
+) -> Result<&Path, String> {
+    let dir = path
+        .parent()
+        .ok_or_else(|| format!("no parent directory for {}", path.display()))?;
+    create_dir_all(dir).map_err(|e| format!("create dir {}: {e}", dir.display()))?;
     restrict(dir, 0o700)?;
-    let file_name = session_file_name(label);
-    let path = dir.join(&file_name);
-    let tmp = dir.join(format!("{file_name}.tmp"));
+    Ok(dir)
+}
+
+/// Write `contents` to `path` atomically and owner-only.
+///
+/// The one implementation behind both machine-local stores this app owns — the
+/// per-window session snapshot and the notepad archive — because both carry user
+/// text and both must survive a crash mid-write
+/// (docs/specs/security-local.md -> "Persisted state"). Owner-only before any
+/// bytes are written, and atomic-replace, both live here
+/// (docs/specs/standalone.md -> "Persistence").
+fn write_file_atomically(path: &Path, contents: &str) -> Result<(), String> {
+    write_file_with_permissions(path, contents, restrict_to_owner)
+}
+
+/// `write_file_atomically` with the permission step injected, so a test can
+/// fail either tightening and check that no bytes were written.
+fn write_file_with_permissions(
+    path: &Path,
+    contents: &str,
+    restrict: impl Fn(&Path, u32) -> Result<(), String>,
+) -> Result<(), String> {
+    let dir = ensure_parent_with(path, &restrict)?;
+    let tmp = temp_write_path(path);
     // Atomic replace: write a sibling temp file, fsync it, then rename over the
-    // target so a crash mid-write can never truncate the previous good snapshot.
+    // target so a crash mid-write can never truncate the previous good copy.
     {
         let mut f = File::create(&tmp).map_err(|e| format!("open temp: {e}"))?;
         // Before any bytes land: the rename below preserves the temp file's
         // mode, so tightening here is what makes the final snapshot 0600.
         restrict(&tmp, 0o600)?;
-        f.write_all(state.as_bytes())
+        f.write_all(contents.as_bytes())
             .map_err(|e| format!("write temp: {e}"))?;
         f.sync_all().map_err(|e| format!("fsync temp: {e}"))?;
     }
-    std::fs::rename(&tmp, &path).map_err(|e| format!("rename session {label}: {e}"))?;
+    std::fs::rename(&tmp, path).map_err(|e| format!("rename {}: {e}", path.display()))?;
     // The temp file's own fsync doesn't make the rename durable — on unix the
     // directory entry that now points at the new inode must be fsynced too, or a
     // crash right after quit could leave the rename unrecorded. Best-effort: a
@@ -961,6 +992,10 @@ fn write_session_with_permissions(
     Ok(())
 }
 
+fn write_session_to(dir: &Path, label: &str, state: &str) -> Result<(), String> {
+    write_file_atomically(&dir.join(session_file_name(label)), state)
+}
+
 // Async so the file IO (and save's two fsyncs — temp file + dir, both
 // F_FULLFSYNC on macOS) runs off the main/event-loop thread. Ordering is safe:
 // the webview store issues at most one save_session at a time (its coalescer).
@@ -975,8 +1010,11 @@ async fn save_session(window: tauri::Window, state: String) -> Result<(), String
 }
 
 fn remove_session_from(dir: &Path, label: &str) -> Result<(), String> {
-    let file_name = session_file_name(label);
-    let paths = [dir.join(&file_name), dir.join(format!("{file_name}.tmp"))];
+    let snapshot = dir.join(session_file_name(label));
+    // The temp name comes from the writer, so changing the convention can never
+    // leave this sweep looking for a file `write_file_atomically` stopped making.
+    let tmp = temp_write_path(&snapshot);
+    let paths = [snapshot, tmp];
     let mut first_error = None;
     for path in paths {
         match std::fs::remove_file(&path) {
@@ -1004,6 +1042,241 @@ async fn clear_session(window: tauri::Window) -> Result<(), String> {
     remove_session_from(&sessions_dir(window.app_handle())?, window.label())
 }
 
+// --- Notepad archive (docs/specs/notepad.md) ---------------------------------
+//
+// One machine-local archive per host, kept as `<app_data_dir>/notepad-archive-v1.json`
+// — a *sibling* of `sessions/`, never inside it. A Surface's notes outlive the
+// window whose closure archived them, so they must not ride the per-window
+// session blob or be swept by `clear_session`.
+//
+// The port is compare-and-swap (`NotepadArchivePort` in
+// lib/src/lib/notepad/types.ts): the webview reads the bytes plus an opaque
+// revision, applies its mutation, and writes back naming the revision it read.
+// A stale revision answers "conflict" and the webview retries against a fresh
+// read, so two overlapping mutations cannot drop one another's batches.
+//
+// The revision is a hash of the stored bytes, and every load, save and reset
+// runs under an exclusive lock on a sidecar lock file. Both are needed because
+// `app_data_dir()` is keyed by the Tauri identifier, which `pnpm dev:standalone`
+// shares with the installed app — the same sharing the sessions comment above
+// describes — so a second Dormouse process writing this file is an ordinary
+// state, not an impossible one. A hash is the only revision two processes agree
+// on without talking to each other: a counter only ever tracked this process's
+// own writes, so the loser of an overlapping load→save silently overwrote the
+// winner's batches. The lock is what makes the read-compare-rename one step, so
+// the loser is told "conflict" and retries instead. `None` means nothing is
+// stored — what a first save names as its base, and what a reset leaves behind.
+
+const NOTEPAD_ARCHIVE_FILE: &str = "notepad-archive-v1.json";
+
+#[derive(Default)]
+struct NotepadArchiveState {
+    /// Serializes this process's own load / save / reset, ahead of the
+    /// interprocess file lock those take: the intra-process path is then
+    /// ordered regardless of how a platform scopes an advisory lock, and two
+    /// threads here can never queue on each other through the filesystem.
+    gate: Mutex<()>,
+}
+
+fn notepad_archive_path(app: &AppHandle) -> Result<PathBuf, String> {
+    Ok(app_data_dir(app)?.join(NOTEPAD_ARCHIVE_FILE))
+}
+
+/// The lock guarding every access to `path`, derived from its name so the two
+/// can never drift apart.
+///
+/// A *separate* file, never renamed: the archive itself is replaced by rename on
+/// every save, so its inode is a new one each time and cannot carry a lock.
+fn notepad_archive_lock_path(path: &Path) -> PathBuf {
+    path.with_extension("lock")
+}
+
+/// Exclusive access to the archive, released when it drops.
+///
+/// Taken gate first, then the interprocess file lock. The fields are declared
+/// in the reverse of that on purpose — Rust drops them in declaration order, and
+/// a gate released ahead of the file lock would let the next thread through only
+/// to block on the filesystem, which is the one thing the gate exists to prevent
+/// (`NotepadArchiveState::gate`).
+struct ArchiveLock<'a> {
+    _file: File,
+    _gate: MutexGuard<'a, ()>,
+}
+
+/// The one way in: no caller may take either half on its own.
+fn lock_archive<'a>(gate: &'a Mutex<()>, path: &Path) -> Result<ArchiveLock<'a>, String> {
+    let gate = gate
+        .lock()
+        .map_err(|_| "failed to lock the notepad archive".to_string())?;
+    let file = lock_notepad_archive(path)?;
+    Ok(ArchiveLock {
+        _file: file,
+        _gate: gate,
+    })
+}
+
+/// Take the interprocess lock, blocking until it is ours; released when the
+/// returned handle drops.
+///
+/// Reported rather than swallowed: this lock is what makes the compare-and-swap
+/// correct across processes, so carrying on without it would silently reinstate
+/// the overwrite it exists to close. Blocking is safe because every caller is a
+/// `#[tauri::command(async)]` off the event loop, and each holder does one small
+/// read or write.
+fn lock_notepad_archive(path: &Path) -> Result<File, String> {
+    ensure_parent_with(path, restrict_to_owner)?;
+    let lock_path = notepad_archive_lock_path(path);
+    let file = OpenOptions::new()
+        .create(true)
+        .read(true)
+        .write(true)
+        // Never truncated: the file is a lock, and its bytes (none) are not
+        // state anyone reads.
+        .truncate(false)
+        .open(&lock_path)
+        .map_err(|e| format!("open notepad archive lock: {e}"))?;
+    // Carries no bytes, but it names the archive and sits beside it, so it gets
+    // the same owner-only mode the archive does.
+    let _ = restrict_to_owner(&lock_path, 0o600);
+    file.lock()
+        .map_err(|e| format!("lock notepad archive: {e}"))?;
+    Ok(file)
+}
+
+/// The compare-and-swap token: a hash of exactly the bytes on disk.
+///
+/// `DefaultHasher::new()` is fixed-key rather than randomly seeded, which is the
+/// property that matters — two processes, and two runs of one process, must
+/// derive the same token from the same file or every save after a restart would
+/// read as a conflict.
+fn archive_revision(contents: &str) -> String {
+    use std::hash::{DefaultHasher, Hash, Hasher};
+    let mut hasher = DefaultHasher::new();
+    contents.hash(&mut hasher);
+    format!("{}-{:016x}", contents.len(), hasher.finish())
+}
+
+/// The stored bytes and their revision, with the lock already held.
+fn read_notepad_archive_locked(path: &Path) -> Result<Option<(String, String)>, String> {
+    match std::fs::read_to_string(path) {
+        Ok(contents) => {
+            let revision = archive_revision(&contents);
+            Ok(Some((contents, revision)))
+        }
+        // Nothing stored — including after a reset moved it aside — so the next
+        // save must name a null base revision.
+        Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok(None),
+        Err(e) => Err(format!("read notepad archive: {e}")),
+    }
+}
+
+fn read_notepad_archive_from(
+    path: &Path,
+    gate: &Mutex<()>,
+) -> Result<Option<(String, String)>, String> {
+    let _lock = lock_archive(gate, path)?;
+    read_notepad_archive_locked(path)
+}
+
+fn write_notepad_archive_to(
+    path: &Path,
+    gate: &Mutex<()>,
+    state: &str,
+    base_revision: Option<&str>,
+) -> Result<String, String> {
+    // Held across the whole compare-and-write: the comparison is worth nothing
+    // if another save — this process's or another Dormouse's — can land between
+    // it and the rename.
+    let _lock = lock_archive(gate, path)?;
+    // Re-read under the lock rather than trusting anything cached: a revision
+    // nobody minted (a garbled one, or one whose bytes another process has since
+    // replaced) then reads as a conflict rather than as an error the caller
+    // would have to handle separately.
+    let current = read_notepad_archive_locked(path)?.map(|(_, revision)| revision);
+    if current.as_deref() != base_revision {
+        return Ok("conflict".to_string());
+    }
+    write_file_atomically(path, state)?;
+    Ok("ok".to_string())
+}
+
+/// Move an unreadable archive aside, never delete it.
+///
+/// The recovery that calls this knows only that the stored bytes do not parse;
+/// they are still the user's notes, so they are renamed to
+/// `notepad-archive-v1.unreadable-<unix-millis>.json` beside the original and
+/// left for whoever wants to salvage them (docs/specs/notepad.md).
+fn reset_notepad_archive_at(path: &Path, gate: &Mutex<()>) -> Result<(), String> {
+    let _lock = lock_archive(gate, path)?;
+    let dir = path
+        .parent()
+        .ok_or_else(|| format!("no parent directory for {}", path.display()))?;
+    let millis = SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .map_or(0, |d| d.as_millis());
+    // Derived from the archive's own name so the two can never drift apart.
+    let stem = path.file_stem().unwrap_or_default().to_string_lossy().into_owned();
+    // The name is per-millisecond; on the vanishing chance two recoveries land
+    // inside one, disambiguate rather than let the rename overwrite the earlier
+    // quarantine — surviving is the entire point of this file.
+    let mut target = dir.join(format!("{stem}.unreadable-{millis}.json"));
+    let mut nth = 2;
+    while target.exists() {
+        target = dir.join(format!("{stem}.unreadable-{millis}-{nth}.json"));
+        nth += 1;
+    }
+    match std::fs::rename(path, &target) {
+        Ok(()) => {}
+        // Nothing stored is the desired end state, not a failure.
+        Err(e) if e.kind() == std::io::ErrorKind::NotFound => {}
+        Err(e) => return Err(format!("quarantine notepad archive: {e}")),
+    }
+    // A temp file left by a crash before its rename was never a readable
+    // archive, so unlike the file above it is dropped rather than kept.
+    let tmp = temp_write_path(path);
+    match std::fs::remove_file(&tmp) {
+        Ok(()) => {}
+        Err(e) if e.kind() == std::io::ErrorKind::NotFound => {}
+        Err(e) => return Err(format!("remove notepad archive temp: {e}")),
+    }
+    Ok(())
+}
+
+// Async like the session commands: the read, and the save's two fsyncs, run off
+// the main/event-loop thread.
+#[tauri::command(async)]
+fn load_notepad_archive(
+    app: AppHandle,
+    archive: tauri::State<'_, NotepadArchiveState>,
+) -> Result<Option<(String, String)>, String> {
+    read_notepad_archive_from(&notepad_archive_path(&app)?, &archive.gate)
+}
+
+/// `"ok"` or `"conflict"` — the stored archive moved since `base_revision` was
+/// read, and the caller owes it a retry.
+#[tauri::command(async)]
+fn save_notepad_archive(
+    app: AppHandle,
+    archive: tauri::State<'_, NotepadArchiveState>,
+    state: String,
+    base_revision: Option<String>,
+) -> Result<String, String> {
+    write_notepad_archive_to(
+        &notepad_archive_path(&app)?,
+        &archive.gate,
+        &state,
+        base_revision.as_deref(),
+    )
+}
+
+#[tauri::command(async)]
+fn reset_notepad_archive(
+    app: AppHandle,
+    archive: tauri::State<'_, NotepadArchiveState>,
+) -> Result<(), String> {
+    reset_notepad_archive_at(&notepad_archive_path(&app)?, &archive.gate)
+}
+
 #[tauri::command]
 fn kill_sidecar_now(state: tauri::State<'_, SidecarState>) {
     kill_sidecar_and_wait(&state.child);
@@ -1592,6 +1865,12 @@ pub fn run() {
             // Quit-interception state (docs/specs/standalone.md §Quit flow).
             app.manage(QuitState::default());
 
+            // Serializes this process's notepad-archive access (§Notepad
+            // archive); the revision itself is read off the stored bytes and
+            // the cross-process exclusion is a lock file, so there is no
+            // starting state to seed here.
+            app.manage(NotepadArchiveState::default());
+
             // On non-macOS, remove native decorations for a fully custom title bar.
             // macOS uses titleBarStyle "Overlay" from config instead, which preserves
             // rounded corners and native traffic-light buttons.
@@ -1631,6 +1910,9 @@ pub fn run() {
             load_session,
             save_session,
             clear_session,
+            load_notepad_archive,
+            save_notepad_archive,
+            reset_notepad_archive,
             agent_browser_command,
             agent_browser_edit,
             agent_browser_screenshot,
@@ -1668,11 +1950,14 @@ pub fn run() {
 #[cfg(test)]
 mod tests {
     use super::{
-        find_node_binary, read_session_from, remove_session_from, resolve_dor_cli_paths,
-        resolve_sidecar_path, session_file_name, strip_windows_verbatim_prefix, write_session_to,
+        find_node_binary, notepad_archive_lock_path, read_notepad_archive_from, read_session_from,
+        remove_session_from, reset_notepad_archive_at, resolve_dor_cli_paths, resolve_sidecar_path,
+        session_file_name, strip_windows_verbatim_prefix, write_notepad_archive_to,
+        write_session_to, NOTEPAD_ARCHIVE_FILE,
     };
     use std::fs;
     use std::path::{Path, PathBuf};
+    use std::sync::Mutex;
     use std::time::{SystemTime, UNIX_EPOCH};
 
     // RAII guard so a failing assert doesn't leak the temp dir.
@@ -2083,9 +2368,8 @@ mod tests {
         for fail_mode in [0o700, 0o600] {
             let dir = TempDir::new("sessions-permission-failure");
             write_session_to(dir.path(), "main", "previous").unwrap();
-            let result = super::write_session_with_permissions(
-                dir.path(),
-                "main",
+            let result = super::write_file_with_permissions(
+                &dir.path().join(session_file_name("main")),
                 "private replacement",
                 |path, mode| {
                     if mode == fail_mode {
@@ -2179,6 +2463,275 @@ mod tests {
         assert_eq!(session_file_name("a/b"), "a_b.json");
     }
 
+    // ── Notepad archive (docs/specs/notepad.md) ─────────────────────────────
+    //
+    // A compare-and-swap store, so what is worth pinning is the pair the webview
+    // leans on: a save lands only on the revision it read, and no failure path —
+    // a stale save, a crash mid-write, a recovery from an unreadable file — may
+    // cost the user notes.
+
+    struct Archive {
+        dir: PathBuf,
+        // `None` for a second process over a directory the first one owns: only
+        // the owner's drop may remove it.
+        _owned: Option<TempDir>,
+        // The process-local gate — so two of these over one directory are two
+        // Dormouse processes, sharing only what is on disk.
+        gate: Mutex<()>,
+    }
+
+    impl Archive {
+        fn new(name: &str) -> Self {
+            let dir = TempDir::new(name);
+            Archive {
+                dir: dir.path().to_path_buf(),
+                _owned: Some(dir),
+                gate: Mutex::new(()),
+            }
+        }
+        /// A second Dormouse over the same `app_data_dir()` — a dev build beside
+        /// the installed app, which share a Tauri identifier and so a data
+        /// directory.
+        fn second_process(&self) -> Self {
+            Archive {
+                dir: self.dir.clone(),
+                _owned: None,
+                gate: Mutex::new(()),
+            }
+        }
+        fn dir(&self) -> &Path {
+            &self.dir
+        }
+        fn path(&self) -> PathBuf {
+            self.dir.join(NOTEPAD_ARCHIVE_FILE)
+        }
+        fn load(&self) -> Option<(String, String)> {
+            read_notepad_archive_from(&self.path(), &self.gate).unwrap()
+        }
+        /// The bytes alone, for a test asserting only what is stored.
+        fn bytes(&self) -> Option<String> {
+            self.load().map(|(bytes, _)| bytes)
+        }
+        /// The token a save must quote. Opaque: the tests assert only that it
+        /// moves with the bytes, never its shape.
+        fn revision(&self) -> Option<String> {
+            self.load().map(|(_, revision)| revision)
+        }
+        fn save(&self, state: &str, base: Option<&str>) -> String {
+            write_notepad_archive_to(&self.path(), &self.gate, state, base).unwrap()
+        }
+        fn reset(&self) {
+            reset_notepad_archive_at(&self.path(), &self.gate).unwrap()
+        }
+        /// Every file in the archive directory bar the lock, sorted — so a test
+        /// can assert what was left behind as well as what was written. The lock
+        /// exists from the first operation onward and is nothing these
+        /// assertions are about; `notepad_archive_is_owner_only_on_disk` is what
+        /// pins it.
+        fn entries(&self) -> Vec<String> {
+            let lock = notepad_archive_lock_path(&self.path());
+            let lock = lock.file_name().unwrap().to_string_lossy().into_owned();
+            let mut names: Vec<String> = fs::read_dir(self.dir())
+                .unwrap()
+                .map(|entry| entry.unwrap().file_name().to_string_lossy().into_owned())
+                .filter(|name| *name != lock)
+                .collect();
+            names.sort();
+            names
+        }
+    }
+
+    #[test]
+    fn notepad_archive_round_trips_and_moves_its_revision() {
+        let archive = Archive::new("notepad-roundtrip");
+
+        // Nothing archived yet: the load reports absence, and the first save
+        // names a null base revision.
+        assert_eq!(archive.load(), None);
+        assert_eq!(archive.save(r#"{"version":1,"batches":[]}"#, None), "ok");
+
+        let (bytes, first) = archive.load().expect("archived");
+        assert_eq!(bytes, r#"{"version":1,"batches":[]}"#);
+        // Re-reading unchanged bytes reproduces the token — the property a
+        // retry-after-conflict leans on.
+        assert_eq!(archive.revision().as_deref(), Some(first.as_str()));
+
+        // Each accepted save moves it, so the next one must quote what it read.
+        assert_eq!(
+            archive.save(r#"{"version":1,"batches":["b1"]}"#, Some(&first)),
+            "ok",
+        );
+        let (bytes, second) = archive.load().expect("archived");
+        assert_eq!(bytes, r#"{"version":1,"batches":["b1"]}"#);
+        assert_ne!(second, first);
+
+        // Atomic replace, not append — and the temp file it went through is gone.
+        assert_eq!(archive.entries(), vec![NOTEPAD_ARCHIVE_FILE.to_string()]);
+    }
+
+    #[test]
+    fn notepad_archive_refuses_a_save_against_a_stale_revision() {
+        let archive = Archive::new("notepad-conflict");
+        assert_eq!(archive.save(r#"{"version":1,"batches":["a"]}"#, None), "ok");
+        let stale = archive.revision().expect("archived");
+        assert_eq!(
+            archive.save(r#"{"version":1,"batches":["b"]}"#, Some(&stale)),
+            "ok",
+        );
+
+        // A second writer still holding the earlier token is refused rather than
+        // silently overwriting the batches it never saw.
+        assert_eq!(
+            archive.save(r#"{"version":1,"batches":["c"]}"#, Some(&stale)),
+            "conflict",
+        );
+        // So does a token nothing ever minted, and so does a first-save null
+        // base once something is stored.
+        assert_eq!(archive.save("{}", Some("not-a-revision")), "conflict");
+        assert_eq!(archive.save("{}", None), "conflict");
+        // …and no refusal touched the file.
+        assert_eq!(
+            archive.bytes().as_deref(),
+            Some(r#"{"version":1,"batches":["b"]}"#),
+        );
+        assert_eq!(archive.entries(), vec![NOTEPAD_ARCHIVE_FILE.to_string()]);
+    }
+
+    /// The revision is a hash of the stored bytes, not a count of this process's
+    /// own writes, so a write it never made is still seen.
+    #[test]
+    fn notepad_archive_conflicts_with_a_write_it_did_not_make() {
+        let archive = Archive::new("notepad-foreign");
+        assert_eq!(archive.save(r#"{"version":1,"batches":["a"]}"#, None), "ok");
+        let base = archive.revision().expect("archived");
+
+        // Straight at the file, as another process's rename leaves it.
+        fs::write(archive.path(), r#"{"version":1,"batches":["a","yours"]}"#).unwrap();
+
+        assert_eq!(
+            archive.save(r#"{"version":1,"batches":["a","mine"]}"#, Some(&base)),
+            "conflict",
+        );
+        // The refusal kept the bytes it found instead of overwriting them.
+        assert_eq!(
+            archive.bytes().as_deref(),
+            Some(r#"{"version":1,"batches":["a","yours"]}"#),
+        );
+    }
+
+    /// Two Dormouse processes share `app_data_dir()` — a dev build beside the
+    /// installed app — so the loser of an overlapping load→save must be told to
+    /// retry rather than drop the winner's batches.
+    #[test]
+    fn notepad_archive_conflicts_across_two_processes() {
+        let first = Archive::new("notepad-two-processes");
+        let second = first.second_process();
+
+        assert_eq!(first.save(r#"{"version":1,"batches":["a"]}"#, None), "ok");
+        // Both load; the token is the file's, so both read the same one.
+        let base_first = first.revision().expect("archived");
+        let base_second = second.revision().expect("archived");
+        assert_eq!(base_first, base_second);
+
+        assert_eq!(
+            first.save(
+                r#"{"version":1,"batches":["a","first"]}"#,
+                Some(&base_first)
+            ),
+            "ok",
+        );
+        // A process-local counter never observed that save; the hash does.
+        assert_eq!(
+            second.save(
+                r#"{"version":1,"batches":["a","second"]}"#,
+                Some(&base_second)
+            ),
+            "conflict",
+        );
+
+        // And the retry the conflict asks for lands, carrying both batches.
+        let fresh = second.revision().expect("archived");
+        assert_eq!(
+            second.save(
+                r#"{"version":1,"batches":["a","first","second"]}"#,
+                Some(&fresh)
+            ),
+            "ok",
+        );
+        assert_eq!(
+            first.bytes().as_deref(),
+            Some(r#"{"version":1,"batches":["a","first","second"]}"#),
+        );
+    }
+
+    #[test]
+    fn notepad_archive_reset_renames_the_unreadable_file_rather_than_deleting_it() {
+        let archive = Archive::new("notepad-reset");
+        assert_eq!(archive.save("{ not json", None), "ok");
+        // A crash before a rename could have left this; it was never a readable
+        // archive, so it is the one thing reset may drop.
+        let tmp = archive.dir().join("notepad-archive-v1.json.tmp");
+        fs::write(&tmp, b"partial").unwrap();
+
+        archive.reset();
+
+        // The partial write is gone and the archive is not where it was — what
+        // is left is one quarantined copy.
+        assert!(!tmp.exists());
+        let entries = archive.entries();
+        assert_eq!(entries.len(), 1, "expected one quarantined copy: {entries:?}");
+        let quarantined = &entries[0];
+        assert!(
+            quarantined.starts_with("notepad-archive-v1.unreadable-")
+                && quarantined.ends_with(".json"),
+            "unexpected quarantine name: {quarantined}",
+        );
+        // The user's bytes survive the recovery — that is the whole point.
+        assert_eq!(
+            fs::read_to_string(archive.dir().join(quarantined)).unwrap(),
+            "{ not json",
+        );
+
+        // And the archive starts empty again: the next save is a first save,
+        // naming a null base.
+        assert_eq!(archive.load(), None);
+        assert_eq!(archive.save(r#"{"version":1,"batches":[]}"#, None), "ok");
+        assert_eq!(
+            archive.bytes().as_deref(),
+            Some(r#"{"version":1,"batches":[]}"#)
+        );
+    }
+
+    #[test]
+    fn notepad_archive_reset_without_a_file_succeeds() {
+        // Nothing to move aside is the desired end state, not a failure.
+        let archive = Archive::new("notepad-reset-missing");
+        archive.reset();
+        assert_eq!(archive.load(), None);
+        assert!(archive.entries().is_empty());
+    }
+
+    /// The unix half of the guarantee `restrict_to_owner_leaves_one_owner_only_ace`
+    /// pins on Windows: the archive carries captured terminal excerpts, so it and
+    /// its directory are the owner's alone
+    /// (docs/specs/security-local.md -> "Persisted state").
+    #[test]
+    #[cfg(unix)]
+    fn notepad_archive_is_owner_only_on_disk() {
+        use std::os::unix::fs::PermissionsExt;
+
+        let archive = Archive::new("notepad-modes");
+        assert_eq!(archive.save(r#"{"version":1,"batches":[]}"#, None), "ok");
+
+        let mode = |path: &Path| fs::metadata(path).unwrap().permissions().mode() & 0o777;
+        assert_eq!(mode(archive.dir()), 0o700);
+        // 0600 survives because the temp file was tightened *before* the rename.
+        assert_eq!(mode(&archive.path()), 0o600);
+        // The lock carries no bytes, but it names the archive and sits beside it
+        // in the same directory, so it is owner-only on the same terms.
+        assert_eq!(mode(&notepad_archive_lock_path(&archive.path())), 0o600);
+    }
+
     // Enforces the INVARIANT documented above `request_from_sidecar_timeout`:
     // every `#[tauri::command]` whose body reaches the blocking sidecar helpers
     // must be `#[tauri::command(async)]` (or an `async fn`). A plain-sync command
diff --git a/standalone/src/QuitConfirmModal.tsx b/standalone/src/QuitConfirmModal.tsx
index e3580803..86fc2ef1 100644
--- a/standalone/src/QuitConfirmModal.tsx
+++ b/standalone/src/QuitConfirmModal.tsx
@@ -1,9 +1,9 @@
-import { useContext, useEffect, useRef, useSyncExternalStore } from 'react';
+import { useRef, useSyncExternalStore } from 'react';
 // Standalone reaches into the lib source directly (same relative form as the
 // sibling UpdateDebugModal.tsx). The terminal registry comes in via the
 // `dormouse-lib` alias, matching quit.ts.
 import { ModalFrame, modalActionButton } from '../../lib/src/components/design';
-import { DialogKeyboardContext } from '../../lib/src/components/wall/wall-context';
+import { useDialogKeyboardOwner } from '../../lib/src/components/wall/wall-context';
 import {
   countRunningSessions,
   subscribeToTerminalPaneState,
@@ -11,6 +11,7 @@ import {
 import {
   cancelQuit,
   confirmQuit,
+  getQuitArchiveError,
   getQuitConfirmPhase,
   subscribeQuitConfirm,
 } from './quit-confirm-store';
@@ -25,27 +26,57 @@ import {
  */
 export function QuitConfirmModalHost() {
   const phase = useSyncExternalStore(subscribeQuitConfirm, getQuitConfirmPhase);
-  const setDialogKeyboardActive = useContext(DialogKeyboardContext);
+  const storedArchiveError = useSyncExternalStore(subscribeQuitConfirm, getQuitArchiveError);
   const open = phase !== null;
 
   // Suppress the Wall's command-mode key dispatch while the dialog is up.
-  useEffect(() => {
-    setDialogKeyboardActive(open);
-    return () => setDialogKeyboardActive(false);
-  }, [open, setDialogKeyboardActive]);
+  useDialogKeyboardOwner(open);
 
   if (!phase) return null;
-  return <QuitConfirmModal confirming={phase === 'quitting'} />;
+  return (
+    <QuitConfirmModal
+      confirming={phase === 'quitting'}
+      archiveError={phase === 'archive-failed' ? storedArchiveError : null}
+    />
+  );
 }
 
 // Exported for Storybook (QuitConfirmModal.stories.tsx), which renders the
 // presentational modal directly — same split as ExternalLinkModal's stories.
-export function QuitConfirmModal({ confirming }: { confirming: boolean }) {
+export function QuitConfirmModal({
+  confirming,
+  archiveError = null,
+}: {
+  confirming: boolean;
+  /** The quit the notepad archive refused (docs/specs/notepad.md → "Standalone
+   *  quit"). Set means the running-command decision is already made and this
+   *  dialog now asks only whether to lose the notes. */
+  archiveError?: string | null;
+}) {
   const cancelButtonRef = useRef<HTMLButtonElement>(null);
   // Live count — the dialog stays open even if it drops to 0 (see spec).
   const runningCount = useSyncExternalStore(subscribeToTerminalPaneState, countRunningSessions);
   const hasRunning = runningCount > 0;
 
+  // Two dialogs in one frame. An archive error means the running-command
+  // decision is already made and the only question left is whether to lose the
+  // notes — so the copy changes and the default swaps to Cancel, stated once
+  // here rather than as five ternaries through the markup.
+  const title = archiveError ? 'Notes could not be archived' : 'Quit Dormouse?';
+  const body = archiveError
+    ? `${archiveError} Quitting anyway discards them.`
+    : confirming
+      ? 'Quitting…'
+      : hasRunning
+        ? `${runningCount} running command${runningCount === 1 ? '' : 's'} will be stopped.`
+        : 'No commands are still running.';
+  const confirmLabel = archiveError
+    ? 'Quit anyway'
+    : hasRunning ? `Quit and stop ${runningCount}` : 'Quit';
+  const [cancelTone, confirmTone] = archiveError
+    ? (['primary', 'secondary'] as const)
+    : (['secondary', 'primary'] as const);
+
   return (
     <ModalFrame
       titleId="quit-confirm-modal-title"
@@ -57,16 +88,8 @@ export function QuitConfirmModal({ confirming }: { confirming: boolean }) {
       initialFocusRef={cancelButtonRef}
       onEscape={confirming ? undefined : cancelQuit}
     >
-      <h2 id="quit-confirm-modal-title" className="text-sm leading-5 text-foreground">
-        Quit Dormouse?
-      </h2>
-      <p className="mt-2 text-sm text-muted">
-        {confirming
-          ? 'Quitting…'
-          : hasRunning
-            ? `${runningCount} running command${runningCount === 1 ? '' : 's'} will be stopped.`
-            : 'No commands are still running.'}
-      </p>
+      <h2 id="quit-confirm-modal-title" className="text-sm leading-5 text-foreground">{title}</h2>
+      <p className="mt-2 text-sm text-muted">{body}</p>
 
       <div className="mt-4 flex justify-end gap-2">
         <button
@@ -74,7 +97,7 @@ export function QuitConfirmModal({ confirming }: { confirming: boolean }) {
           type="button"
           onClick={cancelQuit}
           disabled={confirming}
-          className={`${modalActionButton({ tone: 'secondary' })} min-w-[5rem]`}
+          className={`${modalActionButton({ tone: cancelTone })} min-w-[5rem]`}
         >
           Cancel
         </button>
@@ -82,9 +105,9 @@ export function QuitConfirmModal({ confirming }: { confirming: boolean }) {
           type="button"
           onClick={confirmQuit}
           disabled={confirming}
-          className={`${modalActionButton({ tone: 'primary' })} min-w-[5rem]`}
+          className={`${modalActionButton({ tone: confirmTone })} min-w-[5rem]`}
         >
-          {hasRunning ? `Quit and stop ${runningCount}` : 'Quit'}
+          {confirmLabel}
         </button>
       </div>
     </ModalFrame>
diff --git a/standalone/src/browser-sidecar-adapter.ts b/standalone/src/browser-sidecar-adapter.ts
index 976400a9..4384f323 100644
--- a/standalone/src/browser-sidecar-adapter.ts
+++ b/standalone/src/browser-sidecar-adapter.ts
@@ -33,6 +33,7 @@ import { AlertManager } from "dormouse-lib/lib/alert-manager";
 import type { AwaitHandle, AwaitOptions } from "dormouse-lib/lib/alert-manager";
 import type { AlertSettings } from "dormouse-lib/lib/alert-settings";
 import { normalizeExternalUri } from "dormouse-lib/lib/external-links";
+import { createMemoryNotepadArchivePort } from "dormouse-lib/lib/notepad/memory-archive-port";
 import { loadSessionState, saveSessionState } from "dormouse-lib/lib/window-persistence";
 import {
   applyTerminalProtocolEvents,
@@ -295,6 +296,17 @@ export class BrowserSidecarAdapter implements PlatformAdapter {
     }
   }
 
+  // The notepad archive as memory, not the Tauri file: this harness is a browser
+  // tab with no app-data directory, and a dev run must not write into (or read)
+  // the installed app's archive. Notes last as long as the page
+  // (docs/specs/notepad.md).
+  readonly notepadArchive = createMemoryNotepadArchivePort();
+
+  // Cmd/Ctrl+N opens a browser window before any listener sees it, so the
+  // harness shows no chord and binds none — the same reason the website's demo
+  // adapter sets this. The shipped Tauri build owns its keyboard and does not.
+  readonly browserReservesNotepadChord = true;
+
   // Delete (not just ignore) pre-gate blobs: they carry transcripts and localStorage
   // outlives the harness's per-run temp state dir.
   private clearPersistedState(): void {
diff --git a/standalone/src/quit-confirm-store.test.ts b/standalone/src/quit-confirm-store.test.ts
index f08fc22b..e86b8a2e 100644
--- a/standalone/src/quit-confirm-store.test.ts
+++ b/standalone/src/quit-confirm-store.test.ts
@@ -2,7 +2,9 @@ import { beforeEach, describe, expect, it, vi } from "vitest";
 import {
   cancelQuit,
   confirmQuit,
+  getQuitArchiveError,
   getQuitConfirmPhase,
+  openQuitArchiveFailure,
   openQuitConfirm,
   subscribeQuitConfirm,
   _resetQuitConfirmForTesting,
@@ -59,6 +61,36 @@ describe("quit-confirm store", () => {
     expect(getQuitConfirmPhase()).toBe("quitting");
   });
 
+  // The archive gate's phase (docs/specs/notepad.md → "Standalone quit").
+  it("takes the archive-failed phase over a decision already made", () => {
+    const first = makeCtx();
+    openQuitConfirm(first);
+    confirmQuit(); // the user said quit; the gate then refused
+
+    const retry = makeCtx();
+    openQuitArchiveFailure("disk is full", retry);
+
+    expect(getQuitConfirmPhase()).toBe("archive-failed");
+    expect(getQuitArchiveError()).toBe("disk is full");
+
+    // Quit anyway reaches the gate's context, not the spent confirmation one.
+    confirmQuit();
+    expect(retry.confirm).toHaveBeenCalledTimes(1);
+    expect(first.confirm).toHaveBeenCalledTimes(1);
+    expect(getQuitConfirmPhase()).toBe("quitting");
+    expect(getQuitArchiveError()).toBeNull();
+  });
+
+  it("opens the archive-failed phase from no dialog at all (an all-idle quit)", () => {
+    const ctx = makeCtx();
+    openQuitArchiveFailure("disk is full", ctx);
+
+    cancelQuit();
+    expect(ctx.cancel).toHaveBeenCalledTimes(1);
+    expect(getQuitConfirmPhase()).toBeNull();
+    expect(getQuitArchiveError()).toBeNull();
+  });
+
   it("ignores a redundant open while a dialog is already up", () => {
     const first = makeCtx();
     const second = makeCtx();
diff --git a/standalone/src/quit-confirm-store.ts b/standalone/src/quit-confirm-store.ts
index a0197b84..ad218f6d 100644
--- a/standalone/src/quit-confirm-store.ts
+++ b/standalone/src/quit-confirm-store.ts
@@ -7,9 +7,11 @@ import type { QuitConfirmContext } from "./quit";
  * docs/specs/standalone.md §Quit flow, "Confirmation dialog".
  */
 
-export type QuitConfirmPhase = "open" | "quitting";
+export type QuitConfirmPhase = "open" | "quitting" | "archive-failed";
 
 let phase: QuitConfirmPhase | null = null;
+// Why the archive gate refused the quit; only set alongside "archive-failed".
+let archiveError: string | null = null;
 // The orchestrator context for the open request. Nulled the instant a decision
 // is made, so a repeated confirm / a late cancel is a no-op.
 let activeCtx: QuitConfirmContext | null = null;
@@ -26,6 +28,11 @@ export function getQuitConfirmPhase(): QuitConfirmPhase | null {
   return phase;
 }
 
+/** The archive error backing the "archive-failed" phase; null in every other. */
+export function getQuitArchiveError(): string | null {
+  return archiveError;
+}
+
 function emit(): void {
   for (const listener of listeners) listener();
 }
@@ -41,12 +48,28 @@ export function openQuitConfirm(ctx: QuitConfirmContext): void {
   emit();
 }
 
+/**
+ * The archive gate refused the quit (docs/specs/notepad.md → "Standalone
+ * quit"). Reached either from "quitting" — the user already confirmed and the
+ * gate ran behind the dialog — or from no dialog at all, since an all-idle quit
+ * archives without ever showing one. So, unlike `openQuitConfirm`, this is not
+ * guarded on an empty phase: it is always a transition from a decision already
+ * made. `ctx.confirm()` is Quit anyway (notes discarded); `ctx.cancel()` closes.
+ */
+export function openQuitArchiveFailure(message: string, ctx: QuitConfirmContext): void {
+  activeCtx = ctx;
+  archiveError = message;
+  phase = "archive-failed";
+  emit();
+}
+
 // The phase survives confirm (as "quitting") so the modal shows a disabled
 // quitting state until the app exits.
 export function confirmQuit(): void {
   const ctx = activeCtx;
   if (!ctx) return;
   activeCtx = null;
+  archiveError = null;
   phase = "quitting";
   emit();
   ctx.confirm();
@@ -56,6 +79,7 @@ export function cancelQuit(): void {
   const ctx = activeCtx;
   if (!ctx) return;
   activeCtx = null;
+  archiveError = null;
   phase = null;
   emit();
   ctx.cancel();
@@ -65,5 +89,6 @@ export function cancelQuit(): void {
 export function _resetQuitConfirmForTesting(): void {
   phase = null;
   activeCtx = null;
+  archiveError = null;
   listeners.clear();
 }
diff --git a/standalone/src/quit-notepad.test.ts b/standalone/src/quit-notepad.test.ts
new file mode 100644
index 00000000..7525fa90
--- /dev/null
+++ b/standalone/src/quit-notepad.test.ts
@@ -0,0 +1,46 @@
+import { afterEach, expect, it, vi } from 'vitest';
+import { FakePtyAdapter, setPlatform } from 'dormouse-lib/lib/platform';
+import { __resetArchiveServiceForTests } from 'dormouse-lib/lib/notepad/archive-service';
+import { addPlainNote, clearAllNotepads, deleteNote, getNotepadSnapshot, getNotes } from 'dormouse-lib/lib/notepad/notepad-store';
+
+vi.mock('@tauri-apps/api/core', () => ({ invoke: vi.fn() }));
+vi.mock('@tauri-apps/api/event', () => ({ listen: vi.fn() }));
+vi.mock('dormouse-lib/lib/terminal-registry', () => ({ countRunningSessions: () => 0 }));
+vi.mock('./updater', () => ({ hasPendingUpdate: () => false, installPendingUpdate: vi.fn() }));
+
+import { archiveNotesBeforeQuit } from './quit';
+
+afterEach(() => {
+  vi.useRealTimers();
+  clearAllNotepads();
+  __resetArchiveServiceForTests();
+});
+
+it('deletes a landed batch on the next quit after timeout, cancellation, and deleting the last note', async () => {
+  vi.useFakeTimers();
+  const adapter = new FakePtyAdapter();
+  setPlatform(adapter);
+  const noteId = addPlainNote('pane-a', 'original');
+  const port = adapter.notepadArchive;
+  const save = port.save.bind(port);
+  let release!: () => void;
+  const reply = new Promise<void>((resolve) => { release = resolve; });
+  vi.spyOn(port, 'save').mockImplementationOnce(async (archive, revision) => {
+    const result = await save(archive, revision);
+    await reply;
+    return result;
+  });
+  const attempt = archiveNotesBeforeQuit();
+  const timedOut = expect(attempt).rejects.toThrow('3s');
+  await vi.advanceTimersByTimeAsync(3000);
+  await timedOut;
+  release();
+  await vi.advanceTimersByTimeAsync(0);
+  expect(getNotes('pane-a')).toHaveLength(1);
+
+  // The user cancelled quit and then removed everything the timed-out save kept.
+  deleteNote('pane-a', noteId!);
+  expect(getNotepadSnapshot().size).toBe(0);
+  await archiveNotesBeforeQuit();
+  expect((await port.load())?.raw).toEqual({ version: 1, batches: [] });
+});
diff --git a/standalone/src/quit.test.ts b/standalone/src/quit.test.ts
index 7b651d17..a16ef228 100644
--- a/standalone/src/quit.test.ts
+++ b/standalone/src/quit.test.ts
@@ -13,6 +13,9 @@ const mocks = vi.hoisted(() => ({
   countRunningSessions: vi.fn(() => 0),
   hasPendingUpdate: vi.fn(() => false),
   installPendingUpdate: vi.fn(async () => {}),
+  archiveSurfaceNotes: vi.fn(async (_ids: readonly string[], _opts?: { signal?: AbortSignal }) => {}),
+  notepadSurfaceIds: vi.fn(() => [] as string[]),
+  removeSurface: vi.fn(),
 }));
 
 vi.mock("@tauri-apps/api/core", () => ({ invoke: mocks.invoke }));
@@ -20,12 +23,34 @@ vi.mock("@tauri-apps/api/event", () => ({ listen: mocks.listen }));
 vi.mock("dormouse-lib/lib/terminal-registry", () => ({
   countRunningSessions: mocks.countRunningSessions,
 }));
+// The archive gate's two collaborators. Mocked for the same reason as the
+// registry: the real modules pull the whole lib platform in behind them, and
+// what this file tests is the ordering around them.
+vi.mock("dormouse-lib/lib/notepad/close-coordinator", () => ({
+  archiveSurfaceNotes: mocks.archiveSurfaceNotes,
+}));
+vi.mock("dormouse-lib/lib/notepad/notepad-store", () => ({
+  notepadSurfaceIds: mocks.notepadSurfaceIds,
+  removeSurface: mocks.removeSurface,
+}));
 vi.mock("./updater", () => ({
   hasPendingUpdate: mocks.hasPendingUpdate,
   installPendingUpdate: mocks.installPendingUpdate,
 }));
 
 import { initQuitFlow, setQuitConfirmGate, _resetForTesting } from "./quit";
+// The quit-confirm store is the real one: the archive-failed phase is the
+// observable half of the gate's failure path.
+import {
+  cancelQuit as dismissQuitDialog,
+  confirmQuit,
+  getQuitArchiveError,
+  getQuitConfirmPhase,
+  _resetQuitConfirmForTesting,
+} from "./quit-confirm-store";
+
+/** One Surface holding notes, as `notepadSurfaceIds` reports it. */
+const oneNotedSurface = () => ["pane-a"];
 
 // The captured `dormouse://quit-requested` listener; call it to simulate Rust
 // emitting a quit request.
@@ -61,6 +86,7 @@ describe("quit orchestrator", () => {
   beforeEach(() => {
     vi.clearAllMocks();
     _resetForTesting();
+    _resetQuitConfirmForTesting();
     quitRequested = null;
     mocks.listen.mockImplementation((event: string, cb: () => void) => {
       if (event === "dormouse://quit-requested") quitRequested = cb;
@@ -70,6 +96,8 @@ describe("quit orchestrator", () => {
     mocks.hasPendingUpdate.mockReturnValue(false);
     mocks.installPendingUpdate.mockResolvedValue(undefined);
     mocks.invoke.mockResolvedValue(undefined);
+    mocks.archiveSurfaceNotes.mockResolvedValue(undefined);
+    mocks.notepadSurfaceIds.mockReturnValue([]);
   });
 
   afterEach(() => setQuitConfirmGate(null));
@@ -220,6 +248,161 @@ describe("quit orchestrator", () => {
     expect(mocks.invoke).not.toHaveBeenCalledWith("quit_proceed");
   });
 
+  // --- The notepad archive gate (docs/specs/notepad.md → "Standalone quit") ---
+
+  it("archives every Surface holding notes before the first quit_progress", async () => {
+    mocks.notepadSurfaceIds.mockReturnValue(oneNotedSurface());
+    const order: string[] = [];
+    mocks.invoke.mockImplementation(async (cmd: string) => {
+      order.push(cmd);
+      return undefined;
+    });
+    mocks.archiveSurfaceNotes.mockImplementation(async () => {
+      order.push("archive");
+    });
+
+    await triggerQuit(fakeAdapter(order));
+
+    // The gate is a step before teardown, not inside it: nothing has told Rust
+    // teardown began when the archive runs.
+    expect(order.slice(0, 3)).toEqual(["quit_ack", "archive", "quit_progress"]);
+    expect(mocks.archiveSurfaceNotes).toHaveBeenCalledWith(["pane-a"], expect.anything());
+    expect(mocks.invoke).toHaveBeenCalledWith("quit_proceed");
+  });
+
+  it("skips the archive entirely when no Surface holds notes", async () => {
+    await triggerQuit(fakeAdapter());
+
+    expect(mocks.archiveSurfaceNotes).not.toHaveBeenCalled();
+    expect(mocks.invoke).toHaveBeenCalledWith("quit_proceed");
+  });
+
+  it("runs the gate after the running-work confirmation, not before it", async () => {
+    mocks.countRunningSessions.mockReturnValue(2);
+    mocks.notepadSurfaceIds.mockReturnValue(oneNotedSurface());
+    const gate = vi.fn(); // never decides
+    setQuitConfirmGate(gate);
+
+    await triggerQuit(fakeAdapter());
+
+    expect(gate).toHaveBeenCalledTimes(1);
+    expect(mocks.archiveSurfaceNotes).not.toHaveBeenCalled();
+  });
+
+  it("leaves the quit pending in Rust and opens the archive-failed dialog when the write fails", async () => {
+    // `quit_cancel` retires Rust's watchdog. Calling it here would leave a later
+    // "Quit anyway" tearing down unwatched, so the pending quit stays in its
+    // unbounded phase-2 wait — which is what waits on a human.
+    mocks.notepadSurfaceIds.mockReturnValue(oneNotedSurface());
+    mocks.archiveSurfaceNotes.mockRejectedValue(new Error("disk is full"));
+    const adapter = fakeAdapter();
+
+    await triggerQuit(adapter);
+
+    expect(mocks.invoke).not.toHaveBeenCalledWith("quit_cancel");
+    expect(mocks.invoke).not.toHaveBeenCalledWith("quit_progress");
+    expect(mocks.invoke).not.toHaveBeenCalledWith("quit_proceed");
+    expect(adapter.requestSessionFlush).not.toHaveBeenCalled();
+    expect(getQuitConfirmPhase()).toBe("archive-failed");
+    expect(getQuitArchiveError()).toBe("disk is full");
+  });
+
+  it("deduplicates a repeat quit trigger while the archive-failed dialog is up", async () => {
+    mocks.notepadSurfaceIds.mockReturnValue(oneNotedSurface());
+    mocks.archiveSurfaceNotes.mockRejectedValue(new Error("disk is full"));
+    await triggerQuit(fakeAdapter());
+    mocks.archiveSurfaceNotes.mockClear();
+
+    quitRequested!();
+    await settle();
+
+    // Acked (Rust's watchdog stands down) but the flow does not restart.
+    expect(mocks.archiveSurfaceNotes).not.toHaveBeenCalled();
+    expect(getQuitConfirmPhase()).toBe("archive-failed");
+  });
+
+  it("Quit anyway discards the notes and runs the teardown", async () => {
+    mocks.notepadSurfaceIds.mockReturnValue(oneNotedSurface());
+    mocks.archiveSurfaceNotes.mockRejectedValue(new Error("disk is full"));
+    const adapter = fakeAdapter();
+    await triggerQuit(adapter);
+
+    confirmQuit();
+    await settle();
+
+    expect(mocks.removeSurface).toHaveBeenCalledWith("pane-a");
+    expect(adapter.requestSessionFlush).toHaveBeenCalled();
+    // Never cancelled, so the teardown runs under the watchdog that was already
+    // armed for this quit.
+    expect(mocks.invoke).not.toHaveBeenCalledWith("quit_cancel");
+    expect(mocks.invoke).toHaveBeenCalledWith("quit_proceed");
+  });
+
+  it("Cancel leaves the app running and lets a later quit start fresh", async () => {
+    mocks.notepadSurfaceIds.mockReturnValue(oneNotedSurface());
+    mocks.archiveSurfaceNotes.mockRejectedValue(new Error("disk is full"));
+    const adapter = fakeAdapter();
+    await triggerQuit(adapter);
+
+    dismissQuitDialog();
+    // Cancel is the one branch that drops the pending quit in Rust.
+    expect(mocks.invoke).toHaveBeenCalledWith("quit_cancel");
+    expect(getQuitConfirmPhase()).toBeNull();
+    expect(mocks.invoke).not.toHaveBeenCalledWith("quit_proceed");
+
+    // The flow returned to idle, so the next trigger runs the gate again.
+    mocks.archiveSurfaceNotes.mockResolvedValue(undefined);
+    quitRequested!();
+    await settle();
+    expect(adapter.requestSessionFlush).toHaveBeenCalled();
+    expect(mocks.invoke).toHaveBeenCalledWith("quit_proceed");
+  });
+
+  it("treats an archive that outruns its 3s bound as a failure", async () => {
+    vi.useFakeTimers();
+    try {
+      mocks.notepadSurfaceIds.mockReturnValue(oneNotedSurface());
+      mocks.archiveSurfaceNotes.mockReturnValue(new Promise<void>(() => {})); // never settles
+      const adapter = fakeAdapter();
+      initQuitFlow(adapter);
+      quitRequested!();
+
+      await vi.advanceTimersByTimeAsync(3000);
+
+      expect(getQuitConfirmPhase()).toBe("archive-failed");
+      expect(getQuitArchiveError()).toContain("3s");
+      expect(adapter.requestSessionFlush).not.toHaveBeenCalled();
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
+  it("aborts the archive it stopped waiting for, so a late success cannot empty the notepads", async () => {
+    // `withDeadline` only stops the waiting. Without the signal the archive
+    // keeps running, succeeds minutes later, and calls `removeSurface` on every
+    // Surface — in front of a user who chose Cancel.
+    vi.useFakeTimers();
+    try {
+      mocks.notepadSurfaceIds.mockReturnValue(oneNotedSurface());
+      let signal: AbortSignal | undefined;
+      mocks.archiveSurfaceNotes.mockImplementation((_ids, opts) => {
+        signal = opts?.signal;
+        return new Promise<void>(() => {}); // never settles
+      });
+      initQuitFlow(fakeAdapter());
+      quitRequested!();
+      await Promise.resolve();
+      expect(signal?.aborted).toBe(false);
+
+      await vi.advanceTimersByTimeAsync(3000);
+
+      expect(signal?.aborted).toBe(true);
+      expect(getQuitConfirmPhase()).toBe("archive-failed");
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
   it("falls through to teardown when no gate is installed even with running sessions", async () => {
     mocks.countRunningSessions.mockReturnValue(2);
     const adapter = fakeAdapter();
diff --git a/standalone/src/quit.ts b/standalone/src/quit.ts
index a012987c..2c6930b4 100644
--- a/standalone/src/quit.ts
+++ b/standalone/src/quit.ts
@@ -1,9 +1,12 @@
 import { invoke } from "@tauri-apps/api/core";
 import { listen } from "@tauri-apps/api/event";
 import { countRunningSessions } from "dormouse-lib/lib/terminal-registry";
+import { archiveSurfaceNotes } from "dormouse-lib/lib/notepad/close-coordinator";
+import { notepadSurfaceIds, removeSurface } from "dormouse-lib/lib/notepad/notepad-store";
 import type { TauriAdapter } from "./tauri-adapter";
+import { openQuitArchiveFailure } from "./quit-confirm-store";
 import { hasPendingUpdate, installPendingUpdate } from "./updater";
-import { withTimeout } from "./with-timeout";
+import { withDeadline, withTimeout } from "./with-timeout";
 
 /**
  * Quit orchestrator. Rust intercepts every quit trigger and emits
@@ -13,8 +16,9 @@ import { withTimeout } from "./with-timeout";
  */
 
 // One quit flow at a time: repeated quit-requested events are ignored while a
-// confirmation decision is outstanding or a teardown is running.
-let quitPhase: "idle" | "confirming" | "tearing-down" = "idle";
+// confirmation decision is outstanding, the archive gate is asking about notes
+// it could not store, or a teardown is running.
+let quitPhase: "idle" | "confirming" | "archive-failed" | "tearing-down" = "idle";
 // The adapter to tear down, captured at init.
 let quitAdapter: TauriAdapter | null = null;
 
@@ -50,12 +54,74 @@ function handleQuitRequested(): void {
   if (countRunningSessions() > 0 && quitConfirmGate) {
     quitPhase = "confirming";
     quitConfirmGate({
-      confirm: () => void runQuitTeardown(),
+      confirm: () => void archiveThenTeardown(),
       cancel: cancelQuit,
     });
     return;
   }
-  void runQuitTeardown();
+  void archiveThenTeardown();
+}
+
+// The archive write is a host round trip; a wedged one must not hold the quit
+// open, so it gets its own bound ahead of the teardown's.
+const ARCHIVE_GATE_MS = 3000;
+
+/**
+ * The notepad's quit gate (docs/specs/notepad.md → "Standalone quit"): every
+ * Surface holding notes or a pending batch identity participates in one archive
+ * mutation, after the running-work decision and before teardown begins.
+ * Rejects with a user-presentable message when the write fails or outruns its
+ * bound — the caller turns that into Cancel / Quit anyway.
+ */
+export async function archiveNotesBeforeQuit(): Promise<void> {
+  const ids = notepadSurfaceIds();
+  if (ids.length === 0) return;
+  // The deadline only stops us *waiting*; the archive itself keeps running and
+  // may still succeed. The signal is what stops it emptying every notepad
+  // afterwards, behind a user who has been told their notes were not stored and
+  // has chosen Cancel.
+  const gaveUp = new AbortController();
+  try {
+    await withDeadline(
+      archiveSurfaceNotes(ids, { signal: gaveUp.signal }),
+      ARCHIVE_GATE_MS,
+      `The notepad archive did not finish within ${ARCHIVE_GATE_MS / 1000}s.`,
+    );
+  } catch (err) {
+    gaveUp.abort();
+    throw err;
+  }
+}
+
+// The decision is made; archive the notes, then tear down. A refused archive is
+// the one thing that stops a confirmed quit, and only until the user answers.
+async function archiveThenTeardown(): Promise<void> {
+  // Committed from here: the gate is an await, so without this a second trigger
+  // arriving mid-archive would start a parallel flow.
+  quitPhase = "tearing-down";
+  try {
+    await archiveNotesBeforeQuit();
+  } catch (err) {
+    // The quit stays pending in Rust. Its phase-2 wait is unbounded precisely
+    // because it waits on a human (docs/specs/standalone.md → "Quit flow"), and
+    // cancelling here would retire the watchdog that a later Quit anyway still
+    // needs. Hold the flow in `archive-failed` so a repeat trigger is deduped
+    // exactly like a pending confirmation.
+    quitPhase = "archive-failed";
+    openQuitArchiveFailure(err instanceof Error ? err.message : String(err), {
+      confirm: () => {
+        // Quit anyway: the user accepts losing these notes, so forget them and
+        // take the teardown that no longer has anything to archive — watchdog
+        // still armed, because nothing cancelled the pending quit.
+        for (const id of notepadSurfaceIds()) removeSurface(id);
+        void runQuitTeardown();
+      },
+      // Cancel is the one branch that drops the pending quit in Rust.
+      cancel: cancelQuit,
+    });
+    return;
+  }
+  await runQuitTeardown();
 }
 
 // Ordering and rationale: docs/specs/standalone.md §Quit flow (Teardown
diff --git a/standalone/src/tauri-adapter.test.ts b/standalone/src/tauri-adapter.test.ts
index 76f63334..09f63a06 100644
--- a/standalone/src/tauri-adapter.test.ts
+++ b/standalone/src/tauri-adapter.test.ts
@@ -16,6 +16,7 @@ vi.mock("@tauri-apps/plugin-shell", () => ({
 
 import { invoke as rawInvoke } from "@tauri-apps/api/core";
 import { listen } from "@tauri-apps/api/event";
+import type { NotepadArchiveV1 } from "dormouse-lib/lib/notepad/types";
 import type { AlertStateDetail, PtyDataDetail } from "dormouse-lib/lib/platform/types";
 import { getTerminalPaneState } from "dormouse-lib/lib/terminal-state-store";
 import { TauriAdapter } from "./tauri-adapter";
@@ -101,6 +102,72 @@ describe("TauriAdapter legacy session cleanup", () => {
   });
 });
 
+// The archive port is a thin bridge to three Rust commands (docs/specs/notepad.md).
+// What is covered here is exactly what this side owns: the None → null mapping,
+// serialization, and passing the stored string through unparsed — the
+// compare-and-swap itself is Rust's, and validation is the shared layer's.
+describe("TauriAdapter notepad archive", () => {
+  const archive: NotepadArchiveV1 = { version: 1, batches: [] };
+
+  function invoking(impl: (cmd: string, args?: Record<string, unknown>) => unknown) {
+    const invoke = vi.mocked(rawInvoke);
+    invoke.mockClear();
+    invoke.mockImplementation((async (cmd: string, args?: Record<string, unknown>) =>
+      impl(cmd, args)) as unknown as typeof rawInvoke);
+    return { adapter: new TauriAdapter(), invoke };
+  }
+
+  it("reads a missing archive as null", async () => {
+    const { adapter } = invoking(() => null);
+    expect(await adapter.notepadArchive.load()).toBeNull();
+  });
+
+  it("hands the stored string through unparsed, with its revision", async () => {
+    // Deliberately not valid JSON: an unreadable archive has to reach the shared
+    // validator as-is, not fail here (its recovery is a user decision).
+    const { adapter } = invoking(() => ["{ not an archive", "7"]);
+    expect(await adapter.notepadArchive.load()).toEqual({
+      raw: "{ not an archive",
+      revision: "7",
+    });
+  });
+
+  it("serializes a save and names the revision it read", async () => {
+    const { adapter, invoke } = invoking(() => "ok");
+    expect(await adapter.notepadArchive.save(archive, "3")).toBe("ok");
+    expect(invoke).toHaveBeenCalledWith("save_notepad_archive", {
+      state: JSON.stringify(archive),
+      baseRevision: "3",
+    });
+
+    // Nothing stored yet: the base revision is null, not omitted.
+    await adapter.notepadArchive.save(archive, null);
+    expect(invoke).toHaveBeenLastCalledWith("save_notepad_archive", {
+      state: JSON.stringify(archive),
+      baseRevision: null,
+    });
+  });
+
+  it("reports a conflict rather than throwing, so the caller can retry", async () => {
+    const { adapter } = invoking(() => "conflict");
+    expect(await adapter.notepadArchive.save(archive, "0")).toBe("conflict");
+  });
+
+  it("moves an unreadable archive aside through the Rust command", async () => {
+    const { adapter, invoke } = invoking(() => undefined);
+    await adapter.notepadArchive.resetUnreadable();
+    expect(invoke).toHaveBeenCalledWith("reset_notepad_archive");
+  });
+
+  it("rejects when the host cannot store the archive", async () => {
+    // A closure that cannot archive its notes must take the failure path.
+    const { adapter } = invoking(() => {
+      throw new Error("disk full");
+    });
+    await expect(adapter.notepadArchive.save(archive, null)).rejects.toThrow("disk full");
+  });
+});
+
 // The Burrow lives in the sidecar; this is the webview's end of the bridge
 // (lib/src/host/remote/service-protocol.ts). Correlation is `burrowRequestId`, never
 // `requestId` — Rust swallows any sidecar line carrying the latter to resolve
diff --git a/standalone/src/tauri-adapter.ts b/standalone/src/tauri-adapter.ts
index 34f58de2..0a051c23 100644
--- a/standalone/src/tauri-adapter.ts
+++ b/standalone/src/tauri-adapter.ts
@@ -18,6 +18,11 @@ import type {
   PtyInfo,
   BurrowLink,
 } from "dormouse-lib/lib/platform/types";
+import type {
+  NotepadArchiveLoadResult,
+  NotepadArchivePort,
+  NotepadArchiveV1,
+} from "dormouse-lib/lib/notepad/types";
 import {
   answerAskCommand,
   createBurrowLinkClient,
@@ -624,6 +629,33 @@ export class TauriAdapter implements PlatformAdapter {
     }
   }
 
+  // --- Notepad archive (docs/specs/notepad.md) ---
+  //
+  // Compare-and-swap over the Rust file store (§Notepad archive in
+  // standalone/src-tauri/src/lib.rs): the shared archive service does the
+  // read-modify-write and retries on `'conflict'`. Nothing is parsed or repaired
+  // here — the stored string rides through as `raw`, because validating it is
+  // the shared layer's job and an unreadable archive must reach the user as
+  // unreadable rather than be quietly replaced.
+  //
+  // Failures reject rather than resolving: a closure that cannot archive its
+  // notes has to take the failure path, not silently drop them.
+  readonly notepadArchive: NotepadArchivePort = {
+    load: async (): Promise<NotepadArchiveLoadResult | null> => {
+      // `None` — nothing has ever been archived — arrives as null.
+      const stored = await rawInvoke<[string, string] | null>("load_notepad_archive");
+      if (!stored) return null;
+      const [raw, revision] = stored;
+      return { raw, revision };
+    },
+    save: (archive: NotepadArchiveV1, baseRevision: string | null) =>
+      rawInvoke<"ok" | "conflict">("save_notepad_archive", {
+        state: JSON.stringify(archive),
+        baseRevision,
+      }),
+    resetUnreadable: () => rawInvoke<void>("reset_notepad_archive"),
+  };
+
   /**
    * Delete any pre-upgrade snapshot or orphaned temp write. Those carry
    * transcripts, so ignoring the slot is not enough — the bytes have to leave the
diff --git a/standalone/src/with-timeout.ts b/standalone/src/with-timeout.ts
index 2ddaca63..fbf3a958 100644
--- a/standalone/src/with-timeout.ts
+++ b/standalone/src/with-timeout.ts
@@ -12,3 +12,15 @@ export function withTimeout(work: Promise<void>, ms: number, warnMessage: string
   });
   return Promise.race([work, timeout]).finally(() => clearTimeout(timer));
 }
+
+// The same bound for the one quit step that is allowed to *stop* the quit: the
+// notepad archive gate, which must be able to say "these notes are not stored"
+// (docs/specs/notepad.md -> "Standalone quit"). So unlike `withTimeout`, running
+// out of time rejects, with a message the quit dialog shows verbatim.
+export function withDeadline<T>(work: Promise<T>, ms: number, timeoutMessage: string): Promise<T> {
+  let timer: ReturnType<typeof setTimeout>;
+  const deadline = new Promise<never>((_resolve, reject) => {
+    timer = setTimeout(() => reject(new Error(timeoutMessage)), ms);
+  });
+  return Promise.race([work, deadline]).finally(() => clearTimeout(timer));
+}
diff --git a/standalone/vitest.config.ts b/standalone/vitest.config.ts
index d2727ce6..08492f59 100644
--- a/standalone/vitest.config.ts
+++ b/standalone/vitest.config.ts
@@ -4,6 +4,7 @@ import { defineConfig } from 'vitest/config';
 export default defineConfig({
   resolve: {
     alias: {
+      dor: path.resolve(import.meta.dirname, '../dor/src'),
       'dormouse-lib': path.resolve(import.meta.dirname, '../lib/src'),
     },
   },
diff --git a/vscode-ext/scripts/esbuild.mjs b/vscode-ext/scripts/esbuild.mjs
index 3fe1083f..79771e86 100644
--- a/vscode-ext/scripts/esbuild.mjs
+++ b/vscode-ext/scripts/esbuild.mjs
@@ -13,6 +13,8 @@
 // `scripts/csp-defaults.mjs` is the one definition of the default for both. See
 // docs/specs/relay.md → "Where a Burrow may reach a Relay".
 
+import { fileURLToPath } from 'node:url';
+
 import * as esbuild from 'esbuild';
 
 import {
@@ -34,6 +36,14 @@ const common = {
   // and would have to be shipped per platform — so they stay as runtime
   // `require`s that `ws` already catches and falls back from.
   external: ['vscode', 'node-pty', 'bufferutil', 'utf-8-validate'],
+  alias: {
+    // Shared `lib/` modules the extension host bundles reach the `dor` CLI's
+    // types through the `dor/*` tsconfig path. esbuild picks the tsconfig
+    // nearest each *input file*, so `vscode-ext/tsconfig.json`'s mapping does
+    // not follow an import out into `lib/`, and `dor` has no package exports to
+    // fall back on. Same alias `lib/vite.config.ts` and standalone carry.
+    dor: fileURLToPath(new URL('../../dor/src', import.meta.url)),
+  },
 };
 
 const builds = [
diff --git a/vscode-ext/src/extension.ts b/vscode-ext/src/extension.ts
index fdfd6139..c743d505 100644
--- a/vscode-ext/src/extension.ts
+++ b/vscode-ext/src/extension.ts
@@ -14,6 +14,8 @@ import { resolveSelectedShell, setSelectedShellPath, getSelectedShellPath } from
 import type { ExtensionMessage } from './message-types';
 import { initBurrow } from './burrow';
 import { disposePeerLink, initPeerLink } from './peer-link';
+import { archiveVolatileMirror } from './notepad-archive-store';
+import { refreshMirrorCwds, takeAllVolatile } from './notepad-volatile';
 
 type NewTerminalMessage = Extract<ExtensionMessage, { type: 'dormouse:newTerminal' }>;
 
@@ -58,13 +60,17 @@ function setupPanel(
     context,
     (savedSession?.panes ?? []).map((pane) => pane.id),
   );
-  const channel = serveWebview(panel.webview, mediaPath, initialState, getSelectedShell?.(), recoveryCommands);
+  // No notepad mirror: a panel is never a live resume of mirrored notes. Its
+  // router carries `killOnDispose`, so the disposal that ended the last panel
+  // already archived whatever it had (docs/specs/notepad.md).
+  const channel = serveWebview(panel.webview, mediaPath, initialState, getSelectedShell?.(), recoveryCommands, null);
 
   const router = attachRouter(channel, {
     reconnect: !!savedState,
     killOnDispose: true,
     savedSession,
     getSelectedShell,
+    context,
     // Reflect this panel's Workspace union onto the editor-tab title
     // (`<title> 🔔 [TODO]`). Icon stays the Dormouse mascot.
     onUnion: (union) => { panel.title = workspaceTitle(union); },
@@ -258,6 +264,27 @@ export async function deactivate() {
   step('capturing agent recovery commands');
   await captureAgentRecoveryCommands(extensionContext, 1200);
   await poppedOutClosed;
+  // Every webview that is still up mirrors its live notes here, and none of them
+  // will get to run a close coordinator — so this is their last chance to be
+  // archived (docs/specs/notepad.md -> Archive and Lifecycle). Ahead of the
+  // session flush, which needs its own share of a budget we do not control;
+  // bounded and best-effort for the same reason, since notes lost to a timeout
+  // are a smaller failure than an unkilled pty host.
+  // The PTYs are still alive here, so a Surface whose shell reports no CWD can
+  // still be asked where it is. Its own, smaller bound, so the refresh and the
+  // write both fit inside the 800 ms below.
+  step('archiving notepad');
+  const notepadContext = extensionContext;
+  let notepadDeadline: ReturnType<typeof setTimeout> | undefined;
+  await Promise.race([
+    refreshMirrorCwds(takeAllVolatile(), ptyManager.getCwd, 300)
+      .then((mirror) => archiveVolatileMirror(notepadContext, mirror))
+      .catch((err) => {
+        log.error('[deactivate] could not archive notepad notes:', String(err));
+      }),
+    new Promise((resolve) => { notepadDeadline = setTimeout(resolve, 800); }),
+  ]);
+  clearTimeout(notepadDeadline);
   // Save session state while PTYs are still alive — CWD queries need live
   // processes. Must happen before gracefulKillAll.
   step('flushing sessions from webview');
diff --git a/vscode-ext/src/message-router.ts b/vscode-ext/src/message-router.ts
index 175acd7e..50d0ab20 100644
--- a/vscode-ext/src/message-router.ts
+++ b/vscode-ext/src/message-router.ts
@@ -25,6 +25,14 @@ import type { WebviewMessage, ExtensionMessage } from './message-types';
 import type { DorControlRequest } from './pty-manager';
 import { createStreamRelayUrl, runAgentBrowserCommand, runAgentBrowserEdit, runAgentBrowserOpen, runAgentBrowserPopIn, runAgentBrowserPopOut, runAgentBrowserScreenshot, runAgentBrowserStreamStatus } from './agent-browser-host';
 import { createIframeProxyUrl } from './iframe-proxy-host';
+import {
+  archiveVolatileMirror,
+  loadNotepadArchive,
+  mutateNotepadArchive,
+  resetUnreadableNotepadArchive,
+  saveNotepadArchive,
+} from './notepad-archive-store';
+import { refreshMirrorCwds, setVolatileForRouter, takeStagedForRouter, takeVolatileForRouter } from './notepad-volatile';
 import { ASK_BUDGET_MS } from '../../lib/src/host/remote/service-protocol';
 import { configurePeerLink, remoteNotifyPeerChange } from './peer-link';
 import { createProcessedPtyStreams } from './processed-pty-streams';
@@ -50,6 +58,11 @@ const clipboardOps = require('../../lib/clipboard-ops.cjs') as {
 // Prevents reconnecting routers from stealing PTYs owned by other webviews.
 const globalOwnedPtyIds = new Set<string>();
 
+/** How long an editor panel's disposal waits for its PTYs to say where they
+ *  are before archiving and killing them. A closing tab is not urgent, but it
+ *  must not hang on a pty host that has stopped answering. */
+const TEARDOWN_CWD_REFRESH_MS = 1000;
+
 interface ActiveRouter {
   flushSessionSave(timeoutMs?: number): Promise<void>;
   ownsPty(id: string): boolean;
@@ -159,6 +172,9 @@ function broadcastToWebviews(message: ExtensionMessage): void {
 
 const activeRouters = new Set<ActiveRouter>();
 let nextFlushRequestId = 0;
+/** Tags each router's contribution to the volatile notepad mirror. Per
+ *  extension-host lifetime, like the mirror itself (`notepad-volatile.ts`). */
+let nextNotepadRouterId = 0;
 const ALLOWED_WORKBENCH_COMMANDS = new Set<string>(VSCODE_WORKBENCH_COMMANDS);
 
 // Shared alert manager — survives router disposal so alert state persists
@@ -329,10 +345,15 @@ export function attachRouter(
     // (owned-PTY alert state, or a PTY claimed/released). The host reflects it
     // onto native chrome (tab title / view badge). See docs/specs/vscode.md.
     onUnion?: (union: WorkspaceUnion) => void;
+    // Only the notepad archive needs it: shared storage is reachable nowhere else
+    // (docs/specs/notepad.md). Absent, the archive requests answer `ok: false`
+    // rather than hang.
+    context?: vscode.ExtensionContext;
   },
 ): vscode.Disposable {
   const reconnect = options?.reconnect ?? false;
   const killOnDispose = options?.killOnDispose ?? false;
+  const notepadRouterId = `notepad-router-${++nextNotepadRouterId}`;
 
   // The router's only send path — it stamps this webview's message token, which
   // the webview requires (docs/specs/vscode.md → "Webview message
@@ -472,6 +493,34 @@ export function attachRouter(
     );
   }
 
+  /**
+   * Answer one notepad-archive request.
+   *
+   * Every outcome crosses back, failures included: the webview's port has no
+   * deadline of its own, and an archive that cannot be written has to surface as
+   * the closure error path rather than as a Surface that never closes
+   * (docs/specs/notepad.md → Archive and Lifecycle).
+   */
+  function respondNotepad(
+    requestId: string,
+    work: (context: vscode.ExtensionContext) => Promise<unknown>,
+  ): void {
+    const context = options?.context;
+    if (!context) {
+      void post({
+        type: 'notepad:result', requestId, ok: false,
+        error: 'the notepad archive is unavailable in this window',
+      } satisfies ExtensionMessage);
+      return;
+    }
+    work(context).then(
+      (result) => post({ type: 'notepad:result', requestId, ok: true, result } satisfies ExtensionMessage),
+      (err) => post({
+        type: 'notepad:result', requestId, ok: false, error: String(err?.message ?? err),
+      } satisfies ExtensionMessage),
+    );
+  }
+
   /**
    * Subscribe PTY data and alert state forwarding to the webview.
    * Called when the webview sends dormouse:init (proving it has live content).
@@ -731,6 +780,20 @@ export function attachRouter(
       case 'burrow:command':
         handleBurrowCommand(msg.payload);
         break;
+      case 'notepad:load':
+        respondNotepad(msg.requestId, (context) => loadNotepadArchive(context));
+        break;
+      case 'notepad:save':
+        respondNotepad(msg.requestId, (context) => saveNotepadArchive(context, msg.state, msg.baseRevision));
+        break;
+      case 'notepad:reset':
+        respondNotepad(msg.requestId, (context) => resetUnreadableNotepadArchive(context));
+        break;
+      case 'notepad:volatile':
+        // Memory only, and nothing to answer: the mirror exists so a teardown
+        // that finds no webview left can still archive (docs/specs/notepad.md).
+        setVolatileForRouter(notepadRouterId, msg.snapshot);
+        break;
       case 'dormouse:themeColors':
         // Webview reports its resolved terminal theme; cache for OSC color replies.
         latestThemeColors = { foreground: msg.foreground, background: msg.background, cursor: msg.cursor };
@@ -942,15 +1005,55 @@ export function attachRouter(
       resolveAllFlushRequests();
       disconnectWebview?.();
       disconnectWebview = null;
+      // Every synchronous bookkeeping step stays here; only the kills wait,
+      // because the archive write below asks each live PTY where its process
+      // is and a dead one cannot answer.
+      const toKill = killOnDispose ? [...ownedPtyIds] : [];
       for (const id of ownedPtyIds) {
-        globalOwnedPtyIds.delete(id);
-        if (killOnDispose) {
-          ownerPtyStreams.delete(id);
-          ptyManager.kill(id);
-        }
+        // Closing PTYs remain reserved while CWD/storage work is pending;
+        // another router must not resume a terminal this disposal will kill.
+        if (!killOnDispose) globalOwnedPtyIds.delete(id);
+        if (killOnDispose) ownerPtyStreams.delete(id);
       }
       ownedPtyIds.clear();
       messageDisposable.dispose();
+      // An editor panel closing is a deliberate ending, so this router's mirrored
+      // notes are archived here: the webview is already gone and cannot run its
+      // own close coordinator. A `WebviewView` disposal is *not* an ending — its
+      // PTYs stay alive — so its *notes* are left in place for the next resolve
+      // to hydrate. Its staged archive deletions are not: the Archive view
+      // promised they were irreversible once this window closed, and the webview
+      // is the window (docs/specs/notepad.md → "VS Code lifecycle").
+      //
+      // Best-effort on both paths: VS Code destroys the container whatever we
+      // say, so a failure is logged rather than allowed to reject out of
+      // `dispose`.
+      const notepadContext = options?.context;
+      // Draining is what keeps `deactivate()` from archiving these a second
+      // time under a fresh batch id; an empty mirror writes nothing. Both
+      // drains are synchronous, so nothing this router reports later can slip
+      // into the write that is now in flight.
+      const write: Promise<unknown> = !notepadContext
+        ? Promise.resolve()
+        : killOnDispose
+          ? refreshMirrorCwds(
+            takeVolatileForRouter(notepadRouterId),
+            ptyManager.getCwd,
+            TEARDOWN_CWD_REFRESH_MS,
+          ).then((refreshed) => archiveVolatileMirror(notepadContext, refreshed))
+          : mutateNotepadArchive(notepadContext, takeStagedForRouter(notepadRouterId));
+      void write
+        .catch((err) => {
+          log.error('[notepad] could not commit a disposed webview\'s archive write:', String(err));
+        })
+        // The kills this disposal owes, once the write that needed them alive
+        // has settled. `toKill` is empty on the non-killing path.
+        .finally(() => {
+          for (const id of toKill) {
+            try { ptyManager.kill(id); }
+            finally { globalOwnedPtyIds.delete(id); }
+          }
+        });
     },
   };
 
diff --git a/vscode-ext/src/message-types.ts b/vscode-ext/src/message-types.ts
index 548e2210..305e6293 100644
--- a/vscode-ext/src/message-types.ts
+++ b/vscode-ext/src/message-types.ts
@@ -10,6 +10,7 @@ import type { DorControlCancelPayload, DorControlRequestPayload, DorControlRespo
 import type { AgentBrowserStreamStatusResult, AlertStateDetail, IframeProxyResult, OpenPort } from '../../lib/src/lib/platform/types';
 import type { VSCodeWorkbenchCommand } from '../../lib/src/lib/vscode-keybindings';
 import type { BurrowCommand, BurrowResult } from '../../lib/src/host/remote/service-protocol';
+import type { VolatileNotepadSnapshot } from '../../lib/src/lib/notepad/types';
 
 // Messages from webview → extension host
 export type WebviewMessage =
@@ -43,6 +44,15 @@ export type WebviewMessage =
   | { type: 'peer:notify' }
   // One command for the Burrow service (`lib/src/host/remote/service-protocol.ts`).
   | { type: 'burrow:command'; payload: BurrowCommand }
+  // The notepad archive lives in shared storage, which only the extension host can
+  // reach, so the webview drives it as compare-and-swap: `state` is the whole
+  // serialized archive and `baseRevision` the token `notepad:load` handed back
+  // (docs/specs/notepad.md). `notepad:volatile` is the live mirror — fire and
+  // forget, since nothing waits on it and the next snapshot supersedes it.
+  | { type: 'notepad:load'; requestId: string }
+  | { type: 'notepad:save'; requestId: string; state: string; baseRevision: string | null }
+  | { type: 'notepad:reset'; requestId: string }
+  | { type: 'notepad:volatile'; snapshot: VolatileNotepadSnapshot }
   | { type: 'dormouse:init' }
   | ({ type: 'dormouse:themeColors' } & TerminalColors)
   | { type: 'dormouse:saveState'; state: unknown }
@@ -103,6 +113,10 @@ export type ExtensionMessage =
   // one that asked finds a pending command to settle.
   | { type: 'burrow:result'; payload: BurrowResult }
   | { type: 'burrow:event'; payload: unknown }
+  // One reply shape for all three archive requests: `result` carries whatever
+  // that request returns, and a failure crosses as `ok: false` rather than
+  // silence, because the webview's port turns it into the closure error path.
+  | { type: 'notepad:result'; requestId: string; ok: boolean; result?: unknown; error?: string }
   | {
       type: 'dormouse:newTerminal';
       shell?: string;
diff --git a/vscode-ext/src/notepad-archive-file.ts b/vscode-ext/src/notepad-archive-file.ts
new file mode 100644
index 00000000..9852c36d
--- /dev/null
+++ b/vscode-ext/src/notepad-archive-file.ts
@@ -0,0 +1,126 @@
+/** Shared archive transactions; globalState is only the legacy migration source. */
+import { createHash, randomUUID } from 'node:crypto';
+import { mkdir, readFile, readdir, rename, rmdir, unlink, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { setTimeout as delay } from 'node:timers/promises';
+
+export const ARCHIVE_FILE = 'notepad-archive.json';
+
+function code(error: unknown): string | undefined {
+  return (error as NodeJS.ErrnoException).code;
+}
+
+/**
+ * Publish a NONEMPTY directory atomically to acquire the lock. Every owner has
+ * a unique filename; releasing/reaping unlinks only that filename then rmdirs
+ * an empty directory. A delayed reaper cannot remove a replacement owner's
+ * nonempty directory. Never evict a live process on a timer (a paused host may
+ * still complete its write). PID reuse can delay recovery, never split the lock.
+ */
+async function acquire(dir: string): Promise<() => Promise<void>> {
+  const lock = join(dir, `${ARCHIVE_FILE}.lock`);
+  const owner = `${process.pid}-${randomUUID()}`;
+  const candidate = join(dir, `${ARCHIVE_FILE}.lock-${owner}`);
+  await mkdir(candidate, { mode: 0o700 });
+  await writeFile(join(candidate, owner), '', { mode: 0o600 });
+  const deadline = Date.now() + 2_000;
+  try {
+    for (;;) {
+      try {
+        await rename(candidate, lock);
+        return async () => {
+          await unlink(join(lock, owner));
+          await rmdir(lock).catch((error) => {
+            if (!['ENOENT', 'ENOTEMPTY', 'EEXIST'].includes(code(error) ?? '')) throw error;
+          });
+        };
+      } catch (error) {
+        if (!['ENOTEMPTY', 'EEXIST', 'EPERM', 'EACCES'].includes(code(error) ?? '')) throw error;
+      }
+      const owners = await readdir(lock).catch((error) => {
+        if (code(error) === 'ENOENT') return [];
+        throw error;
+      });
+      for (const name of owners) {
+        const match = /^(\d+)-[a-f0-9-]+$/.exec(name);
+        if (!match) continue;
+        try { process.kill(Number(match[1]), 0); } catch (error) {
+          if (code(error) !== 'ESRCH') continue;
+          await unlink(join(lock, name)).catch((error) => {
+            if (code(error) !== 'ENOENT') throw error;
+          });
+        }
+      }
+      await rmdir(lock).catch((error) => {
+        if (!['ENOENT', 'ENOTEMPTY', 'EEXIST'].includes(code(error) ?? '')) throw error;
+      });
+      if (Date.now() >= deadline) throw new Error('The notepad archive is busy. Try again.');
+      await delay(20);
+    }
+  } finally {
+    await unlink(join(candidate, owner)).catch((error) => {
+      if (code(error) !== 'ENOENT') throw error;
+    });
+    await rmdir(candidate).catch((error) => {
+      if (code(error) !== 'ENOENT') throw error;
+    });
+  }
+}
+
+async function atomicWrite(path: string, bytes: string): Promise<void> {
+  const temporary = `${path}.${randomUUID()}.tmp`;
+  try {
+    await writeFile(temporary, bytes, { mode: 0o600, flag: 'wx' });
+    await rename(temporary, path);
+  } finally {
+    await unlink(temporary).catch((error) => {
+      if (code(error) !== 'ENOENT') throw error;
+    });
+  }
+}
+
+export interface ArchiveStorage {
+  raw: string | undefined;
+  revision: string | null;
+  write(raw: string): Promise<void>;
+  reset(): Promise<void>;
+}
+
+export async function withArchiveFile<T>(
+  dir: string,
+  legacy: () => string | undefined,
+  operation: (storage: ArchiveStorage) => Promise<T>,
+): Promise<T> {
+  await mkdir(dir, { recursive: true, mode: 0o700 });
+  const release = await acquire(dir);
+  try {
+    const path = join(dir, ARCHIVE_FILE);
+    const encode = (raw: string | undefined) => JSON.stringify({ revision: randomUUID(), raw: raw ?? null });
+    let bytes: string;
+    try { bytes = await readFile(path, 'utf8'); } catch (error) {
+      if (code(error) !== 'ENOENT') throw error;
+      // Even an absent legacy entry becomes a tombstone, so a stale globalState
+      // cache cannot resurrect it after a recovery in another extension host.
+      bytes = encode(legacy());
+      await atomicWrite(path, bytes);
+    }
+    let raw: string | undefined = bytes;
+    try {
+      const envelope = JSON.parse(bytes);
+      if (envelope && typeof envelope.revision === 'string'
+        && (typeof envelope.raw === 'string' || envelope.raw === null)
+        && Object.keys(envelope).length === 2) raw = envelope.raw ?? undefined;
+    } catch { /* Expose corrupt storage to the ordinary unreadable recovery UI. */ }
+    return await operation({
+      raw,
+      revision: raw === undefined ? null : createHash('sha256').update(bytes).digest('hex'),
+      write: (next) => atomicWrite(path, encode(next)),
+      reset: async () => {
+        await atomicWrite(`${path}.unreadable-${randomUUID()}`, bytes);
+        await atomicWrite(path, encode(undefined));
+      },
+    });
+  } finally {
+    await release();
+  }
+}
diff --git a/vscode-ext/src/notepad-archive-store.ts b/vscode-ext/src/notepad-archive-store.ts
new file mode 100644
index 00000000..5ead8f18
--- /dev/null
+++ b/vscode-ext/src/notepad-archive-store.ts
@@ -0,0 +1,137 @@
+/**
+ * The VS Code half of the notepad archive (`docs/specs/notepad.md`).
+ *
+ * The webview owns the archive's *shape* — it validates, mutates, and retries;
+ * this side only stores bytes and names the version they were read at, so two
+ * webviews appending at once cannot lose each other's batches. The host-side
+ * mutations at the bottom exist for the one case the webview cannot cover: a
+ * teardown where the webview is already gone (an editor panel closing, the
+ * extension deactivating) and nobody is left to run its close coordinator.
+ */
+import type * as vscode from 'vscode';
+import { randomUUID } from 'crypto';
+
+import { withArchiveFile, type ArchiveStorage } from './notepad-archive-file';
+import {
+  applyArchiveMutation,
+  batchFromVolatile,
+  EMPTY_ARCHIVE,
+  isEmptyMutation,
+  readNotepadArchive,
+} from '../../lib/src/lib/notepad/archive-model';
+import type {
+  ArchiveBatch,
+  NotepadArchiveLoadResult,
+  NotepadArchiveMutation,
+  VolatileNotepadSnapshot,
+} from '../../lib/src/lib/notepad/types';
+
+/** Legacy machine-local key, imported once and never registered for Settings Sync. */
+export const NOTEPAD_ARCHIVE_KEY = 'dormouse.notepadArchive.v1';
+
+function transaction<T>(context: vscode.ExtensionContext, operation: (storage: ArchiveStorage) => Promise<T>): Promise<T> {
+  return withArchiveFile(context.globalStorageUri.fsPath, () => readStored(context), operation);
+}
+
+/**
+ * What is stored, as the JSON text the shared validator reads.
+ *
+ * A stored value that is not a string is re-serialized rather than ignored: it
+ * is still *something*, and reporting the key as empty would let the next save
+ * overwrite it. The archive is never silently replaced — the shared layer shows
+ * it as unreadable and offers the user one recovery.
+ */
+function readStored(context: vscode.ExtensionContext): string | undefined {
+  const stored = context.globalState.get(NOTEPAD_ARCHIVE_KEY);
+  if (stored === undefined) return undefined;
+  if (typeof stored === 'string') return stored;
+  const text = JSON.stringify(stored);
+  // `null` parses cleanly and fails validation, which is exactly the "present
+  // but unreadable" outcome we want for a value we cannot even serialize.
+  return typeof text === 'string' ? text : 'null';
+}
+
+/** The stored archive and the token naming it, or `null` if nothing was ever archived. */
+export function loadNotepadArchive(
+  context: vscode.ExtensionContext,
+): Promise<NotepadArchiveLoadResult | null> {
+  return transaction(context, async ({ raw, revision }) => {
+    return raw === undefined ? null : { raw, revision: revision! };
+  });
+}
+
+/** Replace the stored archive iff it is still at `baseRevision` (`null` = nothing stored). */
+export function saveNotepadArchive(
+  context: vscode.ExtensionContext,
+  json: string,
+  baseRevision: string | null,
+): Promise<'ok' | 'conflict'> {
+  return transaction(context, async (storage) => {
+    if (baseRevision !== storage.revision) return 'conflict';
+    await storage.write(json);
+    return 'ok';
+  });
+}
+
+/**
+ * User-initiated recovery from an unreadable archive: copy the value to a
+ * quarantine file and clear the main one, so the next `load` returns `null` and
+ * appends work again.
+ *
+ * Moved aside, **never deleted**: the user asked for a working archive, not for
+ * their notes to be destroyed, and only a human can tell whether what is in
+ * there is recoverable (`docs/specs/notepad.md` → Archive).
+ */
+export function resetUnreadableNotepadArchive(context: vscode.ExtensionContext): Promise<void> {
+  return transaction(context, async (storage) => {
+    // A recovery button can outlive another webview's successful recovery.
+    if (storage.raw === undefined || readNotepadArchive(storage.raw)) return;
+    await storage.reset();
+  });
+}
+
+/**
+ * Archive one drained volatile mirror: the batches its Surfaces would have
+ * written had they closed normally, and the deletions its Archive view had
+ * staged, as **one** mutation, so a teardown lands whole or not at all, exactly
+ * like a closure.
+ * Reports failure; whether that is fatal is the caller's call, and for both
+ * callers it is not — VS Code destroys the container whatever we say.
+ */
+export function archiveVolatileMirror(
+  context: vscode.ExtensionContext,
+  mirror: VolatileNotepadSnapshot,
+): Promise<void> {
+  const closedAt = Date.now();
+  const append: ArchiveBatch[] = [];
+  const deleteBatchIds = [...(mirror.stagedDeletions.deleteBatchIds ?? [])];
+  for (const surface of mirror.surfaces) {
+    // A timed-out close may already have saved the pre-edit notes. Replace
+    // that batch, including deleting it when the live notepad is now empty.
+    const id = surface.pendingBatchId ?? randomUUID();
+    if (surface.pendingBatchId) deleteBatchIds.push(id);
+    const batch = batchFromVolatile(surface, id, closedAt);
+    if (batch) append.push(batch);
+  }
+  return mutateNotepadArchive(context, { append, ...mirror.stagedDeletions, deleteBatchIds });
+}
+
+/** Read-modify-write under the same transaction lock the webview's saves go through.
+ *  Idempotent by batch and note id; nothing to write touches nothing. */
+export function mutateNotepadArchive(
+  context: vscode.ExtensionContext,
+  mutation: NotepadArchiveMutation,
+): Promise<void> {
+  if (isEmptyMutation(mutation)) return Promise.resolve();
+  return transaction(context, async (storage) => {
+    const raw = storage.raw;
+    const archive = raw === undefined ? EMPTY_ARCHIVE : readNotepadArchive(raw);
+    if (!archive) {
+      // Every append fails until the user recovers it. Replacing it here would
+      // destroy whatever is in there without anyone being asked
+      // (`docs/specs/notepad.md` → Archive).
+      throw new Error('the notepad archive is unreadable; recovery is user-initiated');
+    }
+    await storage.write(JSON.stringify(applyArchiveMutation(archive, mutation)));
+  });
+}
diff --git a/vscode-ext/src/notepad-volatile.ts b/vscode-ext/src/notepad-volatile.ts
new file mode 100644
index 00000000..41ffc4b9
--- /dev/null
+++ b/vscode-ext/src/notepad-volatile.ts
@@ -0,0 +1,263 @@
+/**
+ * The extension host's volatile notepad mirror (`docs/specs/notepad.md` →
+ * Archive and Lifecycle).
+ *
+ * VS Code can destroy a webview without asking — an editor tab closed, a window
+ * gone — so the close coordinator that normally archives a Surface's notes may
+ * never run. Every webview therefore mirrors its live notes here, and a teardown
+ * archives from the mirror instead.
+ *
+ * **Memory only, never a file.** Module state is cleared by an extension restart
+ * by construction, which is the point: this is not a draft store, it is the
+ * bridge across one disposal. It hydrates exactly one path — a live resume, a
+ * webview re-resolved over PTYs this extension host still owns — never a cold
+ * restore.
+ */
+import { readMirrorTerminalId, readNotepadArchive } from '../../lib/src/lib/notepad/archive-model';
+import type {
+  VolatileNotepadSnapshot,
+  VolatileSurfaceNotes,
+} from '../../lib/src/lib/notepad/types';
+import { settleAllWithin } from '../../lib/src/lib/settle-within';
+import { cwdFromProcessPath, processCwdMayReplace } from '../../lib/src/lib/terminal-state';
+
+type StagedDeletions = VolatileNotepadSnapshot['stagedDeletions'];
+
+/** Live notes by Surface id, so a resume can be handed exactly the ids its PTYs still have. */
+const mirroredSurfaces = new Map<string, VolatileSurfaceNotes>();
+/** Which router last reported each Surface, so a router's next snapshot can
+ *  retire what it dropped without touching another webview's notes. */
+const surfaceOwner = new Map<string, string>();
+/** Archive deletions staged in each router's open Archive view. */
+const stagedByRouter = new Map<string, StagedDeletions>();
+
+const EMPTY_STAGED: StagedDeletions = Object.freeze({ deleteBatchIds: [], deleteNotes: [] });
+
+/**
+ * Keep only what the archive validator will read back.
+ *
+ * The webview is our own code, but what it mirrors here is written verbatim into
+ * the archive by a teardown that has no webview left to ask, and one malformed
+ * note would make the *whole* archive unreadable on the next load. Round-tripping
+ * the batch this Surface would produce through the shared validator is the
+ * cheapest way to be sure. The validator *rejects* unknown fields rather than
+ * dropping them, which is what the webview sends anyway — `buildVolatileSnapshot`
+ * maps every note through `toArchivedNote` and the CWD is the canonical
+ * `CwdState` (`readNotepadArchive` in `lib/src/lib/notepad/archive-model.ts`).
+ */
+function sanitizeSurface(value: unknown): VolatileSurfaceNotes | null {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return null;
+  const surface = value as Record<string, unknown>;
+  if (typeof surface.surfaceId !== 'string' || !surface.surfaceId) return null;
+  const archive = readNotepadArchive({
+    version: 1,
+    batches: [
+      {
+        id: 'probe',
+        closedAt: 0,
+        surfaceTitle: surface.surfaceTitle,
+        surfaceKind: surface.surfaceKind,
+        cwd: surface.cwd ?? null,
+        notes: surface.notes ?? [],
+      },
+    ],
+  });
+  const batch = archive?.batches[0];
+  if (!batch) return null;
+  // Mirror-only, so it goes around the batch validator rather than through it: a
+  // batch carrying this field would be rejected on the next load.
+  const terminalId = readMirrorTerminalId(surface.terminalId);
+  return {
+    surfaceId: surface.surfaceId,
+    surfaceTitle: batch.surfaceTitle,
+    surfaceKind: batch.surfaceKind,
+    cwd: batch.cwd,
+    ...(terminalId ? { terminalId } : {}),
+    ...(typeof surface.pendingBatchId === 'string' && surface.pendingBatchId
+      ? { pendingBatchId: surface.pendingBatchId } : {}),
+    notes: batch.notes,
+  };
+}
+
+function sanitizeStaged(value: unknown): StagedDeletions {
+  if (!value || typeof value !== 'object') return { deleteBatchIds: [], deleteNotes: [] };
+  const staged = value as Record<string, unknown>;
+  const deleteBatchIds = Array.isArray(staged.deleteBatchIds)
+    ? staged.deleteBatchIds.filter((id): id is string => typeof id === 'string' && id.length > 0)
+    : [];
+  const deleteNotes: Array<{ batchId: string; noteId: string }> = [];
+  if (Array.isArray(staged.deleteNotes)) {
+    for (const entry of staged.deleteNotes) {
+      if (!entry || typeof entry !== 'object') continue;
+      const { batchId, noteId } = entry as Record<string, unknown>;
+      if (typeof batchId !== 'string' || typeof noteId !== 'string') continue;
+      deleteNotes.push({ batchId, noteId });
+    }
+  }
+  return { deleteBatchIds, deleteNotes };
+}
+
+/**
+ * Replace one router's whole contribution.
+ *
+ * A router reports its live Surfaces every time they change, so anything it
+ * stops reporting has been closed through the ordinary path (already archived by
+ * the webview) or replaced in place. Only what this router still owns is
+ * retired: two webviews mirror into the same map, and one must never drop the
+ * other's notes.
+ */
+export function setVolatileForRouter(routerId: string, snapshot: unknown): void {
+  const raw = (snapshot ?? {}) as Record<string, unknown>;
+  const surfaces: VolatileSurfaceNotes[] = [];
+  if (Array.isArray(raw.surfaces)) {
+    for (const entry of raw.surfaces) {
+      const surface = sanitizeSurface(entry);
+      if (surface) surfaces.push(surface);
+    }
+  }
+
+  const next = new Set(surfaces.map((surface) => surface.surfaceId));
+  for (const [id, owner] of surfaceOwner) {
+    if (owner !== routerId || next.has(id)) continue;
+    surfaceOwner.delete(id);
+    mirroredSurfaces.delete(id);
+  }
+  for (const surface of surfaces) {
+    mirroredSurfaces.set(surface.surfaceId, surface);
+    surfaceOwner.set(surface.surfaceId, routerId);
+  }
+  stagedByRouter.set(routerId, sanitizeStaged(raw.stagedDeletions));
+}
+
+/** Remove and return the mirrored notes for these Surface ids. */
+export function takeVolatileForSurfaces(ids: Iterable<string>): VolatileSurfaceNotes[] {
+  const taken: VolatileSurfaceNotes[] = [];
+  for (const id of ids) {
+    const surface = mirroredSurfaces.get(id);
+    if (!surface) continue;
+    taken.push(surface);
+    mirroredSurfaces.delete(id);
+    surfaceOwner.delete(id);
+  }
+  return taken;
+}
+
+/** Every Surface this router currently owns. */
+export function surfaceIdsForRouter(routerId: string): string[] {
+  const ids: string[] = [];
+  for (const [id, owner] of surfaceOwner) {
+    if (owner === routerId) ids.push(id);
+  }
+  return ids;
+}
+
+/**
+ * Take one router's staged archive deletions.
+ *
+ * Drained on *every* disposal, not only a killing one: the Archive view's
+ * contract is that a deletion is irreversible once the window closes, and the
+ * webview is the window. Left here they would reappear as still-pending in the
+ * next resolve and then be committed hours later by `deactivate()`, with no
+ * Undo left anywhere.
+ */
+export function takeStagedForRouter(routerId: string): StagedDeletions {
+  const staged = stagedByRouter.get(routerId) ?? EMPTY_STAGED;
+  stagedByRouter.delete(routerId);
+  return staged;
+}
+
+/** Drain one router's mirror — what its disposal has to archive. */
+export function takeVolatileForRouter(routerId: string): VolatileNotepadSnapshot {
+  const surfaces = takeVolatileForSurfaces(surfaceIdsForRouter(routerId));
+  return { surfaces, stagedDeletions: takeStagedForRouter(routerId) };
+}
+
+/**
+ * Fill in the process CWD of every mirrored terminal Surface, while its PTY is
+ * still alive.
+ *
+ * The mirror carries whatever CWD the webview last reported, which for a shell
+ * with no CWD escapes is nothing at all — and a teardown archives it verbatim.
+ * The PTY is still running at that moment, so the host asks it directly, exactly
+ * as the session-save path does per pane. Pure: the caller archives what comes
+ * back (`docs/specs/notepad.md` → "VS Code lifecycle").
+ *
+ * A Surface whose CWD came from shell integration keeps it, and is never even
+ * asked — `processCwdMayReplace` is the same rule the webview side applies in
+ * `updateCwdIfAllowed`. Bounded as one batch and best effort: on this path the
+ * kill is waiting behind it.
+ */
+export async function refreshMirrorCwds(
+  mirror: VolatileNotepadSnapshot,
+  getCwd: (terminalId: string) => Promise<string | null>,
+  boundMs: number,
+): Promise<VolatileNotepadSnapshot> {
+  const asking = mirror.surfaces.filter(
+    (surface): surface is VolatileSurfaceNotes & { terminalId: string } => (
+      !!surface.terminalId
+      && surface.notes.length > 0
+      && processCwdMayReplace(surface.cwd?.source)
+    ),
+  );
+  const paths = await settleAllWithin(
+    // `async` so a `getCwd` that throws outright is a rejection like any other.
+    asking.map(async (surface) => getCwd(surface.terminalId)),
+    boundMs,
+    null,
+  );
+  const answered = new Map(asking.map((surface, index) => [surface.surfaceId, paths[index]]));
+  const surfaces = mirror.surfaces.map((surface) => {
+    const path = answered.get(surface.surfaceId);
+    const cwd = path ? cwdFromProcessPath(path) : null;
+    return cwd ? { ...surface, cwd } : surface;
+  });
+  return { ...mirror, surfaces };
+}
+
+/** Drain everything — what `deactivate()` has to archive. */
+export function takeAllVolatile(): VolatileNotepadSnapshot {
+  const surfaces = [...mirroredSurfaces.values()];
+  mirroredSurfaces.clear();
+  surfaceOwner.clear();
+  const stagedDeletions = mergeStaged([...stagedByRouter.keys()]);
+  stagedByRouter.clear();
+  return { surfaces, stagedDeletions };
+}
+
+/**
+ * The mirror a resuming webview boots with, for the pane ids of its saved
+ * session — the same ids it claims recovery commands under.
+ *
+ * Non-destructive on purpose: a webview that is served this and then never comes
+ * back (a crash between boot and its first sync) must still have its notes
+ * archived by `deactivate()`. The resumed webview re-reports them under its own
+ * router, which is what re-establishes ownership. Returns `null` when there is
+ * nothing to hand over, so the boot payload matches the panel case exactly.
+ *
+ * Only the notes survive a disposal: the staged archive deletions behind them
+ * were committed by it (`takeStagedForRouter`), so there is never anything
+ * pending left to hand a resume.
+ */
+export function snapshotForLiveResume(liveSurfaceIds: Iterable<string>): VolatileNotepadSnapshot | null {
+  const surfaces: VolatileSurfaceNotes[] = [];
+  for (const id of liveSurfaceIds) {
+    const surface = mirroredSurfaces.get(id);
+    if (!surface) continue;
+    surfaces.push(surface);
+  }
+  if (surfaces.length === 0) return null;
+  return { surfaces, stagedDeletions: EMPTY_STAGED };
+}
+
+/** Deletions are archive-wide, so deactivate commits every router's staged set as one. */
+function mergeStaged(routerIds: readonly string[]): StagedDeletions {
+  const deleteBatchIds = new Set<string>();
+  const deleteNotes = new Map<string, { batchId: string; noteId: string }>();
+  for (const routerId of routerIds) {
+    const staged = stagedByRouter.get(routerId);
+    if (!staged) continue;
+    for (const id of staged.deleteBatchIds ?? []) deleteBatchIds.add(id);
+    for (const ref of staged.deleteNotes ?? []) deleteNotes.set(`${ref.batchId} ${ref.noteId}`, ref);
+  }
+  return { deleteBatchIds: [...deleteBatchIds], deleteNotes: [...deleteNotes.values()] };
+}
diff --git a/vscode-ext/src/webview-html.ts b/vscode-ext/src/webview-html.ts
index f1628d35..3cfab2ae 100644
--- a/vscode-ext/src/webview-html.ts
+++ b/vscode-ext/src/webview-html.ts
@@ -6,7 +6,9 @@ import * as fs from 'fs';
 import { randomBytes } from 'crypto';
 import { CSP_NONCE_PLACEHOLDER } from './csp-nonce-placeholder';
 import { HOST_MESSAGE_TOKEN_GLOBAL } from '../../lib/src/lib/vscode-message-token';
+import { NOTEPAD_VOLATILE_GLOBAL } from '../../lib/src/lib/vscode-notepad-global';
 import { RECOVERY_COMMANDS_GLOBAL } from '../../lib/src/lib/vscode-recovery-global';
+import type { VolatileNotepadSnapshot } from '../../lib/src/lib/notepad/types';
 
 function serializeForInlineScript(value: unknown): string {
   return JSON.stringify(value ?? null)
@@ -32,6 +34,15 @@ export function getWebviewHtml(
    * replay it (docs/specs/transport.md -> "Consuming it").
    */
   recoveryCommands?: Record<string, string> | null,
+  /**
+   * The extension host's volatile notepad mirror for this webview's live PTYs.
+   * Rides the boot payload for the same reason the recovery commands do — it is
+   * host-owned and must never enter a save/restore cycle — and is non-null on
+   * exactly one path, a live resume (docs/specs/notepad.md → Archive and
+   * Lifecycle). An editor panel always gets `null`: its own disposal archived
+   * whatever it had mirrored.
+   */
+  notepadVolatile?: VolatileNotepadSnapshot | null,
 ): { html: string; messageToken: string } {
   const indexPath = path.join(mediaPath, 'index.html');
   let html = fs.readFileSync(indexPath, 'utf-8');
@@ -105,7 +116,7 @@ export function getWebviewHtml(
   // substituted a second time.
   html = html.replace(
     '</head>',
-    `    <script nonce="${nonce}">globalThis.${HOST_MESSAGE_TOKEN_GLOBAL} = ${serializeForInlineScript(messageToken)};\nglobalThis.__DORMOUSE_HOST_STATE__ = ${serializeForInlineScript(initialState)};\nglobalThis.__DORMOUSE_SELECTED_SHELL__ = ${serializeForInlineScript(selectedShell ?? null)};\nglobalThis.${RECOVERY_COMMANDS_GLOBAL} = ${serializeForInlineScript(recoveryCommands ?? null)};</script>\n  </head>`,
+    `    <script nonce="${nonce}">globalThis.${HOST_MESSAGE_TOKEN_GLOBAL} = ${serializeForInlineScript(messageToken)};\nglobalThis.__DORMOUSE_HOST_STATE__ = ${serializeForInlineScript(initialState)};\nglobalThis.__DORMOUSE_SELECTED_SHELL__ = ${serializeForInlineScript(selectedShell ?? null)};\nglobalThis.${RECOVERY_COMMANDS_GLOBAL} = ${serializeForInlineScript(recoveryCommands ?? null)};\nglobalThis.${NOTEPAD_VOLATILE_GLOBAL} = ${serializeForInlineScript(notepadVolatile ?? null)};</script>\n  </head>`,
   );
 
   return { html, messageToken };
diff --git a/vscode-ext/src/webview-messaging.ts b/vscode-ext/src/webview-messaging.ts
index 1b48a575..640eb79e 100644
--- a/vscode-ext/src/webview-messaging.ts
+++ b/vscode-ext/src/webview-messaging.ts
@@ -2,6 +2,7 @@ import * as vscode from 'vscode';
 import { HOST_MESSAGE_TOKEN_FIELD } from '../../lib/src/lib/vscode-message-token';
 import { getWebviewHtml } from './webview-html';
 import type { ExtensionMessage } from './message-types';
+import type { VolatileNotepadSnapshot } from '../../lib/src/lib/notepad/types';
 
 /**
  * The host's handle on a served webview. `serveWebview` returns one of these
@@ -30,8 +31,11 @@ export function serveWebview(
   initialState?: unknown,
   selectedShell?: { shell?: string; args?: string[] } | null,
   recoveryCommands?: Record<string, string> | null,
+  notepadVolatile?: VolatileNotepadSnapshot | null,
 ): WebviewChannel {
-  const { html, messageToken } = getWebviewHtml(webview, mediaPath, initialState, selectedShell, recoveryCommands);
+  const { html, messageToken } = getWebviewHtml(
+    webview, mediaPath, initialState, selectedShell, recoveryCommands, notepadVolatile,
+  );
   webview.html = html;
 
   return {
diff --git a/vscode-ext/src/webview-view-provider.ts b/vscode-ext/src/webview-view-provider.ts
index 6a4af340..01f78a7f 100644
--- a/vscode-ext/src/webview-view-provider.ts
+++ b/vscode-ext/src/webview-view-provider.ts
@@ -3,6 +3,7 @@ import * as path from 'path';
 import { attachRouter, getAlertStates } from './message-router';
 import { serveWebview, type WebviewChannel } from './webview-messaging';
 import { takeRecoveryCommands, getSavedSessionState, saveSessionState, mergeAlertStates } from './session-state';
+import { snapshotForLiveResume } from './notepad-volatile';
 import type { ExtensionMessage } from './message-types';
 import * as ptyManager from './pty-manager';
 import { resolveSelectedShell } from './shell-selection';
@@ -71,22 +72,31 @@ export class DormouseViewProvider implements vscode.WebviewViewProvider {
     }
 
     const savedSession = getSavedSessionState(this.context);
+    // The pane ids both boot globals below are claimed under. One list, because
+    // the recovery claim and the notepad mirror must scope to the same panes.
+    const savedPaneIds = (savedSession?.panes ?? []).map((pane) => pane.id);
     // Claimed by pane id, and deliberately separate from the session: the commands
     // ride their own boot global, so the webview cannot save them back and a
     // resume happens exactly once (docs/specs/transport.md -> "Consuming it").
     // Scoped to *this* view's panes because the capture interrupts every live PTY,
     // including any owned by an editor panel — taking the record whole would delete
     // their commands before the panel ever resolved.
-    const recoveryCommands = takeRecoveryCommands(
-      this.context,
-      (savedSession?.panes ?? []).map((pane) => pane.id),
+    const recoveryCommands = takeRecoveryCommands(this.context, savedPaneIds);
+    // The one path that hydrates the notepad mirror: this view's `onDidDispose`
+    // leaves its PTYs alive, so a re-resolve (a move between panel containers) is
+    // a live resume and the notes for those panes are still in extension-host
+    // memory. A cold restore finds nothing mirrored and gets `null`
+    // (docs/specs/notepad.md).
+    const notepadVolatile = snapshotForLiveResume(savedPaneIds);
+    this.channel = serveWebview(
+      view.webview, mediaPath, savedSession, this.selectedShell, recoveryCommands, notepadVolatile,
     );
-    this.channel = serveWebview(view.webview, mediaPath, savedSession, this.selectedShell, recoveryCommands);
 
     this.routerDisposable?.dispose();
     this.routerDisposable = attachRouter(this.channel, {
       reconnect: true,
       savedSession,
+      context: this.context,
       onSaveState: (state) => {
         return saveSessionState(this.context, mergeAlertStates(state, getAlertStates()));
       },
diff --git a/vscode-ext/test/message-router.test.ts b/vscode-ext/test/message-router.test.ts
index 2421e414..bb2f222a 100644
--- a/vscode-ext/test/message-router.test.ts
+++ b/vscode-ext/test/message-router.test.ts
@@ -6,6 +6,11 @@
  * does to a snapshot that was already handed to the phone.
  */
 
+import { mkdtempSync, readFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { ARCHIVE_FILE } from '../src/notepad-archive-file';
+
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
 import type { ExtensionMessage, WebviewMessage } from '../src/message-types';
@@ -26,6 +31,32 @@ vi.mock('../src/peer-link', () => ({
   remoteNotifyPeerChange: () => {},
 }));
 
+/** The pty host, as far as a disposal is concerned: what it was asked, what it
+ *  answered, and the order the archive write and the kills happened in. */
+const ptys = vi.hoisted(() => ({
+  cwd: null as string | null,
+  cwdAsked: [] as string[],
+  cwdWait: null as Promise<void> | null,
+  buffered: new Map<string, { alive: boolean }>(),
+  /** `'write'` and `'kill <id>'`, in the order they happened. */
+  order: [] as string[],
+}));
+
+vi.mock('../src/pty-manager', async (importOriginal) => ({
+  ...(await importOriginal<typeof import('../src/pty-manager')>()),
+  spawn: (id: string) => { ptys.buffered.set(id, { alive: true }); },
+  getBufferedPtys: () => new Map(ptys.buffered),
+  getCwd: async (id: string) => {
+    ptys.cwdAsked.push(id);
+    await ptys.cwdWait;
+    return ptys.cwd;
+  },
+  kill: (id: string) => {
+    ptys.order.push(`kill ${id}`);
+    ptys.buffered.delete(id);
+  },
+}));
+
 vi.mock('../src/burrow', () => ({
   configureBurrow: () => {},
   deliverCommandResult: () => {},
@@ -40,6 +71,7 @@ vi.mock('../src/burrow', () => ({
 }));
 
 type RouterModule = typeof import('../src/message-router');
+type MirrorModule = typeof import('../src/notepad-volatile');
 
 /** One webview: what it was sent, and a way to make it say something back. */
 function fakeWebview() {
@@ -69,12 +101,21 @@ function fakeWebview() {
 }
 
 let router: RouterModule;
+let mirror: MirrorModule;
 
 beforeEach(async () => {
   vi.resetModules();
   wiring.peer = null;
   wiring.invalidations = 0;
+  ptys.cwd = null;
+  ptys.cwdAsked = [];
+  ptys.cwdWait = null;
+  ptys.buffered.clear();
+  ptys.order = [];
   router = (await import('../src/message-router')) as RouterModule;
+  // The same instance the router holds — `resetModules` gave this test its own
+  // extension host, and both imports land in that one registry.
+  mirror = (await import('../src/notepad-volatile')) as MirrorModule;
 });
 
 afterEach(() => {
@@ -207,6 +248,239 @@ describe('webview fan-out', () => {
   });
 });
 
+/**
+ * The notepad archive lives in shared storage, which only the extension host can
+ * reach (docs/specs/notepad.md). What this side owns is the request/response
+ * plumbing and the disposal rule: an editor panel closing archives its mirrored
+ * notes, the bottom-panel view's disposal does not — its PTYs stay alive.
+ */
+describe('notepad archive requests', () => {
+  const dirs: string[] = [];
+  function storageUri() {
+    const dir = mkdtempSync(join(tmpdir(), 'notepad-router-'));
+    dirs.push(dir);
+    return { fsPath: dir };
+  }
+  afterEach(() => { for (const dir of dirs.splice(0)) rmSync(dir, { recursive: true, force: true }); });
+  function readArchive(context: { globalStorageUri: { fsPath: string } }): string | undefined {
+    try { return JSON.parse(readFileSync(join(context.globalStorageUri.fsPath, ARCHIVE_FILE), 'utf8')).raw ?? undefined; }
+    catch { return undefined; }
+  }
+  function fakeContext() {
+    const store = new Map<string, unknown>();
+    const context = {
+      globalStorageUri: storageUri(),
+      globalState: {
+        get: (key: string) => store.get(key),
+        update: async (key: string, value: unknown) => {
+          ptys.order.push('write');
+          if (value === undefined) store.delete(key);
+          else store.set(key, value);
+        },
+      },
+    };
+    return { context: context as never, store };
+  }
+
+  /** Every archive reply this webview was sent, in order. */
+  function results(webview: ReturnType<typeof fakeWebview>) {
+    return webview.posted
+      .filter((message) => message.type === 'notepad:result')
+      .map((message) => message as { requestId: string; ok: boolean; result?: unknown; error?: string });
+  }
+
+  const mirrored = {
+    surfaceId: 'pane-1',
+    surfaceTitle: 'zsh',
+    surfaceKind: 'terminal',
+    cwd: null,
+    notes: [{ id: 'n1', createdAt: 1, content: { kind: 'plain', text: 'remember this' } }],
+  };
+
+  it('round-trips a save and a load through shared storage', async () => {
+    const webview = fakeWebview();
+    const { context } = fakeContext();
+    const disposable = router.attachRouter(webview.channel, { context });
+    try {
+      webview.send({ type: 'notepad:load', requestId: 'np-1' } as never);
+      await vi.waitFor(() => expect(results(webview)).toHaveLength(1));
+      // Nothing archived yet, and `null` is the base revision that says so.
+      expect(results(webview)[0]).toEqual({ type: 'notepad:result', requestId: 'np-1', ok: true, result: null });
+
+      const state = JSON.stringify({ version: 1, batches: [] });
+      webview.send({ type: 'notepad:save', requestId: 'np-2', state, baseRevision: null } as never);
+      await vi.waitFor(() => expect(results(webview)).toHaveLength(2));
+      expect(results(webview)[1]).toMatchObject({ requestId: 'np-2', ok: true, result: 'ok' });
+
+      webview.send({ type: 'notepad:load', requestId: 'np-3' } as never);
+      await vi.waitFor(() => expect(results(webview)).toHaveLength(3));
+      expect(results(webview)[2].result).toMatchObject({ raw: state });
+    } finally {
+      disposable.dispose();
+    }
+  });
+
+  it('answers a failed archive write rather than leaving the webview waiting', async () => {
+    // The port has no deadline of its own, and an archive that cannot be written
+    // has to become the closure error path, never a Surface that never closes.
+    const webview = fakeWebview();
+    const context = {
+      globalStorageUri: storageUri(),
+      globalState: {
+        get: () => { throw new Error('globalState is gone'); },
+        update: async () => {},
+      },
+    } as never;
+    const disposable = router.attachRouter(webview.channel, { context });
+    try {
+      webview.send({ type: 'notepad:load', requestId: 'np-1' } as never);
+      await vi.waitFor(() => expect(results(webview)).toHaveLength(1));
+      expect(results(webview)[0]).toMatchObject({ ok: false, error: 'globalState is gone' });
+    } finally {
+      disposable.dispose();
+    }
+  });
+
+  it('archives an editor panel\'s mirrored notes when its router is killed on dispose', async () => {
+    const webview = fakeWebview();
+    const { context } = fakeContext();
+    const disposable = router.attachRouter(webview.channel, { context, killOnDispose: true });
+
+    webview.send({ type: 'notepad:volatile', snapshot: { surfaces: [mirrored], stagedDeletions: {} } } as never);
+    // Closing the tab is a deliberate ending, and the webview is already gone —
+    // so nothing but the host can archive what it was holding.
+    disposable.dispose();
+
+    await vi.waitFor(() => expect(readArchive(context)).toBeDefined());
+    const archive = JSON.parse(readArchive(context) as string);
+    expect(archive.batches).toHaveLength(1);
+    expect(archive.batches[0]).toMatchObject({ surfaceTitle: 'zsh', notes: [{ id: 'n1' }] });
+  });
+
+  it('refreshes the mirrored cwd from the live PTY, then kills it', async () => {
+    // The mirror holds whatever the webview last reported, which for a shell
+    // with no CWD escapes is nothing — but the PTY is alive right up to here.
+    const webview = fakeWebview();
+    const { context } = fakeContext();
+    const disposable = router.attachRouter(webview.channel, { context, killOnDispose: true });
+    ptys.cwd = '/Users/me/project';
+
+    webview.send({ type: 'pty:spawn', id: 'pty-1', options: { cwd: '/tmp' } } as never);
+    webview.send({
+      type: 'notepad:volatile',
+      snapshot: { surfaces: [{ ...mirrored, terminalId: 'pty-1' }], stagedDeletions: {} },
+    } as never);
+    disposable.dispose();
+
+    await vi.waitFor(() => expect(readArchive(context)).toBeDefined());
+    const archive = JSON.parse(readArchive(context) as string);
+    expect(archive.batches[0].cwd).toMatchObject({ path: '/Users/me/project', source: 'process' });
+    expect(ptys.cwdAsked).toEqual(['pty-1']);
+    // The kill waits for the write: a dead PTY could not have answered.
+    await vi.waitFor(() => expect(ptys.order).toEqual(['kill pty-1']));
+  });
+
+  it('reserves closing PTYs until the deferred kill finishes', async () => {
+    let release!: () => void;
+    ptys.cwdWait = new Promise<void>((resolve) => { release = resolve; });
+    const closing = fakeWebview();
+    const { context } = fakeContext();
+    const first = router.attachRouter(closing.channel, { context, killOnDispose: true });
+    closing.send({ type: 'pty:spawn', id: 'closing-pty', options: { cwd: '/tmp' } } as never);
+    closing.send({ type: 'notepad:volatile', snapshot: {
+      surfaces: [{ ...mirrored, terminalId: 'closing-pty' }], stagedDeletions: {},
+    } } as never);
+    first.dispose();
+    const reopening = fakeWebview();
+    const second = router.attachRouter(reopening.channel, { reconnect: true });
+    try {
+      reopening.send({ type: 'dormouse:init' } as never);
+      expect(reopening.posted.find((message) => message.type === 'pty:list')).toMatchObject({ ptys: [] });
+      expect(ptys.buffered.has('closing-pty')).toBe(true);
+      expect(ptys.order).toEqual([]);
+      release();
+      await vi.waitFor(() => expect(ptys.order).toEqual(['kill closing-pty']));
+      expect(readArchive(context)).toBeDefined();
+      reopening.send({ type: 'dormouse:init' } as never);
+      expect(reopening.posted.filter((message) => message.type === 'pty:list')).toEqual([
+        { type: 'pty:list', ptys: [] }, { type: 'pty:list', ptys: [] },
+      ]);
+    } finally {
+      release();
+      second.dispose();
+    }
+  });
+
+  it('kills the PTYs even when the archive write fails', async () => {
+    const webview = fakeWebview();
+    const context = {
+      globalStorageUri: storageUri(),
+      globalState: {
+        get: () => { throw new Error('globalState is gone'); },
+        update: async () => {},
+      },
+    } as never;
+    const disposable = router.attachRouter(webview.channel, { context, killOnDispose: true });
+
+    webview.send({ type: 'pty:spawn', id: 'pty-1', options: { cwd: '/tmp' } } as never);
+    webview.send({
+      type: 'notepad:volatile',
+      snapshot: { surfaces: [{ ...mirrored, terminalId: 'pty-1' }], stagedDeletions: {} },
+    } as never);
+    disposable.dispose();
+
+    await vi.waitFor(() => expect(ptys.order).toEqual(['kill pty-1']));
+  });
+
+  it('keeps the mirror when the bottom-panel view is disposed, so the next resolve hydrates it', async () => {
+    const webview = fakeWebview();
+    const { context } = fakeContext();
+    // No `killOnDispose`: the `WebviewView`'s disposal leaves its PTYs alive, so
+    // it is not a closure and the notes are not archived.
+    const disposable = router.attachRouter(webview.channel, { context });
+
+    webview.send({ type: 'notepad:volatile', snapshot: { surfaces: [mirrored], stagedDeletions: {} } } as never);
+    disposable.dispose();
+    await Promise.resolve();
+
+    expect(readArchive(context)).toBeUndefined();
+    expect(mirror.snapshotForLiveResume(['pane-1'])?.surfaces).toEqual([mirrored]);
+  });
+
+  it('commits staged archive deletions on a disposal that is not a closure', async () => {
+    // A `WebviewView` moved between containers is disposed and re-resolved. Left
+    // staged, the deletions would show as still pending in the new view — with
+    // an Undo — and then be committed hours later by `deactivate()`. The Archive
+    // view promised they were irreversible once this window closed.
+    const webview = fakeWebview();
+    const { context } = fakeContext();
+    const { globalState } = context as unknown as { globalState: { update(key: string, value: unknown): Promise<void> } };
+    await globalState.update('dormouse.notepadArchive.v1', JSON.stringify({
+      version: 1,
+      batches: [
+        { id: 'b1', closedAt: 1, surfaceTitle: 'zsh', surfaceKind: 'terminal', cwd: null, notes: [{ id: 'n1', createdAt: 1, content: { kind: 'plain', text: 'gone' } }] },
+        { id: 'b2', closedAt: 2, surfaceTitle: 'zsh', surfaceKind: 'terminal', cwd: null, notes: [{ id: 'n2', createdAt: 2, content: { kind: 'plain', text: 'kept' } }] },
+      ],
+    }));
+    const disposable = router.attachRouter(webview.channel, { context });
+
+    webview.send({
+      type: 'notepad:volatile',
+      snapshot: { surfaces: [mirrored], stagedDeletions: { deleteBatchIds: ['b1'], deleteNotes: [] } },
+    } as never);
+    disposable.dispose();
+
+    await vi.waitFor(() => {
+      const archive = JSON.parse(readArchive(context) as string);
+      expect(archive.batches.map((b: { id: string }) => b.id)).toEqual(['b2']);
+    });
+    // The notes are not a closure, so they stay — and nothing is left pending.
+    const resumed = mirror.snapshotForLiveResume(['pane-1']);
+    expect(resumed?.surfaces).toEqual([mirrored]);
+    expect(resumed?.stagedDeletions).toEqual({ deleteBatchIds: [], deleteNotes: [] });
+  });
+});
+
 /**
  * `dor await` parks in the shared alert manager, which lives here rather than in
  * the webview (docs/specs/alert.md → Await). What this side owns is the
diff --git a/vscode-ext/test/notepad-archive-file.test.ts b/vscode-ext/test/notepad-archive-file.test.ts
new file mode 100644
index 00000000..c8d8216d
--- /dev/null
+++ b/vscode-ext/test/notepad-archive-file.test.ts
@@ -0,0 +1,82 @@
+import { fork } from 'node:child_process';
+import { readFile, mkdtemp, rm, writeFile, stat } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, beforeEach, expect, it } from 'vitest';
+import ts from 'typescript';
+import { ARCHIVE_FILE, withArchiveFile } from '../src/notepad-archive-file';
+
+let dir: string;
+let worker: string;
+beforeEach(async () => {
+  dir = await mkdtemp(join(tmpdir(), 'notepad-process-'));
+  // Run the shipped transaction implementation in independent Node processes.
+  const source = await readFile(new URL('../src/notepad-archive-file.ts', import.meta.url), 'utf8');
+  await writeFile(join(dir, 'store.mjs'), ts.transpileModule(source, {
+    compilerOptions: { target: ts.ScriptTarget.ES2022, module: ts.ModuleKind.ES2022 },
+  }).outputText);
+  worker = join(dir, 'worker.mjs');
+  await writeFile(worker, `
+    import { withArchiveFile } from './store.mjs';
+    process.on('message', async ({ dir, kind, revision, value }) => {
+      try {
+        const result = await withArchiveFile(dir, () => undefined, async (store) => {
+          if (kind === 'crash') process.exit(0);
+          if (kind === 'load') return { raw: store.raw, revision: store.revision };
+          if (kind === 'save' && revision !== store.revision) return 'conflict';
+          const next = kind === 'append' ? [...JSON.parse(store.raw ?? '[]'), value] : value;
+          await new Promise(resolve => setTimeout(resolve, 40));
+          await store.write(JSON.stringify(next));
+          return 'ok';
+        });
+        process.send({ result });
+      } catch (error) { process.send({ error: String(error) }); }
+    });
+  `);
+});
+afterEach(async () => { await rm(dir, { recursive: true, force: true }); });
+
+function request(kind: string, value?: unknown, revision?: string | null): Promise<any> {
+  return new Promise((resolve, reject) => {
+    const child = fork(worker, { stdio: ['ignore', 'ignore', 'inherit', 'ipc'] });
+    let response: any;
+    child.on('error', reject);
+    child.on('message', (message) => { response = message; child.disconnect(); });
+    child.on('exit', (code) => {
+      if (code !== 0 || response?.error) reject(new Error(response?.error ?? `exit ${code}`));
+      else resolve(response?.result);
+    });
+    child.send({ dir, kind, value, revision });
+  });
+}
+
+it('rejects a stale save from an independent extension host', async () => {
+  const [a, b] = await Promise.all([request('load'), request('load')]);
+  expect(a.revision).toBe(b.revision);
+  const outcomes = await Promise.all([
+    request('save', ['a'], a.revision), request('save', ['b'], b.revision),
+  ]);
+  expect(outcomes.sort()).toEqual(['conflict', 'ok']);
+  expect(JSON.parse((await request('load')).raw)).toHaveLength(1);
+});
+
+it('preserves concurrent teardown mutations from independent extension hosts', async () => {
+  await Promise.all([request('append', 'a'), request('append', 'b'), request('append', 'c')]);
+  expect(JSON.parse((await request('load')).raw).sort()).toEqual(['a', 'b', 'c']);
+  if (process.platform !== 'win32') expect((await stat(join(dir, ARCHIVE_FILE))).mode & 0o777).toBe(0o600);
+});
+
+it('recovers a lock left by a terminated extension host', async () => {
+  await request('crash');
+  expect(await request('append', 'after-crash')).toBe('ok');
+});
+
+it('imports legacy data once and never resurrects a stale cache after recovery', async () => {
+  await withArchiveFile(dir, () => 'legacy', async (storage) => {
+    expect(storage.raw).toBe('legacy');
+    await storage.reset();
+  });
+  await withArchiveFile(dir, () => 'stale legacy', async (storage) => {
+    expect(storage.raw).toBeUndefined();
+  });
+});
diff --git a/vscode-ext/test/notepad-archive-store.test.ts b/vscode-ext/test/notepad-archive-store.test.ts
new file mode 100644
index 00000000..8327912d
--- /dev/null
+++ b/vscode-ext/test/notepad-archive-store.test.ts
@@ -0,0 +1,248 @@
+/**
+ * The archive as the extension host stores it (`docs/specs/notepad.md`).
+ *
+ * What is worth pinning here is not the JSON — that is `archive-model`'s — but
+ * the two things only this side can get wrong: the compare-and-swap that keeps
+ * two webviews from clobbering each other, and the queue that keeps a read from
+ * landing between someone else's read and write.
+ */
+
+import { mkdtempSync, rmSync, readFileSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { ARCHIVE_FILE } from '../src/notepad-archive-file';
+import { fileURLToPath } from 'node:url';
+import { afterEach, describe, expect, it } from 'vitest';
+
+import type { ArchiveBatch, NotepadArchiveV1 } from '../../lib/src/lib/notepad/types';
+import {
+  archiveVolatileMirror,
+  loadNotepadArchive,
+  mutateNotepadArchive,
+  NOTEPAD_ARCHIVE_KEY,
+  resetUnreadableNotepadArchive,
+  saveNotepadArchive,
+} from '../src/notepad-archive-store';
+
+/** Legacy storage is a per-context cache; the archive itself uses a shared directory. */
+const dirs = new Map<Map<string, unknown>, string>();
+afterEach(() => {
+  for (const dir of dirs.values()) rmSync(dir, { recursive: true, force: true });
+  dirs.clear();
+});
+
+function fakeContext() {
+  const store = new Map<string, unknown>();
+  const globalState = {
+    get: (key: string) => store.get(key),
+    update: async (key: string, value: unknown) => {
+      await Promise.resolve();
+      if (value === undefined) store.delete(key);
+      else store.set(key, value);
+    },
+    keys: () => [...store.keys()],
+  };
+  const dir = mkdtempSync(join(tmpdir(), 'notepad-store-'));
+  dirs.set(store, dir);
+  return { context: { globalState, globalStorageUri: { fsPath: dir } } as never, store };
+}
+
+function batch(id: string, noteIds: string[]): ArchiveBatch {
+  return {
+    id,
+    closedAt: 1_700_000_000_000,
+    surfaceTitle: `surface ${id}`,
+    surfaceKind: 'terminal',
+    cwd: null,
+    notes: noteIds.map((noteId) => ({
+      id: noteId,
+      createdAt: 1_700_000_000_001,
+      content: { kind: 'plain', text: `note ${noteId}` },
+    })),
+  };
+}
+
+function stored(store: Map<string, unknown>): NotepadArchiveV1 {
+  return JSON.parse(JSON.parse(readFileSync(join(dirs.get(store)!, ARCHIVE_FILE), 'utf8')).raw) as NotepadArchiveV1;
+}
+
+const archiveOf = (...batches: ArchiveBatch[]): NotepadArchiveV1 => ({ version: 1, batches });
+
+describe('the shared notepad archive', () => {
+  it('reports nothing archived, then round-trips what a webview saved', async () => {
+    const { context, store } = fakeContext();
+    expect(await loadNotepadArchive(context)).toBeNull();
+
+    // `null` is the base revision for "nothing stored" — the only one a first
+    // save may pass.
+    expect(await saveNotepadArchive(context, JSON.stringify(archiveOf(batch('b1', ['n1']))), null)).toBe('ok');
+
+    const loaded = await loadNotepadArchive(context);
+    expect(JSON.parse(loaded!.raw)).toEqual(archiveOf(batch('b1', ['n1'])));
+    expect(stored(store).batches).toHaveLength(1);
+  });
+
+  it('refuses a save built on a revision someone else has moved', async () => {
+    const { context, store } = fakeContext();
+    // Two webviews load the same archive; the first one to save wins, and the
+    // second is told to re-read rather than allowed to drop the first's batch.
+    await saveNotepadArchive(context, JSON.stringify(archiveOf(batch('b1', ['n1']))), null);
+    const first = await loadNotepadArchive(context);
+    const second = await loadNotepadArchive(context);
+    expect(second!.revision).toBe(first!.revision);
+
+    expect(await saveNotepadArchive(context, JSON.stringify(archiveOf(batch('b2', ['n2']))), first!.revision))
+      .toBe('ok');
+    expect(await saveNotepadArchive(context, JSON.stringify(archiveOf(batch('b3', ['n3']))), second!.revision))
+      .toBe('conflict');
+
+    expect(stored(store).batches.map((b) => b.id)).toEqual(['b2']);
+    // The conflicted webview re-reads and now has a revision that works.
+    const retry = await loadNotepadArchive(context);
+    expect(await saveNotepadArchive(context, JSON.stringify(archiveOf(batch('b3', ['n3']))), retry!.revision))
+      .toBe('ok');
+  });
+
+  it('moves an unreadable archive aside instead of deleting it', async () => {
+    const { context, store } = fakeContext();
+    await context.globalState.update(NOTEPAD_ARCHIVE_KEY, '{ this is not json');
+
+    await resetUnreadableNotepadArchive(context);
+
+    // The main archive is empty, so appends work again...
+    expect(await loadNotepadArchive(context)).toBeNull();
+    // ...and the user's data is still on disk in a sibling file, because only
+    // a human can tell whether it is recoverable.
+    const dir = dirs.get(store)!;
+    const rescued = readdirSync(dir).filter((name) => name.startsWith(`${ARCHIVE_FILE}.unreadable-`));
+    expect(rescued).toHaveLength(1);
+    expect(JSON.parse(readFileSync(join(dir, rescued[0]), 'utf8')).raw).toBe('{ this is not json');
+  });
+
+  it('preserves notes written after another webview recovered the archive', async () => {
+    const { context, store } = fakeContext();
+    store.set(NOTEPAD_ARCHIVE_KEY, '{ invalid');
+    await loadNotepadArchive(context); // stale recovery UI in a second view
+    await resetUnreadableNotepadArchive(context);
+    await mutateNotepadArchive(context, { append: [batch('recovered', ['new-note'])] });
+    const before = await loadNotepadArchive(context);
+    await resetUnreadableNotepadArchive(context);
+    expect(await loadNotepadArchive(context)).toEqual(before);
+    expect(stored(store).batches).toEqual([batch('recovered', ['new-note'])]);
+  });
+
+  it('appends idempotently by batch id', async () => {
+    const { context, store } = fakeContext();
+    // A teardown that retries — or two paths that both archive the same closure
+    // — must not double the batch. The id is minted once, which is what makes
+    // the repeat a no-op.
+    await mutateNotepadArchive(context, { append: [batch('b1', ['n1'])] });
+    await mutateNotepadArchive(context, { append: [batch('b1', ['n1']), batch('b2', ['n2'])] });
+
+    expect(stored(store).batches.map((b) => b.id)).toEqual(['b1', 'b2']);
+  });
+
+  it('never drops an append that raced another one', async () => {
+    const { context, store } = fakeContext();
+    // Both start before either has written. Without the queue the second would
+    // read the pre-write archive and save a copy of it with only its own batch.
+    await Promise.all([
+      mutateNotepadArchive(context, { append: [batch('b1', ['n1'])] }),
+      mutateNotepadArchive(context, { append: [batch('b2', ['n2'])] }),
+    ]);
+
+    expect(stored(store).batches.map((b) => b.id).sort()).toEqual(['b1', 'b2']);
+  });
+
+  it('refuses to append onto an unreadable archive', async () => {
+    const { context, store } = fakeContext();
+    await context.globalState.update(NOTEPAD_ARCHIVE_KEY, JSON.stringify({ version: 99 }));
+
+    await expect(mutateNotepadArchive(context, { append: [batch('b1', ['n1'])] })).rejects.toThrow(/unreadable/);
+    // Whatever is in there is still in there: replacing it is the user's call.
+    expect(store.get(NOTEPAD_ARCHIVE_KEY)).toBe(JSON.stringify({ version: 99 }));
+  });
+
+  it('commits staged deletions and drops a batch they empty', async () => {
+    const { context, store } = fakeContext();
+    await mutateNotepadArchive(context, { append: [batch('b1', ['n1', 'n2']), batch('b2', ['n3'])] });
+
+    await mutateNotepadArchive(context, {
+      deleteBatchIds: [],
+      deleteNotes: [{ batchId: 'b1', noteId: 'n1' }, { batchId: 'b2', noteId: 'n3' }],
+    });
+
+    const batches = stored(store).batches;
+    expect(batches.map((b) => b.id)).toEqual(['b1']);
+    expect(batches[0].notes.map((n) => n.id)).toEqual(['n2']);
+  });
+
+  it('archives a drained mirror as one batch per Surface that had notes', async () => {
+    const { context, store } = fakeContext();
+    await mutateNotepadArchive(context, { append: [batch('old', ['n0'])] });
+
+    await archiveVolatileMirror(context, {
+      surfaces: [
+        {
+          surfaceId: 'pane-1',
+          surfaceTitle: 'zsh',
+          surfaceKind: 'terminal',
+          cwd: {
+            path: '/repo', pathKind: 'posix', isRemote: false, source: 'osc7', updatedAt: 5,
+          },
+          notes: [{ id: 'n1', createdAt: 3, content: { kind: 'plain', text: 'hi' } }],
+        },
+        // No notes, so nothing to archive — not an empty batch.
+        { surfaceId: 'pane-2', surfaceTitle: 'bash', surfaceKind: 'terminal', cwd: null, notes: [] },
+      ],
+      stagedDeletions: { deleteBatchIds: ['old'], deleteNotes: [] },
+    });
+
+    const batches = stored(store).batches;
+    expect(batches).toHaveLength(1);
+    expect(batches[0]).toMatchObject({
+      surfaceTitle: 'zsh',
+      surfaceKind: 'terminal',
+      cwd: { path: '/repo' },
+      notes: [{ id: 'n1' }],
+    });
+    // The mirror's staged deletions are committed too, so an Archive view whose
+    // webview was destroyed still gets its deletions.
+    expect(batches.map((b) => b.id)).not.toContain('old');
+  });
+});
+
+/**
+ * The one rule about this key that no unit test can reach through the API: the
+ * archive is machine-local, and Settings Sync would carry captured terminal
+ * excerpts to every machine the user signs into (`docs/specs/notepad.md`). VS
+ * Code syncs only what an extension registers, so the check is that this
+ * extension registers nothing.
+ */
+it('never opts any key into Settings Sync', () => {
+  const dir = fileURLToPath(new URL('../src/', import.meta.url));
+  const offenders = readdirSync(dir)
+    .filter((name) => name.endsWith('.ts') || name.endsWith('.js'))
+    // A call, not a mention — the rule is stated in a comment on the key itself.
+    .filter((name) => /setKeysForSync\s*\(/.test(readFileSync(join(dir, name), 'utf8')));
+  expect(offenders).toEqual([]);
+});
+
+it.each([false, true])('replaces a pending close during teardown (all notes deleted: %s)', async (deleted) => {
+  const { context, store } = fakeContext();
+  const original = batch('pending', ['n1', 'n2']);
+  await mutateNotepadArchive(context, { append: [original, batch('unrelated', ['n3'])] });
+  await archiveVolatileMirror(context, {
+    surfaces: [{
+      surfaceId: 's1', surfaceTitle: 'edited', surfaceKind: 'terminal', cwd: null,
+      pendingBatchId: original.id,
+      notes: deleted ? [] : [{ ...original.notes[0], content: { kind: 'plain', text: 'edited after timeout' } }],
+    }],
+    stagedDeletions: {},
+  });
+  const batches = stored(store).batches;
+  expect(batches.find((b) => b.id === 'unrelated')).toEqual(batch('unrelated', ['n3']));
+  expect(batches.find((b) => b.id === 'pending')?.notes ?? []).toEqual(deleted ? [] : [
+    { ...original.notes[0], content: { kind: 'plain', text: 'edited after timeout' } },
+  ]);
+});
diff --git a/vscode-ext/test/notepad-volatile.test.ts b/vscode-ext/test/notepad-volatile.test.ts
new file mode 100644
index 00000000..8a7b8cf1
--- /dev/null
+++ b/vscode-ext/test/notepad-volatile.test.ts
@@ -0,0 +1,291 @@
+/**
+ * The extension host's in-memory notepad mirror (`docs/specs/notepad.md` →
+ * Archive and Lifecycle).
+ *
+ * It exists because VS Code can destroy a webview without asking, so a teardown
+ * has to archive from here instead of from the Surface. What that makes
+ * load-bearing: what it refuses to mirror (anything the archive validator would
+ * later choke on), whose notes a router may retire, and the fact that a live
+ * resume reads it without consuming it.
+ */
+
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import type { VolatileSurfaceNotes } from '../../lib/src/lib/notepad/types';
+import type { CwdState } from '../../lib/src/lib/terminal-state';
+
+type MirrorModule = typeof import('../src/notepad-volatile');
+
+let mirror: MirrorModule;
+
+beforeEach(async () => {
+  // Module state is the mirror, exactly as it is in a real extension host, so
+  // each test gets its own host.
+  vi.resetModules();
+  mirror = await import('../src/notepad-volatile');
+});
+
+function surface(surfaceId: string, text = 'note'): VolatileSurfaceNotes {
+  return {
+    surfaceId,
+    surfaceTitle: `title ${surfaceId}`,
+    surfaceKind: 'terminal',
+    cwd: null,
+    notes: [{ id: `${surfaceId}-n1`, createdAt: 1, content: { kind: 'plain', text } }],
+  };
+}
+
+const noDeletions = { deleteBatchIds: [], deleteNotes: [] };
+
+describe('the volatile notepad mirror', () => {
+  it('refuses a Surface the archive validator would later reject', () => {
+    // One malformed note written verbatim into globalState would make the whole
+    // archive unreadable on the next load — and by then there is no webview left
+    // to blame. So the mirror is the gate.
+    mirror.setVolatileForRouter('router-1', {
+      surfaces: [
+        surface('good'),
+        { ...surface('bad-kind'), surfaceKind: 'spreadsheet' },
+        { ...surface('bad-note'), notes: [{ id: 'n', createdAt: 'yesterday', content: { kind: 'plain', text: '' } }] },
+        { ...surface('bad-colour'), notes: [{
+          id: 'n', createdAt: 1, content: { kind: 'terminal', runs: [{ text: 'x', foreground: 'red' }] },
+        }] },
+        // A field the validator does not know. The webview strips the runtime
+        // marker link before mirroring, so one arriving here is not our snapshot
+        // — and storing it would erase it again on the next mutation anyway.
+        { ...surface('foreign-field'), notes: [{
+          id: 'n', createdAt: 1, source: { terminalId: 't' }, content: { kind: 'plain', text: 'x' },
+        }] },
+        { surfaceId: '', surfaceTitle: 't', surfaceKind: 'terminal', cwd: null, notes: [] },
+      ],
+      stagedDeletions: noDeletions,
+    });
+
+    expect(mirror.surfaceIdsForRouter('router-1')).toEqual(['good']);
+  });
+
+  it('keeps a rich note whole', () => {
+    mirror.setVolatileForRouter('router-1', {
+      surfaces: [{
+        ...surface('pane-1'),
+        notes: [{
+          id: 'n1', createdAt: 1,
+          content: { kind: 'terminal', runs: [{ text: 'ok', bold: true, foreground: '#00ff00' }] },
+        }],
+      }],
+      stagedDeletions: noDeletions,
+    });
+
+    const [mirrored] = mirror.takeVolatileForSurfaces(['pane-1']);
+    expect(mirrored.notes).toEqual([{
+      id: 'n1',
+      createdAt: 1,
+      content: { kind: 'terminal', runs: [{ text: 'ok', bold: true, foreground: '#00ff00' }] },
+    }]);
+  });
+
+  it('lets a router retire only what it stopped reporting', () => {
+    // Two webviews mirror into the same map. A snapshot that no longer mentions
+    // a Surface means that Surface closed through the ordinary path — but only
+    // for the router that sent it.
+    mirror.setVolatileForRouter('router-1', {
+      surfaces: [surface('a'), surface('b')],
+      stagedDeletions: noDeletions,
+    });
+    mirror.setVolatileForRouter('router-2', { surfaces: [surface('c')], stagedDeletions: noDeletions });
+
+    mirror.setVolatileForRouter('router-1', { surfaces: [surface('b')], stagedDeletions: noDeletions });
+
+    expect(mirror.surfaceIdsForRouter('router-1')).toEqual(['b']);
+    expect(mirror.surfaceIdsForRouter('router-2')).toEqual(['c']);
+  });
+
+  it('hands a live resume its own panes without consuming them', () => {
+    mirror.setVolatileForRouter('router-1', {
+      surfaces: [surface('pane-1'), surface('pane-2')],
+      stagedDeletions: { deleteBatchIds: ['batch-1'], deleteNotes: [] },
+    });
+
+    const resumed = mirror.snapshotForLiveResume(['pane-1', 'pane-missing']);
+    expect(resumed!.surfaces.map((s) => s.surfaceId)).toEqual(['pane-1']);
+    // Never a pending deletion: the disposal that produced this resume already
+    // committed the staged set, so showing it as still-stageable would promise
+    // an Undo that no longer exists.
+    expect(resumed!.stagedDeletions).toEqual(noDeletions);
+
+    // Still mirrored: a webview served this and then lost (a crash before its
+    // first sync) must still have its notes archived at deactivate.
+    expect(mirror.surfaceIdsForRouter('router-1')).toEqual(['pane-1', 'pane-2']);
+  });
+
+  it('gives a cold restore nothing', () => {
+    mirror.setVolatileForRouter('router-1', { surfaces: [surface('pane-1')], stagedDeletions: noDeletions });
+    // A cold restore's pane ids are from a previous extension host; nothing in
+    // this one's memory answers to them.
+    expect(mirror.snapshotForLiveResume(['pane-from-last-week'])).toBeNull();
+  });
+
+  it('drains one router without touching another', () => {
+    mirror.setVolatileForRouter('router-1', {
+      surfaces: [surface('a')],
+      stagedDeletions: { deleteBatchIds: ['batch-1'], deleteNotes: [] },
+    });
+    mirror.setVolatileForRouter('router-2', {
+      surfaces: [surface('b')],
+      stagedDeletions: { deleteBatchIds: ['batch-2'], deleteNotes: [] },
+    });
+
+    const drained = mirror.takeVolatileForRouter('router-1');
+    expect(drained.surfaces.map((s) => s.surfaceId)).toEqual(['a']);
+    expect(drained.stagedDeletions.deleteBatchIds).toEqual(['batch-1']);
+
+    // Drained means gone: `deactivate()` must not archive these a second time
+    // under a fresh batch id.
+    expect(mirror.takeVolatileForRouter('router-1').surfaces).toEqual([]);
+    expect(mirror.surfaceIdsForRouter('router-2')).toEqual(['b']);
+  });
+
+  it('takes a router\'s staged deletions without touching its notes', () => {
+    // What a non-killing disposal does: the deletions are committed there and
+    // then, the notes stay for the next resolve to hydrate.
+    mirror.setVolatileForRouter('router-1', {
+      surfaces: [surface('a')],
+      stagedDeletions: { deleteBatchIds: ['batch-1'], deleteNotes: [{ batchId: 'batch-9', noteId: 'n1' }] },
+    });
+
+    const staged = mirror.takeStagedForRouter('router-1');
+    expect(staged.deleteBatchIds).toEqual(['batch-1']);
+    expect(staged.deleteNotes).toEqual([{ batchId: 'batch-9', noteId: 'n1' }]);
+
+    expect(mirror.surfaceIdsForRouter('router-1')).toEqual(['a']);
+    // Taken means gone: `deactivate()` must not re-commit them hours later.
+    expect(mirror.takeStagedForRouter('router-1')).toEqual(noDeletions);
+    expect(mirror.takeAllVolatile().stagedDeletions).toEqual(noDeletions);
+  });
+
+  it('carries a Surface\'s PTY id through, and only when it is a string', () => {
+    mirror.setVolatileForRouter('router-1', {
+      surfaces: [
+        { ...surface('a'), terminalId: 'pty-9' },
+        { ...surface('b'), terminalId: 7 },
+        surface('c'),
+      ],
+      stagedDeletions: noDeletions,
+    });
+
+    const taken = mirror.takeVolatileForSurfaces(['a', 'b', 'c']);
+    expect(taken.map((s) => s.terminalId)).toEqual(['pty-9', undefined, undefined]);
+    // Absent, not present-and-undefined: `batchFromVolatile` never copies it,
+    // and the validator would reject a batch that carried it.
+    expect(Object.keys(taken[2])).not.toContain('terminalId');
+  });
+
+  it('drains every router at once, merging their staged deletions', () => {
+    mirror.setVolatileForRouter('router-1', {
+      surfaces: [surface('a')],
+      stagedDeletions: { deleteBatchIds: ['batch-1'], deleteNotes: [{ batchId: 'batch-9', noteId: 'n1' }] },
+    });
+    mirror.setVolatileForRouter('router-2', {
+      surfaces: [surface('b')],
+      stagedDeletions: { deleteBatchIds: ['batch-1', 'batch-2'], deleteNotes: [] },
+    });
+
+    const all = mirror.takeAllVolatile();
+    expect(all.surfaces.map((s) => s.surfaceId).sort()).toEqual(['a', 'b']);
+    expect(all.stagedDeletions.deleteBatchIds.sort()).toEqual(['batch-1', 'batch-2']);
+    expect(all.stagedDeletions.deleteNotes).toEqual([{ batchId: 'batch-9', noteId: 'n1' }]);
+    expect(mirror.takeAllVolatile().surfaces).toEqual([]);
+  });
+});
+
+describe('refreshMirrorCwds', () => {
+  const OSC7: CwdState = {
+    path: '/srv/app',
+    pathKind: 'posix',
+    isRemote: false,
+    source: 'osc7',
+    updatedAt: 5,
+  };
+
+  function snapshot(...surfaces: VolatileSurfaceNotes[]) {
+    return { surfaces, stagedDeletions: noDeletions };
+  }
+
+  it('fills a mirrored Surface that reported no CWD from its live PTY', async () => {
+    const getCwd = vi.fn(async () => '/Users/me/project');
+
+    const refreshed = await mirror.refreshMirrorCwds(
+      snapshot({ ...surface('a'), terminalId: 'pty-9' }),
+      getCwd,
+      50,
+    );
+
+    expect(getCwd).toHaveBeenCalledWith('pty-9');
+    expect(refreshed.surfaces[0].cwd).toMatchObject({ path: '/Users/me/project', source: 'process' });
+    // The rest of the mirror is untouched.
+    expect(refreshed.surfaces[0].notes).toEqual(surface('a').notes);
+    expect(refreshed.stagedDeletions).toEqual(noDeletions);
+  });
+
+  it('replaces a stale process CWD but never one the shell integration reported', async () => {
+    const stale: CwdState = { ...OSC7, path: '/old', source: 'process' };
+    const getCwd = vi.fn(async () => '/new');
+
+    const refreshed = await mirror.refreshMirrorCwds(
+      snapshot(
+        { ...surface('a'), cwd: stale, terminalId: 'pty-a' },
+        { ...surface('b'), cwd: OSC7, terminalId: 'pty-b' },
+      ),
+      getCwd,
+      50,
+    );
+
+    expect(refreshed.surfaces[0].cwd).toMatchObject({ path: '/new', source: 'process' });
+    expect(refreshed.surfaces[1].cwd).toEqual(OSC7);
+    expect(getCwd).toHaveBeenCalledTimes(1);
+  });
+
+  it('never asks about a Surface with no PTY id', async () => {
+    const getCwd = vi.fn(async () => '/Users/me/project');
+
+    const refreshed = await mirror.refreshMirrorCwds(snapshot(surface('a')), getCwd, 50);
+
+    expect(getCwd).not.toHaveBeenCalled();
+    expect(refreshed.surfaces[0].cwd).toBeNull();
+  });
+
+  it('keeps what it had when the host rejects', async () => {
+    const getCwd = vi.fn(async () => { throw new Error('the pty host is gone'); });
+
+    const refreshed = await mirror.refreshMirrorCwds(
+      snapshot({ ...surface('a'), cwd: OSC7, terminalId: 'pty-9' }),
+      getCwd,
+      50,
+    );
+
+    expect(refreshed.surfaces[0].cwd).toEqual(OSC7);
+  });
+
+  it('gives up at the bound rather than holding the teardown open', async () => {
+    // The kill waits behind this on an editor-panel disposal, so a pty host
+    // that has stopped answering must not keep the write from happening.
+    const never = new Promise<string | null>(() => {});
+    const started = Date.now();
+
+    const refreshed = await mirror.refreshMirrorCwds(
+      snapshot({ ...surface('a'), terminalId: 'pty-9' }),
+      () => never,
+      20,
+    );
+
+    expect(Date.now() - started).toBeLessThan(500);
+    expect(refreshed.surfaces[0].cwd).toBeNull();
+  });
+});
+
+it('retains a pending batch identity with an empty mirrored notepad', () => {
+  const empty = { ...surface('s1'), notes: [], pendingBatchId: 'pending' };
+  mirror.setVolatileForRouter('r1', { surfaces: [empty], stagedDeletions: {} });
+  expect(mirror.snapshotForLiveResume(['s1'])?.surfaces).toEqual([empty]);
+  expect(mirror.takeVolatileForRouter('r1').surfaces).toEqual([empty]);
+});
diff --git a/vscode-ext/test/webview-html.test.ts b/vscode-ext/test/webview-html.test.ts
index 1edec9ff..b5751d88 100644
--- a/vscode-ext/test/webview-html.test.ts
+++ b/vscode-ext/test/webview-html.test.ts
@@ -2,6 +2,7 @@ import { writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { afterAll, beforeAll, describe, expect, it } from 'vitest';
 
+import { NOTEPAD_VOLATILE_GLOBAL } from '../../lib/src/lib/vscode-notepad-global';
 import { CSP_NONCE_PLACEHOLDER } from '../src/csp-nonce-placeholder';
 import { getWebviewHtml } from '../src/webview-html';
 import { removeDir, tempStorageDir } from './helpers';
@@ -147,6 +148,32 @@ describe('getWebviewHtml', () => {
     expect(html).toContain(`${CSP_SOURCE}${mediaPath}/assets/rolldown-runtime-BBBBBBBB.js`);
   });
 
+  it('boots with no notepad mirror unless one is handed to it', () => {
+    // Only a live resume gets one; every other document — a cold restore, an
+    // editor panel — must find `null` there (docs/specs/notepad.md).
+    const { html } = getWebviewHtml(webview, mediaPath);
+    expect(html).toContain(`globalThis.${NOTEPAD_VOLATILE_GLOBAL} = null;`);
+  });
+
+  it('cannot be broken out of by a captured note', () => {
+    // Notes carry arbitrary terminal output, and this payload is an inline
+    // script. `</script>` inside a note would otherwise end the tag early,
+    // leaving the rest of the archive as markup in the document.
+    const note = { id: 'n1', createdAt: 1, content: { kind: 'plain' as const, text: '</script><img src=x>' } };
+    const { html } = getWebviewHtml(webview, mediaPath, undefined, null, null, {
+      surfaces: [{
+        surfaceId: 'pane-1', surfaceTitle: 'zsh', surfaceKind: 'terminal', cwd: null, notes: [note],
+      }],
+      stagedDeletions: { deleteBatchIds: [], deleteNotes: [] },
+    });
+
+    const inline = /<script nonce="[^"]+">([\s\S]*?)<\/script>/.exec(html);
+    expect(inline, 'the boot payload script was cut short').not.toBeNull();
+    expect(inline![1]).toContain(NOTEPAD_VOLATILE_GLOBAL);
+    expect(inline![1]).toContain('\\u003c/script>');
+    expect(html).not.toContain('<img src=x>');
+  });
+
   it('mints a fresh nonce and message token per document', () => {
     const first = getWebviewHtml(webview, mediaPath);
     const second = getWebviewHtml(webview, mediaPath);
diff --git a/vscode-ext/vitest.config.mts b/vscode-ext/vitest.config.mts
index 284c8a1e..ca07e392 100644
--- a/vscode-ext/vitest.config.mts
+++ b/vscode-ext/vitest.config.mts
@@ -15,6 +15,11 @@ export default defineConfig({
   resolve: {
     alias: {
       vscode: fileURLToPath(new URL('test/vscode-stub.ts', import.meta.url)),
+      // Shared `lib/` modules the extension host bundles reach the `dor` CLI's
+      // types through the `dor/*` tsconfig path. Vite reads no tsconfig paths and
+      // `dor` has no package exports, so resolve it to source — the same alias
+      // `lib/vite.config.ts` and standalone use.
+      dor: fileURLToPath(new URL('../dor/src', import.meta.url)),
     },
   },
   test: {
diff --git a/vscode-ext/vitest.smoketest.config.mts b/vscode-ext/vitest.smoketest.config.mts
index d0db84ea..c3ee4c4c 100644
--- a/vscode-ext/vitest.smoketest.config.mts
+++ b/vscode-ext/vitest.smoketest.config.mts
@@ -1,6 +1,5 @@
-import { fileURLToPath } from 'node:url';
-
 import { defineConfig } from 'vitest/config';
+import unitConfig from './vitest.config.mts';
 
 /**
  * The webview boot smoketest, kept out of `pnpm test` on purpose: it needs a
@@ -11,11 +10,8 @@ import { defineConfig } from 'vitest/config';
  * `getWebviewHtml`, so it needs `Uri.file` for exactly the same reason.
  */
 export default defineConfig({
-  resolve: {
-    alias: {
-      vscode: fileURLToPath(new URL('test/vscode-stub.ts', import.meta.url)),
-    },
-  },
+  // Both run getWebviewHtml and its shared notepad schema imports.
+  resolve: unitConfig.resolve,
   test: {
     environment: 'node',
     include: ['test/**/*.smoketest.ts'],
diff --git a/website/src/pages/PlaygroundDesktop.tsx b/website/src/pages/PlaygroundDesktop.tsx
index 3f51328d..08c9faaf 100644
--- a/website/src/pages/PlaygroundDesktop.tsx
+++ b/website/src/pages/PlaygroundDesktop.tsx
@@ -144,6 +144,10 @@ function PlaygroundDesktopExperience() {
       if (cancelled) return;
 
       const adapter = platform.initPlatform("fake");
+      // The demo gets the notepad — its archive is the fake adapter's in-memory
+      // one — but no keyboard shortcut for it: a browser tab cannot take
+      // Cmd/Ctrl+N (docs/specs/notepad.md).
+      adapter.browserReservesNotepadChord = true;
       registry.initAlertStateReceiver();
       adapterRef.current = adapter;