diff --git a/docs/specs/alert.md b/docs/specs/alert.md
index 929bf355..ca0536e9 100644
--- a/docs/specs/alert.md
+++ b/docs/specs/alert.md
@@ -33,8 +33,6 @@ Public `status` is a projection — first match wins:
 
 Persist `status`, `watchingEnabled`, `todo`, and sanitized `notification`. Restore `todo` and `notification`, then restart WATCHING only if `watchingEnabled` is true. Restore must not recreate protocol progress, command-exit arms, or a fresh ring; replay filtering in `docs/specs/terminal-escapes.md` prevents old terminal output from firing notification side effects again.
 
-Source of truth: `migrateTodoState` in `lib/src/lib/alert-manager.ts` defines the legacy-TODO-value migration to boolean.
-
 ## Attention
 
 `attentionSessionId` is set only by explicit user actions that plausibly mean "I am looking at this Session":
diff --git a/docs/specs/dor-browser.md b/docs/specs/dor-browser.md
index 9ae1b2a1..a939d5ca 100644
--- a/docs/specs/dor-browser.md
+++ b/docs/specs/dor-browser.md
@@ -25,8 +25,8 @@ Two independent axes define a browser pane:
 | Render | `ab-screencast`, `ab-popout`, `iframe` |
 
 The render axis is a pane parameter, not a separate surface type. The `dor` CLI
-still reports `iframe` or `agent-browser` as a legacy/informative surface type;
-that is derived from `renderMode`.
+still reports `iframe` or `agent-browser` as an informative surface type derived
+from `renderMode` (never stored).
 
 Source of truth: `lib/src/components/wall/BrowserPanel.tsx`,
 `lib/src/components/wall/browser-surface.ts`, `lib/src/components/Wall.tsx`
@@ -46,15 +46,12 @@ type BrowserPanelParams = {
   wsPort?: number;
   binaryPath?: string;
   syncEngaged?: boolean;
-  poppedOut?: boolean; // legacy migration only
 };
 ```
 
 Invariants:
 
-- `renderMode` is canonical. Legacy params (`surfaceType: 'iframe'`,
-  `surfaceType: 'agent-browser'`, `poppedOut`) are migrated by
-  `resolveRenderMode`.
+- `renderMode` is canonical.
 - `url` is the canonical target across render swaps and relaunches. Agent-browser
   mirrors the newest non-blank active tab URL into params; iframe persists only
   navigations initiated by Dormouse chrome.
@@ -513,7 +510,7 @@ Source of truth: `lib/src/lib/platform/types.ts`,
 
 When changing browser-surface behavior:
 
-- `renderMode` is canonical. Never reintroduce `surfaceType: 'iframe' | 'agent-browser'` or `poppedOut` as stored state — extend the `resolveRenderMode` migration instead, and update the kind-mapping table in `docs/specs/glossary.md` if adding a render mode.
+- `renderMode` is canonical. Never reintroduce `surfaceType: 'iframe' | 'agent-browser'` or `poppedOut` as stored state; update the kind-mapping table in `docs/specs/glossary.md` if adding a render mode.
 - Never move a browser surface's DOM. Lath's leaf div is never re-parented, so an `<iframe>` never reloads and the screencast canvas never moves mid-click (which would break click synthesis) — do not add any re-parenting/reordering that would defeat this.
 - A new agent-browser subcommand must be added to `AGENT_BROWSER_ALLOWED_SUBCOMMANDS` (`lib/src/lib/platform/types.ts`); the host-side allowlist is the security boundary, not the CLI.
 - External-binary spawns go through `spawnAndCapture` (`dor-lib-common`), never raw `child_process` — see `docs/specs/dor-cli.md` → Spawning External Binaries.
diff --git a/docs/specs/glossary.md b/docs/specs/glossary.md
index 051ea415..52ffc8ee 100644
--- a/docs/specs/glossary.md
+++ b/docs/specs/glossary.md
@@ -33,14 +33,14 @@ Today every Pane holds exactly one Surface, but the model reserves multiple Surf
 
 Three related enums name a Surface's kind at different layers. This table is the canonical mapping:
 
-| Surface | Persisted `surfaceType` (`docs/specs/transport.md`) | `renderMode` (`docs/specs/dor-browser.md`) | CLI `SurfaceType` (`dor`, legacy/derived) |
+| Surface | Persisted `surfaceType` (`docs/specs/transport.md`) | `renderMode` (`docs/specs/dor-browser.md`) | CLI `SurfaceType` (`dor`, derived) |
 |---|---|---|---|
 | terminal Session | `'terminal'` (the default, omitted from the row) | — | `terminal` |
 | browser, iframe renderer | `'browser'` | `iframe` | `iframe` |
 | browser, screencast renderer | `'browser'` | `ab-screencast` | `agent-browser` |
 | browser, popped-out renderer | `'browser'` | `ab-popout` | `agent-browser` |
 
-For browser Surfaces `renderMode` is canonical; the CLI column is derived from it for backwards-compatible `dor` output and is never stored.
+For browser Surfaces `renderMode` is canonical; the CLI column is derived from it for `dor` output and is never stored.
 
 A **Session** runs the full six-axis model below. A **browser Surface** participates only where a web view meaningfully can:
 
@@ -70,7 +70,7 @@ A Surface never floats free: it sits in a **Pane**, every Pane belongs to exactl
 | **Window** | One or more Workspaces. The OS frame (the standalone Tauri window) or the host frame (a VS Code window). | host (Tauri / VS Code) |
 | **Workspace** | A named set of Panes and their Surfaces, plus the layout that arranges them (Lath layout snapshot + doors). Exactly one **Wall** renders one Workspace. | `lib/src/components/Wall.tsx` at render time; persisted per `docs/specs/transport.md` |
 
-A **Workspace** is the durable grouping a user thinks of as "a window's worth of panes." It has a `WorkspaceId`, a user-facing `name`, the Surfaces it contains, and the layout that arranges them. The pre-workspace model had exactly one implicit Workspace per Window; the model now allows several.
+A **Workspace** is the durable grouping a user thinks of as "a window's worth of panes." It has a `WorkspaceId`, a user-facing `name`, the Surfaces it contains, and the layout that arranges them. The model allows several Workspaces per Window, though the app mounts one at a time today.
 
 How many are visible at once is host-specific:
 
@@ -241,7 +241,7 @@ Use glossary names instead of these. The left column retains a meaning only wher
 | **session** | The durable identity of a **terminal Surface**. Do not use it for the Activity projection (that is `ActivityState`, not `SessionUiState`), nor for the agent-browser daemon's lowercase `session` string (`dormouse.1.<key>`), which is not a Dormouse durable unit. |
 | **terminal** | Keeps its meaning for the `xterm.Terminal` instance. Prose meaning "the whole thing" is **Session** (a terminal Surface). |
 | **surface** | A glossary term, not retired: the durable occupant of a Pane (a terminal Session or a browser Surface). Use **Session** only for the terminal kind; use **Surface** when a statement holds for both. |
-| **panel / pane / leaf** | Prefer **pane** for the layout slot; **leaf** is Lath's tree node for the same thing (they map 1:1). "panel" survives only in legacy persisted-blob field names. |
+| **panel / pane / leaf** | Prefer **pane** for the layout slot; **leaf** is Lath's tree node for the same thing (they map 1:1). "panel" survives only in React component names (`TerminalPanel`, `BrowserPanel`, `IframePanel`). |
 | **tether** | Remote-control term only: a display showing "tethering to \<device\>" has ceded terminal size authority to a remote viewer (`docs/specs/remote-api.md`). Not a layout term — do not use it for Pane/Door relationships. |
 
 Remote-only vocabulary (**Viewer**, the wire-level `DirectoryEntry` projection) is defined in `docs/specs/remote-api.md` § Terminology.
diff --git a/docs/specs/layout.md b/docs/specs/layout.md
index 83771ad2..fce4a122 100644
--- a/docs/specs/layout.md
+++ b/docs/specs/layout.md
@@ -147,7 +147,7 @@ Extreme case: a single door with a very long title, with more doors on both side
 
 A **Workspace** is one Wall's worth of Surfaces (terminal Sessions and browser surfaces) plus its layout, with a user-facing name. The standalone Window hosts several Workspaces but mounts only one — the **active** Workspace — at a time. Each Workspace owns its own Content (Lath layout) and Baseboard (doors).
 
-What exists today lives behind the `dormouse.flags.workspaces` flag (`WORKSPACES_FLAG_KEY` in `lib/src/lib/feature-flags.ts`, **off by default**): the in-memory workspace model and its container verbs (`createWorkspace` / `closeWorkspace` / `renameWorkspace` / `setActiveWorkspace` in `lib/src/lib/workspace-store.ts`), the union projection (`computeWorkspaceUnion` in `lib/src/lib/workspace-union.ts`), and Window persistence (`PersistedWindow`, `docs/specs/transport.md`). `setActiveWorkspace` changes the active id in the model but does not yet re-render the Wall, and the single-Workspace cap is still in place. With the flag off, the app persists a bare `PersistedSession` and runs exactly one implicit Workspace — byte-identical to pre-workspace behavior.
+What exists today lives behind the `dormouse.flags.workspaces` flag (`WORKSPACES_FLAG_KEY` in `lib/src/lib/feature-flags.ts`, **off by default**): the in-memory workspace model and its container verbs (`createWorkspace` / `closeWorkspace` / `renameWorkspace` / `setActiveWorkspace` in `lib/src/lib/workspace-store.ts`), the union projection (`computeWorkspaceUnion` in `lib/src/lib/workspace-union.ts`), and Window persistence (`PersistedWindow`, `docs/specs/transport.md`). `setActiveWorkspace` changes the active id in the model but does not yet re-render the Wall, and the single-Workspace cap is still in place. With the flag off, the app persists a bare `PersistedSession` and runs exactly one implicit Workspace.
 
 The strip UI, real switching, and lifecycle UX are staged in [Future](#future) — this spec's `## Future` is the single rollout ledger for the feature; other specs link here.
 
@@ -264,7 +264,7 @@ Swaps session **content** between two panes — the layout shape is unchanged. A
 - **Neighbor** — the sibling still exists: split beside it on the original edge (at 50/50).
 - **Fallback** — split beside a caller-supplied live reference (the selected pane, else the first pane) via `autoEdge`; into an empty tree the leaf becomes the root.
 
-A Door persisted before Lath has no token; the Wall synthesizes a neighbor-tier one from its legacy `{neighborId, direction}` fields (`legacyTokenFromDoor`). A door dragged out of the baseboard skips the token entirely and inserts at the hit-tested drop position the user chose (`onExternalDrop` → `lath.insertLeaf`).
+A door dragged out of the baseboard skips the token entirely and inserts at the hit-tested drop position the user chose (`onExternalDrop` → `lath.insertLeaf`).
 
 ## Inline rename
 
@@ -295,15 +295,15 @@ For a terminal Surface the pane ID is its session ID. `TerminalPane` calls `getO
 
 ### Session persistence
 
-Layout, scrollback, cwd, minimized items, user-pinned titles, untouched state, and alert state are saved to persistent storage via a debounced save (500ms). The layout persists as the native Lath format (`lathLayout`; `docs/specs/tiling-engine.md` → "Persistence and migration"); the legacy dockview `layout` key is no longer written. Derived command/app labels shown on minimized doors are display-only and are not persisted as user-pinned titles. Every Lath store commit (add/remove/resize/swap/meta, including the active-pane the layout records) *schedules* the debounced save; content changes (terminal output, activity/TODO, pane title/command state, minimized-door changes) only *mark the session dirty*; a 30s heartbeat persists only when the session is dirty, so an idle app stops writing. Saves are flushed immediately and unconditionally on PTY exit, `pagehide`, and extension shutdown requests — the correctness net for any dirty-trigger gap. The dirty-gating mechanism and the store-level identical-value backstop are specified in `docs/specs/standalone.md` §Persistence.
+Layout, scrollback, cwd, minimized items, user-pinned titles, untouched state, and alert state are saved to persistent storage via a debounced save (500ms). The layout persists as the native Lath format (`lathLayout`; `docs/specs/tiling-engine.md` → "Persistence"). Derived command/app labels shown on minimized doors are display-only and are not persisted as user-pinned titles. Every Lath store commit (add/remove/resize/swap/meta, including the active-pane the layout records) *schedules* the debounced save; content changes (terminal output, activity/TODO, pane title/command state, minimized-door changes) only *mark the session dirty*; a 30s heartbeat persists only when the session is dirty, so an idle app stops writing. Saves are flushed immediately and unconditionally on PTY exit, `pagehide`, and extension shutdown requests — the correctness net for any dirty-trigger gap. The dirty-gating mechanism and the store-level identical-value backstop are specified in `docs/specs/standalone.md` §Persistence.
 
-In standalone, each Workspace's snapshot is wrapped in a Window snapshot that records every Workspace (name + layout) and which one is active, so all Workspaces — not just the mounted one — survive a restart. VS Code persists one Workspace per webview exactly as today (one snapshot per `WebviewView` / `WebviewPanel`). The persisted container types (`PersistedWorkspace`, `PersistedWindow`) and their migration live in `docs/specs/transport.md`.
+In standalone, each Workspace's snapshot is wrapped in a Window snapshot that records every Workspace (name + layout) and which one is active, so all Workspaces — not just the mounted one — survive a restart. VS Code persists one Workspace per webview exactly as today (one snapshot per `WebviewView` / `WebviewPanel`). The persisted container types (`PersistedWorkspace`, `PersistedWindow`) live in `docs/specs/transport.md`.
 
-Saved snapshots are read through `readPersistedSession()`, which accepts the canonical object shape and defensively parses a JSON-stringified blob before validation and migration. This keeps malformed storage inert while covering hosts that hand back serialized JSON instead of the parsed object.
+Saved snapshots are read through `readPersistedSession()`, which accepts the canonical object shape and defensively parses a JSON-stringified blob before validation. A present-but-unreadable blob is logged and discarded, so malformed storage starts fresh rather than blocking startup, while hosts that hand back serialized JSON instead of the parsed object are still covered.
 
 On startup, recovery is priority-based:
-1. **Resume** (webview hidden/shown, live PTYs): request PTY list + replay data from platform, `resumeTerminal()` for each (500ms timeout). Saved pane and door titles are seeded back via `setTerminalUserTitle()` (see `docs/specs/transport.md`) so persisted placeholder labels never replay as user pins. If the saved session covers every live PTY, restore the saved Lath layout when its leaf set matches (a pre-Lath save's legacy dockview `layout` blob is migrated into that single channel at the session read boundary) and reattach saved minimized items as doors. This still counts as a live resume when every live session is minimized, so recovery must not fall through to cold restore just because the visible `paneIds` list is empty.
-2. **Restore** (app restart, cold start): the Wall's `seed` hydrates from the restored Lath layout (the read boundary already migrated any legacy dockview `layout` blob one-way into it), else falls to (3); `restoreTerminal()` for each pane with saved cwd + scrollback, spawning each PTY with the current default shell selection
+1. **Resume** (webview hidden/shown, live PTYs): request PTY list + replay data from platform, `resumeTerminal()` for each (500ms timeout). Saved pane and door titles are seeded back via `setTerminalUserTitle()` (see `docs/specs/transport.md`) so persisted placeholder labels never replay as user pins. If the saved session covers every live PTY, restore the saved Lath layout when its leaf set matches and reattach saved minimized items as doors. This still counts as a live resume when every live session is minimized, so recovery must not fall through to cold restore just because the visible `paneIds` list is empty.
+2. **Restore** (app restart, cold start): the Wall's `seed` hydrates from the restored Lath layout, else falls to (3); `restoreTerminal()` for each pane with saved cwd + scrollback, spawning each PTY with the current default shell selection
 3. **Fallback/manual pane creation**: when no saved layout can be safely applied, add multiple panes as splits from the previous pane, and spawn each PTY with the current default shell selection
 4. **Empty state**: create a single new pane with the current default shell selection
 
@@ -401,7 +401,7 @@ When changing layout behavior:
 
 - Changing a command-mode binding or the mode-switch gesture: update the shortcut table here **and** `docs/specs/shortcuts.md` in the same edit.
 - Pane-header changes: this spec owns placement and sizing only. Bell/TODO behavior and visual states belong to `docs/specs/alert.md`; the mouse-override icon and banner to `docs/specs/mouse-and-clipboard.md`; the derived label to `docs/specs/terminal-state.md`.
-- Persisted-shape changes (`PersistedPane` / `PersistedDoor` / layout blobs) belong to `docs/specs/transport.md` — add the migration note there.
+- Persisted-shape changes (`PersistedPane` / `PersistedDoor` / layout blobs) belong to `docs/specs/transport.md` — update it there.
 - New pane chrome uses tokens from `lib/src/components/design.tsx` (see AGENTS.md Design); never raw color classes.
 - Pane spawn/kill/tween motion is owned by the Lath animator (`docs/specs/tiling-engine.md` → "Animation"); layout.md owns only the interaction behavior around it.
 - Anything workspace-strip or switching related stays under `## Future` (workspaces-rollout) until built.
diff --git a/docs/specs/standalone.md b/docs/specs/standalone.md
index 731b1b50..ef9079bb 100644
--- a/docs/specs/standalone.md
+++ b/docs/specs/standalone.md
@@ -246,19 +246,6 @@ trigger missed; the cache is boot-seeded from disk in `hydrate`, so the compare
 is valid from the first write. Source of truth: `session-dirty.ts`,
 `use-session-persistence.ts`, `standalone/src/tauri-session-store.ts`.
 
-**Migration.** On the first boot after this change `load_session` returns null;
-if a legacy blob is still in `localStorage` under `TauriAdapter.STATE_KEY`, the
-adapter adopts it, persists it to the Rust store (through the store's normal
-write path, so it shares the coalescing), and removes the key — so WebKit stops
-rewriting it and its bloated WAL collapses on the next quit. The legacy blob is
-per-origin (window-shared), so adoption is gated to the `main` window — a
-second window never races the adopt-and-clear (removal criteria: `## Future`).
-Because the
-identical-value short-circuit above would swallow a `setItem` whose value equals
-the freshly hydrated cache, the migration hydrates with the pre-migration seed
-(null) and lets the `setItem` be a genuine change — localStorage is already
-cleared, so the Rust store is the blob's only remaining home.
-
 **Durability on quit.** A clean quit durably writes the latest state before the
 process exits. `saveState` still returns after updating the cache and *firing*
 `save_session`, but the quit orchestrator (§Quit flow) now awaits the pipeline to
@@ -460,21 +447,3 @@ root `package.json` for the `dev:standalone*` orchestration.
 | `standalone/sidecar/clipboard-ops.js` | OS clipboard tiers (owned by `docs/specs/mouse-and-clipboard.md`) |
 | `standalone/scripts/build-sidecar-proxy.mjs` | Bundles `lib/src/host/` into the sidecar `.cjs` copies |
 | `standalone/scripts/dev-agent-browser.mjs` | `dev:standalone:ab` entry (owned by `docs/specs/transport.md`) |
-
-## Future
-
-Requirements for the next round of session-persistence work — what must be true,
-not how. (Detailed working notes live outside the specs while the work is in
-flight.)
-
-**Retire the `localStorage` → Rust migration.** The one-time migration branch in
-`standalone/src/tauri-adapter.ts` (marked `SUNSET`, gated to the `main` window)
-cannot be removed on a version fence: the Tauri updater jumps directly from any
-old version to the latest, so there is no release after which "all shipped
-builds have migrated" — a pre-migration straggler updating much later would
-adopt nothing and lose exactly one session restore. Removal is therefore an
-acceptance decision, recorded here (2026-07-07): remove once a one-time lost
-restore for pre-0.12 stragglers is acceptable — recommended at least six months
-or two minor releases after the migration ships. Multi-window (the
-workspaces-rollout scope, `docs/specs/layout.md` `## Future`) does not block
-removal: the branch already gates adoption to the `main` window.
diff --git a/docs/specs/tiling-engine.md b/docs/specs/tiling-engine.md
index 3eec17d3..d7a1750a 100644
--- a/docs/specs/tiling-engine.md
+++ b/docs/specs/tiling-engine.md
@@ -2,7 +2,7 @@
 
 > See [glossary.md](glossary.md) for the Surface model, the `Window ⊃ Workspace ⊃ Pane ⊃ Surface` hierarchy, and the Pane / Door / baseboard / passthrough vocabulary used here.
 
-> Status: implemented. Lath is Dormouse's tiling engine — the pure core under `lib/src/lib/lath/` (model, layout, ops, animator, hit-testing) and the full Wall binding with native motion and hierarchical DnD. The dockview-react dependency has been removed; the only trace of it left in the codebase is the one-way legacy migration reader (`lib/src/lib/lath/dockview-convert.ts`) that upgrades a pre-Lath persisted `layout` blob to a Lath tree once, at the session read boundary. [layout.md](layout.md) describes the shipped layout/interaction model; this spec owns the engine internals. Lath is an in-house headless tiling engine named for the strips hidden behind a plaster wall.
+> Status: implemented. Lath is Dormouse's tiling engine — the pure core under `lib/src/lib/lath/` (model, layout, ops, animator, hit-testing) and the full Wall binding with native motion and hierarchical DnD. The dockview-react dependency has been removed. [layout.md](layout.md) describes the shipped layout/interaction model; this spec owns the engine internals. Lath is an in-house headless tiling engine named for the strips hidden behind a plaster wall.
 
 ## Why
 
@@ -134,14 +134,14 @@ Source of truth: `RestoreToken` and `restore` in `lib/src/lib/lath/ops.ts`.
 
 A leaf removed from a two-child split whose survivor is a single leaf always degrades to the neighbor tier: the collapse erases the fingerprinted parent, and the neighbor tier reproduces the same position (at 50/50 rather than the original weights). If the survivor is a split subtree, exact restore targets that unchanged subtree by `siblingLeafIds` / `siblingFingerprint` so `A | (B over C)` restores beside the whole `B/C` column rather than inside it. A token whose sibling is gone and whose caller supplies no `fallbackRef` fails with `ok: false` — callers own picking a live reference.
 
-Tokens serialize with Doors (`PersistedDoor.token`) as the sole restore payload; a Door persisted before Lath (no token) restores at the neighbor tier via a token synthesized from its legacy `{neighborId, direction}` fields (`legacyTokenFromDoor` in `lib/src/components/wall/lath-wall-engine.ts`; an absent `neighborId` degrades to the fallback tier, an absent `direction` defaults to `'right'`).
+Tokens serialize with Doors (`PersistedDoor.token`) as the sole restore payload.
 
 ## The wall store and engine
 
 Source of truth: `lib/src/components/wall/lath-wall-store.ts`; `lib/src/components/wall/lath-wall-engine.ts`. `Wall.tsx` constructs the engine lazily once per mount and renders LathHost. The split is crisp: the **store** is the state machine + geometry + enter hints, and every state op / geometry query reaches it directly as `lath.store.*`; the **engine** layers presentation / vocabulary / persistence conveniences over it and re-exports none of the store's mutators or queries.
 
 - **`lath-wall-store.ts`** — the headless store (the sole state authority): `{ tree, leafMeta, zoomedId, revision }` behind a `useSyncExternalStore` contract (snapshot identity is stable between commits; `revision` bumps on every commit), plus the reported layout geometry and the pending enter-hint map (both side state, never in the snapshot). `leafMeta` maps leaf id → `{ component, tabComponent, title, params }`, serialized inside the persisted Lath layout. Every mutator applies exactly one core op; a rejected op commits nothing and never notifies. Geometry-dependent queries (`neighborOf`, `autoEdgeFor`, `resizeBoundary`, restore's fallback tier, `addLeaf`'s null-position autoEdge) use the rect + opts LathHost last reported via `setLayoutGeometry`, which **rejects a degenerate (zero-area) rect**: `autoEdge` on 0×0 returns `'bottom'` for every split, so a seed reading it would stack every pane vertically — strictly worse than the `!geometry` fallback (`'right'`). Keeping the last good geometry (or none) lets those queries hit their benign fallback until the container has a real size.
-- **`lath-wall-engine.ts`** — the Wall-facing handle over the store, holding only what the store does not: the animator (+ `exitMs` / `markDying` / `isDying` / frame + wake signals; see Animation), the read projections `listPanes()` (tree pre-order + meta — read by `buildDorSurfaces`, persistence, and dev-server correlation) and `getMeta(id)`, the vocabulary maps (Edge ↔ dor-direction, Door-direction → Edge via `edgeForDoorDirection`, arrow → direction), the meta builders `terminalLeafMeta` / `browserLeafMeta` / `leafMetaFromDoor` (which canonicalizes legacy `iframe`/`agent-browser` component aliases to `browser`), `legacyTokenFromDoor`, and the persistence conveniences `serializeLayout` + three-way hydration `seed` (persisted Lath layout → migrated legacy dockview blob → fresh panes). It holds no selection/focus/mode/activation state.
+- **`lath-wall-engine.ts`** — the Wall-facing handle over the store, holding only what the store does not: the animator (+ `exitMs` / `markDying` / `isDying` / frame + wake signals; see Animation), the read projections `listPanes()` (tree pre-order + meta — read by `buildDorSurfaces`, persistence, and dev-server correlation) and `getMeta(id)`, the vocabulary maps (Edge ↔ dor-direction, arrow → direction), the meta builders `terminalLeafMeta` / `browserLeafMeta` / `leafMetaFromDoor`, and the persistence conveniences `serializeLayout` + two-way hydration `seed` (persisted Lath layout → fresh panes). It holds no selection/focus/mode/activation state.
 - The Wall keeps all selection/focus/mode policy: `dor split`-style adds are inherently focus-neutral (nothing re-parents, nothing activates), so focus-neutral creation reduces to a selection decision (`settleAddSelection`); the Cmd-Arrow swap is one `store.swapLeaves` call with **no** companion title swap (meta and registry entries follow ids); kills fade then remove (the two-phase animator kill, below), with a selection-adoption tail; keyboard spatial nav rides `store.neighborOf` through the `WallNav` seam in `lib/src/components/wall/keyboard/types.ts`.
 - Embed self-focus adoption (acceptance row 8) has no activation event to piggyback on: LathHost surfaces `focusin` inside a leaf as `onLeafFocused(id)`, and the Wall adopts it with the same passthrough/command policy a click would.
 
@@ -154,7 +154,7 @@ An adapter owns exactly three things: mapping input into Wall coordinates (point
 LathHost, the HTML adapter (a thin React component, the only non-headless part of the engine):
 
 - One flat container; one stable `position: absolute` div per leaf, keyed by id and carrying `data-lath-leaf`. Pane content renders as ordinary React children into that div. The div moves and resizes via inline styles; it is **never re-parented, never reordered, and never unmounted** except on remove-commit — leaf divs render in *sorted-by-id* DOM order, not tree order, because React reordering keyed siblings moves DOM nodes and a moved `<iframe>` reloads. This deletes the re-parent blur class of bugs and the iframe-reload constraint at the root rather than healing them.
-- Each leaf div is a 30px header slot over a filling body; components resolve from `leafMeta.component` / `.tabComponent` with the alias table (legacy `iframe`/`agent-browser` → BrowserPanel). A `componentsOverride` prop is the jsdom test seam (never mounts real xterm). The positioned wrapper carries geometry only; its header + body live in a memoized inner content unit keyed on `{ id, meta, resolved components }`, so a geometry-only frame (a sash-drag preview, a resize commit) re-renders the wrapper but never the header or body.
+- Each leaf div is a 30px header slot over a filling body; components resolve from `leafMeta.component` / `.tabComponent` (`terminal` → TerminalPanel, `browser` → BrowserPanel). A `componentsOverride` prop is the jsdom test seam (never mounts real xterm). The positioned wrapper carries geometry only; its header + body live in a memoized inner content unit keyed on `{ id, meta, resolved components }`, so a geometry-only frame (a sash-drag preview, a resize commit) re-renders the wrapper but never the header or body.
 - Sashes render from core `sashes()` geometry as sibling divs (hit area widened to 8px, cursor per axis); a drag streams a core `resize` preview from the drag-start tree with the cumulative delta and proposes a single commit on pointerup (`onCommitResize`); Escape cancels. Geometry is reported back via `store.setLayoutGeometry` so store queries match the screen (`LATH_LAYOUT_OPTS`: gap 6; minLeaf 100×60). The report is made from inside the measuring layout effect (with the just-read `getBoundingClientRect`), *not* a passive effect over the rendered size: the Wall's seed runs in a passive effect and reads this geometry through `addLeaf`'s `autoEdge`, and a layout effect (children-first, before any passive effect) is what makes the *real* measured rect available at seed time rather than a lagging one. The store's zero-area rejection (above) is the backstop that keeps a degenerate early report from mis-seeding regardless.
 - The zoomed leaf renders full-rect above the others via z-index; sashes sit between (they disappear under the zoomed leaf).
 - The binding never calls `.focus()` and emits no activation events. Gestures surface as proposals (`onCommitResize`, `onLeafFocused`) that the Wall commits — selection/focus policy stays at the Wall call sites.
@@ -183,25 +183,21 @@ Every pane body / header component (`TerminalPanel`, `BrowserPanel`, `AgentBrows
 - **Visibility**: under Lath a mounted leaf is always engine-visible, so there is no per-pane visibility prop; `useSurfaceVisibility()` reduces to document visibility (a backgrounded window still gates streaming so a hidden pane stops consuming resources).
 - `use-pane-chrome` registers the pane's root element in `PaneElementsContext` (so the overlays can measure it) and nothing else — there is no CSS spawn-animation to trigger.
 
-## Persistence and migration
+## Persistence
 
-Source of truth: the wire format + reader/writer (`LeafMeta`, `LathPersistedLayout`, `lathLayoutFromStore`, `isLathPersistedLayout`) in `lib/src/lib/lath/persistence.ts`; `lathLayout` / `token` in `lib/src/lib/session-types.ts`; the save in `use-session-persistence.ts` / `session-save.ts`; the legacy upgrade reader `lib/src/lib/lath/dockview-convert.ts`; the single migration point `persistedLathLayout` in `session-restore.ts`, consumed by `reconnect.ts`.
+Source of truth: the wire format + reader/writer (`LeafMeta`, `LathPersistedLayout`, `lathLayoutFromStore`, `isLathPersistedLayout`) in `lib/src/lib/lath/persistence.ts`; `lathLayout` / `token` in `lib/src/lib/session-types.ts`; the save in `use-session-persistence.ts` / `session-save.ts`; `persistedLathLayout` in `session-restore.ts`, consumed by `reconnect.ts`.
 
-The Lath layout serializes as `{ version: 1, tree, leafMeta }` (`LathPersistedLayout`, defined in `persistence.ts` beside the core model) — the tree is its own wire format, and `leafMeta` carries the per-leaf `{ component, tabComponent, title, params }`. It rides **inside** `PersistedSession` as the optional field `lathLayout` (no v3 version bump). Doors carry an optional restore `token`. Saves write `lathLayout` only; the pre-Lath dockview `layout` key is no longer emitted.
+The Lath layout serializes as `{ version: 1, tree, leafMeta }` (`LathPersistedLayout`, defined in `persistence.ts` beside the core model) — the tree is its own wire format, and `leafMeta` carries the per-leaf `{ component, tabComponent, title, params }`. It rides **inside** `PersistedSession` as the optional field `lathLayout`. Doors carry an optional restore `token`. Saves write `lathLayout` only.
 
-`PersistedSession.layout` is retained as an **optional legacy field** — read-only, only present in blobs written before Lath — and `PersistedDoor`'s `{neighborId, direction, remainingPaneIds, layoutAtMinimize, layoutAtMinimizeSignature}` are likewise optional legacy-read-only fields; the v3 guard accepts a blob carrying either `layout` or `lathLayout`. Per the persisted-session migration conventions in [transport.md](transport.md), old blobs flow through unchanged.
-
-A persisted session's two layout fields collapse to one channel at the session read boundary: `persistedLathLayout` (`session-restore.ts`) returns the native `lathLayout` when present, else migrates a legacy dockview `layout` one-way via `dockviewLayoutToLath` (grid branches → splits, sizes → normalized weights, panels → leaves + leafMeta, multi-view groups degrading to even splits; `dockview-convert.ts` models the serialized dockview shape with local structural types, no dockview dependency). Everything downstream — the resume gate in `reconnect.ts` (leaf set must match the visible pane set), the `restoredLathLayout` prop threading, and the engine's `seed` — sees only a Lath layout; on an unusable layout, `seed` falls back to fresh panes. A Door persisted before Lath (no token) degrades to neighbor-tier restore. This one-way reader is the only remaining trace of dockview in the codebase; it stays for the deprecation window so existing users' saved layouts survive the upgrade.
-
-Reserved: the legacy `layout` / `PersistedDoor` fields stay defined and read on restore so a pre-Lath snapshot still opens; deleting them would break the upgrade path for users on an old save.
+The session read boundary resolves the layout once: `persistedLathLayout` (`session-restore.ts`) returns the native `lathLayout` when present, else undefined. Everything downstream — the resume gate in `reconnect.ts` (leaf set must match the visible pane set), the `restoredLathLayout` prop threading, and the engine's `seed` — sees only a Lath layout; on an absent or unusable layout, `seed` falls back to fresh panes.
 
 ## Testing
 
-Source of truth: `lib/src/lib/lath/{model,layout,ops,animator,hit-test,property,persistence,dockview-convert}.test.ts` (+ shared core builders in `test-util.ts`, shared `leafMeta` / dockview fixtures in `test-fixtures.ts`); `lath-wall-store.test.ts`, `LathHost.test.tsx`, `lath-wall-engine.test.ts`, `Wall.test.tsx` under `lib/src/components/`.
+Source of truth: `lib/src/lib/lath/{model,layout,ops,animator,hit-test,property,persistence}.test.ts` (+ shared core builders in `test-util.ts`, shared `leafMeta` fixtures in `test-fixtures.ts`); `lath-wall-store.test.ts`, `LathHost.test.tsx`, `lath-wall-engine.test.ts`, `Wall.test.tsx` under `lib/src/components/`.
 
 - Core: DOM-free property tests over seeded random op sequences (tiling exactness, invariant preservation via `validate` after every op, the `ok: false` identity contract, `move` ≡ `remove`+insert, restore-tier degradation) plus golden trees, `neighbors`/`autoEdge`/`sashes` geometry, and per-op rejection cases. Animator: fake-clock tests asserting real interpolated rects/opacities against the exported easing — retarget mid-flight from the interpolated frame, enter-from-edge starting rects, dying freeze-and-fade + shrink geometry, snap semantics, settled detection, reduced-motion zero-duration. Hit-testing: center/edge-band/ancestor-coincidence candidates in depth order, band caps, self/no-op/duplicate filtering, external (null-dragged) drags, and previewRect equality against an explicit `move`+`layout`.
-- Binding (jsdom): **node identity is preserved** across every op (the no-re-parent guarantee) and DOM order stays fixed while layout order changes; imperative frame application between commits (fake rAF + fixed-duration engine), mid-tween React re-renders not snapping styles, dying pointer-events; sash drag preview/commit/cancel and the snap-on-commit; the pane-drag gesture (threshold entry, button bail, preview overlay, wheel depth cycling, baseboard-zone minimize, Escape cancel, external door-drag mode); zoom; the pane props contract via `componentsOverride`; store mutator/rejection/notify semantics; the legacy-blob migration reader against a hand-written serialized-dockview fixture, plus the read-boundary collapse to a single channel (`session-restore.test.ts` / `reconnect.test.ts`); engine hydration from a persisted Lath layout and from fresh pane ids; a `<Wall>` smoke (split, kill, Lath-layout save capture).
-- Acceptance: all rows (1–13) of the matrix below were driven live through the standalone agent-browser harness (`pnpm dev:standalone:ab`; mechanics in `.claude/skills/debug-standalone-agent-browser/SKILL.md`) — including the exact-tier door restore from a 3-child row, sash live-resize, embed self-focus adoption, restart restores from both the native layout and a hand-built pre-Lath legacy blob, frame-sampled motion (kill freeze-and-fade then survivor tween, last-pane shrink-to-corner with top-left auto-spawn entry, continuous retarget under two kills 200ms apart), and the full DnD surface (pixel-exact preview-equals-commit at leaf/column/root depths with wheel cycling, center swap, drag-to-baseboard minimize, door drag-out restore at the previewed slot, selection adoption on drag start).
+- Binding (jsdom): **node identity is preserved** across every op (the no-re-parent guarantee) and DOM order stays fixed while layout order changes; imperative frame application between commits (fake rAF + fixed-duration engine), mid-tween React re-renders not snapping styles, dying pointer-events; sash drag preview/commit/cancel and the snap-on-commit; the pane-drag gesture (threshold entry, button bail, preview overlay, wheel depth cycling, baseboard-zone minimize, Escape cancel, external door-drag mode); zoom; the pane props contract via `componentsOverride`; store mutator/rejection/notify semantics; the read-boundary layout resolution (`session-restore.test.ts` / `reconnect.test.ts`); engine hydration from a persisted Lath layout and from fresh pane ids; a `<Wall>` smoke (split, kill, Lath-layout save capture).
+- Acceptance: all rows (1–13) of the matrix below were driven live through the standalone agent-browser harness (`pnpm dev:standalone:ab`; mechanics in `.claude/skills/debug-standalone-agent-browser/SKILL.md`) — including the exact-tier door restore from a 3-child row, sash live-resize, embed self-focus adoption, restart restores from the native layout, frame-sampled motion (kill freeze-and-fade then survivor tween, last-pane shrink-to-corner with top-left auto-spawn entry, continuous retarget under two kills 200ms apart), and the full DnD surface (pixel-exact preview-equals-commit at leaf/column/root depths with wheel cycling, center swap, drag-to-baseboard minimize, door drag-out restore at the previewed slot, selection adoption on drag start).
 
 Acceptance matrix — each row is an end-to-end observable, independent of engine internals:
 
@@ -216,7 +212,7 @@ Acceptance matrix — each row is an end-to-end observable, independent of engin
 | 7 | Click a door | Reattach at original position when structure allows (exact tier); pane selected |
 | 8 | Embedded page focuses itself (iframe surface) | Selection moves onto that pane — visible jump, same as a click; never a silent desync |
 | 9 | Zoom toggle on a pane | Full-rect render and back; layout identical after |
-| 10 | Restart the app (harness re-open) | Layout, doors, titles, and params restored — including from a pre-Lath legacy blob |
+| 10 | Restart the app (harness re-open) | Layout, doors, titles, and params restored |
 | 11 | Kill with animation | Fade in place, survivors tween into the space; a second kill mid-tween retargets cleanly; reduced-motion instant |
 | 12 | Drag a pane to a leaf edge, an ancestor edge, and center | Split-beside-pane, split-beside-column/row, and swap respectively; preview rect matches the committed result; dragging while a door is selected moves selection onto the dragged pane |
 | 13 | Drag a pane onto the baseboard; drag a door out | Minimize with token; restore at the hit-tested position |
diff --git a/docs/specs/transport.md b/docs/specs/transport.md
index 4202e89e..0bc07f91 100644
--- a/docs/specs/transport.md
+++ b/docs/specs/transport.md
@@ -73,10 +73,10 @@ Both are capped at 1M chars per PTY. When the cap is reached, oldest chunks are
    - { type: 'pty:list', ptys: [{ id, alive, exitCode }] }   // all owned PTYs
    - { type: 'pty:replay', id, data }                         // buffered output per PTY
 4. Webview restores terminals from replay data, seeds saved pane and door titles back via `setTerminalUserTitle()` (which rejects titles starting with `<idle>`, the sentinel that prefixes the auto-generated finished-pane header). The seed callers in `terminal-lifecycle.ts` additionally skip `<unnamed>` so the default panel placeholder does not get seeded as a real user pin during cold-restore. (Persistence cannot distinguish a deliberate `<unnamed>` pin from the default placeholder, so a user who explicitly pinned `<unnamed>` will see it revert to the derived header on app reload.)
-5. If the saved session covers those live PTYs, the frontend uses the saved Lath layout when its leaf set matches (migrating a legacy dockview blob if that is all a pre-Lath save carries) and reattaches saved minimized doors; minimized PTYs are registered but remain doors instead of visible panes.
+5. If the saved session covers those live PTYs, the frontend uses the saved Lath layout when its leaf set matches and reattaches saved minimized doors; minimized PTYs are registered but remain doors instead of visible panes.
 ```
 
-For cold restore (no live PTYs), the webview falls back to saved session state: spawns new PTYs in saved CWDs using the currently selected Dormouse shell, injects saved scrollback (with trailing newline to avoid the zsh `%` artifact), and restores the saved Lath layout (migrating a legacy dockview blob one-way for pre-Lath saves). The entry module (`reconnect.ts`) uses a 500ms timeout when waiting for the PTY list.
+For cold restore (no live PTYs), the webview falls back to saved session state: spawns new PTYs in saved CWDs using the currently selected Dormouse shell, injects saved scrollback (with trailing newline to avoid the zsh `%` artifact), and restores the saved Lath layout. The entry module (`reconnect.ts`) uses a 500ms timeout when waiting for the PTY list.
 
 ## Message protocol
 
@@ -108,21 +108,21 @@ The OSC parsing/stripping rules that produce `pty:data` and `terminal:semanticEv
 
 ## Persisted session types
 
-Source of truth: `lib/src/lib/session-types.ts` defines the persisted-session interfaces (`PersistedSession` v3, `PersistedPane` — now carrying `surfaceType` — `PersistedAlertState`, `PersistedDoor`, and the container types `PersistedWorkspace` / `PersistedWindow`) and their migrations.
+Source of truth: `lib/src/lib/session-types.ts` defines the persisted-session interfaces (`PersistedSession` v3, `PersistedPane` — now carrying `surfaceType` — `PersistedAlertState`, `PersistedDoor`, and the container types `PersistedWorkspace` / `PersistedWindow`).
 
-**The layout field.** A `PersistedSession` records the layout as `lathLayout` — the native Lath tree (`docs/specs/tiling-engine.md` → "Persistence and migration"). The legacy dockview `layout` key is retained as an **optional, read-only** field: it appears only in blobs written before Lath and is migrated one-way to a Lath tree on restore; new saves never write it. The v3 guard accepts a blob carrying either field. `PersistedDoor`'s pre-Lath positioning fields (`neighborId` / `direction` / `remainingPaneIds` / `layoutAtMinimize` / `layoutAtMinimizeSignature`) are likewise optional legacy-read-only; a new door carries a Lath restore `token` instead.
+**The layout field.** A `PersistedSession` records the layout as `lathLayout` — the native Lath tree (`docs/specs/tiling-engine.md` → "Persistence"). Each `PersistedDoor` carries a Lath restore `token` as its sole restore payload.
 
-**Surface kinds in the snapshot.** Each `PersistedPane` records a `surfaceType` (`docs/specs/glossary.md`): `'terminal'` (the default, omitted from the row to keep terminal snapshots byte-identical) or `'browser'`. This is the discriminator that routes restore/resume. `restoreSession` skips terminal restoration for a browser pane, so it no longer mints a stray PTY + xterm for each browser pane id (`session-restore.ts`); the resume plan keeps browser panes (and minimized browser doors) even though they have no live PTY, so the saved layout's pane set still matches and is not discarded (`reconnect.ts` gates the session's single Lath channel — a legacy `layout` blob is migrated at the read boundary before gating — on its leaf set). A browser pane rebuilds from the persisted layout (visible) or `PersistedDoor.params` (minimized); its render params (`renderMode`, `url`, agent-browser `session`) live there, not in `PersistedPane` — `surfaceType` alone is enough to route restore. A pane lacking `surfaceType` reads as `'terminal'`, so older snapshots migrate transparently.
+**Surface kinds in the snapshot.** Each `PersistedPane` records a `surfaceType` (`docs/specs/glossary.md`): `'terminal'` (the default, omitted from the row to keep terminal snapshots byte-identical) or `'browser'`. This is the discriminator that routes restore/resume. `restoreSession` skips terminal restoration for a browser pane, so it no longer mints a stray PTY + xterm for each browser pane id (`session-restore.ts`); the resume plan keeps browser panes (and minimized browser doors) even though they have no live PTY, so the saved layout's pane set still matches and is not discarded (`reconnect.ts` gates the session's Lath layout on its leaf set). A browser pane rebuilds from the persisted layout (visible) or `PersistedDoor.params` (minimized); its render params (`renderMode`, `url`, agent-browser `session`) live there, not in `PersistedPane` — `surfaceType` alone is enough to route restore. A pane lacking `surfaceType` reads as `'terminal'`.
 
 **Workspace/Window containers (implemented, dormant behind the `dormouse.flags.workspaces` flag; rollout ledger in `docs/specs/layout.md` `## Future`).** A **Workspace** persists as a `PersistedWorkspace`: a `WorkspaceId`, a user-facing `name`, and the Workspace's `PersistedSession` (its panes, doors, and Lath layout). The standalone Window persists as a `PersistedWindow`: the ordered list of `PersistedWorkspace` plus the active `WorkspaceId`. Source of truth: `PersistedWorkspace` / `PersistedWindow` / `readPersistedWindow` / `replaceActiveSession` in `session-types.ts`. VS Code does **not** use `PersistedWindow`; each webview persists exactly one `PersistedSession` — its single Workspace — through the same per-surface state API as today (`workspaceState` for the view, `vscode.setState()` per editor panel; see `docs/specs/vscode.md`).
 
-The wrapping lives at the **standalone adapter boundary**, not in the shared save/restore code: `lib/src/lib/window-persistence.ts` (`activeSessionFromStored` / `storedValueForSession`) translates between the host's stored top-level blob and the bare `PersistedSession` that `reconnect.ts` / `session-save.ts` operate on, and `tauri-adapter.ts` / `browser-sidecar-adapter.ts` route `getState` / `saveState` through it. The blob round-trips through a `SessionKeyValueStore` — a single synchronous key/value slot the host persists natively: the browser-dev sidecar uses `localStorage`, while the real standalone adapter uses a Rust-backed per-window file store (`docs/specs/standalone.md` §Persistence), never WebKit `localStorage`. With the flag **off** (the default) these are identity passthroughs — the stored blob stays a bare `PersistedSession` and behavior is byte-identical to pre-workspace behavior. With the flag **on**, load returns the active Workspace's session and save merges it back into the active slot, preserving the other Workspaces.
+The wrapping lives at the **standalone adapter boundary**, not in the shared save/restore code: `lib/src/lib/window-persistence.ts` (`activeSessionFromStored` / `storedValueForSession`) translates between the host's stored top-level blob and the bare `PersistedSession` that `reconnect.ts` / `session-save.ts` operate on, and `tauri-adapter.ts` / `browser-sidecar-adapter.ts` route `getState` / `saveState` through it. The blob round-trips through a `SessionKeyValueStore` — a single synchronous key/value slot the host persists natively: the browser-dev sidecar uses `localStorage`, while the real standalone adapter uses a Rust-backed per-window file store (`docs/specs/standalone.md` §Persistence), never WebKit `localStorage`. With the flag **off** (the default) these are identity passthroughs — the stored blob stays a bare `PersistedSession`. With the flag **on**, load returns the active Workspace's session and save merges it back into the active slot, preserving the other Workspaces.
 
-Versioning and migration: the standalone top-level snapshot is a `PersistedWindow` (its own `version: 1`) wrapping v3 sessions. A pre-workspace bare `PersistedSession` (any version) migrates on read to a single `PersistedWorkspace` named `Workspace 1`, marked active, inside a `PersistedWindow` (`readPersistedWindow`); unreadable inner sessions are dropped and a dangling `activeWorkspaceId` is repaired to the first Workspace. A host that hands back a bare `PersistedSession` (VS Code, or legacy/flag-off standalone storage) is read as one Workspace. Migrations stay additive — older shapes keep flowing v1→v2→v3→(window) without losing panes, doors, alert state, or surface kind.
+Versioning: the standalone top-level snapshot is a `PersistedWindow` (its own `version: 1`) wrapping v3 sessions. `readPersistedWindow` drops Workspaces whose inner session is unreadable and repairs a dangling `activeWorkspaceId` to the first Workspace; an unreadable or corrupt blob is logged and discarded so startup continues fresh rather than blocking on a bad save. VS Code hands back a bare `PersistedSession` — its single Workspace.
 
 **Persisted scrollback cap.** Each terminal pane's persisted scrollback is capped at 100,000 chars, keeping the tail cut at a line boundary (with the trailing `\n` preserved, per "Scrollback trailing newline" below) so N busy panes can't rewrite N MB on every save. The trim happens where scrollback is resolved for persistence — the frontend save path (`session-save.ts`) and the VS Code host-side refresh (`vscode-ext/src/session-state.ts`) both apply it — before resume-command detection, which is unaffected because resume patterns live at the tail. The sidecar's larger in-memory live-buffer cap (`standalone/sidecar/pty-core.js`) is unchanged. Source of truth: `lib/src/lib/scrollback-trim.ts`.
 
-Every saved-session entry point must pass through `readPersistedSession()`. That reader accepts both the canonical parsed object and a JSON-stringified session blob before validating/migrating; this covers host state APIs that may hand back the inner serialized JSON string.
+Every saved-session entry point must pass through `readPersistedSession()`. That reader accepts both the canonical parsed object and a JSON-stringified session blob before validating it (covering host state APIs that may hand back the inner serialized JSON string); a present-but-unreadable blob is logged and discarded so the caller starts fresh — a corrupt save can never block startup.
 
 ## Universal invariants
 
@@ -132,6 +132,6 @@ These rules apply to every adapter. Adapter-specific layering (deactivate orderi
 - **Shell login args are shell-specific.** The shared `pty-core.js` launches POSIX shells with `-l` only for shells that accept it. `csh`/`tcsh` must be spawned without `-l` so users whose login shell is C-shell-derived can open a usable terminal in any adapter.
 - **Scrollback trailing newline.** Restored scrollback must end with `\n` to avoid zsh printing a `%` artifact at the top of the terminal.
 - **Replay drops terminal replies only.** While saved output is being replayed into xterm.js, terminal-generated OSC/CSI/DCS query and focus reports are dropped so they do not enter the resumed/restored shell's input buffer. The replay filter must preserve user keyboard escape sequences, including arrows, function keys, and bracketed paste.
-- **Untouched defaults conservatively.** New saved panes include `untouched`. Older saved panes without the field are read as `untouched: false`, so legacy sessions still require kill confirmation.
+- **Untouched defaults conservatively.** New saved panes include `untouched`; a pane read without the field defaults to `untouched: false`, so it still requires kill confirmation.
 - **PTY ownership.** Each message router tracks the PTY ids it owns. A PTY routed to one webview must not be stolen by another router; new routers attaching to a host must respect existing ownership.
 - **Replay filtering does not re-fire alerts.** `pty:replay` re-injects buffered output into xterm.js but must not re-trigger `AlertManager`, activity-monitor events, or protocol notifications.
diff --git a/lib/src/components/Wall.test.tsx b/lib/src/components/Wall.test.tsx
index c777fac3..307390cd 100644
--- a/lib/src/components/Wall.test.tsx
+++ b/lib/src/components/Wall.test.tsx
@@ -115,10 +115,9 @@ describe('Wall on the Lath engine', () => {
     await flush();
     await flush();
 
-    const saved = fake.getState() as { version?: number; layout?: unknown; lathLayout?: { version?: number; leafMeta?: Record<string, unknown> } } | null;
+    const saved = fake.getState() as { version?: number; lathLayout?: { version?: number; leafMeta?: Record<string, unknown> } } | null;
     expect(saved).not.toBeNull();
     expect(saved!.version).toBe(3);
-    expect(saved!.layout).toBeUndefined();
     expect(saved!.lathLayout).toBeDefined();
     expect(saved!.lathLayout!.version).toBe(1);
     // The surviving pane is present in the Lath layout's leaf meta.
diff --git a/lib/src/components/Wall.tsx b/lib/src/components/Wall.tsx
index c291d8f9..f291cc47 100644
--- a/lib/src/components/Wall.tsx
+++ b/lib/src/components/Wall.tsx
@@ -60,7 +60,6 @@ import {
   createLathWallEngine,
   terminalLeafMeta,
   browserLeafMeta,
-  legacyTokenFromDoor,
   leafMetaFromDoor,
   edgeForDorDirection,
   directionForArrow,
@@ -186,9 +185,8 @@ export function Wall({
 }: {
   initialPaneIds?: string[];
   initialMode?: WallMode;
-  /** The restored Lath persisted layout — the session read boundary already
-   *  migrated any pre-Lath dockview save into this single channel
-   *  (docs/specs/tiling-engine.md → "Persistence and migration"). */
+  /** The restored Lath persisted layout (docs/specs/tiling-engine.md →
+   *  "Persistence"). */
   restoredLathLayout?: unknown;
   initialDoors?: PersistedDoor[];
   onEvent?: (event: WallEvent) => void;
@@ -493,12 +491,9 @@ export function Wall({
     const { token } = lath.store.removeLeaf(id); // may auto-spawn if this was the last leaf
     if (!token) return;
     clearSessionAttention(id);
-    // The Door's component/tabComponent are the leaf's own canonical meta (browser
-    // aliases are canonicalized at `leafMetaFromDoor`, so `reconnect.ts`'s `component
-    // === 'browser'` filter keys off them). The core token is the restore payload
-    // (docs/specs/tiling-engine.md → "Restore tokens"); the legacy `{neighborId,
-    // direction, remainingPaneIds, layoutAtMinimize}` fields are omitted — only pre-Lath
-    // doors carry them, read-only for migration.
+    // The Door's component/tabComponent are the leaf's own canonical meta, so
+    // `reconnect.ts`'s `component === 'browser'` filter keys off them. The core token
+    // is the restore payload (docs/specs/tiling-engine.md → "Restore tokens").
     const door: DooredItem = {
       id,
       title: persistedPanelTitle(meta.title),
@@ -634,17 +629,15 @@ export function Wall({
 
     // Restore through the core token (the real payload): exact tier when the
     // captured context survives, else neighbor, else fallback beside a live ref.
-    // A pre-Lath door has no token — synthesize a neighbor-tier one from its
-    // {neighborId, direction} so it restores beside its old neighbor.
     const meta = leafMetaFromDoor(item);
-    const token = (item.token as RestoreToken | undefined) ?? legacyTokenFromDoor(item);
+    const token = item.token as RestoreToken | undefined;
     // The enter hint (from the token's edge) is derived inside `restoreLeaf`.
     const sel = selectedIdRef.current;
     const fallbackRef = sel && selectedTypeRef.current === 'pane' && lath.store.has(sel)
       ? sel
       : lath.listPanes()[0]?.id;
-    const r = lath.store.restoreLeaf(meta, token, { fallbackRef });
-    // `!ok` means no fallback was possible (empty tree) — make the leaf the root.
+    const r = token ? lath.store.restoreLeaf(meta, token, { fallbackRef }) : { ok: false };
+    // No token (or no fallback was possible — empty tree): make the leaf the root.
     if (!r.ok) lath.store.addLeaf(item.id, meta, null);
 
     removeDoorAndSelect(item.id);
diff --git a/lib/src/components/wall/BrowserPanel.tsx b/lib/src/components/wall/BrowserPanel.tsx
index 3024a53d..266ce5f7 100644
--- a/lib/src/components/wall/BrowserPanel.tsx
+++ b/lib/src/components/wall/BrowserPanel.tsx
@@ -9,11 +9,9 @@
  * the renderer choice. The browser chrome each child registers is keyed by
  * `api.id`, so the shared header/modal are unaffected by which child is mounted.
  */
-import { useContext, useEffect } from 'react';
 import type { RenderMode } from './agent-browser-screen';
 import { resolveRenderMode } from './browser-surface';
 import type { PaneProps } from './pane-props';
-import { PaneWriteContext } from './wall-context';
 import { AgentBrowserPanel } from './AgentBrowserPanel';
 import { IframePanel } from './IframePanel';
 
@@ -29,24 +27,10 @@ export type BrowserPanelParams = {
   wsPort?: number;
   binaryPath?: string;
   syncEngaged?: boolean;
-  /** Legacy: surfaces persisted before `renderMode` existed stored pop-out as a
-   *  boolean alongside surfaceType 'iframe' | 'agent-browser'. Migrated below. */
-  poppedOut?: boolean;
 };
 
 export function BrowserPanel(props: PaneProps) {
-  const { params } = props;
-  const paneWrite = useContext(PaneWriteContext);
-  const renderMode = resolveRenderMode(params);
-
-  // Canonicalize a legacy layout once: write renderMode + surfaceType:'browser'
-  // so later reads and persistence use the unified shape (the children read
-  // renderMode from the prop below, so this is purely for the persisted blob).
-  useEffect(() => {
-    if (params?.renderMode === renderMode && params?.surfaceType === 'browser') return;
-    paneWrite.updateParams(props.id, { renderMode, surfaceType: 'browser' });
-  }, [paneWrite, props.id, params?.renderMode, params?.surfaceType, renderMode]);
-
+  const renderMode = resolveRenderMode(props.params);
   if (renderMode === 'iframe') return <IframePanel {...props} />;
   return <AgentBrowserPanel {...props} renderMode={renderMode} />;
 }
diff --git a/lib/src/components/wall/LathHost.tsx b/lib/src/components/wall/LathHost.tsx
index 86d20eb0..592a7ad6 100644
--- a/lib/src/components/wall/LathHost.tsx
+++ b/lib/src/components/wall/LathHost.tsx
@@ -61,13 +61,11 @@ export type LathComponentsOverride = {
   tabs?: Record<string, ComponentType<PaneProps>>;
 };
 
-// The same alias tables Wall.tsx uses: legacy `iframe` / `agent-browser` bodies
-// resolve to the unified BrowserPanel; `surface` headers to SurfacePaneHeader.
+// Body components keyed by `leafMeta.component`; `surface` headers to
+// SurfacePaneHeader. Every browser surface resolves to the unified BrowserPanel.
 const BODY_COMPONENTS: Record<string, ComponentType<PaneProps>> = {
   terminal: TerminalPanel,
   browser: BrowserPanel,
-  iframe: BrowserPanel,
-  'agent-browser': BrowserPanel,
 };
 const TAB_COMPONENTS: Record<string, ComponentType<PaneProps>> = {
   terminal: TerminalPaneHeader,
diff --git a/lib/src/components/wall/agent-browser-surface-controller.ts b/lib/src/components/wall/agent-browser-surface-controller.ts
index 396dcfbc..f0f14649 100644
--- a/lib/src/components/wall/agent-browser-surface-controller.ts
+++ b/lib/src/components/wall/agent-browser-surface-controller.ts
@@ -35,7 +35,6 @@ import {
   openAgentBrowserScreenModal,
 } from './agent-browser-screen';
 import { hostPathDisplay, tabDisplayTitle } from './browser-url';
-import { resolveRenderMode } from './browser-surface';
 import { clearAgentBrowserSessionClosed, isAgentBrowserSessionClosed } from './agent-browser-sessions';
 import {
   EDIT_OPS,
@@ -302,10 +301,9 @@ export class AgentBrowserSurfaceController {
     this.paramsKey = params.key ?? null;
     this.paramsSyncEngaged = params.syncEngaged;
     this.latestRestorableUrl = isRestorableUrl(params.url) ? params.url : undefined;
-    // poppedOut is derived from the canonical renderMode; fall back to resolving
-    // it from params for a direct mount (tests) or a legacy blob.
-    const seededMode = params.renderMode ?? resolveRenderMode(params);
-    this.poppedOut = seededMode === 'ab-popout';
+    // poppedOut is derived from the canonical renderMode; an unset mode (a direct
+    // mount in tests) is not popped out.
+    this.poppedOut = params.renderMode === 'ab-popout';
     // A fresh surface auto-engages sync (no persisted flag); a re-attached one
     // restores whatever was persisted into the layout blob.
     this.syncEngaged = params.syncEngaged ?? true;
diff --git a/lib/src/components/wall/browser-surface.ts b/lib/src/components/wall/browser-surface.ts
index b1fb5274..dca2544e 100644
--- a/lib/src/components/wall/browser-surface.ts
+++ b/lib/src/components/wall/browser-surface.ts
@@ -1,49 +1,36 @@
 /**
  * Browser-surface param classification — the single source of truth for "what
- * renderer does this pane use?" and "is this a browser pane at all?", including
- * migration of layouts persisted before `renderMode` existed (surfaceType
- * 'iframe' | 'agent-browser' + a `poppedOut` boolean). Used by the BrowserPanel
- * shell, the Wall (dispatch + lifecycle + CLI type), and the dev-server-port
- * correlation, so the classification never drifts between them.
+ * renderer does this pane use?" and "is this a browser pane at all?". Used by the
+ * BrowserPanel shell, the Wall (dispatch + lifecycle + CLI type), and the
+ * dev-server-port correlation, so the classification never drifts between them.
  */
 import type { RenderMode } from './agent-browser-screen';
 
 type BrowserParamsLike = {
   surfaceType?: unknown;
   renderMode?: unknown;
-  session?: unknown;
-  poppedOut?: unknown;
 };
 
 function asParams(params: unknown): BrowserParamsLike {
   return params && typeof params === 'object' ? (params as BrowserParamsLike) : {};
 }
 
-/** Resolve the canonical render mode, migrating a legacy layout blob. */
+/** Resolve the canonical render mode; defaults to `iframe` when unset. */
 export function resolveRenderMode(params: unknown): RenderMode {
   const p = asParams(params);
-  if (p.renderMode === 'ab-screencast' || p.renderMode === 'ab-popout' || p.renderMode === 'iframe') {
-    return p.renderMode;
-  }
-  if (p.surfaceType === 'iframe') return 'iframe';
-  if (p.surfaceType === 'agent-browser' || typeof p.session === 'string') {
-    return p.poppedOut ? 'ab-popout' : 'ab-screencast';
-  }
-  return 'iframe';
+  return p.renderMode === 'ab-screencast' || p.renderMode === 'ab-popout' ? p.renderMode : 'iframe';
 }
 
 /** Whether params describe an agent-browser-rendered surface (ab-screencast /
- *  ab-popout, or a legacy agent-browser blob). */
+ *  ab-popout). */
 export function isAgentBrowserParams(params: unknown): boolean {
   const p = asParams(params);
-  return p.renderMode === 'ab-screencast' || p.renderMode === 'ab-popout' || p.surfaceType === 'agent-browser';
+  return p.renderMode === 'ab-screencast' || p.renderMode === 'ab-popout';
 }
 
 /** Whether params describe any browser surface (vs a terminal): the unified
- *  'browser' type, a legacy iframe/agent-browser blob, or anything carrying a
- *  renderMode. */
+ *  'browser' type, or anything carrying a renderMode. */
 export function isBrowserParams(params: unknown): boolean {
   const p = asParams(params);
-  return p.surfaceType === 'browser' || p.surfaceType === 'iframe'
-    || p.surfaceType === 'agent-browser' || typeof p.renderMode === 'string';
+  return p.surfaceType === 'browser' || typeof p.renderMode === 'string';
 }
diff --git a/lib/src/components/wall/lath-wall-engine.test.ts b/lib/src/components/wall/lath-wall-engine.test.ts
index bd078320..eb27a9cc 100644
--- a/lib/src/components/wall/lath-wall-engine.test.ts
+++ b/lib/src/components/wall/lath-wall-engine.test.ts
@@ -3,10 +3,8 @@ import {
   createLathWallEngine,
   edgeForDorDirection,
   dorDirectionForEdge,
-  edgeForDoorDirection,
   directionForArrow,
   leafMetaFromDoor,
-  legacyTokenFromDoor,
 } from './lath-wall-engine';
 import type { DooredItem } from './wall-types';
 import { leaves } from '../../lib/lath/model';
@@ -64,13 +62,6 @@ describe('lath-wall-engine edge/direction maps', () => {
     expect(dorDirectionForEdge('left')).toBe('left');
   });
 
-  it('maps door directions to lath edges', () => {
-    expect(edgeForDoorDirection('above')).toBe('top');
-    expect(edgeForDoorDirection('below')).toBe('bottom');
-    expect(edgeForDoorDirection('right')).toBe('right');
-    expect(edgeForDoorDirection('left')).toBe('left');
-  });
-
   it('maps keyboard arrows to lath directions', () => {
     expect(directionForArrow('ArrowLeft')).toBe('left');
     expect(directionForArrow('ArrowRight')).toBe('right');
@@ -82,61 +73,11 @@ describe('lath-wall-engine edge/direction maps', () => {
 describe('leafMetaFromDoor', () => {
   const base: DooredItem = { id: 'door-1', title: 'Door' } as DooredItem;
 
-  it('canonicalizes legacy iframe/agent-browser component aliases to browser', () => {
-    expect(leafMetaFromDoor({ ...base, component: 'iframe' }).component).toBe('browser');
-    expect(leafMetaFromDoor({ ...base, component: 'agent-browser' }).component).toBe('browser');
-  });
-
   it('passes browser/terminal through and defaults an absent component to terminal', () => {
     expect(leafMetaFromDoor({ ...base, component: 'browser' }).component).toBe('browser');
     expect(leafMetaFromDoor({ ...base, component: 'terminal' }).component).toBe('terminal');
     expect(leafMetaFromDoor(base).component).toBe('terminal');
   });
-
-  it('minimizing a reattached legacy-alias door persists component "browser"', () => {
-    // A pre-Lath door carrying the legacy `iframe` alias reattaches (leaf meta is
-    // canonicalized here), so a subsequent minimize — which reads `meta.component`
-    // straight through — persists the canonical `browser` value `reconnect.ts` filters on.
-    const engine = createLathWallEngine();
-    engine.seed(null, ['p1'], () => 'gen');
-    const meta = leafMetaFromDoor({ ...base, id: 'legacy', component: 'iframe', params: { renderMode: 'iframe', url: 'x' } });
-    engine.store.addLeaf('legacy', meta, { refId: 'p1', edge: 'right' });
-    expect(engine.getMeta('legacy')?.component).toBe('browser');
-  });
-});
-
-describe('legacyTokenFromDoor', () => {
-  function door(overrides: Partial<DooredItem>): DooredItem {
-    return {
-      id: 'door-1',
-      title: 'Door',
-      neighborId: 'pane-x',
-      direction: 'right',
-      remainingPaneIds: [],
-      layoutAtMinimize: null,
-      layoutAtMinimizeSignature: '',
-      ...overrides,
-    } as DooredItem;
-  }
-
-  it('synthesizes a neighbor-tier token (no fingerprint) from {neighborId, direction}', () => {
-    const token = legacyTokenFromDoor(door({ neighborId: 'pane-x', direction: 'below' }));
-    expect(token).toEqual({
-      leafId: 'door-1',
-      weight: 0.5,
-      siblingId: 'pane-x',
-      edge: 'bottom', // 'below' → 'bottom'
-      index: 0,
-      fingerprint: null,
-    });
-  });
-
-  it('carries a null neighbor (fallback tier at restore time)', () => {
-    const token = legacyTokenFromDoor(door({ neighborId: null, direction: 'right' }));
-    expect(token.siblingId).toBeNull();
-    expect(token.edge).toBe('right');
-    expect(token.fingerprint).toBeNull();
-  });
 });
 
 describe('lath-wall-engine listPanes projection', () => {
diff --git a/lib/src/components/wall/lath-wall-engine.ts b/lib/src/components/wall/lath-wall-engine.ts
index 85fcebf8..94b84dc5 100644
--- a/lib/src/components/wall/lath-wall-engine.ts
+++ b/lib/src/components/wall/lath-wall-engine.ts
@@ -2,10 +2,10 @@
 // and engine"). The store (`lath-wall-store.ts`) is the state machine + geometry +
 // enter hints; the engine layers presentation, vocabulary, and persistence
 // conveniences over it — the animator (entry/exit/tween + dying state), the
-// pane-list / meta projections, the dor-direction ↔ Edge ↔ Door-direction maps, the
-// leaf-meta builders, the legacy-Door → neighbor-tier token bridge, and the
-// hydration `seed` + `serializeLayout`. Every state op and geometry query
-// goes straight to `lath.store.*`; the engine no longer re-exports them.
+// pane-list / meta projections, the dor-direction ↔ Edge maps, the leaf-meta
+// builders, and the hydration `seed` + `serializeLayout`. Every state op and
+// geometry query goes straight to `lath.store.*`; the engine no longer re-exports
+// them.
 //
 // The engine holds NO selection/focus/mode/activation state — those stay in the Wall.
 
@@ -17,7 +17,6 @@ import {
   validate,
 } from '../../lib/lath/model';
 import type { Direction } from '../../lib/lath/layout';
-import type { RestoreToken } from '../../lib/lath/ops';
 import {
   type LathAnimator,
   LATH_EASING,
@@ -27,7 +26,6 @@ import {
 import { prefersReducedMotion } from '../../lib/ui-geometry';
 import { UNNAMED_PANEL_TITLE } from '../../lib/terminal-registry';
 import type { ResolvedSplitDirection as DorResolvedSplitDirection } from 'dor/commands/types';
-import type { DoorDirection } from '../../lib/session-types';
 import {
   type LathWallSnapshot,
   type LathWallStore,
@@ -76,21 +74,6 @@ export function dorDirectionForEdge(edge: Edge): DorResolvedSplitDirection {
   }
 }
 
-/** Door direction → Lath edge (Baseboard placement token, matching session-types'
- *  `DoorDirection`); used to synthesize a neighbor-tier token from a pre-Lath Door. */
-export function edgeForDoorDirection(direction: DoorDirection): Edge {
-  switch (direction) {
-    case 'left':
-      return 'left';
-    case 'right':
-      return 'right';
-    case 'above':
-      return 'top';
-    case 'below':
-      return 'bottom';
-  }
-}
-
 /** Keyboard arrow → Lath spatial direction. */
 export function directionForArrow(key: 'ArrowLeft' | 'ArrowRight' | 'ArrowUp' | 'ArrowDown'): Direction {
   switch (key) {
@@ -118,39 +101,16 @@ export function browserLeafMeta(title: string, params: Record<string, unknown>):
 
 /** The engine-tracked meta for a Door's surface. Shared by the two reattach paths —
  *  click-reattach (`restore`) and drag-out (`insert`) — so they build the same shape.
- *  Legacy `'iframe'` / `'agent-browser'` component aliases are canonicalized to
- *  `'browser'` here, so a leaf always carries the canonical body key: a re-minimize
- *  reads `meta.component` straight through, and `reconnect.ts`'s `component ===
- *  'browser'` filter keys off it. Component/tabComponent default to terminal for
- *  pre-Lath doors that carry neither. */
+ *  Component/tabComponent default to terminal for a door that carries neither. */
 export function leafMetaFromDoor(item: DooredItem): LeafMeta {
-  const component = item.component === 'iframe' || item.component === 'agent-browser'
-    ? 'browser'
-    : item.component ?? 'terminal';
   return {
-    component,
+    component: item.component ?? 'terminal',
     tabComponent: item.tabComponent ?? 'terminal',
     title: item.title,
     params: item.params,
   };
 }
 
-/** Synthesize a neighbor-tier restore token for a Door persisted before Lath (no
- *  core `token`): no fingerprint (skips the exact tier), the sibling + edge reproduce
- *  the original split beside the neighbor, weight 0.5, index 0. Missing legacy fields
- *  degrade gracefully — an absent `neighborId` (null sibling) falls to the fallback
- *  tier at restore, and an absent `direction` defaults to `'right'`. */
-export function legacyTokenFromDoor(item: DooredItem): RestoreToken {
-  return {
-    leafId: item.id,
-    weight: 0.5,
-    siblingId: item.neighborId ?? null,
-    edge: edgeForDoorDirection(item.direction ?? 'right'),
-    index: 0,
-    fingerprint: null,
-  };
-}
-
 export type LathWallEngine = {
   /** The underlying headless store — the state machine + geometry every state op and
    *  query goes through directly (`lath.store.*`), and the reader LathHost + the
@@ -186,11 +146,10 @@ export type LathWallEngine = {
   // --- persistence ---
   serializeLayout(): LathPersistedLayout;
 
-  /** Hydration: a persisted Lath layout when usable (pre-Lath saves were already
-   *  migrated into one at the session read boundary — `session-restore.ts`), else a
-   *  fresh tree from `initialPaneIds` (or one generated id). Returns the resulting
-   *  pane ids (pre-order) and whether the fresh path was taken (so the Wall knows
-   *  to prime default-shell opts, mirroring `addTerminalPanel`). */
+  /** Hydration: a persisted Lath layout when usable, else a fresh tree from
+   *  `initialPaneIds` (or one generated id). Returns the resulting pane ids
+   *  (pre-order) and whether the fresh path was taken (so the Wall knows to prime
+   *  default-shell opts, mirroring `addTerminalPanel`). */
   seed(
     lathBlob: unknown,
     initialPaneIds: string[] | undefined,
diff --git a/lib/src/components/wall/wall-types.ts b/lib/src/components/wall/wall-types.ts
index b74c36d6..63140015 100644
--- a/lib/src/components/wall/wall-types.ts
+++ b/lib/src/components/wall/wall-types.ts
@@ -1,8 +1,7 @@
 import type { PersistedDoor } from '../../lib/session-types';
 
-/** A minimized surface's baseboard chip. Identical to its persisted form; new doors
- *  carry a Lath restore `token`, pre-Lath doors carry the legacy `{neighborId,
- *  direction, ...}` fields (read-only for migration). */
+/** A minimized surface's baseboard chip. Identical to its persisted form; each door
+ *  carries a Lath restore `token`. */
 export type DooredItem = PersistedDoor;
 
 /** The visible-pane projection (`lath.listPanes()`). Shared by the Wall helpers,
diff --git a/lib/src/lib/alert-manager.ts b/lib/src/lib/alert-manager.ts
index 11f5d929..faaa3f59 100644
--- a/lib/src/lib/alert-manager.ts
+++ b/lib/src/lib/alert-manager.ts
@@ -44,16 +44,6 @@ interface CommandExitWatch {
   seenWithAttentionAt: number | null;
 }
 
-/** Migrate legacy persisted TodoState values (numeric, string, boolean) to a boolean. */
-export function migrateTodoState(todo: unknown): TodoState {
-  if (typeof todo === 'boolean') return todo;
-  // v2 numeric encoding: -1 = off, [0,1] = soft, 2 = hard
-  if (typeof todo === 'number') return Number.isFinite(todo) && (todo === 2 || (todo >= 0 && todo <= 1));
-  // v1 string encoding: 'soft' | 'hard' | false
-  if (todo === 'hard' || todo === 'soft') return true;
-  return false;
-}
-
 export function normalizeActivityNotification(value: unknown): ActivityNotification | null {
   if (!value || typeof value !== 'object' || Array.isArray(value)) return null;
   const record = value as Record<string, unknown>;
@@ -628,7 +618,7 @@ export class AlertManager {
    */
   seed(id: string, state: { status: string; todo: unknown; notification?: unknown; watchingEnabled?: unknown }): void {
     const entry = this.getOrCreateEntry(id);
-    entry.todo = migrateTodoState(state.todo);
+    entry.todo = state.todo === true;
     entry.notification = entry.todo ? normalizeActivityNotification(state.notification) : null;
     entry.protocolStatus = 'IDLE';
     entry.progress = null;
@@ -638,9 +628,7 @@ export class AlertManager {
 
     const watchingEnabled = typeof state.watchingEnabled === 'boolean'
       ? state.watchingEnabled
-      // Accept legacy persisted ALERT_DISABLED as the old name for WATCHING_DISABLED.
       : state.status !== 'WATCHING_DISABLED'
-        && state.status !== 'ALERT_DISABLED'
         && state.status !== 'OSC_NOTIF_BUSY'
         && state.status !== 'COMMAND_EXIT_ARMED';
     if (watchingEnabled) {
diff --git a/lib/src/lib/lath/dockview-convert.test.ts b/lib/src/lib/lath/dockview-convert.test.ts
deleted file mode 100644
index c2470223..00000000
--- a/lib/src/lib/lath/dockview-convert.test.ts
+++ /dev/null
@@ -1,129 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { dockviewLayoutToLath } from './dockview-convert';
-import { validate, type LathNode } from './model';
-import { dockviewFixture, leafMeta as makeLeafMeta } from './test-fixtures';
-
-describe('dockviewLayoutToLath — real-shaped blob', () => {
-  it('maps orientation-by-depth to split dirs, sizes to normalized weights, panels to meta', () => {
-    const layout = dockviewLayoutToLath(dockviewFixture());
-    expect(layout).not.toBeNull();
-    const { tree, leafMeta } = layout!;
-
-    // Root HORIZONTAL branch → 'row'; nested branch (orthogonal) → 'col'.
-    expect(tree.root?.kind).toBe('split');
-    const root = tree.root as Extract<LathNode, { kind: 'split' }>;
-    expect(root.dir).toBe('row');
-    // sizes 600 / 400 → weights 0.6 / 0.4.
-    expect(root.children[0].weight).toBeCloseTo(0.6, 5);
-    expect(root.children[1].weight).toBeCloseTo(0.4, 5);
-    expect(root.children[0].node).toEqual({ kind: 'leaf', id: 'pane-a' });
-
-    const nested = root.children[1].node as Extract<LathNode, { kind: 'split' }>;
-    expect(nested.dir).toBe('col');
-    // sizes 300 / 500 → weights 0.375 / 0.625.
-    expect(nested.children[0].weight).toBeCloseTo(0.375, 5);
-    expect(nested.children[1].weight).toBeCloseTo(0.625, 5);
-
-    expect(leafMeta['pane-a']).toEqual(makeLeafMeta({ component: 'terminal', title: 'A' }));
-    expect(leafMeta['pane-b']).toEqual(makeLeafMeta({ component: 'browser', title: 'B', params: { renderMode: 'iframe', url: 'https://example.com' } }));
-    expect(leafMeta['pane-c']).toEqual(makeLeafMeta({ component: 'terminal', title: 'C' }));
-
-    expect(validate(tree)).toEqual([]);
-  });
-});
-
-describe('dockviewLayoutToLath — legacy alias mapping', () => {
-  it('maps iframe / agent-browser content components to the unified browser body', () => {
-    const blob = {
-      grid: {
-        root: {
-          type: 'branch',
-          data: [
-            { type: 'leaf', data: { id: 'g1', views: ['p1'] }, size: 1 },
-            { type: 'leaf', data: { id: 'g2', views: ['p2'] }, size: 1 },
-          ],
-          size: 1,
-        },
-        width: 100,
-        height: 100,
-        orientation: 'HORIZONTAL',
-      },
-      panels: {
-        p1: { id: 'p1', contentComponent: 'iframe', title: 'legacy iframe' },
-        p2: { id: 'p2', contentComponent: 'agent-browser', title: 'legacy ab' },
-      },
-    };
-    const layout = dockviewLayoutToLath(blob)!;
-    expect(layout.leafMeta['p1'].component).toBe('browser');
-    // No explicit tabComponent → defaults to 'surface' for a browser body.
-    expect(layout.leafMeta['p1'].tabComponent).toBe('surface');
-    expect(layout.leafMeta['p2'].component).toBe('browser');
-  });
-});
-
-describe('dockviewLayoutToLath — multi-view group degradation', () => {
-  it('degrades an n-view group to one leaf per view (Dormouse never tab-stacks)', () => {
-    const blob = {
-      grid: {
-        root: {
-          type: 'branch',
-          data: [
-            { type: 'leaf', data: { id: 'g1', views: ['solo'] }, size: 500 },
-            { type: 'leaf', data: { id: 'g2', views: ['v1', 'v2'] }, size: 500 },
-          ],
-          size: 800,
-        },
-        width: 1000,
-        height: 800,
-        orientation: 'HORIZONTAL',
-      },
-      panels: {
-        solo: { id: 'solo', contentComponent: 'terminal' },
-        v1: { id: 'v1', contentComponent: 'terminal' },
-        v2: { id: 'v2', contentComponent: 'terminal' },
-      },
-    };
-    const layout = dockviewLayoutToLath(blob)!;
-    expect(new Set(Object.keys(layout.leafMeta))).toEqual(new Set(['solo', 'v1', 'v2']));
-    const root = layout.tree.root as Extract<LathNode, { kind: 'split' }>;
-    // solo stays a leaf; the 2-view group becomes a split of its two views.
-    expect(root.children[0].node).toEqual({ kind: 'leaf', id: 'solo' });
-    expect(root.children[1].node.kind).toBe('split');
-    expect(validate(layout.tree)).toEqual([]);
-  });
-});
-
-describe('dockviewLayoutToLath — malformed blobs', () => {
-  it.each([
-    ['null', null],
-    ['undefined', undefined],
-    ['a string', 'nope'],
-    ['no grid', {}],
-    ['no root', { grid: { width: 1, height: 1, orientation: 'HORIZONTAL' } }],
-    ['empty branch', { grid: { root: { type: 'branch', data: [] }, width: 1, height: 1, orientation: 'HORIZONTAL' } }],
-    ['empty group', { grid: { root: { type: 'leaf', data: { id: 'g', views: [] } }, width: 1, height: 1, orientation: 'HORIZONTAL' } }],
-    ['bad node type', { grid: { root: { type: 'weird', data: [] }, width: 1, height: 1, orientation: 'HORIZONTAL' } }],
-  ])('returns null for %s', (_label, blob) => {
-    expect(dockviewLayoutToLath(blob)).toBeNull();
-  });
-
-  it('returns null when the tree fails validation (duplicate leaf ids)', () => {
-    const blob = {
-      grid: {
-        root: {
-          type: 'branch',
-          data: [
-            { type: 'leaf', data: { id: 'g1', views: ['dup'] }, size: 1 },
-            { type: 'leaf', data: { id: 'g2', views: ['dup'] }, size: 1 },
-          ],
-          size: 1,
-        },
-        width: 1,
-        height: 1,
-        orientation: 'HORIZONTAL',
-      },
-      panels: { dup: { id: 'dup', contentComponent: 'terminal' } },
-    };
-    expect(dockviewLayoutToLath(blob)).toBeNull();
-  });
-});
diff --git a/lib/src/lib/lath/dockview-convert.ts b/lib/src/lib/lath/dockview-convert.ts
deleted file mode 100644
index 033d27f7..00000000
--- a/lib/src/lib/lath/dockview-convert.ts
+++ /dev/null
@@ -1,169 +0,0 @@
-// The legacy dockview → Lath layout upgrade reader (docs/specs/tiling-engine.md →
-// "Persistence and migration"). Lath is the sole layout format Dormouse writes; this
-// module exists only to migrate a `SerializedDockview` blob persisted by a pre-Lath
-// build one-way into a Lath tree, once, at the session read boundary
-// (`session-restore.ts`'s `persistedLathLayout`). It models the serialized dockview
-// shape with LOCAL structural types (no dockview dependency).
-//
-// dockview's serialized grid stores orientation only at the root (`grid.orientation`)
-// and *alternates it per depth*: a branch node lays its children along its own
-// orientation, and its child branches take the orthogonal orientation. A HORIZONTAL
-// branch lays children left→right → a Lath `'row'` split; VERTICAL → `'col'`. Because
-// Lath's `normalize` forbids a split directly containing a same-direction split, a
-// normalized Lath tree's dirs already strictly alternate by depth, so the two models
-// line up level-for-level.
-
-import { type LathChild, type LathNode, type LathTree, leaves, normalize, validate } from './model';
-import type { LathPersistedLayout, LeafMeta } from './persistence';
-
-type Orientation = 'HORIZONTAL' | 'VERTICAL';
-
-// --- local structural models of the serialized dockview shape (read-only) ---
-
-/** A dockview leaf group's state (its un-exported `GroupPanelViewState`). */
-type GroupState = { views: string[]; activeView?: string; id: string };
-
-/** One serialized grid object: a leaf group or a branch of them. */
-type GridNodeLike = { type?: string; data?: unknown; size?: number };
-
-/** The per-panel state in a serialized blob's flat `panels` map. */
-type PanelStateLike = {
-  id?: string;
-  contentComponent?: string;
-  tabComponent?: string;
-  title?: unknown;
-  params?: unknown;
-};
-
-/** A serialized dockview layout blob (the subset the migration reads). */
-type SerializedDockviewLike = {
-  grid?: { root?: unknown; orientation?: unknown };
-  panels?: Record<string, PanelStateLike>;
-};
-
-function orthogonal(o: Orientation): Orientation {
-  return o === 'HORIZONTAL' ? 'VERTICAL' : 'HORIZONTAL';
-}
-
-function dirOf(o: Orientation): 'row' | 'col' {
-  return o === 'HORIZONTAL' ? 'row' : 'col';
-}
-
-// --- component / tab kind aliasing (matches the LathHost component tables) ---
-
-/** Normalize a dockview `contentComponent` to a Lath body key: the legacy `iframe`
- *  / `agent-browser` names and `browser` all collapse to `'browser'`; everything
- *  else (and absence) is a terminal. */
-function componentKind(contentComponent: string | undefined): 'terminal' | 'browser' {
-  return contentComponent === 'browser' ||
-    contentComponent === 'iframe' ||
-    contentComponent === 'agent-browser'
-    ? 'browser'
-    : 'terminal';
-}
-
-/** Resolve the header key: an explicit `terminal` / `surface` wins; otherwise it
- *  defaults by body kind (browser → `surface`, terminal → `terminal`). */
-function tabKind(component: 'terminal' | 'browser', tabComponent: string | undefined): string {
-  if (tabComponent === 'terminal' || tabComponent === 'surface') return tabComponent;
-  return component === 'browser' ? 'surface' : 'terminal';
-}
-
-function metaFromPanel(panel: PanelStateLike | undefined): LeafMeta {
-  const component = componentKind(panel?.contentComponent);
-  return {
-    component,
-    tabComponent: tabKind(component, panel?.tabComponent),
-    title: typeof panel?.title === 'string' ? panel.title : '',
-    // `params` is preserved verbatim (renderMode, url, session, …).
-    params: panel?.params && typeof panel.params === 'object' ? { ...(panel.params as Record<string, unknown>) } : undefined,
-  };
-}
-
-// --- dockview → Lath (defensive against any malformed blob) ---
-
-/** Weights from sibling `size` values, normalized to sum 1. If any size is missing
- *  or non-positive the whole group falls back to equal weights — keeping every
- *  weight strictly positive (the Lath invariant) rather than emitting a zero. */
-function weightsFromSizes(sizes: Array<number | undefined>): number[] {
-  const n = sizes.length;
-  const allPositive = sizes.every((s) => typeof s === 'number' && s > 0);
-  if (!allPositive) return new Array<number>(n).fill(1 / n);
-  const sum = (sizes as number[]).reduce((a, b) => a + b, 0);
-  return (sizes as number[]).map((s) => s / sum);
-}
-
-/** Convert one serialized grid object (leaf group or branch) at a known depth
- *  orientation into a Lath node, appending each view's meta into `leafMeta`.
- *  Returns null for an empty subtree; throws are caught by the top-level loader. */
-function convertObj(
-  obj: GridNodeLike | null | undefined,
-  orientation: Orientation,
-  panels: Record<string, PanelStateLike>,
-  leafMeta: Record<string, LeafMeta>,
-): LathNode | null {
-  if (obj == null || typeof obj !== 'object') return null;
-
-  if (obj.type === 'leaf') {
-    const data = obj.data as GroupState;
-    const views = Array.isArray(data?.views) ? data.views.filter((v): v is string => typeof v === 'string') : [];
-    if (views.length === 0) return null;
-    for (const viewId of views) leafMeta[viewId] = metaFromPanel(panels[viewId]);
-    if (views.length === 1) return { kind: 'leaf', id: views[0] };
-    // Dormouse never tab-stacks; a multi-view group degrades to an even split
-    // along the branch axis at this depth (one Lath leaf per view).
-    const children: LathChild[] = views.map((id) => ({ node: { kind: 'leaf', id }, weight: 1 / views.length }));
-    return { kind: 'split', dir: dirOf(orientation), children };
-  }
-
-  if (obj.type === 'branch') {
-    const raw = Array.isArray(obj.data) ? (obj.data as GridNodeLike[]) : [];
-    const converted = raw.map((child) => ({
-      node: convertObj(child, orthogonal(orientation), panels, leafMeta),
-      size: typeof child?.size === 'number' ? child.size : undefined,
-    }));
-    const kept = converted.filter((c): c is { node: LathNode; size: number | undefined } => c.node !== null);
-    if (kept.length === 0) return null;
-    if (kept.length === 1) return kept[0].node;
-    const weights = weightsFromSizes(kept.map((k) => k.size));
-    const children: LathChild[] = kept.map((k, i) => ({ node: k.node, weight: weights[i] }));
-    return { kind: 'split', dir: dirOf(orientation), children };
-  }
-
-  return null;
-}
-
-/** Migrate a legacy `SerializedDockview` blob to a Lath layout, or null if it is not
- *  a usable dockview blob (callers fall back to fresh panes). The built tree is run
- *  through `normalize` + `validate`; a tree that still fails validation returns null. */
-export function dockviewLayoutToLath(blob: unknown): LathPersistedLayout | null {
-  try {
-    if (blob == null || typeof blob !== 'object') return null;
-    const dv = blob as SerializedDockviewLike;
-    const grid = dv.grid;
-    if (!grid || typeof grid !== 'object' || grid.root == null || typeof grid.root !== 'object') return null;
-    const orientation: Orientation = grid.orientation === 'VERTICAL' ? 'VERTICAL' : 'HORIZONTAL';
-    const panels = (dv.panels && typeof dv.panels === 'object' ? dv.panels : {}) as Record<string, PanelStateLike>;
-
-    const leafMeta: Record<string, LeafMeta> = {};
-    const converted = convertObj(grid.root as GridNodeLike, orientation, panels, leafMeta);
-    // A blob that converts to nothing usable (bad node types, empty groups, an
-    // empty grid) is treated as malformed — a real dockview layout always has ≥1
-    // pane, and the caller falls back to fresh panes on null.
-    if (converted === null) return null;
-    const normalized = normalize(converted);
-    if (normalized === null) return null;
-    const tree: LathTree = { root: normalized };
-
-    const errors = validate(tree);
-    if (errors.length > 0) return null;
-
-    // Drop meta for any view that did not survive into the tree (defensive).
-    const live = new Set(leaves(tree));
-    for (const id of Object.keys(leafMeta)) if (!live.has(id)) delete leafMeta[id];
-
-    return { version: 1, tree, leafMeta };
-  } catch {
-    return null;
-  }
-}
diff --git a/lib/src/lib/lath/persistence.ts b/lib/src/lib/lath/persistence.ts
index 254f76d8..f34bbfa1 100644
--- a/lib/src/lib/lath/persistence.ts
+++ b/lib/src/lib/lath/persistence.ts
@@ -1,10 +1,9 @@
 // The Lath persisted-layout wire format and its reader/writer (docs/specs/
-// tiling-engine.md → "Persistence and migration"). Plain data over the core model:
+// tiling-engine.md → "Persistence"). Plain data over the core model:
 // `lathLayoutFromStore` snapshots the wall store into the on-disk blob, and
 // `isLathPersistedLayout` recognizes one at the session read boundary
-// (`session-restore.ts`). The legacy dockview reader (`dockview-convert.ts`) emits
-// this shape; the engine (`lath-wall-engine.ts`) owns `serializeLayout`/`seed`,
-// which call through here.
+// (`session-restore.ts`). The engine (`lath-wall-engine.ts`) owns
+// `serializeLayout`/`seed`, which call through here.
 
 import type { LathTree } from './model';
 
@@ -12,9 +11,7 @@ import type { LathTree } from './model';
  *  "read side", owned live by the wall store's `leafMeta` map and serialized
  *  verbatim inside the persisted Lath layout. */
 export type LeafMeta = {
-  /** Body component key — `'terminal'` | `'browser'` (legacy `'iframe'` /
-   *  `'agent-browser'` aliases are resolved to `'browser'` at conversion time and
-   *  again at render time). */
+  /** Body component key — `'terminal'` | `'browser'`. */
   component: string;
   /** Header component key — `'terminal'` | `'surface'`. */
   tabComponent: string;
diff --git a/lib/src/lib/lath/test-fixtures.ts b/lib/src/lib/lath/test-fixtures.ts
index 13f69418..4e7580a7 100644
--- a/lib/src/lib/lath/test-fixtures.ts
+++ b/lib/src/lib/lath/test-fixtures.ts
@@ -1,6 +1,5 @@
 // Shared fixtures for the Lath wall tests: the `leafMeta` builder every suite uses to
-// stamp per-leaf metadata, and a hand-written SerializedDockview blob for the
-// persistence/migration tests.
+// stamp per-leaf metadata.
 
 import type { LeafMeta } from './persistence';
 
@@ -21,46 +20,3 @@ export function leafMeta(overrides: {
     ...(overrides.params ? { params: overrides.params } : {}),
   };
 }
-
-// The dockview fixture matches dockview-core's serialized shape: grid.orientation is
-// the ROOT orientation; a HORIZONTAL branch lays children left→right; each child's
-// `size` is its extent along the parent axis; a leaf `data` is a group ({ id, views,
-// activeView }); the per-panel state lives in the flat `panels` map. Returned as
-// `unknown` so callers cast/pass it as their assertion needs.
-export function dockviewFixture(): unknown {
-  return {
-    grid: {
-      root: {
-        type: 'branch',
-        data: [
-          { type: 'leaf', data: { id: 'group-1', views: ['pane-a'], activeView: 'pane-a' }, size: 600 },
-          {
-            type: 'branch',
-            data: [
-              { type: 'leaf', data: { id: 'group-2', views: ['pane-b'], activeView: 'pane-b' }, size: 300 },
-              { type: 'leaf', data: { id: 'group-3', views: ['pane-c'], activeView: 'pane-c' }, size: 500 },
-            ],
-            size: 400,
-          },
-        ],
-        size: 800,
-      },
-      width: 1000,
-      height: 800,
-      orientation: 'HORIZONTAL',
-    },
-    panels: {
-      'pane-a': { id: 'pane-a', contentComponent: 'terminal', tabComponent: 'terminal', title: 'A' },
-      'pane-b': {
-        id: 'pane-b',
-        contentComponent: 'browser',
-        tabComponent: 'surface',
-        title: 'B',
-        renderer: 'always',
-        params: { renderMode: 'iframe', url: 'https://example.com' },
-      },
-      'pane-c': { id: 'pane-c', contentComponent: 'terminal', tabComponent: 'terminal', title: 'C' },
-    },
-    activeGroup: 'group-1',
-  };
-}
diff --git a/lib/src/lib/reconnect.test.ts b/lib/src/lib/reconnect.test.ts
index 8982435f..4052caf0 100644
--- a/lib/src/lib/reconnect.test.ts
+++ b/lib/src/lib/reconnect.test.ts
@@ -15,7 +15,6 @@ vi.mock('./terminal-registry', () => ({
 }));
 
 import { resumeOrRestore } from './reconnect';
-import { dockviewFixture } from './lath/test-fixtures';
 import type { LathNode } from './lath/model';
 
 /** A native Lath persisted layout over `ids` (row split; empty tree for none) —
@@ -92,11 +91,6 @@ describe('resumeOrRestore', () => {
     const doors = [{
       id: 'pane-c',
       title: 'Pane C',
-      neighborId: 'pane-b',
-      direction: 'right' as const,
-      remainingPaneIds: ['pane-a', 'pane-b'],
-      layoutAtMinimize: { panels: {} },
-      layoutAtMinimizeSignature: 'sig',
     }];
     const saved: PersistedSession = {
       version: 3,
@@ -195,11 +189,6 @@ describe('resumeOrRestore', () => {
       doors: [{
         id: 'pane-a',
         title: 'Renamed Door',
-        neighborId: null,
-        direction: 'right',
-        remainingPaneIds: [],
-        layoutAtMinimize: { panels: {} },
-        layoutAtMinimizeSignature: 'sig',
       }],
       panes: [
         { id: 'pane-a', title: 'Renamed Door', cwd: null, scrollback: null, resumeCommand: null },
@@ -243,19 +232,9 @@ describe('resumeOrRestore', () => {
     const doors = [{
       id: 'pane-a',
       title: 'Pane A',
-      neighborId: 'pane-b',
-      direction: 'right' as const,
-      remainingPaneIds: ['pane-b'],
-      layoutAtMinimize: { panels: { 'pane-b': {} } },
-      layoutAtMinimizeSignature: 'sig-a',
     }, {
       id: 'pane-b',
       title: 'Pane B',
-      neighborId: 'pane-a',
-      direction: 'left' as const,
-      remainingPaneIds: ['pane-a'],
-      layoutAtMinimize: { panels: { 'pane-a': {} } },
-      layoutAtMinimizeSignature: 'sig-b',
     }];
     const saved: PersistedSession = {
       version: 3,
@@ -393,11 +372,6 @@ describe('resumeOrRestore', () => {
       title: 'localhost',
       component: 'browser',
       params: { surfaceType: 'browser', renderMode: 'iframe', url: 'http://localhost:5173' },
-      neighborId: 'pane-term',
-      direction: 'right' as const,
-      remainingPaneIds: ['pane-term'],
-      layoutAtMinimize: { panels: {} },
-      layoutAtMinimizeSignature: 'sig',
     }];
     const saved: PersistedSession = {
       version: 3,
@@ -419,27 +393,4 @@ describe('resumeOrRestore', () => {
       lathLayout,
     });
   });
-
-  it('migrates a pre-Lath dockview layout at the read boundary during live resume', async () => {
-    // A pre-Lath save carries only the legacy dockview `layout` blob; the resume plan
-    // must hand back the single migrated Lath channel, gated on the same leaf set.
-    const saved: PersistedSession = {
-      version: 3,
-      layout: dockviewFixture(), // panes a (terminal), b (browser), c (terminal)
-      panes: [
-        { id: 'pane-a', title: 'A', cwd: null, scrollback: null, resumeCommand: null },
-        { id: 'pane-b', title: 'B', cwd: null, scrollback: null, resumeCommand: null, surfaceType: 'browser' },
-        { id: 'pane-c', title: 'C', cwd: null, scrollback: null, resumeCommand: null },
-      ],
-    };
-
-    const result = await resumeOrRestore(createPlatform([
-      { id: 'pane-a', alive: true },
-      { id: 'pane-c', alive: true },
-    ], saved));
-
-    expect(result.paneIds).toEqual(['pane-a', 'pane-b', 'pane-c']);
-    expect(result.lathLayout?.version).toBe(1);
-    expect(Object.keys(result.lathLayout!.leafMeta).sort()).toEqual(['pane-a', 'pane-b', 'pane-c']);
-  });
 });
diff --git a/lib/src/lib/reconnect.ts b/lib/src/lib/reconnect.ts
index 9d54481d..3538d74b 100644
--- a/lib/src/lib/reconnect.ts
+++ b/lib/src/lib/reconnect.ts
@@ -6,9 +6,8 @@ import { persistedLathLayout, restoreSession } from './session-restore';
 
 export interface ReconnectResult {
   paneIds: string[];
-  /** The saved session's single layout channel (native, or migrated from a pre-Lath
-   *  save at the read boundary — `persistedLathLayout`), gated on its leaf set
-   *  matching the visible pane set. */
+  /** The saved session's persisted Lath layout (`persistedLathLayout`), gated on its
+   *  leaf set matching the visible pane set. */
   lathLayout?: LathPersistedLayout;
   doors?: PersistedDoor[];
 }
@@ -133,9 +132,8 @@ function getSavedResumePlan(savedState: unknown, liveIds: string[]): ReconnectRe
   const paneIds = saved.panes
     .filter((pane) => !doorIds.has(pane.id) && (liveSet.has(pane.id) || pane.surfaceType === 'browser'))
     .map((pane) => pane.id);
-  // Gate the layout (already the single Lath channel — pre-Lath saves were migrated
-  // at the read boundary) on its leaf set matching the visible pane set, so a stale
-  // blob is dropped rather than restored over a mismatched pane set.
+  // Gate the layout on its leaf set matching the visible pane set, so a stale blob
+  // is dropped rather than restored over a mismatched pane set.
   const lathLayout = persistedLathLayout(saved);
   const leafIds = lathLayout ? Object.keys(lathLayout.leafMeta) : null;
   const layoutMatchesVisiblePanes =
diff --git a/lib/src/lib/session-migration.test.ts b/lib/src/lib/session-migration.test.ts
deleted file mode 100644
index 1070f112..00000000
--- a/lib/src/lib/session-migration.test.ts
+++ /dev/null
@@ -1,401 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import {
-  migrateSessionV1toV2,
-  migrateSessionV2toV3,
-  readPersistedSession,
-  type PersistedSessionV1,
-  type PersistedSessionV2,
-} from './session-types';
-
-describe('session migration v1 → v2', () => {
-  it('migrates a v1 blob with doors to v2, renaming fields', () => {
-    const v1: PersistedSessionV1 = {
-      version: 1,
-      layout: { panels: { 'pane-a': {} } },
-      panes: [
-        { id: 'pane-a', title: 'Pane A', cwd: '/home/ned', scrollback: '$ ls\n', resumeCommand: null, alert: null },
-        { id: 'pane-b', title: 'Pane B', cwd: null, scrollback: null, resumeCommand: null },
-      ],
-      detached: [
-        {
-          id: 'pane-b',
-          title: 'Pane B',
-          neighborId: 'pane-a',
-          direction: 'right',
-          remainingPanelIds: ['pane-a'],
-          restoreLayout: { panels: { 'pane-a': {}, 'pane-b': {} } },
-          detachedLayoutSignature: 'sig-abc',
-        },
-      ],
-    };
-
-    const v2 = migrateSessionV1toV2(v1);
-
-    expect(v2).toEqual({
-      version: 2,
-      layout: { panels: { 'pane-a': {} } },
-      panes: v1.panes,
-      doors: [
-        {
-          id: 'pane-b',
-          title: 'Pane B',
-          neighborId: 'pane-a',
-          direction: 'right',
-          remainingPaneIds: ['pane-a'],
-          layoutAtMinimize: { panels: { 'pane-a': {}, 'pane-b': {} } },
-          layoutAtMinimizeSignature: 'sig-abc',
-        },
-      ],
-    });
-  });
-
-  it('migrates a v1 blob with no detached field to v2 with empty doors', () => {
-    const v1: PersistedSessionV1 = {
-      version: 1,
-      layout: null,
-      panes: [{ id: 'pane-a', title: 'Pane A', cwd: null, scrollback: null, resumeCommand: null }],
-    };
-
-    const v2 = migrateSessionV1toV2(v1);
-
-    expect(v2.version).toBe(2);
-    expect(v2.doors).toEqual([]);
-  });
-});
-
-describe('session migration v2 → v3', () => {
-  it('converts numeric TODO_HARD (2) to boolean true', () => {
-    const v2: PersistedSessionV2 = {
-      version: 2,
-      layout: null,
-      panes: [
-        {
-          id: 'pane-hard',
-          title: 'Pane Hard',
-          cwd: null,
-          scrollback: null,
-          resumeCommand: null,
-          alert: { status: 'NOTHING_TO_SHOW', todo: 2 },
-        },
-      ],
-    };
-    const v3 = migrateSessionV2toV3(v2);
-    expect(v3.panes[0].alert?.todo).toBe(true);
-    expect(v3.panes[0].untouched).toBe(false);
-    expect(v3.version).toBe(3);
-  });
-
-  it('converts numeric soft-bucket values ([0,1]) to boolean true', () => {
-    const v2: PersistedSessionV2 = {
-      version: 2,
-      layout: null,
-      panes: [
-        {
-          id: 'pane-soft-full',
-          title: 'full',
-          cwd: null,
-          scrollback: null,
-          resumeCommand: null,
-          alert: { status: 'NOTHING_TO_SHOW', todo: 1 },
-        },
-        {
-          id: 'pane-soft-half',
-          title: 'half',
-          cwd: null,
-          scrollback: null,
-          resumeCommand: null,
-          alert: { status: 'NOTHING_TO_SHOW', todo: 0.5 },
-        },
-        {
-          id: 'pane-soft-zero',
-          title: 'zero',
-          cwd: null,
-          scrollback: null,
-          resumeCommand: null,
-          alert: { status: 'NOTHING_TO_SHOW', todo: 0 },
-        },
-      ],
-    };
-    const v3 = migrateSessionV2toV3(v2);
-    expect(v3.panes[0].alert?.todo).toBe(true);
-    expect(v3.panes[1].alert?.todo).toBe(true);
-    expect(v3.panes[2].alert?.todo).toBe(true);
-  });
-
-  it('converts TODO_OFF (-1) to boolean false', () => {
-    const v2: PersistedSessionV2 = {
-      version: 2,
-      layout: null,
-      panes: [
-        {
-          id: 'pane-off',
-          title: 'off',
-          cwd: null,
-          scrollback: null,
-          resumeCommand: null,
-          alert: { status: 'NOTHING_TO_SHOW', todo: -1 },
-        },
-      ],
-    };
-    const v3 = migrateSessionV2toV3(v2);
-    expect(v3.panes[0].alert?.todo).toBe(false);
-  });
-
-  it('converts unknown numeric TODO values to boolean false', () => {
-    const v2: PersistedSessionV2 = {
-      version: 2,
-      layout: null,
-      panes: [
-        {
-          id: 'pane-unknown-high',
-          title: 'unknown high',
-          cwd: null,
-          scrollback: null,
-          resumeCommand: null,
-          alert: { status: 'NOTHING_TO_SHOW', todo: 3 },
-        },
-        {
-          id: 'pane-unknown-low',
-          title: 'unknown low',
-          cwd: null,
-          scrollback: null,
-          resumeCommand: null,
-          alert: { status: 'NOTHING_TO_SHOW', todo: -2 },
-        },
-        {
-          id: 'pane-unknown-nan',
-          title: 'unknown nan',
-          cwd: null,
-          scrollback: null,
-          resumeCommand: null,
-          alert: { status: 'NOTHING_TO_SHOW', todo: Number.NaN },
-        },
-      ],
-    };
-    const v3 = migrateSessionV2toV3(v2);
-    expect(v3.panes[0].alert?.todo).toBe(false);
-    expect(v3.panes[1].alert?.todo).toBe(false);
-    expect(v3.panes[2].alert?.todo).toBe(false);
-  });
-
-  it('preserves panes with null alert', () => {
-    const v2: PersistedSessionV2 = {
-      version: 2,
-      layout: null,
-      panes: [
-        { id: 'pane-null', title: 'null', cwd: null, scrollback: null, resumeCommand: null, alert: null },
-      ],
-    };
-    const v3 = migrateSessionV2toV3(v2);
-    expect(v3.panes[0].alert).toBeNull();
-  });
-});
-
-describe('readPersistedSession', () => {
-  it('returns a v3 blob unchanged', () => {
-    const v3 = {
-      version: 3 as const,
-      layout: null,
-      panes: [{ id: 'pane-a', title: 'Pane A', cwd: null, scrollback: null, resumeCommand: null, untouched: true }],
-      doors: [],
-    };
-    expect(readPersistedSession(v3)).toBe(v3);
-  });
-
-  it('defaults missing v3 untouched state to false', () => {
-    const v3 = {
-      version: 3 as const,
-      layout: null,
-      panes: [{ id: 'pane-a', title: 'Pane A', cwd: null, scrollback: null, resumeCommand: null }],
-      doors: [],
-    };
-    expect(readPersistedSession(v3)).toEqual({
-      ...v3,
-      panes: [{ ...v3.panes[0], untouched: false }],
-    });
-  });
-
-  it('reads a JSON-stringified v3 blob', () => {
-    const v3 = {
-      version: 3 as const,
-      layout: null,
-      panes: [{ id: 'pane-a', title: 'Pane A', cwd: null, scrollback: 'saved output', resumeCommand: null, untouched: true }],
-      doors: [],
-    };
-
-    expect(readPersistedSession(JSON.stringify(v3))).toEqual(v3);
-  });
-
-  it('round-trips a v3 blob carrying the additive lathLayout field', () => {
-    const v3 = {
-      version: 3 as const,
-      layout: { root: 'dockview' },
-      lathLayout: { version: 1, tree: { root: { kind: 'leaf', id: 'pane-a' } }, leafMeta: {} },
-      panes: [{ id: 'pane-a', title: 'Pane A', cwd: null, scrollback: null, resumeCommand: null, untouched: true }],
-      doors: [],
-    };
-    // Fast path (all untouched present) returns the object unchanged, lathLayout intact.
-    expect(readPersistedSession(v3)).toBe(v3);
-    // And it survives a JSON round-trip.
-    expect(readPersistedSession(JSON.stringify(v3))).toEqual(v3);
-  });
-
-  it('accepts (and carries) a v3 door with a Lath restore token', () => {
-    const token = { leafId: 'door-a', weight: 0.5, siblingId: 'pane-b', edge: 'right', index: 0, fingerprint: null };
-    const v3 = {
-      version: 3 as const,
-      layout: null,
-      panes: [{ id: 'pane-b', title: 'Pane B', cwd: null, scrollback: null, resumeCommand: null, untouched: false }],
-      doors: [{
-        id: 'door-a',
-        title: 'Door',
-        neighborId: 'pane-b',
-        direction: 'right' as const,
-        remainingPaneIds: ['pane-b'],
-        layoutAtMinimize: null,
-        layoutAtMinimizeSignature: '',
-        token,
-      }],
-    };
-    expect(readPersistedSession(v3)?.doors?.[0]?.token).toEqual(token);
-  });
-
-  it('reads a new-format door (token only, no legacy fields)', () => {
-    const token = { leafId: 'door-a', weight: 0.5, siblingId: 'pane-b', edge: 'right', index: 0, fingerprint: null };
-    const v3 = {
-      version: 3 as const,
-      lathLayout: { version: 1, tree: { root: { kind: 'leaf', id: 'pane-b' } }, leafMeta: {} },
-      panes: [{ id: 'pane-b', title: 'Pane B', cwd: null, scrollback: null, resumeCommand: null, untouched: false }],
-      doors: [{ id: 'door-a', title: 'Door', component: 'terminal', tabComponent: 'terminal', token }],
-    };
-    const door = readPersistedSession(v3)?.doors?.[0];
-    expect(door?.token).toEqual(token);
-    // The legacy fields are simply absent — restore synthesizes them if ever needed.
-    expect(door?.neighborId).toBeUndefined();
-    expect(door?.direction).toBeUndefined();
-  });
-
-  it('reads a v3 blob carrying only a lathLayout (no legacy dockview `layout`)', () => {
-    const v3 = {
-      version: 3 as const,
-      lathLayout: { version: 1, tree: { root: { kind: 'leaf', id: 'pane-a' } }, leafMeta: {} },
-      panes: [{ id: 'pane-a', title: 'Pane A', cwd: null, scrollback: null, resumeCommand: null, untouched: true }],
-      doors: [],
-    };
-    const read = readPersistedSession(v3);
-    expect(read).not.toBeNull();
-    expect(read?.lathLayout).toEqual(v3.lathLayout);
-    expect('layout' in (read as object)).toBe(false);
-  });
-
-  it('rejects a v3 door whose token is not an object with a string leafId', () => {
-    const base = {
-      version: 3 as const,
-      layout: null,
-      panes: [{ id: 'pane-b', title: 'Pane B', cwd: null, scrollback: null, resumeCommand: null, untouched: false }],
-    };
-    const door = {
-      id: 'door-a', title: 'Door', neighborId: null, direction: 'right' as const,
-      remainingPaneIds: [], layoutAtMinimize: null, layoutAtMinimizeSignature: '',
-    };
-    expect(readPersistedSession({ ...base, doors: [{ ...door, token: { weight: 1 } }] })).toBeNull();
-    expect(readPersistedSession({ ...base, doors: [{ ...door, token: 'nope' }] })).toBeNull();
-  });
-
-  it('decodes escaped control bytes in JSON-stringified scrollback', () => {
-    const v3 = {
-      version: 3 as const,
-      layout: null,
-      panes: [{ id: 'pane-a', title: 'Pane A', cwd: null, scrollback: '\u001b[31mred', resumeCommand: null, untouched: false }],
-      doors: [],
-    };
-
-    expect(readPersistedSession(JSON.stringify(v3))?.panes[0].scrollback).toBe('\x1b[31mred');
-  });
-
-  it('accepts persisted terminal bell notification detail', () => {
-    const v3 = {
-      version: 3 as const,
-      layout: null,
-      panes: [
-        {
-          id: 'pane-a',
-          title: 'Pane A',
-          cwd: null,
-          scrollback: null,
-          resumeCommand: null,
-          untouched: false,
-          alert: {
-            status: 'ALERT_RINGING' as const,
-            todo: true,
-            notification: { source: 'BEL' as const, title: 'Terminal bell', body: null },
-          },
-        },
-      ],
-      doors: [],
-    };
-
-    expect(readPersistedSession(v3)).toBe(v3);
-  });
-
-  it('migrates a v2 blob on read (numeric TODO → boolean)', () => {
-    const v2 = {
-      version: 2 as const,
-      layout: null,
-      panes: [
-        {
-          id: 'pane-a',
-          title: 'Pane A',
-          cwd: null,
-          scrollback: null,
-          resumeCommand: null,
-          alert: { status: 'NOTHING_TO_SHOW' as const, todo: 2 },
-        },
-      ],
-      doors: [],
-    };
-    const result = readPersistedSession(v2);
-    expect(result?.version).toBe(3);
-    expect(result?.panes[0].alert?.todo).toBe(true);
-  });
-
-  it('migrates a v1 blob on read through v2 to v3', () => {
-    const v1 = {
-      version: 1 as const,
-      layout: null,
-      panes: [{ id: 'pane-a', title: 'Pane A', cwd: null, scrollback: null, resumeCommand: null }],
-      detached: [
-        {
-          id: 'pane-b',
-          title: 'Pane B',
-          neighborId: null,
-          direction: 'right' as const,
-          remainingPanelIds: [],
-          restoreLayout: null,
-          detachedLayoutSignature: '',
-        },
-      ],
-    };
-    const result = readPersistedSession(v1);
-    expect(result?.version).toBe(3);
-    expect(result?.doors?.[0]).toMatchObject({
-      id: 'pane-b',
-      remainingPaneIds: [],
-      layoutAtMinimize: null,
-      layoutAtMinimizeSignature: '',
-    });
-  });
-
-  it('returns null for malformed or missing blobs', () => {
-    expect(readPersistedSession(null)).toBeNull();
-    expect(readPersistedSession(undefined)).toBeNull();
-    expect(readPersistedSession({ version: 99 })).toBeNull();
-    expect(readPersistedSession('not an object')).toBeNull();
-    expect(readPersistedSession('{')).toBeNull();
-    expect(readPersistedSession(JSON.stringify({ version: 99 }))).toBeNull();
-    expect(readPersistedSession({ version: 2, layout: null, panes: 'nope' })).toBeNull();
-    expect(readPersistedSession({ version: 2, layout: null, panes: [], doors: {} })).toBeNull();
-    expect(readPersistedSession({ version: 1, layout: null, panes: [] as const, detached: {} })).toBeNull();
-    expect(readPersistedSession({ version: 1, layout: null, panes: {} })).toBeNull();
-  });
-});
diff --git a/lib/src/lib/session-restore.test.ts b/lib/src/lib/session-restore.test.ts
index 3167cfce..637f3c06 100644
--- a/lib/src/lib/session-restore.test.ts
+++ b/lib/src/lib/session-restore.test.ts
@@ -15,7 +15,6 @@ vi.mock('./terminal-registry', () => ({
 }));
 
 import { restoreSession } from './session-restore';
-import { dockviewFixture } from './lath/test-fixtures';
 
 function createPlatform(savedState: PersistedSession | null): PlatformAdapter {
   return {
@@ -72,7 +71,6 @@ describe('restoreSession', () => {
     });
     const saved: PersistedSession = {
       version: 3,
-      layout: { panels: { 'pane-a': {} } },
       panes: [
         { id: 'pane-a', title: 'Pane A', cwd: 'C:\\repo', scrollback: 'hello', resumeCommand: null },
       ],
@@ -93,7 +91,6 @@ describe('restoreSession', () => {
   it('seeds restored untouched state', () => {
     const saved: PersistedSession = {
       version: 3,
-      layout: { panels: { 'pane-a': {} } },
       panes: [
         { id: 'pane-a', title: 'Pane A', cwd: null, scrollback: null, resumeCommand: null, untouched: true },
       ],
@@ -109,7 +106,6 @@ describe('restoreSession', () => {
   it('does not spawn a terminal for a browser surface, but keeps it in paneIds', () => {
     const saved: PersistedSession = {
       version: 3,
-      layout: { panels: { 'pane-term': {}, 'pane-web': {} } },
       panes: [
         { id: 'pane-term', title: 'Terminal', cwd: null, scrollback: null, resumeCommand: null, untouched: false },
         { id: 'pane-web', title: 'localhost', cwd: null, scrollback: null, resumeCommand: null, untouched: false, surfaceType: 'browser' },
@@ -124,24 +120,7 @@ describe('restoreSession', () => {
     expect(result?.paneIds).toEqual(['pane-term', 'pane-web']);
   });
 
-  it('migrates a pre-Lath dockview layout into the single lath channel on read', () => {
-    const saved: PersistedSession = {
-      version: 3,
-      layout: dockviewFixture(),
-      panes: [
-        { id: 'pane-a', title: 'A', cwd: null, scrollback: null, resumeCommand: null, untouched: false },
-        { id: 'pane-b', title: 'B', cwd: null, scrollback: null, resumeCommand: null, untouched: false, surfaceType: 'browser' },
-        { id: 'pane-c', title: 'C', cwd: null, scrollback: null, resumeCommand: null, untouched: false },
-      ],
-    };
-
-    const result = restoreSession(createPlatform(saved));
-
-    expect(result?.lathLayout?.version).toBe(1);
-    expect(Object.keys(result!.lathLayout!.leafMeta).sort()).toEqual(['pane-a', 'pane-b', 'pane-c']);
-  });
-
-  it('prefers the native lathLayout and passes it through untouched', () => {
+  it('passes the native lathLayout through untouched', () => {
     const lathLayout = {
       version: 1 as const,
       tree: { root: { kind: 'leaf' as const, id: 'pane-a' } },
@@ -150,7 +129,6 @@ describe('restoreSession', () => {
     const saved: PersistedSession = {
       version: 3,
       lathLayout,
-      layout: dockviewFixture(), // stale legacy blob must lose to the native layout
       panes: [
         { id: 'pane-a', title: 'A', cwd: null, scrollback: null, resumeCommand: null, untouched: false },
       ],
@@ -164,7 +142,6 @@ describe('restoreSession', () => {
   it('restores browser surface TODO from the persisted alert during cold restore', () => {
     const saved: PersistedSession = {
       version: 3,
-      layout: { panels: { 'pane-web': {} } },
       panes: [
         {
           id: 'pane-web',
diff --git a/lib/src/lib/session-restore.ts b/lib/src/lib/session-restore.ts
index 0caff9e4..99f12e3f 100644
--- a/lib/src/lib/session-restore.ts
+++ b/lib/src/lib/session-restore.ts
@@ -1,4 +1,3 @@
-import { dockviewLayoutToLath } from './lath/dockview-convert';
 import { type LathPersistedLayout, isLathPersistedLayout } from './lath/persistence';
 import type { PlatformAdapter } from './platform/types';
 import { readPersistedSession, type PersistedDoor, type PersistedSession } from './session-types';
@@ -6,20 +5,15 @@ import { getDefaultShellOpts, restoreBrowserSurfaceTodo, restoreTerminal } from
 
 export interface RestoredSession {
   paneIds: string[];
-  /** The session's single layout channel — native, or migrated from a pre-Lath
-   *  save by `persistedLathLayout`. */
+  /** The session's persisted Lath layout, when present. */
   lathLayout?: LathPersistedLayout;
   doors: PersistedDoor[];
 }
 
-/** The one layout a persisted session carries: the native Lath layout when present,
- *  else a pre-Lath dockview `layout` blob migrated one-way via `dockviewLayoutToLath`
- *  (docs/specs/tiling-engine.md → "Persistence and migration"). This is the single
- *  migration point — everything downstream of the session read sees only a Lath
- *  layout. */
+/** The persisted Lath layout a session carries, or undefined when absent/unusable
+ *  (docs/specs/tiling-engine.md → "Persistence"). */
 export function persistedLathLayout(saved: PersistedSession): LathPersistedLayout | undefined {
-  if (isLathPersistedLayout(saved.lathLayout)) return saved.lathLayout;
-  return dockviewLayoutToLath(saved.layout) ?? undefined;
+  return isLathPersistedLayout(saved.lathLayout) ? saved.lathLayout : undefined;
 }
 
 export function restoreSession(platform: PlatformAdapter): RestoredSession | null {
diff --git a/lib/src/lib/session-save.test.ts b/lib/src/lib/session-save.test.ts
index 176c6062..ca0d3f06 100644
--- a/lib/src/lib/session-save.test.ts
+++ b/lib/src/lib/session-save.test.ts
@@ -134,11 +134,6 @@ describe('saveSession', () => {
     await saveSession(platform, [], [{
       id: 'pane-a',
       title: 'npm test',
-      neighborId: null,
-      direction: 'right',
-      remainingPaneIds: [],
-      layoutAtMinimize: null,
-      layoutAtMinimizeSignature: 'empty',
     }]);
 
     expect(platform.saveState).toHaveBeenCalledWith({
@@ -169,11 +164,6 @@ describe('saveSession', () => {
     await saveSession(platform, [], [{
       id: 'pane-a',
       title: 'npm test',
-      neighborId: null,
-      direction: 'right',
-      remainingPaneIds: [],
-      layoutAtMinimize: null,
-      layoutAtMinimizeSignature: 'empty',
     }]);
 
     expect(platform.saveState).toHaveBeenCalledWith({
@@ -238,11 +228,6 @@ describe('saveSession', () => {
       title: 'localhost',
       component: 'browser',
       params: { surfaceType: 'browser', renderMode: 'iframe', url: 'http://localhost:5173' },
-      neighborId: null,
-      direction: 'right',
-      remainingPaneIds: [],
-      layoutAtMinimize: null,
-      layoutAtMinimizeSignature: 'empty',
     }]);
 
     const saved = vi.mocked(platform.saveState).mock.calls[0]![0] as PersistedSession;
@@ -298,11 +283,6 @@ describe('saveSession', () => {
     await saveSession(platform, [], [{
       id: 'door-a',
       title: 'npm test',
-      neighborId: 'pane-b',
-      direction: 'right',
-      remainingPaneIds: ['pane-b'],
-      layoutAtMinimize: null,
-      layoutAtMinimizeSignature: '',
       token,
     }]);
 
diff --git a/lib/src/lib/session-save.ts b/lib/src/lib/session-save.ts
index e2977f35..be1d092e 100644
--- a/lib/src/lib/session-save.ts
+++ b/lib/src/lib/session-save.ts
@@ -19,9 +19,8 @@ export async function saveSession(
   platform: PlatformAdapter,
   panes: Array<{ id: string; title: string; surfaceType?: PersistedSurfaceType }>,
   doors: PersistedDoor[] = [],
-  // The native Lath persisted layout (docs/specs/tiling-engine.md → "Persistence
-  // and migration"). The only layout Dormouse writes; the legacy dockview `layout`
-  // key is no longer emitted (pre-Lath blobs are still read on restore).
+  // The native Lath persisted layout (docs/specs/tiling-engine.md → "Persistence").
+  // The only layout Dormouse writes.
   lathLayout?: unknown,
 ): Promise<void> {
   const previousPanes = getPreviousPaneMap(platform);
diff --git a/lib/src/lib/session-types.ts b/lib/src/lib/session-types.ts
index ca6f370c..e1033915 100644
--- a/lib/src/lib/session-types.ts
+++ b/lib/src/lib/session-types.ts
@@ -1,10 +1,5 @@
 import type { SessionStatus } from './activity-monitor';
-import { ACTIVITY_NOTIFICATION_SOURCES, migrateTodoState, type ActivityNotification, type TodoState } from './alert-manager';
-
-/** The direction a minimized pane sat relative to its neighbor, as captured by
- *  pre-Lath saves (`PersistedDoor.direction`). Read-only legacy field; new doors
- *  restore from a Lath `token` instead. */
-export type DoorDirection = 'left' | 'right' | 'above' | 'below';
+import { ACTIVITY_NOTIFICATION_SOURCES, type ActivityNotification, type TodoState } from './alert-manager';
 
 export interface PersistedAlertState {
   status: SessionStatus;
@@ -61,19 +56,10 @@ export interface PersistedDoor {
   component?: string;
   tabComponent?: string;
   params?: Record<string, unknown>;
-  /** Lath restore token (`RestoreToken`), written by every new door so it restores
+  /** Lath restore token (`RestoreToken`), written by every door so it restores
    *  at its captured tier (docs/specs/tiling-engine.md → "Restore tokens"). Typed
-   *  `unknown` to keep this module free of the lath core dep. Absent only on
-   *  pre-Lath doors, which fall back to the legacy fields below. */
+   *  `unknown` to keep this module free of the lath core dep. */
   token?: unknown;
-  /** Legacy fields — written only by pre-Lath saves, read-only for migration. A
-   *  door lacking a `token` synthesizes a neighbor-tier restore from `neighborId` +
-   *  `direction`. */
-  neighborId?: string | null;
-  direction?: DoorDirection;
-  remainingPaneIds?: string[];
-  layoutAtMinimize?: unknown;
-  layoutAtMinimizeSignature?: string;
 }
 
 export interface PersistedSession {
@@ -81,11 +67,8 @@ export interface PersistedSession {
   panes: PersistedPane[];
   doors?: PersistedDoor[];
   /** Native Lath persisted layout (`LathPersistedLayout`) — the layout Dormouse
-   *  writes today (docs/specs/tiling-engine.md → "Persistence and migration"). */
+   *  writes (docs/specs/tiling-engine.md → "Persistence"). */
   lathLayout?: unknown;
-  /** Legacy dockview layout blob, written only by pre-Lath saves and read-only for
-   *  one-way migration on restore. Absent on saves made by the Lath engine. */
-  layout?: unknown;
 }
 
 export type WorkspaceId = string;
@@ -112,7 +95,7 @@ export interface PersistedWindow {
   activeWorkspaceId: WorkspaceId;
 }
 
-/** Default id/name for the single Workspace a pre-workspace snapshot migrates to. */
+/** Default id/name for the single Workspace a fresh Window is created with. */
 export const DEFAULT_WORKSPACE_ID: WorkspaceId = 'workspace-1';
 export const DEFAULT_WORKSPACE_NAME = 'Workspace 1';
 
@@ -122,52 +105,9 @@ interface PersistedSessionV3Input {
   version: 3;
   panes: PersistedPaneInput[];
   doors?: PersistedDoor[];
-  layout?: unknown;
   lathLayout?: unknown;
 }
 
-// --- Legacy v2 shapes (read-only, for migration) ---
-
-export interface PersistedAlertStateV2 {
-  status: SessionStatus;
-  todo: unknown; // numeric encoding: -1=off, [0,1]=soft, 2=hard
-}
-
-export interface PersistedPaneV2 {
-  id: string;
-  cwd: string | null;
-  title: string;
-  scrollback: string | null;
-  resumeCommand: string | null;
-  alert?: PersistedAlertStateV2 | null;
-}
-
-export interface PersistedSessionV2 {
-  version: 2;
-  panes: PersistedPaneV2[];
-  doors?: PersistedDoor[];
-  layout: unknown;
-}
-
-// --- Legacy v1 shapes (read-only, for migration) ---
-
-export interface PersistedDoorV1 {
-  id: string;
-  title: string;
-  neighborId: string | null;
-  direction: DoorDirection;
-  remainingPanelIds: string[];
-  restoreLayout: unknown;
-  detachedLayoutSignature: string;
-}
-
-export interface PersistedSessionV1 {
-  version: 1;
-  panes: PersistedPaneV2[];
-  detached?: PersistedDoorV1[];
-  layout: unknown;
-}
-
 // --- Validation guards (reject untrusted blobs) ---
 
 function isRecord(value: unknown): value is Record<string, unknown> {
@@ -179,8 +119,7 @@ function isPersistedAlertShape(value: unknown): boolean {
   if (!isRecord(value)) return false;
   if (typeof value.status !== 'string') return false;
   if (value.watchingEnabled !== undefined && typeof value.watchingEnabled !== 'boolean') return false;
-  const t = value.todo;
-  if (!(typeof t === 'boolean' || typeof t === 'number' || typeof t === 'string')) return false;
+  if (typeof value.todo !== 'boolean') return false;
   return value.notification === undefined || value.notification === null || isActivityNotificationShape(value.notification);
 }
 
@@ -207,19 +146,6 @@ function isPersistedPaneShape(value: unknown): boolean {
   );
 }
 
-function isPersistedDoorV1(value: unknown): value is PersistedDoorV1 {
-  if (!isRecord(value)) return false;
-  return (
-    typeof value.id === 'string' &&
-    typeof value.title === 'string' &&
-    (typeof value.neighborId === 'string' || value.neighborId === null) &&
-    typeof value.direction === 'string' &&
-    Array.isArray(value.remainingPanelIds) &&
-    value.remainingPanelIds.every((id) => typeof id === 'string') &&
-    typeof value.detachedLayoutSignature === 'string'
-  );
-}
-
 function isPersistedDoor(value: unknown): value is PersistedDoor {
   if (!isRecord(value)) return false;
   return (
@@ -228,90 +154,32 @@ function isPersistedDoor(value: unknown): value is PersistedDoor {
     (value.component === undefined || typeof value.component === 'string') &&
     (value.tabComponent === undefined || typeof value.tabComponent === 'string') &&
     (value.params === undefined || isRecord(value.params)) &&
-    // Legacy fields (pre-Lath doors) — present-or-absent, but well-typed if present.
-    (value.neighborId === undefined || typeof value.neighborId === 'string' || value.neighborId === null) &&
-    (value.direction === undefined || typeof value.direction === 'string') &&
-    (value.remainingPaneIds === undefined ||
-      (Array.isArray(value.remainingPaneIds) && value.remainingPaneIds.every((id) => typeof id === 'string'))) &&
-    (value.layoutAtMinimizeSignature === undefined || typeof value.layoutAtMinimizeSignature === 'string') &&
     // A Lath restore token, when present, is structurally an object with a string
     // `leafId` (kept permissive — the core owns full validation on restore).
     (value.token === undefined || (isRecord(value.token) && typeof value.token.leafId === 'string'))
   );
 }
 
-function isPersistedSessionV1(value: unknown): value is PersistedSessionV1 {
-  if (!isRecord(value) || value.version !== 1) return false;
-  return (
-    Array.isArray(value.panes) &&
-    value.panes.every(isPersistedPaneShape) &&
-    (value.detached === undefined || (Array.isArray(value.detached) && value.detached.every(isPersistedDoorV1))) &&
-    'layout' in value
-  );
-}
-
-function isPersistedSessionV2(value: unknown): value is PersistedSessionV2 {
-  if (!isRecord(value) || value.version !== 2) return false;
-  return (
-    Array.isArray(value.panes) &&
-    value.panes.every(isPersistedPaneShape) &&
-    (value.doors === undefined || (Array.isArray(value.doors) && value.doors.every(isPersistedDoor))) &&
-    'layout' in value
-  );
-}
-
 function isPersistedSessionV3(value: unknown): value is PersistedSessionV3Input {
   if (!isRecord(value) || value.version !== 3) return false;
   return (
     Array.isArray(value.panes) &&
     value.panes.every(isPersistedPaneShape) &&
-    (value.doors === undefined || (Array.isArray(value.doors) && value.doors.every(isPersistedDoor))) &&
-    // A v3 blob carries a layout in one form or the other: native `lathLayout` (Lath
-    // saves) or a legacy dockview `layout` (pre-Lath saves, migrated on restore).
-    ('layout' in value || 'lathLayout' in value)
+    (value.doors === undefined || (Array.isArray(value.doors) && value.doors.every(isPersistedDoor)))
   );
 }
 
-// --- Migrations ---
-
-export function migrateSessionV1toV2(v1: PersistedSessionV1): PersistedSessionV2 {
-  return {
-    version: 2,
-    panes: v1.panes,
-    layout: v1.layout,
-    doors: (v1.detached ?? []).map((door) => ({
-      id: door.id,
-      title: door.title,
-      neighborId: door.neighborId,
-      direction: door.direction,
-      remainingPaneIds: door.remainingPanelIds,
-      layoutAtMinimize: door.restoreLayout,
-      layoutAtMinimizeSignature: door.detachedLayoutSignature,
-    })),
-  };
-}
-
-export function migrateSessionV2toV3(v2: PersistedSessionV2): PersistedSession {
-  return {
-    version: 3,
-    layout: v2.layout,
-    doors: v2.doors,
-    panes: v2.panes.map((pane) => ({
-      ...pane,
-      untouched: false,
-      alert: pane.alert
-        ? { status: pane.alert.status, todo: migrateTodoState(pane.alert.todo) }
-        : pane.alert,
-    })),
-  };
-}
-
+/**
+ * Parse a persisted session blob (`version: 3`), or null if nothing usable is
+ * present. A blob that is absent/empty returns null silently; one that is present
+ * but unreadable (bad JSON, wrong shape) is logged and discarded so a corrupt save
+ * can never block startup — the caller starts fresh (`docs/specs/transport.md`).
+ */
 export function readPersistedSession(raw: unknown): PersistedSession | null {
+  if (isEmptyState(raw)) return null;
   const value = parseJsonString(raw);
-  if (!isRecord(value)) return null;
   if (isPersistedSessionV3(value)) return normalizeSessionV3(value);
-  if (isPersistedSessionV2(value)) return migrateSessionV2toV3(value);
-  if (isPersistedSessionV1(value)) return migrateSessionV2toV3(migrateSessionV1toV2(value));
+  console.warn('[dormouse] Ignoring unreadable persisted session; starting fresh.');
   return null;
 }
 
@@ -337,6 +205,12 @@ function parseJsonString(raw: unknown): unknown {
   }
 }
 
+/** No saved state at all (fresh install): null/undefined or an empty string. Not an
+ *  error — the caller starts fresh without a warning. */
+function isEmptyState(raw: unknown): boolean {
+  return raw == null || (typeof raw === 'string' && raw.trim() === '');
+}
+
 // --- Window container (stage 2b) ---
 
 // Structural gate only: a v1 Window with a workspaces array and an active id.
@@ -361,37 +235,35 @@ export function wrapSessionInWindow(
 }
 
 /**
- * Read a persisted Window snapshot. Accepts a canonical `PersistedWindow`, a
- * JSON-stringified one, or a bare `PersistedSession` (any version) — the
- * pre-workspace shape — which migrates to a single Workspace named `Workspace 1`
- * (`docs/specs/transport.md`). Returns null when nothing usable is present.
+ * Read a persisted Window snapshot (a canonical `PersistedWindow` or a
+ * JSON-stringified one). Returns null when nothing usable is present — an
+ * absent/empty blob silently, a present-but-unreadable one with a warning so a
+ * corrupt save can never block startup (`docs/specs/transport.md`).
  *
- * Each inner session is normalized/migrated through `readPersistedSession`. If
- * `activeWorkspaceId` does not match any Workspace, the first Workspace is made
- * active so the snapshot stays usable.
+ * Each inner session is validated through `readPersistedSession`; Workspaces whose
+ * session is unreadable are dropped. If `activeWorkspaceId` does not match any
+ * Workspace, the first Workspace is made active so the snapshot stays usable.
  */
 export function readPersistedWindow(raw: unknown): PersistedWindow | null {
+  if (isEmptyState(raw)) return null;
   const value = parseJsonString(raw);
-  if (!isRecord(value)) return null;
-
-  if (isPersistedWindowShape(value)) {
-    const workspaces = (value.workspaces as unknown[])
-      .map((ws): PersistedWorkspace | null => {
-        if (!isRecord(ws) || typeof ws.id !== 'string' || typeof ws.name !== 'string') return null;
-        const session = readPersistedSession(ws.session);
-        return session ? { id: ws.id, name: ws.name, session } : null;
-      })
-      .filter((ws): ws is PersistedWorkspace => ws !== null);
-    if (workspaces.length === 0) return null;
-    const activeWorkspaceId = workspaces.some((ws) => ws.id === value.activeWorkspaceId)
-      ? (value.activeWorkspaceId as WorkspaceId)
-      : workspaces[0].id;
-    return { version: 1, workspaces, activeWorkspaceId };
+  if (!isRecord(value) || !isPersistedWindowShape(value)) {
+    console.warn('[dormouse] Ignoring unreadable persisted window; starting fresh.');
+    return null;
   }
 
-  // Pre-workspace bare PersistedSession → single-Workspace window.
-  const session = readPersistedSession(value);
-  return session ? wrapSessionInWindow(session) : null;
+  const workspaces = (value.workspaces as unknown[])
+    .map((ws): PersistedWorkspace | null => {
+      if (!isRecord(ws) || typeof ws.id !== 'string' || typeof ws.name !== 'string') return null;
+      const session = readPersistedSession(ws.session);
+      return session ? { id: ws.id, name: ws.name, session } : null;
+    })
+    .filter((ws): ws is PersistedWorkspace => ws !== null);
+  if (workspaces.length === 0) return null;
+  const activeWorkspaceId = workspaces.some((ws) => ws.id === value.activeWorkspaceId)
+    ? (value.activeWorkspaceId as WorkspaceId)
+    : workspaces[0].id;
+  return { version: 1, workspaces, activeWorkspaceId };
 }
 
 /** The active Workspace's session, or the first Workspace's as a fallback. */
diff --git a/lib/src/lib/session-window.test.ts b/lib/src/lib/session-window.test.ts
index 66772914..4b353641 100644
--- a/lib/src/lib/session-window.test.ts
+++ b/lib/src/lib/session-window.test.ts
@@ -1,8 +1,6 @@
 import { describe, expect, it } from 'vitest';
 import {
   activeWorkspaceSession,
-  DEFAULT_WORKSPACE_ID,
-  DEFAULT_WORKSPACE_NAME,
   readPersistedWindow,
   wrapSessionInWindow,
   type PersistedSession,
@@ -11,39 +9,15 @@ import {
 
 const sessionA: PersistedSession = {
   version: 3,
-  layout: { panels: { 'pane-a': {} } },
   panes: [{ id: 'pane-a', title: 'A', cwd: null, scrollback: null, resumeCommand: null, untouched: false }],
 };
 
 const sessionB: PersistedSession = {
   version: 3,
-  layout: { panels: { 'pane-b': {} } },
   panes: [{ id: 'pane-b', title: 'B', cwd: null, scrollback: null, resumeCommand: null, untouched: false }],
 };
 
 describe('readPersistedWindow', () => {
-  it('migrates a pre-workspace bare PersistedSession to a single Workspace named "Workspace 1"', () => {
-    const win = readPersistedWindow(sessionA);
-    expect(win).toEqual({
-      version: 1,
-      activeWorkspaceId: DEFAULT_WORKSPACE_ID,
-      workspaces: [{ id: DEFAULT_WORKSPACE_ID, name: DEFAULT_WORKSPACE_NAME, session: sessionA }],
-    });
-  });
-
-  it('migrates a legacy v2 bare session through readPersistedSession (panes preserved)', () => {
-    const v2 = {
-      version: 2 as const,
-      layout: { panels: { 'pane-a': {} } },
-      panes: [{ id: 'pane-a', title: 'A', cwd: null, scrollback: null, resumeCommand: null }],
-    };
-    const win = readPersistedWindow(v2);
-    expect(win?.workspaces).toHaveLength(1);
-    expect(win?.workspaces[0].session.version).toBe(3);
-    expect(win?.workspaces[0].session.panes[0].id).toBe('pane-a');
-    expect(win?.workspaces[0].session.panes[0].untouched).toBe(false);
-  });
-
   it('round-trips a canonical multi-Workspace window', () => {
     const win: PersistedWindow = {
       version: 1,
diff --git a/lib/src/lib/window-persistence.test.ts b/lib/src/lib/window-persistence.test.ts
index b47e61c7..c8bcd045 100644
--- a/lib/src/lib/window-persistence.test.ts
+++ b/lib/src/lib/window-persistence.test.ts
@@ -19,12 +19,10 @@ function stubLocalStorage(): void {
 
 const sessionA: PersistedSession = {
   version: 3,
-  layout: { panels: { 'pane-a': {} } },
   panes: [{ id: 'pane-a', title: 'A', cwd: null, scrollback: null, resumeCommand: null, untouched: false }],
 };
 const sessionB: PersistedSession = {
   version: 3,
-  layout: { panels: { 'pane-b': {} } },
   panes: [{ id: 'pane-b', title: 'B', cwd: null, scrollback: null, resumeCommand: null, untouched: false }],
 };
 
@@ -60,10 +58,6 @@ describe('window-persistence', () => {
       expect(activeSessionFromStored(stored)).toEqual(sessionA);
     });
 
-    it('load migrates a pre-workspace bare session transparently', () => {
-      expect(activeSessionFromStored(sessionA)).toEqual(sessionA);
-    });
-
     it('save replaces only the active Workspace, preserving the others', () => {
       const existing: PersistedWindow = {
         version: 1,
diff --git a/lib/src/lib/window-persistence.ts b/lib/src/lib/window-persistence.ts
index 7a2fce0b..c064a743 100644
--- a/lib/src/lib/window-persistence.ts
+++ b/lib/src/lib/window-persistence.ts
@@ -61,11 +61,12 @@ export interface SessionKeyValueStore {
 // so each adapter's get/save collapses to one call instead of re-implementing
 // the read-merge-write dance.
 
-/** Read the stored blob and return the `PersistedSession` to restore (or null). */
+/** Read the stored blob and return the `PersistedSession` to restore (or null). A
+ *  corrupt (unparseable) blob is discarded, so a bad save can never block startup. */
 export function loadSessionState(storage: SessionKeyValueStore, key: string): unknown {
   const raw = storage.getItem(key);
   if (raw === null) return null;
-  return activeSessionFromStored(JSON.parse(raw));
+  return activeSessionFromStored(parseStoredJson(raw));
 }
 
 /** Persist `session` under `key`, merging into the active Workspace when the flag is on. */
@@ -78,6 +79,17 @@ export function saveSessionState(storage: SessionKeyValueStore, key: string, ses
     return;
   }
   const raw = storage.getItem(key);
-  const existing = raw === null ? null : JSON.parse(raw);
+  const existing = raw === null ? null : parseStoredJson(raw);
   storage.setItem(key, JSON.stringify(storedValueForSession(existing, session)));
 }
+
+/** Parse a stored JSON blob, or null when it is corrupt — a bad blob degrades to a
+ *  fresh start rather than throwing at the boot boundary (`docs/specs/transport.md`). */
+function parseStoredJson(raw: string): unknown {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    console.warn('[dormouse] Ignoring corrupt persisted state; starting fresh.');
+    return null;
+  }
+}
diff --git a/lib/src/stories/Baseboard.stories.tsx b/lib/src/stories/Baseboard.stories.tsx
index 2f97c725..26d1df33 100644
--- a/lib/src/stories/Baseboard.stories.tsx
+++ b/lib/src/stories/Baseboard.stories.tsx
@@ -8,11 +8,6 @@ const BASE_TIME = 1_700_000_000_000;
 const makeItem = (id: string, title: string): DooredItem => ({
   id,
   title,
-  neighborId: null,
-  direction: 'right',
-  remainingPaneIds: [],
-  layoutAtMinimize: null,
-  layoutAtMinimizeSignature: '',
 });
 
 function withState(items: DooredItem[], byId: Record<string, Record<string, unknown>>) {
diff --git a/lib/src/stories/ShellCwd.stories.tsx b/lib/src/stories/ShellCwd.stories.tsx
index 660cf831..8bfc8a90 100644
--- a/lib/src/stories/ShellCwd.stories.tsx
+++ b/lib/src/stories/ShellCwd.stories.tsx
@@ -407,11 +407,6 @@ function makeDoorItem(id: string, title: string): DooredItem {
   return {
     id,
     title,
-    neighborId: null,
-    direction: 'right',
-    remainingPaneIds: [],
-    layoutAtMinimize: null,
-    layoutAtMinimizeSignature: '',
   };
 }
 
diff --git a/standalone/src/tauri-adapter.ts b/standalone/src/tauri-adapter.ts
index 11ddc18e..5c19303f 100644
--- a/standalone/src/tauri-adapter.ts
+++ b/standalone/src/tauri-adapter.ts
@@ -1,6 +1,5 @@
 import { invoke as rawInvoke } from "@tauri-apps/api/core";
 import { listen } from "@tauri-apps/api/event";
-import { getCurrentWindow } from "@tauri-apps/api/window";
 import { open } from "@tauri-apps/plugin-shell";
 import type {
   AgentBrowserCommandResult,
@@ -176,10 +175,9 @@ export class TauriAdapter implements PlatformAdapter {
   }
 
   // Seed the session cache from the Rust file store before restore reads it
-  // (bootstrap() awaits init() before resumeOrRestore). On the first boot after
-  // moving off WebKit localStorage, adopt any legacy blob still parked there,
-  // persist it to Rust, and clear it — so WebKit stops rewriting that key and
-  // its bloated WAL collapses on the next quit (docs/specs/standalone.md).
+  // (bootstrap() awaits init() before resumeOrRestore). The Rust store is the sole
+  // backing — the session blob never lives in WebKit localStorage
+  // (docs/specs/standalone.md).
   private async hydrateSessionStore(): Promise<void> {
     let seed: string | null = null;
     try {
@@ -187,25 +185,7 @@ export class TauriAdapter implements PlatformAdapter {
     } catch (err) {
       console.error("[tauri-adapter] load_session failed:", err);
     }
-    let migrated: string | null = null;
-    // One-time migration off WebKit localStorage. SUNSET: removal criteria in
-    // docs/specs/standalone.md `## Future`. The legacy blob is per-origin
-    // (window-shared) and window-agnostic, so only the main window may adopt
-    // and clear it — a second window racing this would double-adopt.
-    if (seed === null && getCurrentWindow().label === "main") {
-      migrated = localStorage.getItem(TauriAdapter.STATE_KEY);
-      if (migrated !== null) {
-        localStorage.removeItem(TauriAdapter.STATE_KEY);
-      }
-    }
-    // Do NOT seed the cache with the migrated blob: setItem's identical-value
-    // short-circuit would skip the write, and localStorage is already cleared —
-    // the setItem below must be a genuine change so the blob reaches the Rust
-    // store (setItem updates the cache synchronously for the cold-restore read).
     this.sessionStore.hydrate(seed);
-    // Persist the adopted blob through the store's normal write path (not a raw
-    // invoke) so it shares the same coalescing — and the planned drain-on-quit.
-    if (migrated !== null) this.sessionStore.setItem(TauriAdapter.STATE_KEY, migrated);
   }
 
   shutdown(): void {
diff --git a/standalone/src/tauri-session-store.test.ts b/standalone/src/tauri-session-store.test.ts
index 4cd166f1..efd845bf 100644
--- a/standalone/src/tauri-session-store.test.ts
+++ b/standalone/src/tauri-session-store.test.ts
@@ -66,19 +66,19 @@ describe("TauriSessionStore", () => {
     expect(saved).toEqual(["a"]);
   });
 
-  it("does not short-circuit a value equal to the hydrated seed (migration path)", async () => {
-    // Mirrors tauri-adapter's hydrateSessionStore: hydrate(null) leaves the
-    // migrated blob a genuine change, so the short-circuit can't swallow it.
+  it("writes the first setItem after hydrate(null) (cold start)", async () => {
+    // Mirrors tauri-adapter's hydrateSessionStore: hydrate(null) seeds no value, so
+    // the first save is a genuine change the short-circuit can't swallow.
     const saved: string[] = [];
     const store = new TauriSessionStore(async (v) => {
       saved.push(v);
     });
     store.hydrate(null);
-    store.setItem("k", '{"migrated":1}');
+    store.setItem("k", '{"v":1}');
     // The cache updates synchronously for the cold-restore read that follows.
-    expect(store.getItem("k")).toBe('{"migrated":1}');
+    expect(store.getItem("k")).toBe('{"v":1}');
     await tick();
-    expect(saved).toEqual(['{"migrated":1}']);
+    expect(saved).toEqual(['{"v":1}']);
   });
 
   it("recovers after a rejected write instead of wedging", async () => {