diff --git a/docs/specs/alert.md b/docs/specs/alert.md
index d9374e52c..55f955250 100644
--- a/docs/specs/alert.md
+++ b/docs/specs/alert.md
@@ -418,6 +418,8 @@ Source of truth: `SettingsDialog` and `TOPICS` in `lib/src/components/SettingsDi
 
 **Must project every Workspace, active or not.** The Activity store spans the whole Window, so what scopes it to one Workspace is the membership each mounted Wall publishes — panes ∪ doors, on every layout commit.
 
+**Must retain TODO and attention by stable Surface ID across a Workspace move and republish membership on both sides**, without replaying notifications on remount. GUI focus acknowledges without input; CLI movement alone does not acknowledge. Pinned by `preserves Session identity, TODO and retained cwd, retires the source ref, and recomputes both unions` in `lib/src/components/WorkspaceWindow.test.tsx`.
+
 Source of truth: `computeWorkspaceUnion` in `lib/src/lib/workspace-union.ts`; `setWorkspaceSurfaces` in `lib/src/lib/workspace-surfaces.ts`; `lib/src/lib/workspace-union.test.ts`.
 
 Where it surfaces is host-specific:
diff --git a/docs/specs/dor-browser.md b/docs/specs/dor-browser.md
index 76f40f10b..e43568840 100644
--- a/docs/specs/dor-browser.md
+++ b/docs/specs/dor-browser.md
@@ -971,6 +971,8 @@ Source of truth: `lib/src/lib/platform/iframe-proxy-types.ts`,
 `vscode-ext/src/message-router.ts`, `vscode-ext/src/webview-html.ts`,
 `standalone/src/tauri-adapter.ts`.
 
+A moved iframe Surface remounts at its saved URL after consent: `docs/specs/layout.md` → Moving Surfaces between Workspaces.
+
 ## Future
 
 - Stable agent-browser profile/state persistence so pop-out preserves logins,
diff --git a/docs/specs/dor-cli.md b/docs/specs/dor-cli.md
index 118832f67..5242731f9 100644
--- a/docs/specs/dor-cli.md
+++ b/docs/specs/dor-cli.md
@@ -267,9 +267,7 @@ and each host's hop in `standalone/src/tauri-adapter.ts`,
 
 ## Handle Model
 
-`Window ⊃ Workspace ⊃ Pane ⊃ Surface` (`docs/specs/glossary.md`). **A command's
-positional target is always a Surface; a container is named by `--workspace
-<ref>`** ([dor workspace](#dor-workspace)). `Reserved:` no command targets
+`Window ⊃ Workspace ⊃ Pane ⊃ Surface` (`docs/specs/glossary.md`). **Must treat a command's primary target as a Surface; `dor move` also takes a destination Workspace, while `--workspace <ref>` scopes the source** ([dor workspace](#dor-workspace)). `Reserved:` no command targets
 another Window; a request reaches the window that owns its Surface instead
 (§Standalone), and the ref grammar for one is [Future](#future).
 
@@ -283,12 +281,12 @@ Invariants:
   layout/list positions: each Workspace starts at `surface:1` and assigns the
   next number when a Surface is created/restored. The map and its counter
   persist in the session snapshot, which is what keeps a retired number from
-  being reused (`docs/specs/transport.md` → "Persisted session types"). **Only
-  creation assigns a ref** — layout churn (reorder,
+  being reused (`docs/specs/transport.md` → "Persisted session types"). **Must assign a ref on creation or adoption into another Workspace** — layout churn (reorder,
   minimize/reattach, zoom, focus), replacing an untouched terminal with a
   browser Surface, and browser render-mode swaps all leave it unchanged.
   **Killing a Surface retires its ref; a later target that names it must fail
   rather than silently retarget.**
+- **Must retire a moved Surface's source ref**, retaining its stable ID. **Must route a moved caller by that stable ID**: its cached `surface:N` refs now resolve in the destination and may name strangers; unscoped `ensure` searches there and may duplicate work left behind. Agents must use stable IDs across moves or explicitly scope the original Workspace. Print a renderer-local notice in the moved terminal with old/new handles and these scope changes, once after success, without PTY input or Activity changes; use an eight-second pane notice in alternate-screen programs.
 - Surface targets also accept `title:<exact display title>`, for human recovery;
   a title can drift, so automation should prefer refs from command responses or
   `dor list`. Action commands (`read`, `send`, `await`, `kill`, `dor agent-browser
@@ -318,7 +316,7 @@ Invariants:
   never a name. **A Window is `window:<label>` — its host's own name for it**
   (`window:main`, `window:ws-2`), and a host with one Window answers
   `window:1`; each accepts its own ref bare.
-  **Every Workspace has a `surface:1`**, so a Surface ref alone
+  Workspaces can each have a `surface:1`, so a Surface ref alone
   never identifies a Workspace.
 - **One Wall answers each request**, resolved in order: the Window's own verbs
   ([dor workspace](#dor-workspace), and `dor list --all`, which fans out to
@@ -457,6 +455,14 @@ Source of truth: `dor/src/commands/`, `HELP_PATTERN_TOKENS` and pre-parsing in
 `lib/src/components/wall/use-dor-control.ts`; help snapshots in
 `dor/test/snapshots/help/`, pinned exhaustive by `dor/test/cli-help.test.mjs`.
 
+## dor move
+
+**Must move one Surface within this Window through the shared move coordinator.** Syntax and response fields are owned by `dor move --help` and `MoveSurfaceRequest` / `MoveSurfaceResponse` in `dor/src/commands/types.ts`; interaction and refusal rules follow `docs/specs/layout.md` → Moving Surfaces between Workspaces.
+
+**Must require exactly one destination: a Workspace argument or `--new`.** Never reserve the bare name `new`; `--workspace` scopes the source. CLI moves preserve focus unless `--focus` follows the pane; if the active source disappears, activate the destination in command mode. **Must refuse iframe moves unless `--dangerously-destroy-iframe-page-state` is explicit**, without a GUI prompt. Single-Workspace hosts refuse `surface.move` through `spansWorkspaces`.
+
+Source of truth: `moveCommand` in `dor/src/commands/move.ts`; `moveSurface` in `lib/src/components/wall/surface-move.ts`. Tests: `dor/test/move.test.mjs`, `lib/src/components/WorkspaceWindow.test.tsx`.
+
 ## dor workspace
 
 **`dor workspace` mutates and `dor list` enumerates**, so the overview has one
diff --git a/docs/specs/dor-tool.md b/docs/specs/dor-tool.md
index 47f81491c..d92a776f7 100644
--- a/docs/specs/dor-tool.md
+++ b/docs/specs/dor-tool.md
@@ -333,6 +333,8 @@ The Tool-specific local boundaries are `docs/specs/security-local.md` → Dor To
 
 **Must cold-restore an approved Tool by starting its saved command through integration-gated shell readiness**, then rediscover its port. Agent-resume commands do not override the saved Tool command. Pending approvals restore as ordinary terminals and execute nothing. **Must rebuild visible Tool metadata from its pane row when layout geometry is unusable**, rather than starting the command in a plain terminal with no serving behavior.
 
+Dirty or pending Tools refuse Surface moves between Workspaces: `docs/specs/layout.md` → Moving Surfaces between Workspaces.
+
 **Must retain live Tool browser params and OSC announcements in volatile Workspace-transfer content**, applying them to the destination plan without mutating the durable record. A serving iframe Tool participates in the ordinary iframe move confirmation. **Must refuse transfer while a Tool awaits approval or its browser startup has no session binding.**
 
 **Must pause serving updates during Workspace closure or transfer**, and recheck that a Workspace remains available after asynchronous launch lookup. Approval completion must not launch into a closing or transferring Workspace.
diff --git a/docs/specs/layout.md b/docs/specs/layout.md
index 921da3f04..12f57087a 100644
--- a/docs/specs/layout.md
+++ b/docs/specs/layout.md
@@ -88,7 +88,7 @@ Popups share the zoomed pane’s app-background halo.
 
 | Row | Content |
 |---|---|
-| Title | Derived display title, labeled Explain action, copyable source Surface ref and close at right |
+| Title | Derived display title, icon-only Explain bug immediately beside the title, copyable source Surface ref and close at right |
 | Dir | Home-abbreviated directory, its unlabeled absolute-path copy, native explorer action |
 | Ports | One scan per opening; scanning/empty/failure states; one port inline, multiple ports in a dropdown with count beside it; labeled launch actions |
 | Alerts | Source Watch and TODO controls; notification details directly below |
@@ -98,7 +98,7 @@ Popups share the zoomed pane’s app-background halo.
 
 **Must write visible action text in the Title, Dir, and Ports rows in lowercase**, since `iframe` and `agent-browser` cannot be capitalized; proper nouns such as Finder, tooltips, and accessible names keep their case.
 
-**Must keep the Title and Dir rows on one line.** Title: explain drops its label, the title truncates to 8 characters, the Surface ref drops to its copy icon (the tooltip keeps it), then the title truncates further. Dir: the explorer action drops its label before the directory truncates from its start, keeping its end.
+**Must keep the title and its icon-only Explain bug on one line**, with the bug immediately beside the title. In Window hosts, wrap the copyable ref and Move to workspace picker together below the title; keep Dir on one line. Title: the title truncates to 8 characters, the Surface ref drops to its copy icon (the tooltip keeps it), then the title truncates further. Dir: the explorer action drops its label before the directory truncates from its start, keeping its end.
 
 **Must focus context controls on opening.** Explicit entry into helper xterm gives it terminal keys; Escape there belongs to its program. Escape from controls closes the innermost disclosure, then context. Terminal clipboard routing uses the focused helper rather than the selected source. Actions use subdued link color and shared compact `OnOffSwitch` controls.
 
@@ -248,6 +248,19 @@ Source of truth: `deriveWorkspaceAutoName` in `lib/src/lib/workspace-autoname.ts
 
 Source of truth: `createWorkspaceMotion` in `lib/src/components/workspace-motion.ts`; `WorkspaceMotion` in `lib/src/components/WorkspaceMotion.tsx`; `closeAll` in `lib/src/components/Wall.tsx`.
 
+### Moving Surfaces between Workspaces
+
+- **Must move a Pane or Door on release over another Workspace tab**, inserting beside the destination's last selected live pane. Never activate on hover; highlight valid targets. A header/ Door press owns a pane drag; a tab press owns reorder and cross-Window tear-out. Strip gaps, the source tab, and disabled targets consume the drop without a layout move or tear-out. Escape and pointer cancellation change nothing.
+- **Must offer `+` and New workspace only when the source has more than one Surface**, counting Panes and Doors; create a receiving Wall with only the moved Surface. Disable the picker item and `+` drop otherwise, and refuse CLI `--new`.
+- **Must offer Move to workspace in terminal and Tool context** (placement: the Title row above), using the same coordinator as dragging. **Never add a browser context menu. Never add a command-mode move binding.** Browser Surfaces move by dragging or CLI.
+- **Must retain stable Surface identity and Session state while remounting in the destination Wall**: terminals keep their registry instance, browser automation reconnects, and a retained helper follows its source. Never close a departing Session. Pin a moved preview slot by removing its preview mark.
+- **Must confirm plain iframe and serving iframe Tool moves before creating a destination or changing membership**, with a stable random character over the Window content area. Doors remain minimized while waiting. Show “moving this iframe will trigger a refresh and reopen at its saved URL, possibly losing page state or returning to an earlier page”; the prompted character confirms, anything else cancels. Saved URLs are last-known URLs, not necessarily the page's current location. CLI consent follows `docs/specs/dor-cli.md` → dor move.
+- **Must refuse dirty Tools, pending Tool approval, browser startup, closing Surfaces/Workspaces and helper promotion**, rechecking after consent and asynchronous preparation. Dirty/pending refusals cannot be bypassed by iframe consent.
+- **Must follow a GUI move into destination passthrough** (acknowledgement: `docs/specs/alert.md` → Workspace union); CLI focus policy follows `docs/specs/dor-cli.md` → dor move. Remove a source with no Panes or Doors; if Doors remain but no pane does, refill normally.
+- **Must prepare before departure and roll back failed adoption**, restoring layout, Doors, parked state, selection, zoom, metadata and refs. Ref allocation belongs to `docs/specs/dor-cli.md` → Handle Model; coordinated durable publication belongs to `docs/specs/transport.md` → Persisted session types; Activity follows `docs/specs/alert.md` → Workspace union.
+
+Source of truth: `moveSurface` in `lib/src/components/wall/surface-move.ts`; `surfaceWorkspaceDrag` in `lib/src/components/wall/surface-workspace-drag.ts`; `MoveWorkspaceAction` in `lib/src/components/wall/MoveWorkspaceAction.tsx`; `prepareSurfaceMove` / `adoptSurfaceMove` in `lib/src/components/Wall.tsx`. Tests: `lib/src/components/WorkspaceWindow.test.tsx`, `lib/src/components/wall/LathHost.test.tsx`.
+
 ### Workspace lifecycle
 
 Each Wall renders one Workspace's Content and Baseboard (doors). Standalone mounts one Wall **per Workspace**; VS Code and the website playground mount a bare Wall with no Workspace id, which behaves exactly as a single-Workspace Window (VS Code's per-webview mapping is `docs/specs/vscode.md`).
@@ -565,7 +578,7 @@ Source of truth: `TerminalPane` in `lib/src/components/TerminalPane.tsx`; `Termi
 
 A newly added leaf grows in from the boundary it was placed against; `docs/specs/tiling-engine.md` → "Animation" → Enter owns the hint and its precedence.
 
-Shell-selection replacement shows a short fixed-position notice over the resulting pane, fading in/out over 1500ms via `.shell-spawn-notice`, suppressed to a static render under reduced motion.
+Shell-selection replacement shows a fixed-position notice over the resulting pane, fading in/out over 1500ms via `.shell-spawn-notice`, suppressed to a static render under reduced motion. Surface moves reuse it in alternate-screen programs (`docs/specs/dor-cli.md` → Handle Model).
 
 ### Kill (two-phase fade + tween reclaim)
 
diff --git a/docs/specs/shortcuts.md b/docs/specs/shortcuts.md
index 67ac11085..6c7ac93cd 100644
--- a/docs/specs/shortcuts.md
+++ b/docs/specs/shortcuts.md
@@ -94,6 +94,8 @@ Mirrored workbench chords — the terminal still receives the key too; [vscode.m
 | `⌘⇧P` / `Ctrl+Shift+P`, or `F1` (unmodified) | `workbench.action.showCommands` |
 | `⌘B` / `Ctrl+B` | `workbench.action.toggleSidebarVisibility` |
 
+Surface moves have no command-mode binding; see `docs/specs/layout.md` → Moving Surfaces between Workspaces.
+
 The standalone host contributes no chords; `docs/specs/standalone.md` owns its native-menu contract.
 
 ## Implementation references
diff --git a/docs/specs/terminal-context.md b/docs/specs/terminal-context.md
index 8ac446629..f00fa3f5b 100644
--- a/docs/specs/terminal-context.md
+++ b/docs/specs/terminal-context.md
@@ -59,6 +59,8 @@ Source of truth: `context` in `standalone/sidecar/pty-core.js`; `terminalContext
 
 Source of truth: `TerminalContextView` in `lib/src/components/wall/TerminalContextView.tsx`; `lib/src/stories/TerminalContext.stories.tsx` supplies sample output; `lib/src/stories/Wall.stories.tsx` exercises the live helper. `lib/src/stories/HelperPlacement.stories.tsx` checks rendered placement and real xterm input/focus retention; the gallery checks narrow controls and always-visible details. `visualSnapshot` in `lib/.storybook/preview.ts` suppresses scrollbar paint.
 
+The Window-host workspace picker follows `docs/specs/layout.md` → Moving Surfaces between Workspaces.
+
 ## Tool context
 
 **Must show a Tool's primary Session in Terminal Context instead of creating an auxiliary helper.** Reuse the title, directory, port, and alert presentation, showing Tool command status without helper Modify, Reset, or Promote controls; a preview slot's adds Keep open (`docs/specs/layout.md` → Pane header). Pending approval cannot open context.
diff --git a/docs/specs/tiling-engine.md b/docs/specs/tiling-engine.md
index 53481b247..8e2b8ac20 100644
--- a/docs/specs/tiling-engine.md
+++ b/docs/specs/tiling-engine.md
@@ -102,6 +102,8 @@ Adapter gesture (LathHost):
 
 Source of truth: `hitTest` in `lib/src/lib/lath/hit-test.ts`; `createDragController` in `lib/src/components/wall/lath-drag-controller.ts`; the drag callbacks in `lib/src/components/Wall.tsx`; presses in `lib/src/components/Door.tsx` / `lib/src/components/Baseboard.tsx`.
 
+**Must delegate Workspace-strip pane drops to `docs/specs/layout.md` → Moving Surfaces between Workspaces** before local hit testing; cross-Wall adoption remounts the leaf. Source of truth: `createDragController` in `lib/src/components/wall/lath-drag-controller.ts`.
+
 ## Restore tokens (Doors)
 
 `remove` returns a JSON-serializable `RestoreToken` of the leaf's ancestry: its own `leafId`; `siblingId` (the nearest same-parent sibling leaf it sat beside); `siblingLeafIds` / `siblingFingerprint` (that sibling *node's* leaf set and structure fingerprint, **written on every non-root removal and consulted only when the set holds more than one leaf**, i.e. when the sibling was itself a split subtree); `edge` (such that neighbor-tier restore is `split(siblingId, edge, leafId)`); its normalized `weight` and child `index`; and a structure-only `fingerprint` — kinds, dirs, leaf ids, no weights — of the parent split *post-removal*. **A root-leaf removal writes neither sibling field**, with `siblingId` and `fingerprint` null, so it can only reach the fallback tier. `restore` applies three tiers, driven from the Wall's `handleReattach`:
@@ -154,7 +156,7 @@ The **store** is the state machine + geometry + enter hints, reached directly as
 
 **`lath-wall-engine.ts` is the Wall-facing handle**, holding only what the store does not — the animator and its `exitMs` / `markDying` / `isDying` / frame + wake signals, the vocabulary maps (Edge ↔ dor direction, arrow → direction), the meta builders (`terminalLeafMeta` / `browserLeafMeta` / `leafMetaFromPersistedDoor`), `shouldParkOnMinimize`, and the persistence conveniences `serializeLayout` / `seed` — and **no selection/focus/mode/activation state**. Two projection rules bind its readers: `listPanes()` is tree pre-order + meta, so **parked leaves are not visible and are not listed**, while `getMeta(id)` *does* resolve Doored leaves.
 
-**All selection/focus/mode policy stays at the Wall** ([layout.md](layout.md)); three consequences bind editors here. Because nothing re-parents and nothing activates, a focus-neutral add 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. And **embed self-focus adoption rides `focusin`** (acceptance row 8), which LathHost surfaces as `onLeafFocused(id)` for the Wall to adopt like a click, there being no activation event to piggyback on. Spatial nav reaches `store.neighborOf` through the `WallNav` seam in `lib/src/components/wall/keyboard/types.ts`.
+**All selection/focus/mode policy stays at the Wall** ([layout.md](layout.md)); three consequences bind editors here. Within one Wall, nothing re-parents or activates, so a focus-neutral add 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. And **embed self-focus adoption rides `focusin`** (acceptance row 8), which LathHost surfaces as `onLeafFocused(id)` for the Wall to adopt like a click, there being no activation event to piggyback on. Spatial nav reaches `store.neighborOf` through the `WallNav` seam in `lib/src/components/wall/keyboard/types.ts`.
 
 Source of truth: `lib/src/components/wall/lath-wall-store.ts`; `lib/src/components/wall/lath-wall-engine.ts`.
 
@@ -162,7 +164,7 @@ Source of truth: `lib/src/components/wall/lath-wall-store.ts`; `lib/src/componen
 
 **An adapter owns exactly three things**: mapping input into Wall coordinates, applying animator frames to its scene each tick, and hosting pane content. Layout, ops, sash geometry, and animation timelines are core and shared; LathHost is the engine's only non-headless part.
 
-- One flat container; one stable `position: absolute` div per leaf, keyed by id, carrying `data-lath-leaf`, moved and resized by inline styles, hosting pane content as ordinary React children. The div is **never re-parented, never reordered, and never unmounted** except on a remove commit, and **leaf divs render in sorted-by-id DOM order, not tree order** — reordering keyed siblings moves DOM nodes, blurring the xterm inside one and reloading a moved `<iframe>`.
+- One flat container; one stable `position: absolute` div per leaf, keyed by id, carrying `data-lath-leaf`, moved and resized by inline styles, hosting pane content as ordinary React children. **Must never re-parent, reorder, or unmount the div within one Wall** except on a remove commit, and **leaf divs render in sorted-by-id DOM order, not tree order** — reordering keyed siblings moves DOM nodes, blurring the xterm inside one and reloading a moved `<iframe>`.
 - Each leaf div is a 30px header slot over a filling body, plus an optional whole-leaf **overlay** slot for chrome spanning header *and* body; header slot and zoom inset both derive from `PANE_HEADER_HEIGHT_PX` in `lib/src/components/design.tsx`. **All three slots resolve from `leafMeta.component` / `.tabComponent` through one registry, never a surface-kind branch beside it**; an unregistered key renders that slot empty, and `componentsOverride` is the jsdom test seam for all three. **The positioned wrapper carries geometry only** — header, body, and overlay live in a memoized inner unit keyed on `{ id, meta, parked, resolved components }`, so a geometry-only frame never re-renders the content.
 - 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 one commit on pointerup (`onCommitResize`); Escape cancels. **Geometry is reported through `store.setLayoutGeometry` from inside the measuring layout effect, never a passive effect over the rendered size** (rationale); the store's zero-area rejection is the backstop.
 - Zoom retargets only the chosen leaf to the wall rect inset by `LATH_ZOOM_MARGIN` (half a pane header) and elevates it above tiled/dying panes and sashes, applying the blurred `LATH_ZOOM_SHADOW` while elevated. Unzoom keeps both until the return frame settles.
diff --git a/docs/specs/transport.md b/docs/specs/transport.md
index 113e02cd2..e270184ca 100644
--- a/docs/specs/transport.md
+++ b/docs/specs/transport.md
@@ -243,6 +243,8 @@ Source of truth: `ManagedVoicePort` in `lib/src/lib/platform/managed-voice-types
 
 **Each mounted Workspace publishes its `PersistedSession` to a Window collector**, which orders them by the Workspace store and writes the whole Window through one debounced writer the host installs at boot. **A Workspace with neither a published nor a boot-seeded session is dropped rather than written empty**, so a snapshot taken mid-boot cannot replace a restored Workspace with a blank one. **A Workspace's save compares against its own previous record** — seeded from disk until its Wall publishes — never the Window's active one, or a dead PTY's retained cwd and alert would come from the wrong Workspace. **Reordering, renaming, or switching the active Workspace writes too**: each changes the blob with no Session changing. A `PersistedWorkspace` is a `WorkspaceId`, a `name`, `nameIsAuto`, and that Workspace's `PersistedSession`. **Always write `nameIsAuto`**; lacking it, only a `Workspace <n>` name is auto. The top-level snapshot is a `PersistedWindow` (its own `version: 1`) wrapping v3 sessions: the ordered `PersistedWorkspace` list plus the active `WorkspaceId`. **VS Code does not use it** — each webview persists one bare `PersistedSession`, its single Workspace, through its own per-surface state API (`docs/specs/vscode.md`).
 
+**Must publish both Workspace records together across a Surface move**, fencing saves collected before ownership changed and retaining a departed Session's previous cwd/alert in the destination. Window writes are held until both records publish or the move rolls back. Source of truth: `beginWorkspaceSessionBatch` / `invalidateWorkspaceSaves` / `moveRetainedSurfaceRecord` in `lib/src/lib/window-session-aggregator.ts`; `doSave` in `lib/src/components/wall/use-session-persistence.ts`.
+
 **The Window wrapping lives at the standalone adapter boundary, never in the shared save/restore code.** `window-persistence.ts` owns the JSON and the storage slot over a `SessionKeyValueStore` synchronous slot (`docs/specs/standalone.md` → Persistence); the shared save/restore code still operates on a bare `PersistedSession`, which the boot hands it per Workspace. **A Window-persisting adapter answers through `getWindowState` / `saveWindowState`, and answers nothing on the bare-Session `getState` / `saveState` pair** — its blob is a Window and every shared reader of `getState` wants a Session. **A blob written before standalone persisted Windows is wrapped as the window's one Workspace**; that is the only migration.
 
 **A save probes every non-browser pane's cwd in one host round trip where the adapter offers `getCwds`**, falling back to one `getCwd` per id: standalone resolves them with a synchronous process scan on the sidecar's only event loop, so N panes must cost one scan rather than N. **A flush may say `probeCwd: false`** and keep each pane's previously persisted cwd — the post-kill quit flush, where every probe answers null and is discarded for that value anyway (`docs/specs/standalone.md` → "Quit flow"). Pinned by `lib/src/lib/session-save.test.ts`.
diff --git a/dor/skill.md b/dor/skill.md
index a41a03b3a..d9db49216 100644
--- a/dor/skill.md
+++ b/dor/skill.md
@@ -43,7 +43,7 @@ Text output is designed for you to read: it is terse and carries the same refs.
 
 ## Surface handles
 
-- `surface:N` — short ref, e.g. `surface:3`. Stable for the surface's whole life: reordering, minimizing, zooming, and focus changes never change it, and numbers are never reused after a kill. A ref for a killed surface fails loudly instead of silently retargeting, so refs from earlier in your session stay safe to use.
+- `surface:N` — short ref, e.g. `surface:3`. Stable while the Surface stays in the same Workspace: reordering, minimizing, zooming, and focus changes never change it, and numbers are never reused after a kill. A ref for a killed surface fails loudly instead of silently retargeting, moving to another Workspace retires the old ref and allocates a new destination ref.
 - A stable surface id (or `surface:<stable-id>`) — from `--json` output.
 - `surface:self` — the terminal you are running in.
 - `surface:focused` — whatever the user currently has focused.
@@ -208,7 +208,9 @@ dor workspace switch workspace:build      # move the user to it
 dor workspace close workspace:2 --force   # close it and everything in it
 ```
 
-A Window holds several Workspaces, each with its own surfaces and its own `surface:1`. You almost never need these: your commands land in the Workspace you were started in, and creating one is a change the user sees. When you do, name one as `workspace:<n>` or `workspace:<name>`, and pass `--workspace <ref>` to any surface command to act in it (`dor list --all` lists every Workspace in this Window). A surface's stable id finds it in any Workspace without that flag; `surface:N` does not, since every Workspace has one. `close` refuses a Workspace holding your running work unless you pass `--force`.
+A Window holds several Workspaces, each with its own surfaces and its own `surface:1`. You almost never need these: your commands land in the Workspace that currently owns your terminal's stable ID, and creating one is a change the user sees. When you do, name one as `workspace:<n>` or `workspace:<name>`, and pass `--workspace <ref>` to any surface command to act in it (`dor list --all` lists every Workspace in this Window). A surface's stable id finds it in any Workspace without that flag; `surface:N` does not, since every Workspace has one. `close` refuses a Workspace holding your running work unless you pass `--force`.
+
+**Use stable Surface IDs across moves.** `dor move <surface> <workspace>` moves one pane; `--new` creates a Workspace, and `--focus` follows it. A Workspace named `new` remains targetable. If your own terminal moves, cached `surface:N` refs immediately resolve in the destination: `dor kill surface:3` can target someone else's pane. Unscoped `dor ensure -- pnpm dev` searches only the destination and may duplicate the server you left behind. Keep that server's stable ID, or target its original Workspace with `--workspace`. The moved terminal prints a local notice with its old/new handles; the command response prints its new ref. Iframes require `--dangerously-destroy-iframe-page-state` and reopen at their saved URL; dirty or pending Tools refuse even with that flag.
 
 ## Recipes
 
diff --git a/dor/src/cli.ts b/dor/src/cli.ts
index 77c3bc9ba..a937480dc 100644
--- a/dor/src/cli.ts
+++ b/dor/src/cli.ts
@@ -14,6 +14,7 @@ import { appCommand } from './commands/app.js';
 import { awaitCommand } from './commands/await.js';
 import { ensureCommand } from './commands/ensure.js';
 import { iframeCommand } from './commands/iframe.js';
+import { moveCommand } from './commands/move.js';
 import { killCommand } from './commands/kill.js';
 import { listCommand } from './commands/list.js';
 import { readCommand } from './commands/read.js';
@@ -57,6 +58,8 @@ export type {
   IdFormat,
   IframeSurfaceRequest,
   IframeSurfaceResponse,
+  MoveSurfaceRequest,
+  MoveSurfaceResponse,
   KillSurfaceConfirmation,
   KillSurfaceRequest,
   KillSurfaceResponse,
@@ -103,6 +106,7 @@ const COMMANDS = [
   readCommand,
   awaitCommand,
   killCommand,
+  moveCommand,
   iframeCommand,
   agentBrowserCommand,
   playwrightCommand,
@@ -122,6 +126,7 @@ const ROUTES = {
   read: readCommand.command,
   await: awaitCommand.command,
   kill: killCommand.command,
+  move: moveCommand.command,
   iframe: iframeCommand.command,
   'agent-browser': agentBrowserCommand.command,
   playwright: playwrightCommand.command,
diff --git a/dor/src/commands/move.ts b/dor/src/commands/move.ts
new file mode 100644
index 000000000..acfc91fc4
--- /dev/null
+++ b/dor/src/commands/move.ts
@@ -0,0 +1,59 @@
+import { buildCommand } from '@stricli/core';
+import type { Command, DorCommandContext, MoveSurfaceResponse, WorkspaceScopedFlags } from './types.js';
+import { errorMessage, renderJson, requireControlClient, stringParser, workspaceFlag, workspaceParam, writeStdout } from './shared.js';
+
+interface MoveFlags extends WorkspaceScopedFlags {
+  readonly new?: boolean;
+  readonly focus?: boolean;
+  readonly dangerouslyDestroyIframePageState?: boolean;
+  readonly json?: boolean;
+}
+
+export const moveCommand: Command = {
+  name: 'move',
+  command: buildCommand<MoveFlags, string[], DorCommandContext>({
+    docs: {
+      brief: 'Move a surface to another workspace.',
+      customUsage: ['<surface> <workspace>|--new [--workspace source] [--focus] [--dangerously-destroy-iframe-page-state] [--json]'],
+      fullDescription: `Moves a Surface within this Window, preserving its stable ID and allocating a new surface:N ref in the destination. Focus stays put unless --focus is set. --new creates a Workspace; it is refused for the source's only Surface.
+
+Plain iframes reopen at their saved URL and require --dangerously-destroy-iframe-page-state. Dirty or pending Tools cannot move, even with that flag.
+
+After your own pane moves, short refs and unscoped ensure resolve in the destination. Use stable Surface IDs across moves.
+
+To move an entire Workspace to another Window or strip position, use dor workspace move.
+
+Text output: moved surface:4 workspace:2`,
+    },
+    parameters: {
+      flags: {
+        new: { kind: 'boolean', brief: 'Create a new destination Workspace.', optional: true, withNegated: false },
+        focus: { kind: 'boolean', brief: 'Follow the moved Surface into passthrough.', optional: true, withNegated: false },
+        dangerouslyDestroyIframePageState: { kind: 'boolean', brief: 'Accept reopening an iframe at its saved URL.', optional: true, withNegated: false },
+        json: { kind: 'boolean', brief: 'Print JSON output.', optional: true, withNegated: false },
+        workspace: workspaceFlag,
+      },
+      positional: { kind: 'array', minimum: 1, parameter: { parse: stringParser, brief: 'Surface and destination Workspace.', placeholder: 'args' } },
+    },
+    func: async function(flags, ...args) {
+      if ((flags.new === true && args.length !== 1) || (flags.new !== true && args.length !== 2)) {
+        return new Error('dor move requires a surface and exactly one destination: <workspace> or --new');
+      }
+      const client = requireControlClient(this.options);
+      if (client instanceof Error) return client;
+      try {
+        const result = await client.moveSurface({
+          surface: args[0], destination: flags.new ? { new: true } : { workspace: args[1] },
+          focus: flags.focus === true, dangerouslyDestroyIframePageState: flags.dangerouslyDestroyIframePageState === true,
+          ...workspaceParam(flags.workspace),
+        });
+        writeStdout(this, renderMoveResponse(result, flags.json === true));
+      } catch (error) { return new Error(errorMessage(error)); }
+    },
+  }),
+};
+
+function renderMoveResponse(result: MoveSurfaceResponse, json: boolean): string {
+  if (!json) return `${result.status} ${result.surfaceRef} ${result.workspaceRef}\n`;
+  return renderJson({ status: result.status, surface_id: result.surfaceId, surface_ref: result.surfaceRef, workspace_id: result.workspaceId, workspace_ref: result.workspaceRef });
+}
diff --git a/dor/src/commands/types.ts b/dor/src/commands/types.ts
index 708e9bf64..93d4fb86a 100644
--- a/dor/src/commands/types.ts
+++ b/dor/src/commands/types.ts
@@ -429,6 +429,22 @@ export interface KillSurfaceResponse {
   surfaceRef: string;
 }
 
+/** Move one Surface within this Window. Exactly one destination is required. */
+export type MoveSurfaceRequest = WorkspaceScopedRequest & {
+  surface: string;
+  destination: { workspace: string } | { new: true };
+  focus: boolean;
+  dangerouslyDestroyIframePageState: boolean;
+};
+
+export interface MoveSurfaceResponse {
+  status: 'moved';
+  surfaceId: string;
+  surfaceRef: string;
+  workspaceId: string;
+  workspaceRef: string;
+}
+
 export interface IframeSurfaceRequest extends WorkspaceScopedRequest {
   minimized: boolean;
   surface?: string;
@@ -544,6 +560,7 @@ export interface ControlClient {
   sendSurface(request: SendSurfaceRequest): Promise<SendSurfaceResponse>;
   readSurface(request: ReadSurfaceRequest): Promise<ReadSurfaceResponse>;
   awaitSurface(request: AwaitSurfaceRequest): Promise<AwaitSurfaceResponse>;
+  moveSurface(request: MoveSurfaceRequest): Promise<MoveSurfaceResponse>;
   killSurface(request: KillSurfaceRequest): Promise<KillSurfaceResponse>;
   iframeSurface(request: IframeSurfaceRequest): Promise<IframeSurfaceResponse>;
   resolveOpenTarget(request: ResolveOpenTargetRequest): Promise<ResolveOpenTargetResponse>;
diff --git a/dor/src/commands/workspace.ts b/dor/src/commands/workspace.ts
index 8d09fdf98..277f562d3 100644
--- a/dor/src/commands/workspace.ts
+++ b/dor/src/commands/workspace.ts
@@ -108,7 +108,9 @@ export const workspaceCommand: Command = {
     docs: {
       brief: 'Create, rename, close, switch, or move Workspaces.',
       customUsage: USAGE,
-      fullDescription: `Manages this Window's Workspaces. Listing them is dor list --workspaces (the overview) and dor list --all (every Workspace's Surfaces); this command only mutates.
+      fullDescription: `To move a single Surface between Workspaces, use dor move.
+
+Manages this Window's Workspaces. Listing them is dor list --workspaces (the overview) and dor list --all (every Workspace's Surfaces); this command only mutates.
 
 A <workspace> target is workspace:<n> — a stable number that a strip reorder or a move between windows never changes — or workspace:<name>, which resolves only when exactly one Workspace carries that name and otherwise fails listing the candidates. Both forms are also accepted bare ("2", "build"). A target in another window is routed there.
 
diff --git a/dor/src/control-client.ts b/dor/src/control-client.ts
index bf344304c..8963f3138 100644
--- a/dor/src/control-client.ts
+++ b/dor/src/control-client.ts
@@ -13,6 +13,8 @@ import type {
   EnsureSurfaceResponse,
   IframeSurfaceRequest,
   IframeSurfaceResponse,
+  MoveSurfaceRequest,
+  MoveSurfaceResponse,
   KillSurfaceRequest,
   KillSurfaceResponse,
   ListSurfacesRequest,
@@ -149,6 +151,10 @@ export class SocketControlClient implements ControlClient {
     );
   }
 
+  moveSurface(request: MoveSurfaceRequest): Promise<MoveSurfaceResponse> {
+    return this.request<MoveSurfaceResponse>(SURFACE_CONTROL_METHODS.move, request);
+  }
+
   killSurface(request: KillSurfaceRequest): Promise<KillSurfaceResponse> {
     return this.request<KillSurfaceResponse>(SURFACE_CONTROL_METHODS.kill, request);
   }
diff --git a/dor/src/protocol.ts b/dor/src/protocol.ts
index 6612ad45a..abfe5a8a1 100644
--- a/dor/src/protocol.ts
+++ b/dor/src/protocol.ts
@@ -22,6 +22,7 @@ export const SURFACE_CONTROL_METHODS = {
   read: 'surface.read',
   await: 'surface.await',
   kill: 'surface.kill',
+  move: 'surface.move',
   iframe: 'surface.iframe',
   browser: 'surface.browser',
   browserViewport: 'surface.browserViewport',
@@ -106,7 +107,7 @@ export function isWorkspaceControlMethod(method: string): method is WorkspaceCon
  * Workspace refuses exactly these (`docs/specs/vscode.md` → "Workspaces").
  */
 export function spansWorkspaces(method: string, params?: Record<string, unknown>): boolean {
-  return isWorkspaceControlMethod(method)
+  return method === SURFACE_CONTROL_METHODS.move || isWorkspaceControlMethod(method)
     || (method === SURFACE_CONTROL_METHODS.list && params?.scope === 'all');
 }
 
diff --git a/dor/test/move.test.mjs b/dor/test/move.test.mjs
new file mode 100644
index 000000000..1e129fa5e
--- /dev/null
+++ b/dor/test/move.test.mjs
@@ -0,0 +1,28 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { runCli } from '../dist/cli.js';
+import { spansWorkspaces } from '../dist/protocol.js';
+
+const response = { status: 'moved', surfaceId: 'stable', surfaceRef: 'surface:4', workspaceId: 'ws2', workspaceRef: 'workspace:2' };
+test('move targets a Workspace named new and prints the new ref', async () => {
+  let received;
+  const result = await runCli(['move', 'surface:3', 'new', '--workspace', 'source'], { client: { moveSurface: async request => { received = request; return response; } } });
+  assert.equal(result.stdout, 'moved surface:4 workspace:2\n');
+  assert.equal(result.exitCode, 0);
+  assert.deepEqual(received, { surface: 'surface:3', destination: { workspace: 'new' }, workspace: 'source', focus: false, dangerouslyDestroyIframePageState: false });
+});
+test('move --new carries focus and iframe consent and prints all stable handles in JSON', async () => {
+  let received;
+  const result = await runCli(['move', 'stable', '--new', '--focus', '--dangerously-destroy-iframe-page-state', '--json'], { client: { moveSurface: async request => { received = request; return response; } } });
+  assert.equal(result.exitCode, 0);
+  assert.deepEqual(received, { surface: 'stable', destination: { new: true }, focus: true, dangerouslyDestroyIframePageState: true });
+  assert.deepEqual(JSON.parse(result.stdout), { status: 'moved', surface_id: 'stable', surface_ref: 'surface:4', workspace_id: 'ws2', workspace_ref: 'workspace:2' });
+});
+test('move requires exactly one destination before contacting the host', async () => {
+  for (const args of [['surface:3'], ['surface:3', 'workspace:2', '--new'], ['surface:3', 'workspace:2', 'workspace:3']]) {
+    const result = await runCli(['move', ...args], { client: { moveSurface: () => { throw new Error('host should not be contacted'); } } });
+    assert.equal(result.exitCode, 1);
+    assert.match(result.stderr, /exactly one destination/);
+  }
+  assert.equal(spansWorkspaces('surface.move'), true);
+});
diff --git a/dor/test/snapshots/help/dor.md b/dor/test/snapshots/help/dor.md
index 3c8de4457..9533ee94f 100644
--- a/dor/test/snapshots/help/dor.md
+++ b/dor/test/snapshots/help/dor.md
@@ -16,6 +16,7 @@ USAGE
   dor read <surface> [--json] [--lines count] [--scrollback] [--workspace ref]
   dor await <surface> --until condition [--json] [--timeout seconds] [--workspace ref]
   dor kill <surface> [--confirm-if-read text|--confirm-dangerously] [--json] [--workspace ref]
+  dor move [--new] [--focus] [--dangerously-destroy-iframe-page-state] [--json] [--workspace ref] <args>...
   dor iframe [--json] [--minimize] [--surface id|ref] [--workspace ref] <target>
   dor agent-browser [--key name|--session name|--surface handle] [--workspace ref] [args...]
   dor playwright [--key name] [--session name] [--surface handle] [--workspace ref] <args>...
@@ -41,6 +42,7 @@ COMMANDS
   read           Read terminal text from a surface.
   await          Wait until a terminal surface finishes.
   kill           Kill a surface.
+  move           Move a surface to another workspace.
   iframe         Open a target in an iframe surface.
   agent-browser  Drive a browser surface via your agent-browser install.
   playwright     Drive a browser surface via your playwright CLI install.
diff --git a/dor/test/snapshots/help/move.md b/dor/test/snapshots/help/move.md
new file mode 100644
index 000000000..600127e52
--- /dev/null
+++ b/dor/test/snapshots/help/move.md
@@ -0,0 +1,32 @@
+# dor move
+
+Invocation: `dor move --help`
+
+```text
+USAGE
+  dor move <surface> <workspace>|--new [--workspace source] [--focus] [--dangerously-destroy-iframe-page-state] [--json]
+  dor move --help
+
+Moves a Surface within this Window, preserving its stable ID and allocating a new surface:N ref in the destination. Focus stays put unless --focus is set. --new creates a Workspace; it is refused for the source's only Surface.
+
+Plain iframes reopen at their saved URL and require --dangerously-destroy-iframe-page-state. Dirty or pending Tools cannot move, even with that flag.
+
+After your own pane moves, short refs and unscoped ensure resolve in the destination. Use stable Surface IDs across moves.
+
+To move an entire Workspace to another Window or strip position, use dor workspace move.
+
+Text output: moved surface:4 workspace:2
+
+FLAGS
+     [--new]                                    Create a new destination Workspace.
+     [--focus]                                  Follow the moved Surface into passthrough.
+     [--dangerously-destroy-iframe-page-state]  Accept reopening an iframe at its saved URL.
+     [--json]                                   Print JSON output.
+     [--workspace]                              Workspace to act in, instead of the caller's.
+  -h  --help                                    Print help information and exit
+      --                                        All subsequent inputs should be interpreted as arguments
+
+ARGUMENTS
+  args...  Surface and destination Workspace.
+
+```
diff --git a/dor/test/snapshots/help/workspace.md b/dor/test/snapshots/help/workspace.md
index 7ece1414b..141504013 100644
--- a/dor/test/snapshots/help/workspace.md
+++ b/dor/test/snapshots/help/workspace.md
@@ -11,6 +11,8 @@ USAGE
   dor workspace move <workspace> [--window <label|new>] [--index <n>] [--dangerously-destroy-iframe-page-state] [--json]
   dor workspace --help
 
+To move a single Surface between Workspaces, use dor move.
+
 Manages this Window's Workspaces. Listing them is dor list --workspaces (the overview) and dor list --all (every Workspace's Surfaces); this command only mutates.
 
 A <workspace> target is workspace:<n> — a stable number that a strip reorder or a move between windows never changes — or workspace:<name>, which resolves only when exactly one Workspace carries that name and otherwise fails listing the candidates. Both forms are also accepted bare ("2", "build"). A target in another window is routed there.
diff --git a/lib/src/components/KillConfirm.tsx b/lib/src/components/KillConfirm.tsx
index a3b10becb..f0aa38e43 100644
--- a/lib/src/components/KillConfirm.tsx
+++ b/lib/src/components/KillConfirm.tsx
@@ -27,6 +27,7 @@ export function KillConfirmModal({
   targetElement,
   title = 'Confirm kill',
   detail,
+  cancelHint,
   layer,
 }: {
   char: string;
@@ -37,6 +38,7 @@ export function KillConfirmModal({
    *  (a Workspace move that loses iframe page state); they name themselves. */
   title?: string;
   detail?: string;
+  cancelHint?: string;
   layer?: ModalLayer;
 }) {
   const cancelButtonRef = useRef<HTMLButtonElement>(null);
@@ -74,7 +76,7 @@ export function KillConfirmModal({
           className="contents group cursor-pointer"
         >
           <Shortcut className="justify-self-end group-hover:text-foreground transition-colors">Esc</Shortcut>
-          <span className="justify-self-start group-hover:text-foreground transition-colors">to cancel</span>
+          <span className="justify-self-start group-hover:text-foreground transition-colors">{cancelHint ?? 'to cancel'}</span>
         </button>
       </div>
     </ModalFrame>
diff --git a/lib/src/components/Wall.tsx b/lib/src/components/Wall.tsx
index 4b6bf9a2b..469525ab5 100644
--- a/lib/src/components/Wall.tsx
+++ b/lib/src/components/Wall.tsx
@@ -92,6 +92,8 @@ import {
 import { usePreviewSlotPin } from './wall/preview-slot';
 import { browserSurfaceUrl, hostPathDisplay, iframeRefusal } from './wall/browser-url';
 import { WorkspaceSelectionOverlay } from './wall/WorkspaceSelectionOverlay';
+import { getAgentBrowserSurfaceController } from './wall/agent-browser-surface-controller';
+import { surfaceWorkspaceDrag } from './wall/surface-workspace-drag';
 import { LathHost } from './wall/LathHost';
 import {
   type LathWallEngine,
@@ -146,6 +148,7 @@ type ShellSpawnNoticeState = {
   id: string;
   text: string;
   nonce: number;
+  duration: number;
 };
 
 export type { DoorAfterRestoreAction, DoorChip, DooredItem, WallBootProps, WallEvent, WallMode, WallSelectionKind } from './wall/wall-types';
@@ -239,6 +242,8 @@ function ShellSpawnNotice({
         top: rect.top + 38,
         left: rect.left + rect.width / 2,
         transform: 'translateX(-50%)',
+        maxWidth: Math.min(420, Math.max(0, rect.width - 16)),
+        animationDuration: `${notice.duration}ms`,
       }}
     >
       {notice.text}
@@ -255,6 +260,7 @@ export function Wall({
   initialDoors,
   initialSurfaceRefs,
   initialSurfaceRefsNext,
+  emptyForMove = false,
   onEvent,
   baseboardNotice,
   dialogHost,
@@ -621,7 +627,7 @@ export function Wall({
     return false;
   }, [selectPane]);
 
-  const showShellSpawnNotice = useCallback((id: string, text: string) => {
+  const showShellSpawnNotice = useCallback((id: string, text: string, duration = 1500) => {
     if (shellSpawnNoticeTimerRef.current) {
       clearTimeout(shellSpawnNoticeTimerRef.current);
     }
@@ -629,11 +635,12 @@ export function Wall({
       id,
       text,
       nonce: ++shellSpawnNoticeCounterRef.current,
+      duration,
     });
     shellSpawnNoticeTimerRef.current = setTimeout(() => {
       setShellSpawnNotice(null);
       shellSpawnNoticeTimerRef.current = null;
-    }, 1500);
+    }, duration);
   }, []);
 
   /** Why the helper's running work (or a failed inspection) blocks closing its
@@ -897,6 +904,7 @@ export function Wall({
   useEffect(() => {
     if (lathSeededRef.current) return;
     lathSeededRef.current = true;
+    if (emptyForMove) return;
 
     // Hydrate: the restored Lath layout when usable, else fresh panes. The restored
     // Door rows ride along so their meta lands in the store, which owns it from here
@@ -929,6 +937,7 @@ export function Wall({
    *  auto-spawn refill, which would otherwise repopulate the Workspace being
    *  destroyed the moment its last pane goes. */
   const closingWorkspaceRef = useRef(false);
+  const movingSurfaceRef = useRef(emptyForMove);
 
   /** This Wall's member Surfaces: visible panes then Doors. The one expression
    *  behind membership, `ownsSurface`, and `closeAll`. */
@@ -937,15 +946,18 @@ export function Wall({
     [lath],
   );
 
+  /** A member whose live document cannot leave its webview: a move reopens it. */
+  const isIframeSurface = useCallback((id: string): boolean => {
+    const params = lath.getMeta(id)?.params;
+    return (isBrowserParams(params) || (isToolParams(params) && browserUrlFromParams(params) !== null))
+      && resolveRenderMode(params) === 'iframe';
+  }, [lath]);
+
   /** The members whose live document a move between Windows cannot carry, by
    *  the ref a `dor` caller can act on. */
   const iframeSurfaceRefs = useCallback(
-    (): string[] => memberSurfaceIds().filter((id) => {
-      const params = lath.getMeta(id)?.params;
-      return (isBrowserParams(params) || (isToolParams(params) && browserUrlFromParams(params) !== null))
-        && resolveRenderMode(params) === 'iframe';
-    }).map(surfaceRefForId),
-    [lath, memberSurfaceIds, surfaceRefForId],
+    (): string[] => memberSurfaceIds().filter(isIframeSurface).map(surfaceRefForId),
+    [isIframeSurface, memberSurfaceIds, surfaceRefForId],
   );
 
   const browserSessions = useCallback(
@@ -1030,7 +1042,7 @@ export function Wall({
         prevLeafIdsRef.current = new Set(currentIds);
         publishMembership();
       }
-      if (closingWorkspaceRef.current) return;
+      if (closingWorkspaceRef.current || movingSurfaceRef.current) return;
       // A commit that empties the tree took every pre-commit leaf with it.
       const [departedId] = prevIds;
       refillEmptyTree(departedId);
@@ -1754,7 +1766,92 @@ export function Wall({
   // The methods close over current state, so they are rebuilt each render and
   // assigned INTO one stable object: the registry holds that object, so a
   // re-render never replaces a registered entry.
+  // Capture before a synchronous commit. Rollback restores the complete Wall,
+  // including a Door's held rect and the ref allocator, without killing Sessions.
+  const captureMoveRollback = (incomingId?: string) => {
+    const snapshot = lath.store.getSnapshot();
+    const savedDoors = doorsRef.current;
+    const refs = new Map(dorSurfaceRefsRef.current);
+    const next = nextDorSurfaceRefIndexRef.current;
+    const selected = selectedIdRef.current;
+    const type = selectedTypeRef.current;
+    const last = lastPaneIdRef.current;
+    const savedMode = modeRef.current;
+    const context = terminalContextRef.current;
+    return () => {
+      movingSurfaceRef.current = true;
+      // A temporary auto-refill may already have mounted its default shell.
+      for (const member of memberSurfaceIds()) {
+        if (member !== incomingId && !snapshot.leafMeta.has(member)) disposeSession(member);
+      }
+      doorsRef.current = savedDoors; setDoors(savedDoors);
+      dorSurfaceRefsRef.current = refs; nextDorSurfaceRefIndexRef.current = next;
+      lath.store.restoreSnapshot(snapshot);
+      selectedIdRef.current = selected; setSelectedId(selected);
+      selectedTypeRef.current = type; setSelectedType(type);
+      lastPaneIdRef.current = last;
+      modeRef.current = savedMode; setMode(savedMode);
+      setTerminalContext(context);
+      publishMembership();
+    };
+  };
   const methods: Omit<WallHandle, 'workspaceId'> = {
+    canMoveSurfaces: workspaceId !== undefined,
+    prepareSurfaceMove: (id) => {
+      const meta = lath.getMeta(id);
+      if (!ownsSurface(id) || !meta) throw new Error('The Surface is no longer in this Workspace');
+      if (closingWorkspaceRef.current || lath.isDying(id) || isClosingSurface(id)) throw new Error('The Surface is closing');
+      if (getHelper(id)?.promoting) throw new Error('Wait for helper promotion before moving this Surface');
+      if (isToolDirty(id, meta.params)) throw new Error('Save or discard Tool edits before moving this Surface');
+      captureToolParams(lath, [id]);
+      if ((meta.params?.launchSession && !meta.params?.session) || getAgentBrowserSurfaceController(id)?.snapshot().phase === 'launching') throw new Error('Wait for the browser to connect before moving this Surface');
+      const surfaceRef = surfaceRefForId(id);
+      const params = { ...meta.params };
+      delete params.toolPreview;
+      return {
+        meta: { ...meta, params }, surfaceRef,
+        iframe: isIframeSurface(id), terminal: surfaceHasTerminal(id),
+        depart: () => {
+          const rollback = captureMoveRollback();
+          movingSurfaceRef.current = true;
+          if (terminalContextRef.current?.id === id) cancelContextPortLaunches();
+          setTerminalContext(current => current?.id === id ? null : current);
+          if (nav.hasPane(id)) {
+            if (!lath.store.removeLeaf(id).ok) throw new Error('Could not detach the Surface');
+          } else { removeDoor(id); lath.store.forgetLeaf(id); }
+          forgetSurfaceRef(id);
+          if (selectedIdRef.current === id) {
+            exitTerminalMode();
+            const nextId = livePaneId();
+            if (nextId) selectPane(nextId);
+            else { selectedIdRef.current = null; setSelectedId(null); lastPaneIdRef.current = null; }
+          }
+          publishMembership();
+          return rollback;
+        },
+      };
+    },
+    adoptSurfaceMove: (id, meta) => {
+      if (ownsSurface(id) || closingWorkspaceRef.current) throw new Error('The destination cannot accept this Surface');
+      const rollback = captureMoveRollback(id);
+      movingSurfaceRef.current = true;
+      const ref = livePaneId();
+      if (!lath.store.addLeaf(id, meta, ref ? { refId: ref, edge: lath.store.autoEdgeFor(ref) } : null).ok) throw new Error('Could not place the Surface');
+      const surfaceRef = surfaceRefForId(id);
+      publishMembership();
+      return { surfaceRef, rollback };
+    },
+    finishSurfaceMove: () => {
+      movingSurfaceRef.current = false;
+      if (memberSurfaceIds().length) refillEmptyTree();
+    },
+    focusSurface: (id, acknowledge) => {
+      if (acknowledge) wallActionsRef.current.onFocusPane(id);
+      else enterTerminalMode(id);
+    },
+    showMoveNotice: (id, text) => showShellSpawnNotice(id, text, 8000),
+    serializePersistence: persistence.serialize,
+
     surfaceIds: memberSurfaceIds,
     ownsSurface,
     iframeSurfaceRefs,
@@ -2318,6 +2415,7 @@ export function Wall({
                   onProposeMinimize={onProposeMinimize}
                   externalDrag={doorDrag ? { id: doorDrag.item.id, startX: doorDrag.startX, startY: doorDrag.startY } : null}
                   onExternalDrop={onExternalDrop}
+                  workspaceDrag={workspaceId !== undefined ? surfaceWorkspaceDrag : undefined}
                 />
                 <WorkspaceSelectionOverlay lathStore={lath.store} subscribeLathFrames={lath.subscribeFrames} selectedId={terminalContext?.id ?? selectedId} selectedType={terminalContext ? 'pane' : selectedType} mode={mode} active={active} contextHelper={lath.contextHelper} />
               </div>
diff --git a/lib/src/components/WorkspaceKillConfirm.tsx b/lib/src/components/WorkspaceKillConfirm.tsx
index 7d3ff8e1e..25705f1b8 100644
--- a/lib/src/components/WorkspaceKillConfirm.tsx
+++ b/lib/src/components/WorkspaceKillConfirm.tsx
@@ -13,6 +13,7 @@ export function WorkspaceKillConfirm({ char, onConfirm, onCancel, canConfirm, ti
   title?: string;
   targetElement?: HTMLElement | null;
   detail?: string;
+  cancelHint?: string;
   layer?: ModalLayer;
 }) {
   // Callers pass fresh closures each render; both listeners read the latest ones
diff --git a/lib/src/components/WorkspaceStrip.tsx b/lib/src/components/WorkspaceStrip.tsx
index 792ea5085..738004eae 100644
--- a/lib/src/components/WorkspaceStrip.tsx
+++ b/lib/src/components/WorkspaceStrip.tsx
@@ -72,7 +72,7 @@ export function WorkspaceStrip({
   const { workspaces, activeId } = useSyncExternalStore(subscribeToWorkspaces, getWorkspacesSnapshot);
   const membership = useSyncExternalStore(subscribeToWorkspaceSurfaces, getWorkspaceSurfacesSnapshot);
   const activity = useSyncExternalStore(subscribeToActivity, getActivitySnapshot);
-  const { renamingId, pendingClose, pendingMove, moveError } = useSyncExternalStore(subscribeToWorkspaceUi, getWorkspaceUiSnapshot);
+  const { renamingId, pendingClose, pendingMove, pendingSurfaceMove, moveError } = useSyncExternalStore(subscribeToWorkspaceUi, getWorkspaceUiSnapshot);
   const [draggingId, setDraggingId] = useState<WorkspaceId | null>(null);
 
   const stripRef = useRef<HTMLDivElement>(null);
@@ -80,7 +80,7 @@ export function WorkspaceStrip({
 
   // The editor and the confirmation both sit outside every Wall, so a
   // capture-phase command-mode shortcut would still fire behind them.
-  useDialogKeyboardOwner(renamingId !== null || pendingClose !== null || pendingMove !== null || moveError !== null, acquireChromeKeyboardLease);
+  useDialogKeyboardOwner(renamingId !== null || pendingClose !== null || pendingMove !== null || pendingSurfaceMove !== null || moveError !== null, acquireChromeKeyboardLease);
 
   const activate = useCallback((id: WorkspaceId) => {
     getWallHandle(id)?.enterCommandMode();
@@ -160,8 +160,8 @@ export function WorkspaceStrip({
   // confirmation lands in the same place whichever Workspace it is about. No
   // Window (Storybook) leaves it viewport-centered.
   const confirmTarget = useMemo(
-    () => (pendingClose || pendingMove || moveError ? document.querySelector<HTMLElement>('[data-workspace-content]') : null),
-    [pendingClose, pendingMove, moveError],
+    () => (pendingClose || pendingMove || pendingSurfaceMove || moveError ? document.querySelector<HTMLElement>('[data-workspace-content]') : null),
+    [pendingClose, pendingMove, pendingSurfaceMove, moveError],
   );
 
   // One union per tab, computed in the loop it is rendered in: every tab shows
@@ -236,15 +236,15 @@ export function WorkspaceStrip({
           The move gate is the same typed letter (the page state it destroys is
           as gone as a killed pane's process) and waits behind a close, so only
           one gate ever listens for the letter on screen. */}
-      {moveError && !pendingClose && !pendingMove && !renamingId && (
+      {moveError && !pendingSurfaceMove && !pendingClose && !pendingMove && !renamingId && (
         <ModalFrame titleId="workspace-move-error" targetElement={confirmTarget}
           onEscape={() => setWorkspaceMoveError(null)} className={clsx("w-80 max-w-full overflow-auto text-sm", OVERLAY_MAX_HEIGHT.modal)}>
-          <h2 id="workspace-move-error" className="mb-2 font-semibold">Workspace could not move</h2>
+          <h2 id="workspace-move-error" className="mb-2 font-semibold">Move could not complete</h2>
           <p role="alert" className="mb-3 break-words">{moveError.reason}</p>
           <button type="button" className={modalActionButton()} onClick={() => setWorkspaceMoveError(null)}>Close</button>
         </ModalFrame>
       )}
-      {pendingClose && !renamingId && (
+      {pendingClose && !pendingSurfaceMove && !renamingId && (
         <WorkspaceKillConfirm
           char={pendingClose.char}
           detail={workspaces.find(workspace => workspace.id === pendingClose.id)?.name}
@@ -258,7 +258,15 @@ export function WorkspaceStrip({
           onCancel={() => setPendingWorkspaceClose(null)}
         />
       )}
-      {pendingMove && !pendingClose && !renamingId && (
+      {pendingSurfaceMove && (
+        <WorkspaceKillConfirm char={pendingSurfaceMove.char} targetElement={confirmTarget}
+          title="Move iframe?"
+          detail="moving this iframe will trigger a refresh and reopen at its saved URL, possibly losing page state or returning to an earlier page."
+          cancelHint="anything else to cancel"
+          onConfirm={() => pendingSurfaceMove.answer(true)}
+          onCancel={() => pendingSurfaceMove.answer(false)} />
+      )}
+      {pendingMove && !pendingSurfaceMove && !pendingClose && !renamingId && (
         <WorkspaceKillConfirm
           char={pendingMove.char}
           targetElement={confirmTarget}
diff --git a/lib/src/components/WorkspaceWindow.test.tsx b/lib/src/components/WorkspaceWindow.test.tsx
index c0409aea2..deb03d105 100644
--- a/lib/src/components/WorkspaceWindow.test.tsx
+++ b/lib/src/components/WorkspaceWindow.test.tsx
@@ -10,6 +10,10 @@ import { flushSync } from 'react-dom';
 import { type Root } from 'react-dom/client';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import { SURFACE_CONTROL_METHODS } from 'dor/protocol';
+import { moveSurface } from './wall/surface-move';
+import { recordToolDirty, resetToolDirty } from '../lib/tool-dirty-store';
+import { browserLeafMeta, toolLeafMeta } from './wall/lath-wall-engine';
+import { leafTree } from '../lib/lath/model';
 import { WorkspaceWindow } from './WorkspaceWindow';
 import { WorkspaceStrip } from './WorkspaceStrip';
 import * as workspaceStore from '../lib/workspace-store';
@@ -66,6 +70,7 @@ beforeEach(() => {
 });
 
 afterEach(() => {
+  resetToolDirty();
   harness.dispose();
   vi.clearAllMocks();
   vi.restoreAllMocks();
@@ -919,8 +924,8 @@ it('routes Tools to the requested Workspace and never launches after lookup race
 
   const handle = getWallHandle('ws-2')!;
   const late = vi.fn();
-  act(() => handle.handleDorControl({ requestId: 'late-tool', method: SURFACE_CONTROL_METHODS.tool,
-    params: { name: 'storybook', cwd: '/repo' }, respond: late }));
+  act(() => { void handle.handleDorControl({ requestId: 'late-tool', method: SURFACE_CONTROL_METHODS.tool,
+    params: { name: 'storybook', cwd: '/repo' }, respond: late }); });
   await flush();
   await act(async () => { await handle.closeAll(); });
   await act(async () => gate.resolve(lookup));
@@ -928,3 +933,225 @@ it('routes Tools to the requested Workspace and never launches after lookup race
   expect(late).toHaveBeenCalledWith({ ok: false, error: 'this workspace is closing' });
   expect(handle.surfaceIds()).toEqual([]);
 });
+
+
+describe('Surface moves between Workspaces', () => {
+  const request = (destination: { workspace: string } | { new: true }, focus = false) => ({ destination, focus, dangerouslyDestroyIframePageState: false });
+  async function twoWalls(sourcePanes = ['pane-a', 'pane-b']) {
+    const source = getActiveWorkspaceId();
+    createWorkspace({ id: 'ws-2', name: 'new', activate: false });
+    await render(<><WorkspaceStrip /><WorkspaceWindow initialPlans={{ [source]: { initialPaneIds: sourcePanes }, 'ws-2': { initialPaneIds: ['pane-x'] } }} /></>);
+    return source;
+  }
+
+  it('preserves Session identity, TODO and retained cwd, retires the source ref, and recomputes both unions', async () => {
+    const source = await twoWalls();
+    publishWorkspaceSession(source, { version: 3, panes: [{ id: 'pane-a', title: 'exited', cwd: '/retained' }, { id: 'pane-b', title: 'other' }] });
+    await act(async () => setTerminalActivity('pane-a', { todo: true }));
+    const kill = vi.spyOn(fake, 'killPty');
+    const acknowledge = vi.spyOn(fake, 'alertAcknowledge');
+    let result;
+    await act(async () => { result = await moveSurface('pane-a', request({ workspace: 'new' })); });
+    expect(result).toMatchObject({ surfaceId: 'pane-a', surfaceRef: 'surface:2', workspaceId: 'ws-2' });
+    expect(getWallHandle(source)!.surfaceIds()).toEqual(['pane-b']);
+    expect(getWallHandle('ws-2')!.surfaceIds()).toEqual(['pane-x', 'pane-a']);
+    expect(getActiveWorkspaceId()).toBe(source);
+    expect(kill).not.toHaveBeenCalled();
+    expect(acknowledge).not.toHaveBeenCalled();
+    expect(getActivitySnapshot().get('pane-a')?.todo).toBe(true);
+    expect(getWorkspaceSurfacesSnapshot().get(source)).toEqual(['pane-b']);
+    expect(getWorkspaceSurfacesSnapshot().get('ws-2')).toContain('pane-a');
+    expect(previousWorkspaceSession(source)?.surfaceRefs).not.toHaveProperty('pane-a');
+    expect(previousWorkspaceSession('ws-2')?.panes.find(p => p.id === 'pane-a')?.cwd).toBe('/retained');
+    const respond = vi.fn();
+    await act(async () => getWallHandle(source)!.handleDorControl({ requestId: 'retired', method: SURFACE_CONTROL_METHODS.read, params: { surface: 'surface:1' }, respond }));
+    expect(respond).toHaveBeenCalledWith(expect.objectContaining({ ok: false }));
+  });
+
+  it('routes a moved dor caller to its destination: short refs can name another pane and ensure can duplicate work left behind', async () => {
+    const source = await twoWalls();
+    terminalRegistry.seedTerminalManualCwd('pane-b', '/repo');
+    terminalRegistry.applyTerminalSemanticEvents('pane-b', [{ type: 'commandLine', commandLine: 'pnpm dev' }, { type: 'commandStart', source: 'osc633_boundaries' }]);
+    await act(async () => { await moveSurface('pane-a', request({ workspace: 'workspace:2' })); });
+    const ask = async (method: string, params: Record<string, unknown>) => {
+      let answer: unknown;
+      await act(async () => { answer = await new Promise(resolve => {
+        window.dispatchEvent(new CustomEvent('dormouse:control-request', { detail: {
+          requestId: 'moved-caller', surfaceId: 'pane-a', method, params, respond: resolve,
+        } }));
+        if (method === SURFACE_CONTROL_METHODS.ensure) {
+          const created = getWallHandle('ws-2')!.surfaceIds().find(id => id !== 'pane-x' && id !== 'pane-a')!;
+          terminalRegistry.applyTerminalSemanticEvents(created, [{ type: 'promptStart' }]);
+        }
+      }); });
+      return answer;
+    };
+    expect(await ask(SURFACE_CONTROL_METHODS.read, { surface: 'surface:1' })).toMatchObject({ ok: true, result: { surfaceId: 'pane-x' } });
+    expect(await ask(SURFACE_CONTROL_METHODS.read, { surface: 'surface:pane-b' })).toMatchObject({ ok: true, result: { surfaceId: 'pane-b' } });
+    expect(await ask(SURFACE_CONTROL_METHODS.ensure, { command: ['pnpm', 'dev'], cwd: '/repo', minimized: false, restart: false })).toMatchObject({ ok: true, result: { status: 'created' } });
+    expect(getWallHandle(source)!.surfaceIds()).toEqual(['pane-b']);
+    expect(getWallHandle('ws-2')!.surfaceIds()).toHaveLength(3);
+  });
+
+  it('removes an emptied source and activates the destination in command mode for a neutral CLI move', async () => {
+    const source = await twoWalls(['pane-a']);
+    await act(async () => { await moveSurface('pane-a', request({ workspace: 'workspace:2' })); });
+    expect(getWorkspacesSnapshot().workspaces.map(ws => ws.id)).toEqual(['ws-2']);
+    expect(getWallHandle(source)).toBeNull();
+    expect(getActiveWorkspaceId()).toBe('ws-2');
+    expect(wallFor('ws-2').querySelector('[data-focused="true"]')).toBeNull();
+  });
+
+  it('creates a receiving Workspace with only the moved Surface and follows a GUI move into passthrough', async () => {
+    const source = await twoWalls();
+    let result: Awaited<ReturnType<typeof moveSurface>> = null;
+    await act(async () => { result = await moveSurface('pane-a', request({ new: true }), true); });
+    const target = getActiveWorkspaceId();
+    expect(target).not.toBe(source);
+    expect(getWallHandle(target)!.surfaceIds()).toEqual(['pane-a']);
+    expect(wallFor(target).querySelector('[data-session-id="pane-a"][data-focused="true"]')).not.toBeNull();
+    expect(result).toMatchObject({ surfaceRef: 'surface:1' });
+    await act(async () => { await expect(moveSurface('pane-a', request({ new: true }))).rejects.toThrow('only Surface'); });
+  });
+
+  it('rolls back layout, ownership, references and allocator when destination adoption fails', async () => {
+    const source = await twoWalls();
+    const target = getWallHandle('ws-2')!;
+    const adoption = vi.spyOn(target, 'adoptSurfaceMove').mockImplementation(() => { throw new Error('placement failed'); });
+    await act(async () => { await expect(moveSurface('pane-a', request({ workspace: 'workspace:2' }))).rejects.toThrow('placement failed'); });
+    expect(getWallHandle(source)!.surfaceIds()).toEqual(['pane-a', 'pane-b']);
+    expect(target.surfaceIds()).toEqual(['pane-x']);
+    expect((await getWallHandle(source)!.serializePersistence({ probeCwd: false })).surfaceRefs).toEqual({ 'pane-a': 'surface:1', 'pane-b': 'surface:2' });
+    adoption.mockRestore();
+  });
+
+  it('fences a pre-departure save collected during new Workspace mounting', async () => {
+    const source = await twoWalls();
+    let finishProbe!: (cwd: string | null) => void;
+    let staleSave!: Promise<void>;
+    vi.spyOn(fake, 'getCwd').mockImplementation(id => id === 'pane-a' ? new Promise(resolve => { finishProbe = resolve; }) : Promise.resolve('/other'));
+    const unsubscribe = workspaceStore.subscribeToWorkspaces(() => {
+      if (!staleSave && getWorkspacesSnapshot().workspaces.length === 3) staleSave = getWallHandle(source)!.flushPersistence();
+    });
+    let moved!: NonNullable<Awaited<ReturnType<typeof moveSurface>>>;
+    await act(async () => { moved = (await moveSurface('pane-a', request({ new: true })))!; });
+    unsubscribe();
+    expect(finishProbe).toBeTypeOf('function');
+    await act(async () => { finishProbe('/stale'); await staleSave; });
+    expect(previousWorkspaceSession(source)?.panes.map(p => p.id)).toEqual(['pane-b']);
+    expect(previousWorkspaceSession(moved.workspaceId)?.panes.map(p => p.id)).toEqual(['pane-a']);
+  });
+
+  it('keeps committed membership if destination focus fails after the empty source closes', async () => {
+    const source = await twoWalls(['pane-a']);
+    vi.spyOn(workspaceStore, 'setActiveWorkspace').mockImplementation(() => { throw new Error('focus failed'); });
+    await act(async () => { await expect(moveSurface('pane-a', request({ workspace: 'workspace:2' }, true))).rejects.toThrow('focus failed'); });
+    expect(getWorkspacesSnapshot().workspaces.map(ws => ws.id)).toEqual(['ws-2']);
+    expect(getWallHandle(source)).toBeNull();
+    expect(getWallHandle('ws-2')!.ownsSurface('pane-a')).toBe(true);
+    expect(previousWorkspaceSession(source)).toBeNull();
+    expect(previousWorkspaceSession('ws-2')?.panes.map(p => p.id)).toContain('pane-a');
+  });
+
+  it('refuses same-Workspace moves before inspecting dirty Tool state', async () => {
+    await twoWalls();
+    await act(async () => { await expect(moveSurface('pane-a', request({ workspace: 'workspace:1' }))).rejects.toThrow('already in that Workspace'); });
+  });
+
+  it('shows alternate-screen move notices over the pane without writing into the program display', async () => {
+    await twoWalls();
+    const write = vi.fn();
+    const terminal = vi.spyOn(terminalRegistry, 'getTerminalInstance').mockReturnValue({ buffer: { active: { type: 'alternate' } }, write } as unknown as ReturnType<typeof terminalRegistry.getTerminalInstance>);
+    await act(async () => { await moveSurface('pane-a', request({ workspace: 'workspace:2' }, true)); });
+    expect(write).not.toHaveBeenCalled();
+    expect(container.querySelector('.shell-spawn-notice')?.textContent).toContain('Cached surface:N refs now resolve here');
+    terminal.mockRestore();
+  });
+
+  it('moves a Door into a pane without terminating it and keeps a nonempty source', async () => {
+    const source = await twoWalls();
+    // The same minimize proposal used by a header button.
+    const minimize = wallFor(source).querySelector<HTMLButtonElement>('[aria-label="Minimize"]');
+    expect(minimize).not.toBeNull();
+    await act(async () => minimize!.click());
+    const minimized = getWallHandle(source)!.surfaceIds().find(id => !leafIdsIn(source).includes(id))!;
+    expect(minimized).toBeTruthy();
+    await act(async () => { await moveSurface(minimized, request({ workspace: 'workspace:2' })); });
+    expect(leafIdsIn('ws-2')).toContain(minimized);
+    expect(getWallHandle(source)!.surfaceIds()).not.toContain(minimized);
+  });
+
+  it.each(['browser', 'tool'] as const)('requires consent for %s iframes; cancellation preserves membership and dirty Tools cannot bypass refusal', async kind => {
+    const source = getActiveWorkspaceId();
+    createWorkspace({ id: 'ws-2', activate: false });
+    if (kind === 'tool') terminalRegistry.applyTerminalSemanticEvents('frame', [{ type: 'commandLine', commandLine: 'file-editor' }, { type: 'commandStart', source: 'osc633_boundaries' }]);
+    const meta = kind === 'browser' ? browserLeafMeta('Frame', { surfaceType: 'browser', renderMode: 'iframe', url: 'http://localhost:3000/saved' })
+      : toolLeafMeta('Editor', { surfaceType: 'tool', command: 'file-editor', toolArgv: ['dor', 'builtin:file', '/tmp/file.txt'], renderMode: 'iframe', toolRender: 'iframe', url: 'http://localhost:3000/saved' });
+    await render(<><WorkspaceStrip /><WorkspaceWindow initialPlans={{ [source]: { restoredLathLayout: { version: 1, tree: leafTree('frame'), leafMeta: { frame: meta } } }, 'ws-2': { initialPaneIds: ['pane-x'] } }} /></>);
+    await act(async () => { await expect(moveSurface('frame', request({ workspace: 'workspace:2' }))).rejects.toThrow('dangerously-destroy'); });
+    let pending!: Promise<Awaited<ReturnType<typeof moveSurface>>>;
+    await act(async () => { pending = moveSurface('frame', request({ workspace: 'workspace:2' }), true); });
+    expect(getWorkspaceUiSnapshot().pendingSurfaceMove).not.toBeNull();
+    expect(document.body.textContent).toContain('saved URL');
+    expect(getWallHandle(source)!.ownsSurface('frame')).toBe(true);
+    await act(async () => { getWorkspaceUiSnapshot().pendingSurfaceMove!.answer(false); await pending; });
+    expect(getWallHandle(source)!.ownsSurface('frame')).toBe(true);
+    if (kind === 'tool') {
+      recordToolDirty('frame', true);
+      await act(async () => { await expect(moveSurface('frame', { ...request({ workspace: 'workspace:2' }), dangerouslyDestroyIframePageState: true })).rejects.toThrow('edits'); });
+      recordToolDirty('frame', false);
+      await act(async () => { pending = moveSurface('frame', request({ workspace: 'workspace:2' }), true); });
+      recordToolDirty('frame', true);
+      await act(async () => { getWorkspaceUiSnapshot().pendingSurfaceMove!.answer(true); await expect(pending).rejects.toThrow('edits'); });
+      expect(getWallHandle(source)!.ownsSurface('frame')).toBe(true);
+      recordToolDirty('frame', false);
+    }
+    await act(async () => { pending = moveSurface('frame', request({ workspace: 'workspace:2' }), true); });
+    await act(async () => { getWorkspaceUiSnapshot().pendingSurfaceMove!.answer(true); await pending; });
+    expect(getWallHandle('ws-2')!.ownsSurface('frame')).toBe(true);
+  });
+
+  it('rechecks a Tool that becomes dirty in the final preparation microtask', async () => {
+    const source = getActiveWorkspaceId();
+    createWorkspace({ id: 'ws-2', activate: false });
+    terminalRegistry.applyTerminalSemanticEvents('editor', [{ type: 'commandLine', commandLine: 'file-editor' }, { type: 'commandStart', source: 'osc633_boundaries' }]);
+    const meta = toolLeafMeta('Editor', { surfaceType: 'tool', command: 'file-editor', toolArgv: ['dor', 'builtin:file', '/tmp/file.txt'], renderMode: 'iframe', toolRender: 'iframe', url: 'http://localhost:3000/saved' });
+    await render(<><WorkspaceStrip /><WorkspaceWindow initialPlans={{ [source]: { restoredLathLayout: { version: 1, tree: leafTree('editor'), leafMeta: { editor: meta } } }, 'ws-2': { initialPaneIds: ['pane-x'] } }} /></>);
+    const handle = getWallHandle(source)!;
+    const prepare = handle.prepareSurfaceMove;
+    let calls = 0;
+    vi.spyOn(handle, 'prepareSurfaceMove').mockImplementation(id => {
+      const prepared = prepare(id);
+      if (++calls === 2) queueMicrotask(() => recordToolDirty(id, true));
+      return prepared;
+    });
+    await act(async () => { await expect(moveSurface('editor', { ...request({ workspace: 'workspace:2' }), dangerouslyDestroyIframePageState: true })).rejects.toThrow('edits'); });
+    expect(handle.ownsSurface('editor')).toBe(true);
+    expect(getWallHandle('ws-2')!.ownsSurface('editor')).toBe(false);
+  });
+
+  it('asks again when a Surface becomes an iframe during the persistence flush: dor refuses, the GUI prompts', async () => {
+    const source = getActiveWorkspaceId();
+    createWorkspace({ id: 'ws-2', activate: false });
+    const meta = browserLeafMeta('Frame', { surfaceType: 'browser', renderMode: 'iframe', url: 'http://localhost:3000/saved' });
+    await render(<><WorkspaceStrip /><WorkspaceWindow initialPlans={{ [source]: { restoredLathLayout: { version: 1, tree: leafTree('frame'), leafMeta: { frame: meta } } }, 'ws-2': { initialPaneIds: ['pane-x'] } }} /></>);
+    // Only the first preparation, before the flush, sees no iframe yet.
+    const notYetServing = () => {
+      const handle = getWallHandle(source)!;
+      const real = handle.prepareSurfaceMove;
+      return vi.spyOn(handle, 'prepareSurfaceMove').mockImplementationOnce(id => ({ ...real(id), iframe: false }));
+    };
+    const cli = notYetServing();
+    await act(async () => { await expect(moveSurface('frame', request({ workspace: 'workspace:2' }))).rejects.toThrow('dangerously-destroy'); });
+    expect(cli.mock.calls.length).toBeGreaterThan(1);
+    expect(getWallHandle(source)!.ownsSurface('frame')).toBe(true);
+    cli.mockRestore();
+    notYetServing();
+    let pending!: Promise<Awaited<ReturnType<typeof moveSurface>>>;
+    await act(async () => { pending = moveSurface('frame', request({ workspace: 'workspace:2' }), true); });
+    expect(getWorkspaceUiSnapshot().pendingSurfaceMove).not.toBeNull();
+    expect(getWallHandle(source)!.ownsSurface('frame')).toBe(true);
+    await act(async () => { getWorkspaceUiSnapshot().pendingSurfaceMove!.answer(false); expect(await pending).toBeNull(); });
+    expect(getWallHandle(source)!.ownsSurface('frame')).toBe(true);
+  });
+});
diff --git a/lib/src/components/wall/LathHost.test.tsx b/lib/src/components/wall/LathHost.test.tsx
index 5177383a6..2746737b3 100644
--- a/lib/src/components/wall/LathHost.test.tsx
+++ b/lib/src/components/wall/LathHost.test.tsx
@@ -716,7 +716,7 @@ describe('LathHost — pane / Door drag', () => {
 
   function mountDrag(
     store: LathWallStore,
-    props: { externalDrag?: { id: string; startX: number; startY: number } | null } = {},
+    props: { externalDrag?: { id: string; startX: number; startY: number } | null; workspaceDrag?: import('./surface-workspace-drag').SurfaceWorkspaceDrag } = {},
   ): { engine: ReturnType<typeof createLathWallEngine> } & DragHandlers {
     const engine = createLathWallEngine(store, { durationMs: 0 });
     const handlers: DragHandlers = {
@@ -732,6 +732,7 @@ describe('LathHost — pane / Door drag', () => {
           onCommitResize={vi.fn()}
           componentsOverride={OVERRIDE}
           externalDrag={props.externalDrag ?? null}
+          workspaceDrag={props.workspaceDrag}
           {...handlers}
         />,
       );
@@ -756,8 +757,9 @@ describe('LathHost — pane / Door drag', () => {
   }
   const down = (el: HTMLElement, x: number, y: number) =>
     el.dispatchEvent(new MouseEvent('pointerdown', { bubbles: true, clientX: x, clientY: y, button: 0 }));
-  const moveTo = (x: number, y: number) => window.dispatchEvent(new MouseEvent('pointermove', { clientX: x, clientY: y }));
-  const up = () => window.dispatchEvent(new MouseEvent('pointerup', {}));
+  let pointer = { clientX: 0, clientY: 0 };
+  const moveTo = (x: number, y: number) => { pointer = { clientX: x, clientY: y }; window.dispatchEvent(new MouseEvent('pointermove', pointer)); };
+  const up = () => window.dispatchEvent(new MouseEvent('pointerup', pointer));
 
   // col[ row[a, b], c ]: dragging c onto a's top edge yields two distinct candidates —
   // above 'a' (leaf level) and above the whole a|b row (its ancestor).
@@ -765,6 +767,21 @@ describe('LathHost — pane / Door drag', () => {
     return { root: split('col', [split('row', [leaf('a'), 0.5], [leaf('b'), 0.5]), 0.5], [leaf('c'), 0.5]) };
   }
 
+  it('lets the Workspace strip consume a pane release before local layout proposals and cancels on pointercancel', () => {
+    const store = seeded(rowOf('a', 'b'), [['a', leafMeta()], ['b', leafMeta()]]);
+    const workspaceDrag = { hover: vi.fn(() => true), drop: vi.fn(() => true), end: vi.fn() };
+    const { onProposeMove, onProposeMinimize } = mountDrag(store, { workspaceDrag });
+    act(() => { down(header('a'), 100, 15); moveTo(601, 300); up(); });
+    expect(workspaceDrag.drop).toHaveBeenCalledWith('a', 601, 300);
+    expect(onProposeMove).not.toHaveBeenCalled();
+    expect(onProposeMinimize).not.toHaveBeenCalled();
+    workspaceDrag.drop.mockClear();
+    act(() => { down(header('a'), 100, 15); moveTo(601, 300); window.dispatchEvent(new MouseEvent('pointercancel')); });
+    expect(workspaceDrag.drop).not.toHaveBeenCalled();
+    expect(workspaceDrag.end).toHaveBeenCalled();
+    expect(overlayEl()).toBeNull();
+  });
+
   it('enters a drag past the threshold and calls onDragStart, dimming the leaf', () => {
     const store = seeded(rowOf('a', 'b', 'c'), [['a', leafMeta({ title: 'A' })], ['b', leafMeta({ title: 'B' })], ['c', leafMeta({ title: 'C' })]]);
     const { onDragStart } = mountDrag(store);
diff --git a/lib/src/components/wall/LathHost.tsx b/lib/src/components/wall/LathHost.tsx
index b7cdae744..6456c4658 100644
--- a/lib/src/components/wall/LathHost.tsx
+++ b/lib/src/components/wall/LathHost.tsx
@@ -2,6 +2,7 @@
 // positioning only; gestures surface as proposals and never activate/focus.
 // See docs/specs/tiling-engine.md → "The HTML adapter (LathHost)".
 
+import type { SurfaceWorkspaceDrag } from './surface-workspace-drag';
 import {
   memo,
   useCallback,
@@ -272,6 +273,7 @@ export function LathHost({
   onProposeMinimize,
   externalDrag,
   onExternalDrop,
+  workspaceDrag,
   componentsOverride,
 }: {
   /** The Wall's engine handle: LathHost reads `lath.store`, drives `lath.animator`,
@@ -296,6 +298,7 @@ export function LathHost({
   /** Drop of an external (Door) drag: a hit-tested target, or `null` on cancel / a
    *  release over no candidate — the Wall leaves the Door where it is. */
   onExternalDrop?: (target: DropTarget | null) => void;
+  workspaceDrag?: SurfaceWorkspaceDrag;
   componentsOverride?: LathComponentsOverride;
 }) {
   const { mounted: terminalContext } = useContext(TerminalContextContext);
@@ -356,8 +359,8 @@ export function LathHost({
 
   // Everything the once-built controller reads through: the latest store snapshot + Wall
   // callbacks, re-mirrored each render so it always sees current values.
-  const latestRef = useRef({ snapshot, onDragStart, onProposeMove, onProposeMinimize, onExternalDrop });
-  latestRef.current = { snapshot, onDragStart, onProposeMove, onProposeMinimize, onExternalDrop };
+  const latestRef = useRef({ snapshot, onDragStart, onProposeMove, onProposeMinimize, onExternalDrop, workspaceDrag });
+  latestRef.current = { snapshot, onDragStart, onProposeMove, onProposeMinimize, onExternalDrop, workspaceDrag };
 
   // The current preview overlay rect (null → no overlay). The dragged leaf itself is
   // dimmed imperatively; only this rect is React state.
diff --git a/lib/src/components/wall/MoveWorkspaceAction.tsx b/lib/src/components/wall/MoveWorkspaceAction.tsx
new file mode 100644
index 000000000..658f365c7
--- /dev/null
+++ b/lib/src/components/wall/MoveWorkspaceAction.tsx
@@ -0,0 +1,29 @@
+import { useContext, useSyncExternalStore } from 'react';
+import { CaretDownIcon } from '@phosphor-icons/react';
+import { SUBTLE_ACTION_REST_COLOR_CLASS, SUBTLE_ACTION_WRAPPER_INTERACTION_CLASS } from '../design';
+import type { WorkspaceId } from '../../lib/session-types';
+import { getWorkspacesSnapshot, subscribeToWorkspaces, workspaceRefFor } from '../../lib/workspace-store';
+import { getWorkspaceSurfacesSnapshot, subscribeToWorkspaceSurfaces } from '../../lib/workspace-surfaces';
+import { WindowFocusedContext } from './wall-context';
+import { requestSurfaceMove } from './surface-move';
+import { ACTION_BOX_CLASS, closedSelectKeyDown } from './TerminalContextView';
+
+/** Native picker matches the context's browser actions and escapes its clipping. */
+export function MoveWorkspaceAction({ id, sourceId }: { id: string; sourceId: WorkspaceId }) {
+  const { workspaces } = useSyncExternalStore(subscribeToWorkspaces, getWorkspacesSnapshot);
+  const members = useSyncExternalStore(subscribeToWorkspaceSurfaces, getWorkspaceSurfacesSnapshot);
+  const focused = useContext(WindowFocusedContext);
+  return <span className={`relative ${ACTION_BOX_CLASS} ${SUBTLE_ACTION_REST_COLOR_CLASS} ${focused ? SUBTLE_ACTION_WRAPPER_INTERACTION_CLASS : ''}`}>
+    move to workspace…<CaretDownIcon size={10} weight="fill" />
+    <select aria-label="Move to workspace" title="Move to workspace" value="" className="absolute inset-0 cursor-pointer appearance-none opacity-0"
+      onKeyDown={closedSelectKeyDown}
+      onChange={event => {
+        if (event.target.value === '+') requestSurfaceMove(id, { new: true });
+        else if (event.target.value) requestSurfaceMove(id, { workspace: event.target.value });
+      }}>
+      <option value="">move to workspace…</option>
+      {workspaces.filter(workspace => workspace.id !== sourceId).map(workspace => <option key={workspace.id} value={workspace.id}>{workspaceRefFor(workspace.id)} — {workspace.name}</option>)}
+      <option value="+" disabled={(members.get(sourceId)?.length ?? 0) <= 1}>New workspace</option>
+    </select>
+  </span>;
+}
diff --git a/lib/src/components/wall/TerminalContext.test.tsx b/lib/src/components/wall/TerminalContext.test.tsx
index f4a1e1f8c..1bfe5d20b 100644
--- a/lib/src/components/wall/TerminalContext.test.tsx
+++ b/lib/src/components/wall/TerminalContext.test.tsx
@@ -136,7 +136,7 @@ it('moves trailing actions into the dropdown on resize and dispatches hidden act
   } finally { client.mockRestore(); offset.mockRestore(); vi.unstubAllGlobals(); }
 });
 
-it('drops the explain label, then the Surface ref text, as the title row narrows', () => {
+it('keeps Explain icon-only and compacts the Surface ref as the title row narrows', () => {
   let width = 320;
   const observers = new Set<() => void>();
   vi.stubGlobal('ResizeObserver', class {
@@ -144,14 +144,14 @@ it('drops the explain label, then the Surface ref text, as the title row narrows
     observe() {} disconnect() {} unobserve() {}
   });
   const client = vi.spyOn(HTMLElement.prototype, 'clientWidth', 'get').mockImplementation(function(this: HTMLElement) { return this.hasAttribute('data-context-title') ? width : 0; });
-  // Ten pixels a character, twenty an icon, 8ch as eighty: the title is 80, explain 90 or 20, the ref 110, close 20.
+  // Ten pixels a character, twenty an icon, 8ch as eighty: title 80, Explain 20, ref 110, close 20.
   const offset = vi.spyOn(HTMLElement.prototype, 'offsetWidth', 'get').mockImplementation(function(this: HTMLElement) {
     return (this.textContent?.length ?? 0) * 10 + this.querySelectorAll('svg').length * 20 + (this.classList.contains('w-[8ch]') ? 80 : 0);
   });
   const resize = (next: number) => act(() => { width = next; observers.forEach(notify => notify()); });
   try {
     render();
-    expect(button('Explain this title').textContent).toBe('explain');
+    expect(button('Explain this title').textContent).toBe('');
     expect(button('Copy surface:3').textContent).toBe('surface:3');
     resize(260);
     expect(button('Explain this title').textContent).toBe('');
@@ -159,7 +159,7 @@ it('drops the explain label, then the Surface ref text, as the title row narrows
     resize(200);
     expect(button('Copy surface:3').textContent).toBe('');
     resize(320);
-    expect(button('Explain this title').textContent).toBe('explain');
+    expect(button('Explain this title').textContent).toBe('');
     expect(button('Copy surface:3').textContent).toBe('surface:3');
   } finally { client.mockRestore(); offset.mockRestore(); vi.unstubAllGlobals(); }
 });
diff --git a/lib/src/components/wall/TerminalContext.tsx b/lib/src/components/wall/TerminalContext.tsx
index 05068e19e..a4217aceb 100644
--- a/lib/src/components/wall/TerminalContext.tsx
+++ b/lib/src/components/wall/TerminalContext.tsx
@@ -1,5 +1,7 @@
 import { useCallback, useContext, useEffect, useMemo, useState, useSyncExternalStore } from 'react';
 import { messageOf } from '../../lib/errors';
+import { wallHandleOwning } from './wall-handles';
+import { MoveWorkspaceAction } from './MoveWorkspaceAction';
 import { TerminalPane } from '../TerminalPane';
 import { TerminalContextView, type ContextScan, type TerminalContextViewProps } from './TerminalContextView';
 import { TerminalContextContext, WallActionsContext, type TerminalContextState } from './wall-context';
@@ -53,9 +55,10 @@ export function TerminalContext({ id, title, closing, origin, warning: openWarni
   const onClose = useCallback(() => { context.close(); if (!tool) focusSession(id, true); }, [context, id, tool]);
   const copy = async (value: string) => { if (!await writeTextToClipboard(value)) throw new Error('Could not copy to clipboard'); };
   const mismatch = !!helper && !!cwd && !!helperCwd && (cwd.path !== helperCwd.path || cwd.isRemote !== helperCwd.isRemote || (cwd.isRemote && cwd.host !== helperCwd.host));
+  const source = wallHandleOwning(id);
   const warning = openWarning ?? (helperError || (helper && helper.status !== 'waiting' && (!cwd || !helperCwd) ? 'Directory comparison unavailable: a terminal has not reported its directory.' : undefined));
   return <TerminalContextView placement={placement} terminalRole={tool ? 'tool' : 'helper'} closing={closing} origin={origin} title={deriveSurfaceLabel(state, appTitleForPane, title ?? id)} surfaceRef={actions.resolveSurfaceRef(id)}
-    titleSources={titleSources} cwd={cwd ? display(cwd) : 'Directory unknown'} helperCwd={helperCwd && display(helperCwd)} mismatch={mismatch}
+    workspaceMove={source?.canMoveSurfaces ? <MoveWorkspaceAction id={id} sourceId={source.workspaceId} /> : undefined} titleSources={titleSources} cwd={cwd ? display(cwd) : 'Directory unknown'} helperCwd={helperCwd && display(helperCwd)} mismatch={mismatch}
     scan={scan} watchRule={offeredRule} watching={watchRule !== null} todo={activities.get(id)?.todo === true} notification={activities.get(id)?.notification}
     status={tool ? (state.currentCommand ? 'running' : 'completed') : helper?.status ?? 'waiting'} command={tool ? state.currentCommand?.rawCommandLine ?? state.lastCommand?.rawCommandLine ?? '' : helper?.command ?? defaultCommand} defaultCommand={defaultCommand} warning={warning}
     explorerLabel={IS_MAC ? 'Open in Finder' : IS_WINDOWS ? 'Open in Explorer' : 'Open folder'} canExplore={!!platform.terminalContext && !!cwd && !cwd.isRemote}
diff --git a/lib/src/components/wall/TerminalContextView.tsx b/lib/src/components/wall/TerminalContextView.tsx
index 9cf117cf8..4293a18c9 100644
--- a/lib/src/components/wall/TerminalContextView.tsx
+++ b/lib/src/components/wall/TerminalContextView.tsx
@@ -1,4 +1,4 @@
-import { useCallback, useContext, useEffect, useLayoutEffect, useRef, useState, type CSSProperties, type DependencyList, type ReactNode, type RefObject } from 'react';
+import { useCallback, useContext, useEffect, useLayoutEffect, useRef, useState, type CSSProperties, type DependencyList, type KeyboardEvent, type ReactNode, type RefObject } from 'react';
 import { ArrowCounterClockwiseIcon, ArrowLineUpIcon, ArrowSquareOutIcon, BugBeetleIcon, CaretDownIcon, CheckIcon, CircleNotchIcon, CopyIcon, PauseIcon, PushPinIcon, SlidersHorizontalIcon, TerminalIcon, WarningIcon, XIcon } from '@phosphor-icons/react';
 import { ELEVATED_PANE_SHADOW, OnOffSwitch, POPUP_SURFACE_CLASS, SUBTLE_ACTION_COLOR_CLASS, SUBTLE_ACTION_INTERACTION_CLASS, SUBTLE_ACTION_REST_COLOR_CLASS, SUBTLE_ACTION_WRAPPER_INTERACTION_CLASS, TERMINAL_CONTEXT_SURFACE_CLASS, TERMINAL_CONTEXT_EXIT_MS, TERMINAL_SELECTION_BORDER_RADIUS } from '../design';
 import { stepFocus } from '../focus-step';
@@ -65,6 +65,7 @@ export interface TerminalContextViewProps {
   /** Viewport coordinates the reveal grows from; absent, the top-left corner. */
   origin?: { x: number; y: number };
   defaultCommand?: string; title: string; surfaceRef: string; cwd: string; helperCwd?: string; mismatch?: boolean;
+  workspaceMove?: ReactNode;
   titleSources: { source: string; value: string; note?: string }[];
   scan: ContextScan; watchRule?: string | null; watching: boolean; todo: boolean;
   notification?: { title: string | null; body: string | null } | null;
@@ -82,7 +83,7 @@ export interface TerminalContextViewProps {
 }
 
 /** A context action's box, shared with the port row's off-screen measurements. */
-const ACTION_BOX_CLASS = 'inline-flex h-6 shrink-0 items-center justify-center gap-1.5 whitespace-nowrap rounded px-1.5';
+export const ACTION_BOX_CLASS = 'inline-flex h-6 shrink-0 items-center justify-center gap-1.5 whitespace-nowrap rounded px-1.5';
 
 export function ContextAction({ children, label, onClick, disabled = false, busy = false, muted = false, pressed, keepFocus = false }: { children: ReactNode; label: string; onClick?: () => void; disabled?: boolean; busy?: boolean; muted?: boolean; pressed?: boolean; keepFocus?: boolean }) {
   const windowFocused = useContext(WindowFocusedContext);
@@ -182,33 +183,36 @@ const EXPLORE_ICON = <ArrowSquareOutIcon size={15} />;
 const EXPLAIN_ICON = <BugBeetleIcon size={15} />;
 
 /** The title, its explanation, the copyable Surface ref, and `actions` on one line. */
-function TitleRow({ title, surfaceRef, onExplain, onCopyRef, actions }: {
-  title: string; surfaceRef: string; actions: ReactNode;
+function TitleRow({ title, surfaceRef, onExplain, onCopyRef, actions, workspaceMove }: {
+  title: string; surfaceRef: string; actions: ReactNode; workspaceMove?: ReactNode;
   onExplain(): void; onCopyRef(): Promise<boolean>;
 }) {
   const row = useRef<HTMLDivElement>(null);
   const measures = useRef<HTMLDivElement>(null);
   const actionsRef = useRef<HTMLDivElement>(null);
-  const [explainCompact, setExplainCompact] = useState(false);
   const [refCompact, setRefCompact] = useState(false);
-  // Explain drops its label, the title truncates to 8ch, the ref drops to its icon, then the title truncates on.
-  useRowFit(row, measures, (width, gap, [text, least, explainFull, explainIcon, refFull]) => {
+  // The title truncates to 8ch, the ref drops to its icon, then the title truncates on.
+  useRowFit(row, measures, (width, gap, [text, least, explainIcon, refFull]) => {
     const rest = (actionsRef.current?.offsetWidth ?? 0) + 3 * gap;
-    setExplainCompact(text + explainFull + refFull + rest > width);
     setRefCompact(Math.min(text, least) + explainIcon + refFull + rest > width);
   }, [title, surfaceRef], [actionsRef]);
-  return <div ref={row} data-context-title className="relative flex min-h-6 min-w-0 items-center gap-1.5">
+  return <div ref={row} data-context-title className="relative flex min-h-6 min-w-0 flex-wrap items-center gap-1.5">
     <div ref={measures} aria-hidden="true" inert className={MEASURER_CLASS}>
       <span className="whitespace-nowrap">{title}</span>
       <span className="w-[8ch] shrink-0" />
-      <span className={ACTION_BOX_CLASS}>{EXPLAIN_ICON}explain</span>
       <span className={ACTION_BOX_CLASS}>{EXPLAIN_ICON}</span>
       <span className={ACTION_BOX_CLASS}>{surfaceRef}{COPY_ICON}</span>
     </div>
-    <span className="min-w-0 flex-1 truncate" title={title}>{title}</span>
-    <ContextAction label="Explain this title" onClick={onExplain}>{EXPLAIN_ICON}{!explainCompact && 'explain'}</ContextAction>
-    <ContextCopyAction label={`Copy ${surfaceRef}`} confirmation={refCompact ? COPY_CHECK : undefined} onCopy={onCopyRef}>{!refCompact && <span>{surfaceRef}</span>}{COPY_ICON}</ContextCopyAction>
+    <span className="flex min-w-0 flex-1 items-center gap-1.5">
+      <span className="min-w-0 truncate" title={title}>{title}</span>
+      <ContextAction label="Explain this title" onClick={onExplain}>{EXPLAIN_ICON}</ContextAction>
+    </span>
+    {!workspaceMove && <ContextCopyAction label={`Copy ${surfaceRef}`} confirmation={refCompact ? COPY_CHECK : undefined} onCopy={onCopyRef}>{!refCompact && <span>{surfaceRef}</span>}{COPY_ICON}</ContextCopyAction>}
     <div ref={actionsRef} data-context-header-actions className="flex shrink-0 items-center gap-0.5">{actions}</div>
+    {workspaceMove && <div className="flex w-full min-w-0 flex-wrap items-center gap-1.5">
+      <ContextCopyAction label={`Copy ${surfaceRef}`} onCopy={onCopyRef}>{surfaceRef}{COPY_ICON}</ContextCopyAction>
+      {workspaceMove}
+    </div>}
   </div>;
 }
 
@@ -240,6 +244,14 @@ const MORE = <span className="inline-flex items-center gap-1">more…<CaretDownI
 /** Keys that open, close, or leave a closed select. Chromium on Windows and Linux
  *  lets any other key change a closed select's value, which here would launch. */
 const SELECT_PASSTHROUGH_KEYS = new Set(['Enter', ' ', 'Tab', 'Escape', 'F4']);
+/** Only a choice from the open list commits; arrows open it instead. */
+export function closedSelectKeyDown(event: KeyboardEvent<HTMLSelectElement>): void {
+  if (SELECT_PASSTHROUGH_KEYS.has(event.key) || event.altKey || event.ctrlKey || event.metaKey) return;
+  event.preventDefault();
+  if (event.key === 'ArrowDown' || event.key === 'ArrowUp') {
+    try { event.currentTarget.showPicker(); } catch { /* Space and Alt+↓ still open it */ }
+  }
+}
 
 /** Measure natural action widths so overflow follows this row, not the window.
  * The native dropdown escapes the context's scroll/animation clipping and owns
@@ -304,14 +316,7 @@ function PortLaunchActions({ providers, canIframe, onPort }: {
       {hiddenPending ? OPENING : MORE}
       <select aria-label="More browser actions" title="More browser actions" value="" aria-busy={pending !== null || undefined} aria-disabled={pending !== null || undefined}
         className="absolute inset-0 cursor-pointer appearance-none opacity-0"
-        onKeyDown={event => {
-          if (SELECT_PASSTHROUGH_KEYS.has(event.key) || event.altKey || event.ctrlKey || event.metaKey) return;
-          // Only a choice from the open list launches; arrows open it instead.
-          event.preventDefault();
-          if (event.key === 'ArrowDown' || event.key === 'ArrowUp') {
-            try { event.currentTarget.showPicker(); } catch { /* Space and Alt+↓ still open it */ }
-          }
-        }}
+        onKeyDown={closedSelectKeyDown}
         onChange={event => { const action = actions.find(item => key(item) === event.target.value); if (action) void run(action); }}>
         <option value="">More browser actions</option>
         {actions.slice(visible).map(action => <option key={key(action)} value={key(action)} disabled={action.disabled}>{action.disabled ? action.label : action.text}</option>)}
@@ -413,7 +418,7 @@ export function TerminalContextView(p: TerminalContextViewProps) {
       <div className="shrink-0 max-h-[45%] overflow-auto px-3 py-2">
         <div className="grid grid-cols-[3rem_minmax(0,1fr)] items-center gap-y-1">
           <span className="text-muted">Title</span>
-          <TitleRow title={p.title} surfaceRef={p.surfaceRef} onExplain={() => setDetail('title')} onCopyRef={() => attempt(p.onCopyRef)} actions={<>
+          <TitleRow workspaceMove={p.workspaceMove} title={p.title} surfaceRef={p.surfaceRef} onExplain={() => setDetail('title')} onCopyRef={() => attempt(p.onCopyRef)} actions={<>
             {placement && <div role="group" aria-label="Helper placement" className="flex shrink-0 items-center gap-0.5">{placement.available.map(side =>
               <ContextAction key={side} label={`Place helper at ${side}`} pressed={placement.side === side} keepFocus onClick={() => placement.onChange(side)}><PlacementIcon side={side} /></ContextAction>)}</div>}
             <ContextAction label="Close terminal context" onClick={close} muted><XIcon size={15} /></ContextAction>
diff --git a/lib/src/components/wall/lath-drag-controller.ts b/lib/src/components/wall/lath-drag-controller.ts
index 262bf8c20..e56b6104c 100644
--- a/lib/src/components/wall/lath-drag-controller.ts
+++ b/lib/src/components/wall/lath-drag-controller.ts
@@ -1,6 +1,7 @@
 // One imperative pane/Door gesture owner per LathHost mount; both paths share the
 // threshold, live-tree hit test, depth cycling, cancel, and preview machinery.
 
+import type { SurfaceWorkspaceDrag } from './surface-workspace-drag';
 import type { MutableRefObject, RefObject } from 'react';
 import { type Rect, rectKey } from '../../lib/lath/model';
 import type { DropTarget } from '../../lib/lath/ops';
@@ -57,6 +58,7 @@ export type DragController = {
 export type DragControllerDeps = {
   latestRef: MutableRefObject<{
     snapshot: LathWallSnapshot;
+    workspaceDrag?: SurfaceWorkspaceDrag;
     onDragStart?: (id: string) => void;
     onProposeMove?: (id: string, target: DropTarget) => void;
     onProposeMinimize?: (id: string) => void;
@@ -96,6 +98,7 @@ export function createDragController(deps: DragControllerDeps): DragController {
   const detach = (): void => {
     window.removeEventListener('pointermove', onMove);
     window.removeEventListener('pointerup', onUp);
+    window.removeEventListener('pointercancel', onCancel);
     window.removeEventListener('keydown', onKey);
     window.removeEventListener('wheel', onWheel);
     if (drag && drag.rafId !== null) {
@@ -107,6 +110,7 @@ export function createDragController(deps: DragControllerDeps): DragController {
   const attach = (): void => {
     window.addEventListener('pointermove', onMove);
     window.addEventListener('pointerup', onUp);
+    window.addEventListener('pointercancel', onCancel);
     window.addEventListener('keydown', onKey);
     // Non-passive: the wheel cycles drop depth instead of scrolling.
     window.addEventListener('wheel', onWheel, { passive: false });
@@ -115,6 +119,9 @@ export function createDragController(deps: DragControllerDeps): DragController {
   const runHitTest = (): void => {
     const d = drag;
     if (!d || !d.active) return;
+    if (deps.latestRef.current.workspaceDrag?.hover(d.id, d.lastX, d.lastY)) {
+      d.candidates = []; publishPreview(null); return;
+    }
     const containerEl = deps.containerRef.current;
     if (!containerEl) return;
     const cr = containerEl.getBoundingClientRect();
@@ -165,6 +172,7 @@ export function createDragController(deps: DragControllerDeps): DragController {
       if (el) el.style.opacity = ''; // un-dim (the move commit tweens it into place)
     }
     if (!d) return;
+    deps.latestRef.current.workspaceDrag?.end();
     if (!d.active) {
       // Sub-threshold press: the click behavior stands (a Door click-reattaches; a
       // header selects). An external press that never became a drag still tells the Wall
@@ -180,8 +188,9 @@ export function createDragController(deps: DragControllerDeps): DragController {
       deps.suppressNextClickRef.current = false;
     }, 0);
     const chosen = d.candidates.length > 0 ? d.candidates[Math.min(d.depth, d.candidates.length - 1)] : null;
-    if (!commit) {
-      if (d.external) deps.latestRef.current.onExternalDrop?.(null); // Escape → put the Door back
+    // Escape, or a release the Workspace strip took: a Door goes back.
+    if (!commit || deps.latestRef.current.workspaceDrag?.drop(d.id, d.lastX, d.lastY)) {
+      if (d.external) deps.latestRef.current.onExternalDrop?.(null);
       return;
     }
     if (d.external) {
@@ -215,7 +224,10 @@ export function createDragController(deps: DragControllerDeps): DragController {
     scheduleHitTest();
   }
 
-  function onUp(): void {
+  function onCancel(): void { finish(false); }
+
+  function onUp(e: PointerEvent): void {
+    if (drag) { drag.lastX = e.clientX; drag.lastY = e.clientY; }
     // A release can beat the queued rAF (or follow a background tree commit).
     // Resolve once synchronously so the proposal uses the latest pointer and tree.
     runHitTest();
@@ -259,6 +271,7 @@ export function createDragController(deps: DragControllerDeps): DragController {
       if (drag?.external) {
         detach();
         drag = null;
+        deps.latestRef.current.workspaceDrag?.end();
         publishPreview(null);
       }
     },
@@ -266,7 +279,7 @@ export function createDragController(deps: DragControllerDeps): DragController {
       return drag !== null;
     },
     dispose() {
-      detach();
+      finish(false);
     },
   };
 }
diff --git a/lib/src/components/wall/lath-wall-store.ts b/lib/src/components/wall/lath-wall-store.ts
index e0a7eed6f..a20759208 100644
--- a/lib/src/components/wall/lath-wall-store.ts
+++ b/lib/src/components/wall/lath-wall-store.ts
@@ -61,6 +61,9 @@ export type LathWallStore = {
   /** `useSyncExternalStore` subscriber — returns an unsubscribe. */
   subscribe(listener: () => void): () => void;
 
+  /** Roll back a failed cross-Wall adoption, including parked DOM and zoom. */
+  restoreSnapshot(snapshot: LathWallSnapshot): void;
+
   /** Initial hydration: replace the tree and meta wholesale (clears zoom). */
   seed(tree: LathTree, meta: ReadonlyArray<readonly [LeafId, LeafMeta]>): void;
 
@@ -294,6 +297,8 @@ export function createLathWallStore(): LathWallStore {
       return () => listeners.delete(listener);
     },
 
+    restoreSnapshot(saved) { commit(saved); },
+
     seed(tree, meta) {
       // `meta` carries the incoming Wall whole: the tree's leaves AND any Doors seeded
       // beside them (hydration passes both). Parked Surfaces outlive it — Workspace
diff --git a/lib/src/components/wall/surface-move.ts b/lib/src/components/wall/surface-move.ts
new file mode 100644
index 000000000..cd44b0be8
--- /dev/null
+++ b/lib/src/components/wall/surface-move.ts
@@ -0,0 +1,184 @@
+import { flushSync } from 'react-dom';
+import type { MoveSurfaceRequest, MoveSurfaceResponse } from 'dor/commands/types';
+import { closeWorkspace, createWorkspace, generateWorkspaceId, getActiveWorkspaceId, hasWorkspace, resolveWorkspaceRef, setActiveWorkspace, workspaceRefFor } from '../../lib/workspace-store';
+import { beginWorkspaceSessionBatch, forgetWorkspaceSession, invalidateWorkspaceSaves, isWorkspaceTransferPending, moveRetainedSurfaceRecord, previousWorkspaceSession, publishWorkspaceSession, setWorkspaceTransferPending } from '../../lib/window-session-aggregator';
+import { dismissWorkspaceUi, getWorkspaceUiSnapshot, setPendingSurfaceMove, setWorkspaceMoveError } from '../../lib/workspace-ui-store';
+import type { PersistedSession, WorkspaceId } from '../../lib/session-types';
+import { sanitizeText } from '../../lib/osc-sanitize';
+import { getTerminalInstance } from '../../lib/terminal-registry';
+import { randomKillChar } from '../KillConfirm';
+import { awaitWallHandle, errorText } from './dor-control-shared';
+import { forgetWorkspaceBootPlan, setWorkspaceBootPlan } from './workspace-boot-plans';
+import { getWallHandle, wallHandleOwning, type WallHandle } from './wall-handles';
+
+let moving = false;
+
+const IFRAME_FLAG_REQUIRED = 'Moving this iframe reopens at its saved URL; pass --dangerously-destroy-iframe-page-state to accept losing page state';
+
+function consent(source: string): Promise<boolean> {
+  const ui = getWorkspaceUiSnapshot();
+  if (ui.pendingClose || ui.pendingMove || ui.pendingSurfaceMove || ui.renamingId) throw new Error('Finish the open Workspace dialog before moving this Surface');
+  return new Promise(resolve => setPendingSurfaceMove({ id: source, char: randomKillChar(), answer: accepted => {
+    setPendingSurfaceMove(null);
+    resolve(accepted);
+  } }));
+}
+
+/** The same close tail as `closeWorkspaceWithSurfaces`, for a Wall left empty. */
+function discardWorkspace(id: WorkspaceId): void {
+  closeWorkspace(id);
+  forgetWorkspaceSession(id);
+  forgetWorkspaceBootPlan(id);
+  dismissWorkspaceUi(id);
+}
+
+/** One coordinator for GUI and dor. Preparation and consent change no membership;
+ * the synchronous departure/adoption is reversible until both records are published. */
+export async function moveSurface(id: string, request: Omit<MoveSurfaceRequest, 'surface' | 'workspace'>, gui = false): Promise<MoveSurfaceResponse | null> {
+  if (moving) throw new Error('Another Surface move is in progress');
+  const source = wallHandleOwning(id);
+  if (!source?.canMoveSurfaces) throw new Error('This host does not support moving Surfaces between Workspaces');
+  const destination = request.destination;
+  const resolved = 'workspace' in destination ? resolveWorkspaceRef(destination.workspace) : null;
+  if (resolved && !resolved.ok) throw new Error(resolved.message);
+  let targetId = resolved?.ok ? resolved.id : null;
+  if (targetId === source.workspaceId) throw new Error('The Surface is already in that Workspace');
+  const toNew = !targetId;
+  let target: WallHandle | null = targetId ? getWallHandle(targetId) : null;
+  /** Rechecked after every await: either Wall may close or remount meanwhile. */
+  const checkEndpoints = () => {
+    if (!hasWorkspace(source.workspaceId) || getWallHandle(source.workspaceId) !== source) throw new Error('The source Surface is no longer available');
+    if (toNew && source.surfaceIds().length <= 1) throw new Error('The only Surface is already in its own Workspace');
+    if (targetId && (!hasWorkspace(targetId) || !target?.canMoveSurfaces || getWallHandle(targetId) !== target)) throw new Error('The destination Workspace is unavailable');
+  };
+  checkEndpoints();
+  if (isWorkspaceTransferPending(source.workspaceId) || (targetId && isWorkspaceTransferPending(targetId))) throw new Error('A Workspace is already moving');
+  let prepared = source.prepareSurfaceMove(id);
+  let iframeConsented = request.dangerouslyDestroyIframePageState;
+  if (prepared.iframe && !iframeConsented && !gui) throw new Error(IFRAME_FLAG_REQUIRED);
+  /** False when the user cancels; a dor caller never sees a dialog. */
+  const ensureIframeConsent = async (): Promise<boolean> => {
+    if (!prepared.iframe || iframeConsented) return true;
+    if (!gui) throw new Error(IFRAME_FLAG_REQUIRED);
+    if (!await consent(source.workspaceId)) return false;
+    iframeConsented = true;
+    prepared = source.prepareSurfaceMove(id);
+    return true;
+  };
+  moving = true;
+  setWorkspaceTransferPending(source.workspaceId, true);
+  if (targetId) setWorkspaceTransferPending(targetId, true);
+  const activeBefore = getActiveWorkspaceId();
+  const oldWorkspaceRef = workspaceRefFor(source.workspaceId);
+  let created = false;
+  let committed = false;
+  let endBatch: (() => void) | undefined;
+  let undoDeparture: (() => void) | undefined;
+  let undoAdoption: (() => void) | undefined;
+  let sourceRecord: PersistedSession | null = null;
+  let targetRecord: PersistedSession | null = null;
+  try {
+    if (!await ensureIframeConsent()) return null;
+    // Neither a dialog nor a cwd probe reserves the Surface's kind or dirty state.
+    await Promise.all([source.flushPersistence({ probeCwd: false }), target?.flushPersistence({ probeCwd: false })]);
+    checkEndpoints();
+    prepared = source.prepareSurfaceMove(id);
+    // A Tool may start serving an iframe while the persistence flush awaits.
+    if (!await ensureIframeConsent()) return null;
+    checkEndpoints();
+    endBatch = beginWorkspaceSessionBatch();
+    sourceRecord = previousWorkspaceSession(source.workspaceId);
+    invalidateWorkspaceSaves(source.workspaceId);
+    if (!targetId) {
+      targetId = generateWorkspaceId();
+      setWorkspaceBootPlan(targetId, { emptyForMove: true });
+      flushSync(() => createWorkspace({ id: targetId!, activate: false }));
+      created = true;
+      setWorkspaceTransferPending(targetId, true);
+      target = getWallHandle(targetId) ?? await awaitWallHandle(targetId);
+      if (!target) throw new Error('The new Workspace did not mount');
+      // Revalidate after the new Wall's passive registration; no prompt here.
+      checkEndpoints();
+    }
+    // No await may separate this final dirty/kind check from departure.
+    prepared = source.prepareSurfaceMove(id);
+    if (prepared.iframe && !iframeConsented) throw new Error('This Surface started serving an iframe; retry the move to confirm its refresh');
+    targetRecord = previousWorkspaceSession(targetId);
+    invalidateWorkspaceSaves(targetId);
+    const receiver = target!;
+    let surfaceRef = '';
+    flushSync(() => {
+      undoDeparture = prepared.depart();
+      try {
+        const adopted = receiver.adoptSurfaceMove(id, prepared.meta);
+        undoAdoption = adopted.rollback;
+        surfaceRef = adopted.surfaceRef;
+      } catch (error) { undoDeparture(); undoDeparture = undefined; throw error; }
+      receiver.finishSurfaceMove();
+      source.finishSurfaceMove();
+    });
+    // Mounting a new Wall can let saves collect the pre-departure layout. Fence
+    // those too, once both ownership changes have completed synchronously.
+    invalidateWorkspaceSaves(source.workspaceId);
+    invalidateWorkspaceSaves(targetId);
+    moveRetainedSurfaceRecord(id, source.workspaceId, targetId);
+    const [sourceSession, targetSession] = await Promise.all([
+      source.serializePersistence({ probeCwd: false }), receiver.serializePersistence({ probeCwd: false }),
+    ]);
+    publishWorkspaceSession(source.workspaceId, sourceSession);
+    publishWorkspaceSession(targetId, targetSession);
+    // Closing the source is irreversible. Later UI/notice failures must never
+    // restore membership into a Wall that has already unmounted.
+    committed = true;
+    const sourceEmpty = source.surfaceIds().length === 0;
+    flushSync(() => {
+      if (sourceEmpty) discardWorkspace(source.workspaceId);
+      if (gui || request.focus) {
+        setActiveWorkspace(targetId!);
+        receiver.focusSurface(id, gui);
+      } else if (sourceEmpty && activeBefore === source.workspaceId) {
+        setActiveWorkspace(targetId!); receiver.enterCommandMode();
+      }
+    });
+    const workspaceRef = workspaceRefFor(targetId);
+    if (prepared.terminal) {
+      const moved = `Moved ${prepared.surfaceRef} from ${oldWorkspaceRef} to ${workspaceRef} ${surfaceRef}.`;
+      const terminal = getTerminalInstance(id);
+      if (terminal?.buffer.active.type === 'alternate') {
+        receiver.showMoveNotice(id, `${moved} Cached surface:N refs now resolve here; use stable ID ${id}. Unscoped dor ensure can duplicate work left behind.`);
+      } else {
+        // Raw xterm write: keep host-minted refs and ids from carrying controls.
+        const line = sanitizeText(`${moved} Stable ID: ${id}.`, 500);
+        terminal?.write(`\r\n[Dormouse] ${line}\r\nShort surface:N refs now resolve in the destination Workspace; cached refs may target other panes. Unscoped dor ensure searches here and can duplicate a server left behind. Use stable IDs across moves.\r\n`);
+      }
+    }
+    return { status: 'moved', surfaceId: id, surfaceRef, workspaceId: targetId, workspaceRef };
+  } catch (error) {
+    if (committed) throw error;
+    invalidateWorkspaceSaves(source.workspaceId);
+    if (targetId) invalidateWorkspaceSaves(targetId);
+    flushSync(() => {
+      undoAdoption?.(); undoDeparture?.();
+      source.finishSurfaceMove(); target?.finishSurfaceMove();
+      if (created && targetId) discardWorkspace(targetId);
+      if (hasWorkspace(activeBefore)) setActiveWorkspace(activeBefore);
+    });
+    if (sourceRecord) publishWorkspaceSession(source.workspaceId, sourceRecord);
+    if (!created && targetId && targetRecord) publishWorkspaceSession(targetId, targetRecord);
+    throw error;
+  } finally {
+    endBatch?.();
+    setWorkspaceTransferPending(source.workspaceId, false);
+    if (targetId) setWorkspaceTransferPending(targetId, false);
+    moving = false;
+  }
+}
+
+/** Gesture errors use the Window's existing move refusal presentation. */
+export function requestSurfaceMove(id: string, destination: MoveSurfaceRequest['destination']): void {
+  const source = wallHandleOwning(id);
+  const target = 'workspace' in destination && hasWorkspace(destination.workspace) ? { workspace: workspaceRefFor(destination.workspace) } : destination;
+  void moveSurface(id, { destination: target, focus: true, dangerouslyDestroyIframePageState: false }, true).catch(error => {
+    if (source) setWorkspaceMoveError({ id: source.workspaceId, reason: errorText(error) });
+  });
+}
diff --git a/lib/src/components/wall/surface-workspace-drag.test.ts b/lib/src/components/wall/surface-workspace-drag.test.ts
new file mode 100644
index 000000000..3dace6c87
--- /dev/null
+++ b/lib/src/components/wall/surface-workspace-drag.test.ts
@@ -0,0 +1,57 @@
+/** @vitest-environment jsdom */
+import { afterEach, beforeEach, expect, it, vi } from 'vitest';
+import { resetWorkspaceUi } from '../../lib/workspace-ui-store';
+import { registerWallHandle, resetWallHandles, stubWallHandle } from './wall-handles';
+import { requestSurfaceMove } from './surface-move';
+import { surfaceWorkspaceDrag } from './surface-workspace-drag';
+
+vi.mock('./surface-move', () => ({ requestSurfaceMove: vi.fn() }));
+
+let count: number;
+let sourceTab: HTMLElement;
+let targetTab: HTMLElement;
+let plus: HTMLElement;
+const rect = (left: number, width: number) => ({ left, right: left + width, top: 0, bottom: 30 }) as DOMRect;
+
+beforeEach(() => {
+  resetWorkspaceUi();
+  count = 2;
+  registerWallHandle(stubWallHandle('source', { canMoveSurfaces: true, ownsSurface: id => id === 'pane', surfaceIds: () => Array.from({ length: count }, (_, i) => `pane-${i}`) }));
+  document.body.innerHTML = '<div data-workspace-strip><div data-workspace-tab="source"></div><div data-workspace-tab="target"></div><button data-workspace-new></button></div>';
+  const strip = document.querySelector<HTMLElement>('[data-workspace-strip]')!;
+  sourceTab = document.querySelector<HTMLElement>('[data-workspace-tab="source"]')!;
+  targetTab = document.querySelector<HTMLElement>('[data-workspace-tab="target"]')!;
+  plus = document.querySelector<HTMLElement>('[data-workspace-new]')!;
+  strip.getBoundingClientRect = () => rect(0, 300);
+  sourceTab.getBoundingClientRect = () => rect(0, 80);
+  targetTab.getBoundingClientRect = () => rect(90, 80);
+  plus.getBoundingClientRect = () => rect(260, 30);
+});
+
+afterEach(() => {
+  surfaceWorkspaceDrag.end();
+  resetWallHandles();
+  document.body.innerHTML = '';
+  vi.clearAllMocks();
+});
+
+it('uses live tab bounds on release when a tab resizes during the gesture', () => {
+  expect(surfaceWorkspaceDrag.hover('pane', 100, 15)).toBe(true);
+  expect(targetTab.hasAttribute('data-surface-drop')).toBe(true);
+  sourceTab.getBoundingClientRect = () => rect(0, 130);
+  targetTab.getBoundingClientRect = () => rect(140, 80);
+  expect(surfaceWorkspaceDrag.drop('pane', 100, 15)).toBe(true);
+  expect(requestSurfaceMove).not.toHaveBeenCalled();
+  expect(targetTab.hasAttribute('data-surface-drop')).toBe(false);
+});
+
+it('updates the new-Workspace highlight if source membership changes under the pointer', () => {
+  count = 1;
+  surfaceWorkspaceDrag.hover('pane', 275, 15);
+  expect(plus.hasAttribute('data-surface-drop')).toBe(false);
+  count = 2;
+  surfaceWorkspaceDrag.hover('pane', 275, 15);
+  expect(plus.hasAttribute('data-surface-drop')).toBe(true);
+  surfaceWorkspaceDrag.drop('pane', 275, 15);
+  expect(requestSurfaceMove).toHaveBeenCalledWith('pane', { new: true });
+});
diff --git a/lib/src/components/wall/surface-workspace-drag.ts b/lib/src/components/wall/surface-workspace-drag.ts
new file mode 100644
index 000000000..90de02210
--- /dev/null
+++ b/lib/src/components/wall/surface-workspace-drag.ts
@@ -0,0 +1,52 @@
+import { getWorkspaceUiSnapshot } from '../../lib/workspace-ui-store';
+import { workspaceStripElement, workspaceTabElement, workspaceTabElements } from '../workspace-tab-elements';
+import { wallHandleOwning } from './wall-handles';
+import { requestSurfaceMove } from './surface-move';
+
+/** A pane press owns this path; only a tab press owns reorder/tear-out. */
+export interface SurfaceWorkspaceDrag {
+  hover(id: string, x: number, y: number): boolean;
+  drop(id: string, x: number, y: number): boolean;
+  end(): void;
+}
+
+let highlighted: HTMLElement | null = null;
+
+const inside = (r: DOMRect, x: number, y: number) => x >= r.left && x <= r.right && y >= r.top && y <= r.bottom;
+/** Read live bounds: titles, tab scrolling and CLI reorders can change them mid-drag. */
+function targetAt(x: number, y: number): HTMLElement | null {
+  const strip = workspaceStripElement();
+  if (!strip || !inside(strip.getBoundingClientRect(), x, y)) return null;
+  const targets = [...workspaceTabElements(), workspaceTabElement(null)];
+  return targets.find(target => target && inside(target.getBoundingClientRect(), x, y)) ?? strip;
+}
+function eligible(id: string, target: HTMLElement): boolean {
+  const source = wallHandleOwning(id);
+  const ui = getWorkspaceUiSnapshot();
+  return !!source?.canMoveSurfaces && !ui.pendingSurfaceMove && !ui.pendingMove && !ui.pendingClose
+    && (target.hasAttribute('data-workspace-new') ? source.surfaceIds().length > 1 : !!target.dataset.workspaceTab && target.dataset.workspaceTab !== source.workspaceId);
+}
+function highlight(target: HTMLElement | null): void {
+  if (target === highlighted) return;
+  highlighted?.removeAttribute('data-surface-drop');
+  target?.setAttribute('data-surface-drop', '');
+  highlighted = target;
+}
+function end(): void {
+  highlight(null);
+}
+export const surfaceWorkspaceDrag: SurfaceWorkspaceDrag = {
+  hover(id, x, y) {
+    const target = targetAt(x, y);
+    highlight(target && eligible(id, target) ? target : null);
+    return target !== null; // Strip gaps and disabled targets consume the drop too.
+  },
+  drop(id, x, y) {
+    const target = targetAt(x, y);
+    end();
+    if (!target) return false;
+    if (eligible(id, target)) requestSurfaceMove(id, target.hasAttribute('data-workspace-new') ? { new: true } : { workspace: target.dataset.workspaceTab! });
+    return true;
+  },
+  end,
+};
diff --git a/lib/src/components/wall/use-dor-control.ts b/lib/src/components/wall/use-dor-control.ts
index f354b4e25..b94ae120f 100644
--- a/lib/src/components/wall/use-dor-control.ts
+++ b/lib/src/components/wall/use-dor-control.ts
@@ -1,3 +1,4 @@
+import { moveSurface } from './surface-move';
 import { recordToolDirty } from '../../lib/tool-dirty-store';
 import { createSerialQueue } from '../../host/remote/serial-queue';
 import { useCallback, useEffect, useRef, type MutableRefObject } from 'react';
@@ -33,7 +34,7 @@ import { cwdPathsEqual, surfaceRunsCommand, type TerminalPaneState } from '../..
 import { isAllowedBinaryFor } from '../../lib/agent-browser-binary';
 import { getHelper } from '../../lib/helper-terminal';
 import { isWorkspaceTransferPending } from '../../lib/window-session-aggregator';
-import { stringParam } from './dor-control-shared';
+import { errorText, stringParam } from './dor-control-shared';
 import { getAgentBrowserSurfaceController, handOverBrowserStream } from './agent-browser-surface-controller';
 import {
   callerStillPlaceable,
@@ -83,6 +84,9 @@ import type { DooredItem } from './wall-types';
  *  verbs' own) are the router's, not a Wall's: `WindowControlParams` in
  *  `workspace-control.ts`. */
 export type DorControlParams = {
+  destination?: unknown;
+  focus?: unknown;
+  dangerouslyDestroyIframePageState?: unknown;
   provider?: unknown;
   proposed?: unknown;
   command?: unknown;
@@ -562,6 +566,14 @@ function missingIntegrationError(shell?: string): string {
   return `dor ensure requires OSC 633 shell integration, which ${name} does not provide. Run it from a shell with Dormouse integration, such as Git Bash or PowerShell.`;
 }
 
+/** Exactly one of `{ new: true }` or `{ workspace }`, as `dor move` sends it. */
+function moveDestinationParam(value: unknown): { new: true } | { workspace: string } | null {
+  if (!value || typeof value !== 'object' || Object.keys(value).length !== 1) return null;
+  const destination = value as { new?: unknown; workspace?: unknown };
+  if (destination.new === true) return { new: true };
+  return typeof destination.workspace === 'string' ? { workspace: destination.workspace } : null;
+}
+
 function killConfirmationParam(value: unknown): { mode: 'if-read'; text: string } | { mode: 'dangerously' } | null {
   if (!value || typeof value !== 'object' || Array.isArray(value)) return null;
   const confirmation = value as { mode?: unknown; text?: unknown };
@@ -1889,6 +1901,23 @@ export function useDorControl({
       return;
     }
 
+    if (detail.method === SURFACE_CONTROL_METHODS.move) {
+      const target = requireListedSurface(params.surface, detail);
+      if (!target) return;
+      const destination = moveDestinationParam(params.destination);
+      if (!destination) {
+        detail.respond({ ok: false, error: 'Specify exactly one destination Workspace or --new' }); return;
+      }
+      try {
+        const result = await moveSurface(target.id, {
+          destination, focus: booleanParam(params.focus),
+          dangerouslyDestroyIframePageState: booleanParam(params.dangerouslyDestroyIframePageState),
+        });
+        detail.respond({ ok: true, result });
+      } catch (error) { detail.respond({ ok: false, error: errorText(error) }); }
+      return;
+    }
+
     if (detail.method === SURFACE_CONTROL_METHODS.kill) {
       const confirmation = killConfirmationParam(params.confirmation);
       if (!confirmation) {
diff --git a/lib/src/components/wall/use-session-persistence.ts b/lib/src/components/wall/use-session-persistence.ts
index a0598f8b4..f6f7cbdb3 100644
--- a/lib/src/components/wall/use-session-persistence.ts
+++ b/lib/src/components/wall/use-session-persistence.ts
@@ -4,7 +4,7 @@ import { pasteFilePaths } from '../../lib/clipboard';
 import { getPlatform } from '../../lib/platform';
 import { buildPersistedSession, saveSession, type SaveOptions, type SaveSink } from '../../lib/session-save';
 import { createSessionDirtyTracker } from '../../lib/session-dirty';
-import { previousWorkspaceSession, publishWorkspaceSession, SESSION_SAVE_DEBOUNCE_MS } from '../../lib/window-session-aggregator';
+import { previousWorkspaceSession, publishWorkspaceSession, workspaceSessionRevision, SESSION_SAVE_DEBOUNCE_MS } from '../../lib/window-session-aggregator';
 import { getWorkspace, setWorkspaceAlertDelivery, subscribeToWorkspaces, hasWorkspace } from '../../lib/workspace-store';
 import {
   subscribeToActivity,
@@ -130,11 +130,6 @@ export function useSessionPersistence({
     return { panes, doors, lathLayout: lath.serializeLayout(), surfaceRefs };
   }, [lath, doorsRef, surfaceRefsForSave]);
 
-  const doSave = useCallback((options?: SaveOptions): Promise<void> => {
-    const { panes, doors, lathLayout, surfaceRefs } = collect();
-    return saveSession(getPlatform(), panes, doors, lathLayout, surfaceRefs?.refs, surfaceRefs?.next, sink, saveOptions(options));
-  }, [collect, sink, saveOptions]);
-
   /** The same record a save would publish, handed back instead. The Workspace
    *  is leaving, so nothing here may touch this Window's aggregator. */
   const serialize = useCallback((options?: SaveOptions): Promise<PersistedSession> => {
@@ -145,6 +140,18 @@ export function useSessionPersistence({
     );
   }, [collect, sink, saveOptions]);
 
+  const doSave = useCallback((options?: SaveOptions): Promise<void> => {
+    if (workspaceId === undefined) {
+      const { panes, doors, lathLayout, surfaceRefs } = collect();
+      return saveSession(getPlatform(), panes, doors, lathLayout, surfaceRefs?.refs, surfaceRefs?.next, sink, saveOptions(options));
+    }
+    // A Surface move bumps the revision; a record collected before it is stale.
+    const revision = workspaceSessionRevision(workspaceId);
+    return serialize(options).then(session => {
+      if (revision === workspaceSessionRevision(workspaceId) && hasWorkspace(workspaceId)) publishWorkspaceSession(workspaceId, session);
+    });
+  }, [collect, serialize, sink, saveOptions, workspaceId]);
+
   const persistSessionNow = useCallback(async (options?: SaveOptions): Promise<void> => {
     const runSave = (): Promise<void> => {
       pendingSaveNeededRef.current = false;
diff --git a/lib/src/components/wall/wall-handles.ts b/lib/src/components/wall/wall-handles.ts
index 6422938b5..01c0dafec 100644
--- a/lib/src/components/wall/wall-handles.ts
+++ b/lib/src/components/wall/wall-handles.ts
@@ -1,3 +1,5 @@
+import type { LeafMeta } from '../../lib/lath/persistence';
+import type { PersistedSession } from '../../lib/session-types';
 import type { BrowserAutomationProvider } from 'dor-lib-common/browser-providers';
 import type { WorkspaceId } from '../../lib/session-types';
 import type { SaveOptions } from '../../lib/session-save';
@@ -11,7 +13,23 @@ import type { DorControlRequest } from './use-dor-control';
  * under `DEFAULT_WORKSPACE_ID`, so exactly one handle answers a `dor` request
  * even in the single-Workspace hosts.
  */
+export interface PreparedSurfaceMove {
+  meta: LeafMeta;
+  surfaceRef: string;
+  iframe: boolean;
+  terminal: boolean;
+  /** Detach membership, never the Session. Returns a complete Wall rollback. */
+  depart(): () => void;
+}
+
 export interface WallHandle {
+  canMoveSurfaces: boolean;
+  prepareSurfaceMove(id: string): PreparedSurfaceMove;
+  adoptSurfaceMove(id: string, meta: LeafMeta): { surfaceRef: string; rollback(): void };
+  finishSurfaceMove(): void;
+  focusSurface(id: string, acknowledge: boolean): void;
+  showMoveNotice(id: string, text: string): void;
+  serializePersistence(options?: SaveOptions): Promise<PersistedSession>;
   workspaceId: WorkspaceId;
   /** The Wall's member Surfaces: visible panes ∪ Doors. */
   surfaceIds(): string[];
@@ -104,6 +122,13 @@ export function resetWallHandles(): void {
 export function stubWallHandle(workspaceId: WorkspaceId, overrides: Partial<WallHandle> = {}): WallHandle {
   return {
     workspaceId,
+    canMoveSurfaces: false,
+    prepareSurfaceMove: () => { throw new Error('Surface moves are unavailable'); },
+    adoptSurfaceMove: () => { throw new Error('Surface moves are unavailable'); },
+    finishSurfaceMove: () => {},
+    focusSurface: () => {},
+    showMoveNotice: () => {},
+    serializePersistence: async () => ({ version: 3, panes: [] }),
     surfaceIds: () => [],
     ownsSurface: () => false,
     iframeSurfaceRefs: () => [],
diff --git a/lib/src/components/wall/wall-types.ts b/lib/src/components/wall/wall-types.ts
index 59a516ac5..fca3fa752 100644
--- a/lib/src/components/wall/wall-types.ts
+++ b/lib/src/components/wall/wall-types.ts
@@ -61,6 +61,8 @@ export type DoorAfterRestoreAction =
  * one default-shell pane (docs/specs/layout.md → "Workspaces").
  */
 export interface WallBootProps {
+  /** A move creates an empty receiving Wall; adoption supplies its only pane. */
+  emptyForMove?: boolean;
   initialPaneIds?: string[];
   restoredLathLayout?: unknown;
   initialDoors?: PersistedDoor[];
diff --git a/lib/src/components/workspace-tab-elements.ts b/lib/src/components/workspace-tab-elements.ts
index 997313e20..4d0c8945d 100644
--- a/lib/src/components/workspace-tab-elements.ts
+++ b/lib/src/components/workspace-tab-elements.ts
@@ -1,3 +1,8 @@
+/** The strip itself, whose bounds a pane drag over the tabs claims. */
+export function workspaceStripElement(): HTMLElement | null {
+  return document.querySelector('[data-workspace-strip]');
+}
+
 /** Every Workspace tab in strip order. The strip renders outside every Wall, so
  *  the DOM is what its measurers share. */
 export function workspaceTabElements(): HTMLElement[] {
diff --git a/lib/src/index.css b/lib/src/index.css
index 0323a0bfb..931e97ed2 100644
--- a/lib/src/index.css
+++ b/lib/src/index.css
@@ -151,3 +151,9 @@ body {
 @media (prefers-reduced-motion: reduce) {
   .shell-spawn-notice { animation: none; }
 }
+
+/* The Workspace tab or + a pane drag would move its Surface to on release. */
+[data-surface-drop] {
+  outline: 2px solid var(--color-focus-ring);
+  outline-offset: -2px;
+}
diff --git a/lib/src/lib/window-session-aggregator.test.ts b/lib/src/lib/window-session-aggregator.test.ts
index 69a0dbc87..beea9eb7f 100644
--- a/lib/src/lib/window-session-aggregator.test.ts
+++ b/lib/src/lib/window-session-aggregator.test.ts
@@ -4,6 +4,7 @@
 // and there is no unload without a `window`.
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import {
+  beginWorkspaceSessionBatch,
   clearWorkspaceTransferring,
   flushWindowSession,
   forgetWorkspaceSession,
@@ -271,3 +272,24 @@ describe('window session aggregator', () => {
     });
   });
 });
+
+
+it('holds every write through a Surface move, including pagehide and explicit flush, then writes both records once', async () => {
+  const first = getWorkspacesSnapshot().workspaces[0].id;
+  const second = createWorkspace({ name: 'Second' }).id;
+  publishWorkspaceSession(first, session('moving'));
+  publishWorkspaceSession(second, session('other'));
+  const write = vi.fn();
+  installWindowSessionWriter(write);
+  const end = beginWorkspaceSessionBatch();
+  publishWorkspaceSession(first, { version: 3, panes: [] });
+  window.dispatchEvent(new Event('pagehide'));
+  await flushWindowSession();
+  expect(write).not.toHaveBeenCalled();
+  publishWorkspaceSession(second, { version: 3, panes: [...session('other').panes, ...session('moving').panes] });
+  end();
+  expect(write).toHaveBeenCalledTimes(1);
+  const saved = write.mock.calls[0][0] as PersistedWindow;
+  expect(saved.workspaces[0].session.panes).toEqual([]);
+  expect(saved.workspaces[1].session.panes.map(p => p.id)).toEqual(['other', 'moving']);
+});
diff --git a/lib/src/lib/window-session-aggregator.ts b/lib/src/lib/window-session-aggregator.ts
index 18fd9dbcc..dea0cbc2e 100644
--- a/lib/src/lib/window-session-aggregator.ts
+++ b/lib/src/lib/window-session-aggregator.ts
@@ -14,6 +14,28 @@ import type { PersistedSession, PersistedWindow, PersistedWorkspace, WorkspaceId
  * `cwd` out of (`previousWorkspaceSession`).
  */
 
+const revisions = new Map<WorkspaceId, number>();
+/** Set while a Surface move publishes both Walls: no write sees one half. */
+let batchHeld = false;
+/** Fence asynchronous saves collected before ownership changed. */
+export function workspaceSessionRevision(id: WorkspaceId): number { return revisions.get(id) ?? 0; }
+export function invalidateWorkspaceSaves(id: WorkspaceId): void { revisions.set(id, workspaceSessionRevision(id) + 1); }
+
+/** Hold every write until both Walls have published. */
+export function beginWorkspaceSessionBatch(): () => void {
+  if (batchHeld) throw new Error('A Workspace persistence batch is already running');
+  batchHeld = true;
+  cancelPending();
+  return () => { batchHeld = false; scheduleWrite(); };
+}
+
+/** Preserve a dead Session's retained cwd/alert while its Wall changes. */
+export function moveRetainedSurfaceRecord(id: string, source: WorkspaceId, destination: WorkspaceId): void {
+  const row = records.get(source)?.panes.find(pane => pane.id === id);
+  const target = records.get(destination);
+  if (row && target) records.set(destination, { ...target, panes: [...target.panes.filter(pane => pane.id !== id), row] });
+}
+
 const records = new Map<WorkspaceId, PersistedSession>();
 /** Workspaces this Window has handed to another one and not yet released. */
 const transferring = new Set<WorkspaceId>();
@@ -204,7 +226,7 @@ export async function flushWindowSession(): Promise<void> {
 }
 
 function scheduleWrite(): void {
-  if (!writer) return;
+  if (!writer || batchHeld) return;
   // A publish that lands during `pagehide` — the Walls flush there too — has no
   // later tick to be written on.
   if (unloading) {
@@ -220,7 +242,7 @@ function scheduleWrite(): void {
 }
 
 function writeNow(): void {
-  if (!writer) return;
+  if (!writer || batchHeld) return;
   const result = writer(getWindowSnapshot());
   inFlight = result ? Promise.resolve(result).catch(() => undefined) : null;
 }
@@ -234,6 +256,8 @@ function cancelPending(): void {
 /** Forget every session, seed, transfer guard, and installed writer (tests). */
 export function resetWindowSessionAggregator(): void {
   records.clear();
+  revisions.clear();
+  batchHeld = false;
   transferring.clear();
   pendingTransfers.clear();
   writer = null;
diff --git a/lib/src/lib/workspace-ui-store.ts b/lib/src/lib/workspace-ui-store.ts
index 60cb20991..4316624b5 100644
--- a/lib/src/lib/workspace-ui-store.ts
+++ b/lib/src/lib/workspace-ui-store.ts
@@ -14,13 +14,17 @@ export interface WorkspaceUiState {
   pendingClose: { id: WorkspaceId; char: string } | null;
   /** A refused move stays visible until dismissed or retried. */
   moveError: { id: WorkspaceId; reason: string } | null;
+  /** A Surface move between Workspaces awaiting its typed iframe-refresh
+   *  confirmation; `answer` settles the move
+   *  (`docs/specs/layout.md` → "Moving Surfaces between Workspaces"). */
+  pendingSurfaceMove: { id: WorkspaceId; char: string; answer: (accepted: boolean) => void } | null;
   /** A move between Windows awaiting its typed confirmation, because it would
    *  destroy the page state of `iframeCount` iframe Surfaces; `proceed` runs the
    *  move (`docs/specs/layout.md` → "Workspaces"). */
   pendingMove: { id: WorkspaceId; char: string; iframeCount: number; proceed: () => void } | null;
 }
 
-const EMPTY: WorkspaceUiState = { renamingId: null, pendingClose: null, pendingMove: null, moveError: null };
+const EMPTY: WorkspaceUiState = { renamingId: null, pendingClose: null, pendingMove: null, pendingSurfaceMove: null, moveError: null };
 
 let state: WorkspaceUiState = EMPTY;
 const listeners = new Set<() => void>();
@@ -57,6 +61,10 @@ export function setPendingWorkspaceMove(pending: WorkspaceUiState['pendingMove']
   emit({ ...state, pendingMove: pending });
 }
 
+export function setPendingSurfaceMove(pending: WorkspaceUiState['pendingSurfaceMove']): void {
+  emit({ ...state, pendingSurfaceMove: pending });
+}
+
 export function setWorkspaceMoveError(error: WorkspaceUiState['moveError']): void {
   emit({ ...state, moveError: error });
 }
@@ -65,14 +73,17 @@ export function setWorkspaceMoveError(error: WorkspaceUiState['moveError']): voi
  *  teardown dialog taking the window, and tests. */
 export function resetWorkspaceUi(): void {
   if (state === EMPTY) return;
+  state.pendingSurfaceMove?.answer(false);
   emit(EMPTY);
 }
 
 /** Forget only the departing Workspace's chrome, preserving sibling dialogs. */
 export function dismissWorkspaceUi(id: WorkspaceId): void {
-  const { renamingId, pendingClose, pendingMove, moveError } = state;
-  if (renamingId !== id && pendingClose?.id !== id && pendingMove?.id !== id && moveError?.id !== id) return;
+  const { renamingId, pendingClose, pendingMove, pendingSurfaceMove, moveError } = state;
+  if (renamingId !== id && pendingClose?.id !== id && pendingMove?.id !== id && pendingSurfaceMove?.id !== id && moveError?.id !== id) return;
+  if (pendingSurfaceMove?.id === id) pendingSurfaceMove.answer(false);
   emit({
+    pendingSurfaceMove: pendingSurfaceMove?.id === id ? null : pendingSurfaceMove,
     renamingId: renamingId === id ? null : renamingId,
     pendingClose: pendingClose?.id === id ? null : pendingClose,
     pendingMove: pendingMove?.id === id ? null : pendingMove,
diff --git a/scripts/spec-word-budgets.json b/scripts/spec-word-budgets.json
index e986aa07b..4a1bb7e36 100644
--- a/scripts/spec-word-budgets.json
+++ b/scripts/spec-word-budgets.json
@@ -3,17 +3,17 @@
   "SECURITY.md": 200,
   "SELF_HOST.md": 6100,
   "docs/compatible-agents.md": 1750,
-  "docs/specs/alert.md": 8850,
+  "docs/specs/alert.md": 8900,
   "docs/specs/auto-update.md": 1450,
   "docs/specs/deploy.md": 1950,
   "docs/specs/dor-browser.md": 9350,
-  "docs/specs/dor-cli.md": 6450,
+  "docs/specs/dor-cli.md": 6650,
   "docs/specs/dor-tool.md": 6250,
   "docs/specs/dor-tools-builtin.md": 1100,
   "docs/specs/dor-tools-lib.md": 400,
   "docs/specs/glossary.md": 3000,
   "docs/specs/hosted.md": 4800,
-  "docs/specs/layout.md": 11500,
+  "docs/specs/layout.md": 11950,
   "docs/specs/mobile-terminal-ui.md": 2300,
   "docs/specs/mouse-and-clipboard.md": 5250,
   "docs/specs/one-time.md": 3850,
@@ -35,8 +35,8 @@
   "docs/specs/terminal-escapes.md": 4100,
   "docs/specs/terminal-state.md": 2550,
   "docs/specs/theme.md": 2400,
-  "docs/specs/tiling-engine.md": 4650,
-  "docs/specs/transport.md": 5000,
+  "docs/specs/tiling-engine.md": 4700,
+  "docs/specs/transport.md": 5050,
   "docs/specs/tutorial.md": 2050,
   "docs/specs/vscode.md": 7300,
   "docs/specs/webgl-text.md": 1200,
diff --git a/standalone/src/quit-confirm-store.test.ts b/standalone/src/quit-confirm-store.test.ts
index bbb877fca..b882e3cb5 100644
--- a/standalone/src/quit-confirm-store.test.ts
+++ b/standalone/src/quit-confirm-store.test.ts
@@ -118,7 +118,7 @@ describe("quit-confirm store", () => {
     setWorkspaceMoveError({ id: 'workspace-1', reason: 'Wait for the Tool browser to connect' });
     setWorkspaceTransferPending('workspace-1', true);
     openQuitConfirm(makeCtx());
-    expect(getWorkspaceUiSnapshot()).toEqual({ pendingClose: null, pendingMove: null, renamingId: null, moveError: null });
+    expect(getWorkspaceUiSnapshot()).toEqual({ pendingClose: null, pendingMove: null, pendingSurfaceMove: null, renamingId: null, moveError: null });
     expect(isWorkspaceTransferPending('workspace-1')).toBe(true);
     expect(chromeKeyboardHeld()).toBe(true);
   });