diff --git a/docs/specs/dor-browser.md b/docs/specs/dor-browser.md
index d3cd4ee7..32925a95 100644
--- a/docs/specs/dor-browser.md
+++ b/docs/specs/dor-browser.md
@@ -75,6 +75,15 @@ Both CLI entry points use the same content-surface placement rule in
 otherwise split next to the reference surface. `dor iframe` also accepts
 `--surface`, `--minimize`, and `--json`.
 
+Both open the surface **focus-neutrally** (like `dor ensure`): it renders in the
+background and the caller keeps focus — except when replacing the pane the user
+is currently selected on, where selection follows to the replacement (it would
+otherwise dangle on the removed panel); replacing an active-but-unselected pane
+leaves the user's selection, including a door selection, untouched.
+`createContentSurface`'s
+`focusNeutral` routes through the shared `runSurfaceAdd` helper (see
+`docs/specs/layout.md` corner case #12).
+
 Surface lifetime owns backing resources:
 
 - Killing an agent-browser-rendered pane marks the session closed and runs
diff --git a/docs/specs/layout.md b/docs/specs/layout.md
index 6f5b693c..b7a68dc5 100644
--- a/docs/specs/layout.md
+++ b/docs/specs/layout.md
@@ -358,7 +358,7 @@ Shell-selection replacement uses the same pane add/remove primitives but also sh
 
 ### Kill (in-place fade + FLIP reclaim)
 
-`orchestrateKill(api, killedId)` in `lib/src/lib/kill-animation.ts` runs on kill confirmation. `Wall.tsx` owns the command dispatch and calls it after the user confirms. It fades the real pane element in place (its content dissolves against the same-colored background), then removes the panel and FLIP-reveals the survivors:
+`orchestrateKill(api, killedId, isSelected, …, onRemoved?)` in `lib/src/lib/kill-animation.ts` runs on kill confirmation. `Wall.tsx` owns the command dispatch and calls it after the user confirms. `isSelected` is a live reader, not a snapshot: the selection tail evaluates `isSelected(killedId)` at removal time (up to ~1s after the fade starts), and the overlay ring reads it once at fade start. The optional `onRemoved` callback fires once, on every path, immediately after `removePanel`: collapsing a branch can re-parent and blur the surviving selected pane, so `killPaneImmediately` uses it to re-assert that pane's DOM focus (through the shared `reassertPaneFocus` guard, see corner case #12). It fades the real pane element in place (its content dissolves against the same-colored background), then removes the panel and FLIP-reveals the survivors:
 
 1. Add `.pane-fading-out` (or `.pane-fading-and-shrinking-to-br` for a last-pane kill) to the killed pane's group element. Block pointer events during the fade.
 2. On `animationend`, snapshot `getBoundingClientRect` for every surviving panel's group element.
@@ -368,11 +368,13 @@ Shell-selection replacement uses the same pane add/remove primitives but also sh
 
 Case handling is purely rect-based (measure before and after removal), so 2-pane splits, linear 3+ rows/columns, and nested splits all fall through the same code path with no per-case branching.
 
+Selection tail: after removal, `orchestrateKill` moves selection to a survivor (`panels[0]`, or `null` → auto-spawn when the last pane goes) **only when `isSelected(killedId)` reads true at removal time** — the killed pane is the selected one. `killPaneImmediately` passes a live reader (`selectedType === 'pane' && selectedId === killedId`) rather than a snapshot, so killing a background surface leaves the user's selection untouched, and a selection move *during* the ~1s fade is honored by design: navigating away from a dying selected pane means the tail no longer yanks selection to `panels[0]`, and navigating onto a dying pane means the tail adopts a survivor instead of leaving selection dangling on the removed panel. (The removal is tagged with `withProgrammaticActivation`, so dockview's activate-the-survivor echo — which previously covered those two edges by accident — no longer reads as user intent; the live check covers them explicitly.) The header kill button cannot produce an unselected kill: dockview activates the pane on pointerdown (`doSetGroupActive`) before the button's click handler runs, so mouse kills are always selected-pane kills. The not-selected cases are `dor kill` of a background surface (`dor kill surface:3`) and ensure's throwaway teardown.
+
 ### Auto-spawn delay
 
 When `onDidRemovePanel` triggers the "always keep one pane visible" auto-spawn (see corner case #10), the `api.addPanel` call is deferred by 440ms **for the minimize path** — letting the selection-overlay slide to the door finish before the replacement's reveal starts. The kill path uses no extra delay (0ms): kill sequencing is already handled inside `orchestrateKill`, which removes the panel only after the fade's `animationend`. Reduced-motion users also get 0ms. The deferred spawn re-checks `totalPanels` at fire time and becomes a no-op if anything repopulated the pane area during the delay (e.g. a door reattach). If it does create a replacement pane, that pane spawns with the current default shell selection, matching manual splits and the standalone `[+]` action.
 
-The deferred spawn also only calls `selectPane` if selection is null. The kill handler clears selection to null, so the new pane takes focus. The minimize flow sets selection to the just-created door; preserving that door focus across the delay is the point.
+The deferred spawn adopts the replacement (`selectPane`) only when the current selection no longer points at anything real: null (`orchestrateKill`'s selection tail cleared it after a selected last-pane kill) or dangling (selection still names the removed pane, which the 0ms kill timer can observe if it beats React's flush of `setSelectedId(null)` into `selectedIdRef`). A *valid* selection is left alone — the just-created door on the minimize path (preserving that door focus across the delay is the point) or a live pane after an unselected kill — because the auto-spawn exists to keep a pane visible, not to steal selection.
 
 ## Corner cases
 
@@ -386,7 +388,8 @@ The deferred spawn also only calls `selectPane` if selection is null. The kill h
 8. **Center drop merges panels**: intercepted at group-level `model.onWillDrop` and converted to a swap.
 9. **Group drag has null panelId**: falls back to `api.getGroup(groupId).activePanel.id`.
 10. **Auto-spawn on empty**: `onDidRemovePanel` creates a new session whenever the last visible pane is removed, whether or not doors exist — there is always a pane visible. The `addPanel` call is delayed 440ms on the minimize path (see "Auto-spawn delay" under Animations); the kill path is sequenced by `orchestrateKill` instead.
-11. **Door focus survives auto-spawn**: `api.addPanel` auto-activates the new panel, firing `onDidActivePanelChange`. When the current selection is a door (e.g., just-minimized last pane), that listener must not flip `selectedId` to the new pane — otherwise `selectedType === 'door'` + `selectedId === newPaneId` desyncs and the door loses its highlight while the `WorkspaceSelectionOverlay` is stuck on the stale door rect. The listener early-returns when `selectedType === 'door'`.
+11. **Door focus survives auto-spawn**: `api.addPanel` auto-activates the new panel, firing `onDidActivePanelChange`. When the current selection is a door (e.g., just-minimized last pane), selection must not flip to the new pane — otherwise `selectedType === 'door'` + `selectedId === newPaneId` desyncs and the door loses its highlight while the `WorkspaceSelectionOverlay` is stuck on the stale door rect. The auto-spawn's `addPanel` is tagged with `withProgrammaticActivation` and applies its adopt-or-leave selection policy explicitly at the spawn site (adopt only when selection is null or dangling; a valid door or live-pane selection is left alone), so door survival lives in the spawn-site policy — the listener no longer has a door special case. A dockview-native user interaction, though, DOES move selection off a door now — dragging a panel, or DOM focus landing in a surface (an embed focusing itself) — matching how those already move selection off a pane; explicit user selection of a pane always wins over door stickiness.
+12. **Focus-neutral surface creation (`dor ensure` / `dor iframe` / `dor ab`)**: unlike `dor split`, these must never move focus off the caller (`docs/specs/dor-cli.md`, `docs/specs/dor-browser.md`). Adding the pane `inactive` does **not** work: dockview renders and lays out a pane only once it becomes its group's active panel (a new group's `setActive` runs `doSetActivePanel`), so an `inactive` add — which skips both — leaves the pane behind a blank tile until the first click activates it. Instead the shared `runSurfaceAdd(focusNeutral, add)` helper adds the pane **active** (so it renders), then `add` hands the active group straight back to the caller via `settleFocusAfterAdd` (`caller.api.setActive()`); the new pane stays active *within its own group* and keeps rendering. The helper runs the add inside `withProgrammaticActivation` (`lib/src/lib/programmatic-activation.ts`), a depth-counted tag the `onDidActivePanelChange` listener (#11) checks so this programmatic activation churn never reads as user intent, and `selectedId`/mode never leave the caller. But adding the pane re-parents the caller's grid subtree in the DOM, which **blurs its xterm textarea** — and since `selectedId` never changed, `TerminalPanel`'s focus effect does not re-run to reclaim it, so the caller would silently stop receiving keystrokes until clicked. So the helper re-asserts the selected pane's focus with a deferred `focusSession` through the shared `reassertPaneFocus` rAF helper (deferred to beat dockview's post-split focus handling, like the click-focus rAF in `enterTerminalMode`), gated on three conditions: the pane is still the selected pane in passthrough (the condition `TerminalPanel` uses for `isFocused`, so a legitimate selection move makes it a no-op); the window still has focus (`document.hasFocus()` — a background `dor` command must never yank cross-frame focus out of the host editor, e.g. VS Code); and DOM focus is not in an in-page editable control (the inline-rename input, a non-terminal `<input>`/`<textarea>`/contenteditable — re-parent blur drops focus to `<body>`, so a focused control means the user put it there; the terminal's own `xterm-helper-textarea` is exempt since re-focusing it is idempotent). Callers skip `selectPane`; the `--minimize` case passes `select: false` to `minimizePane` so it creates the door without stealing selection or switching to command mode. (`dor iframe` / `dor ab` replacing the pane the user is *currently selected on* are the exception: selection follows to the replacement, since it would otherwise dangle on the removed panel. Replacing an active-but-unselected pane leaves the user's selection — including a door selection — untouched.) If a freshly created shell never reports OSC 633 integration, ensure tears the throwaway pane down with `killPaneImmediately`; because the focus-neutral create never selected it, `orchestrateKill`'s live selection check (`isSelected(killedId)` read at removal time, see the kill "Selection tail" above) leaves the caller's selection intact. For a `--minimize` create the throwaway is already a door with no dockview panel, and `killPaneImmediately` handles that too — disposing the session and removing the door directly (no panel to animate). Coverage rule: every programmatic dockview mutation runs tagged inside `withProgrammaticActivation` — the focus-neutral adds here, `selectPane`/`enterTerminalMode`'s own trailing `setActive`, reattach's restore mutations (`handleReattach`), the kill removal, `minimizePane`'s removal, and the empty-pane auto-spawn's `addPanel` — so an untagged activation is a dockview-native user interaction (a panel drag, or DOM focus landing in a surface), which the listener adopts through the real dispatchers: `enterTerminalMode` in passthrough, `selectPane` in command. Selection policy lives at the mutation sites, not the listener; `lib/src/lib/programmatic-activation.ts` holds the rationale.
 
 ## Files
 
@@ -400,6 +403,7 @@ The deferred spawn also only calls `selectPane` if selection is null. The kill h
 | `lib/src/components/wall/MarchingAntsRect.tsx` | SVG marching-ants border path and dash sizing |
 | `lib/src/components/wall/MouseOverrideBanner.tsx` | Temporary mouse override banner shown from the header icon |
 | `lib/src/components/wall/use-dockview-ready.ts` | Dockview ready/setup handler: restore/create panels, DnD swap wiring, active panel sync, auto-spawn |
+| `lib/src/lib/programmatic-activation.ts` | `withProgrammaticActivation` depth-tag distinguishing programmatic add-side dockview activation from user activation |
 | `lib/src/components/wall/use-wall-keyboard.ts` | Capture-phase keyboard dispatch for mode switching, pane/door commands, copy/paste, selection drag keys |
 | `lib/src/lib/vscode-keybindings.ts` | VS Code-hosted workbench chord mirror allowlist |
 | `lib/src/components/wall/use-session-persistence.ts` | Debounced layout/session save, flush requests, pagehide, PTY exit, file-drop paste routing |
diff --git a/dor/src/commands/ensure.ts b/dor/src/commands/ensure.ts
index 006a5fc5..5c4c48aa 100644
--- a/dor/src/commands/ensure.ts
+++ b/dor/src/commands/ensure.ts
@@ -62,6 +62,8 @@ export const ensureCommand: Command = {
       brief: 'Ensure one surface is running a command.',
       fullDescription: `Ensures one surface in the current workspace is running the given command at the given path. If it's already running, no-op. If it isn't, then it creates a split and runs the command.
 
+ensure never changes focus. Whether it reuses a match, restarts one, or creates a new split, the surface you ran it from keeps focus — a newly created surface (visible or minimized) starts in the background.
+
 Matching uses the command each shell reports it is running via Dormouse shell integration (OSC 633), not process inspection. This captures the typed command (\`npm run dev\`), not the forked child process (\`node .../vite\`), and works for shells the user started by hand as well as shells Dormouse started. The match is exact: \`npm run dev\` and \`npm run dev --host\` are different commands and get separate surfaces.
 
 ensure requires that integration: a surface can only be matched, reused, or restarted if its shell reports its command. So if the shell has no OSC 633 integration (e.g. cmd.exe), ensure fails with an error rather than starting an untrackable surface — run it from a shell with integration, such as Git Bash or PowerShell.
diff --git a/dor/test/snapshots/help/ensure.md b/dor/test/snapshots/help/ensure.md
index 0f45203b..95039cd4 100644
--- a/dor/test/snapshots/help/ensure.md
+++ b/dor/test/snapshots/help/ensure.md
@@ -9,6 +9,8 @@ USAGE
 
 Ensures one surface in the current workspace is running the given command at the given path. If it's already running, no-op. If it isn't, then it creates a split and runs the command.
 
+ensure never changes focus. Whether it reuses a match, restarts one, or creates a new split, the surface you ran it from keeps focus — a newly created surface (visible or minimized) starts in the background.
+
 Matching uses the command each shell reports it is running via Dormouse shell integration (OSC 633), not process inspection. This captures the typed command (`npm run dev`), not the forked child process (`node .../vite`), and works for shells the user started by hand as well as shells Dormouse started. The match is exact: `npm run dev` and `npm run dev --host` are different commands and get separate surfaces.
 
 ensure requires that integration: a surface can only be matched, reused, or restarted if its shell reports its command. So if the shell has no OSC 633 integration (e.g. cmd.exe), ensure fails with an error rather than starting an untrackable surface — run it from a shell with integration, such as Git Bash or PowerShell.
diff --git a/lib/src/components/Wall.tsx b/lib/src/components/Wall.tsx
index c568edc8..749f6345 100644
--- a/lib/src/components/Wall.tsx
+++ b/lib/src/components/Wall.tsx
@@ -5,6 +5,7 @@ import {
   themeAbyss,
   type DockviewTheme,
   type DockviewApi,
+  type IDockviewPanel,
 } from 'dockview-react';
 import 'dockview-react/dist/styles/dockview.css';
 import { Baseboard } from './Baseboard';
@@ -75,6 +76,7 @@ import { hostPathDisplay } from './wall/browser-url';
 import { SurfacePaneHeader } from './wall/SurfacePaneHeader';
 import { WorkspaceSelectionOverlay } from './wall/WorkspaceSelectionOverlay';
 import { useDockviewReady } from './wall/use-dockview-ready';
+import { withProgrammaticActivation } from '../lib/programmatic-activation';
 import { pickSplitDirection } from './wall/dockview-helpers';
 import { useWallKeyboard } from './wall/use-wall-keyboard';
 import { useSessionPersistence } from './wall/use-session-persistence';
@@ -399,6 +401,32 @@ function spawnDirectionForDockview(direction: DockviewSplitDirection): SpawnDire
   return direction === 'above' || direction === 'below' ? 'top' : 'left';
 }
 
+// After a surface-adding op, settle focus and selection; returns whether it
+// selected the new surface. A non-focus-neutral add selects the new pane
+// outright. A focus-neutral add hands the active group back to `caller` (the
+// active pane at entry) so the new pane renders without the active group
+// wandering — this is purely a dockview-activation concern. Dormouse selection
+// then moves onto the new surface only when the op replaced the pane the user
+// was actually selected on (`selectionReplaced`); otherwise the user's
+// selection would dangle on a removed panel. Selection policy is deliberately
+// keyed on the user's selection, not on whether the captured `caller`
+// (activePanel) survived: activePanel can diverge from selection (e.g. a `dor`
+// op replacing an active-but-unselected pane while the user has a door
+// selected).
+function settleFocusAfterAdd(
+  api: DockviewApi,
+  focusNeutral: boolean,
+  caller: IDockviewPanel | undefined,
+  selectionReplaced: boolean,
+  newId: string,
+  selectPane: (id: string) => void,
+): boolean {
+  if (!focusNeutral) { selectPane(newId); return true; }
+  if (caller && api.getPanel(caller.id)) caller.api.setActive();
+  if (selectionReplaced) { selectPane(newId); return true; }
+  return false;
+}
+
 /**
  * Quote a raw argv into a single command string for the target pane's shell.
  * This is the one place the command is quoted; the CLI sends argv unquoted
@@ -491,6 +519,16 @@ export function Wall({
 
   const killInProgressRef = useRef(false);
 
+  // "Programmatic activation" tag: depth > 0 while an add-side programmatic
+  // dockview mutation is in flight, so the onDidActivePanelChange listener can
+  // tell that activation churn apart from a genuine user click and leave
+  // selection/mode alone. dockview fires the same event for both. The tag is set
+  // via withProgrammaticActivation around runSurfaceAdd's add (focus-neutral
+  // surface creation, layout.md corner case #12); see programmatic-activation.ts
+  // for the full design rationale (why a depth counter, the synchronicity
+  // assumption, and why removal-side echoes are deliberately not tagged).
+  const programmaticActivationRef = useRef(0);
+
   // Ref to the WorkspaceSelectionOverlay's root element. orchestrateKill uses it to
   // animate the focus ring in sync with the killed pane's shrink (last-pane case).
   const overlayElRef = useRef<HTMLDivElement | null>(null);
@@ -593,7 +631,35 @@ export function Wall({
     setSelectedId(id);
     setSelectedType('pane');
     const panel = apiRef.current?.getPanel(id);
-    if (panel) panel.api.setActive();
+    // The echo of our own setActive is not user intent; the refs written above
+    // already neutralized it (selectedIdRef.current === panel.id, so the listener
+    // no-ops), and the tag makes that ordering non-load-bearing.
+    if (panel) withProgrammaticActivation(programmaticActivationRef, () => panel.api.setActive());
+  }, []);
+
+  // Restore DOM focus to the selected pane after a dockview mutation (addPanel /
+  // removePanel) re-parents its grid subtree and blurs it. Deferred a frame past
+  // dockview's own post-mutation focus handling. The first gate (selected pane in
+  // passthrough) is TerminalPane's `isFocused` condition, so this only ever heals
+  // the pane the effect itself would keep focused. `document.hasFocus()` keeps a
+  // background `dor` command from yanking cross-frame focus out of the host editor
+  // (VS Code: a webview blur leaves mode/selectedId untouched). The editable-control
+  // check keeps it from yanking in-page focus the user placed deliberately (e.g. the
+  // inline-rename input) — re-parent blur drops focus to `<body>`, so a focused
+  // control means the user chose it; the `xterm-helper-textarea` exemption is the
+  // terminal's own textarea, where re-focusing is idempotent. See docs/specs/layout.md
+  // corner case #12.
+  const reassertPaneFocus = useCallback((id: string) => {
+    requestAnimationFrame(() => {
+      if (modeRef.current !== 'passthrough' || selectedTypeRef.current !== 'pane' || selectedIdRef.current !== id) return;
+      if (!document.hasFocus()) return;
+      const ae = document.activeElement;
+      const inEditableControl = ae instanceof HTMLElement
+        && (ae.tagName === 'INPUT' || ae.tagName === 'TEXTAREA' || ae.isContentEditable)
+        && !ae.classList.contains('xterm-helper-textarea');
+      if (inEditableControl) return;
+      focusSession(id, true);
+    });
   }, []);
 
   const showShellSpawnNotice = useCallback((id: string, text: string) => {
@@ -613,16 +679,56 @@ export function Wall({
 
   const killPaneImmediately = useCallback((id: string) => {
     const api = apiRef.current;
-    const panel = api?.getPanel(id);
-    if (!api || !panel) return;
+    if (!api) return;
+    const panel = api.getPanel(id);
+    if (!panel) {
+      // A doored surface has no dockview panel but still owns a live session
+      // (its PTY keeps running). `dor ensure --minimize`'s integration-timeout
+      // teardown lands here: the throwaway was created straight into a door.
+      const door = doorsRef.current.find(d => d.id === id);
+      if (!door) return;
+      closeAgentBrowserSession(door.params);
+      disposeAgentBrowserSurfaceController(id);
+      // Dispose the session/registry entry — this stops the PTY and makes a
+      // still-armed typeCommandWhenPromptReady exit via its `!registry.has(id)`
+      // check, so a late OSC signal can't type the command into a dead surface.
+      disposeSession(id);
+      const nextDoors = doorsRef.current.filter(d => d.id !== id);
+      doorsRef.current = nextDoors;
+      setDoors(nextDoors);
+      // Guard: no current caller kills a selected door (ensure's throwaway is
+      // never selected), but if one did, fall back to the active pane.
+      if (selectedIdRef.current === id && selectedTypeRef.current === 'door') {
+        const active = api.activePanel;
+        if (active) selectPane(active.id);
+        else setSelectedId(null);
+      }
+      clearLocalSurfaceActivity(id);
+      fireEvent({ type: 'kill', id });
+      return;
+    }
     closeAgentBrowserSession(panel.params);
     // Release the surface's client-side controller (connection, loops, timers,
     // screen registration). A safe no-op for iframe/terminal surfaces.
     disposeAgentBrowserSurfaceController(id);
-    orchestrateKill(api, id, selectPane, setSelectedId, killInProgressRef, overlayElRef);
+    // Only a kill of the selected pane should move selection; `dor kill` of a
+    // background surface (and ensure's throwaway teardown) leaves it. The check is
+    // LIVE — orchestrateKill re-reads it at removal time (up to ~1s after the fade
+    // starts), so a mid-fade selection move is honored. The `=== 'pane'` term keeps
+    // a doored id from ever reading as selected for the kill tail. Mouse kills always
+    // arrive selected — clicking a pane header activates it (dockview's pointerdown)
+    // before the kill button's click handler runs.
+    const isSelectedPane = (kid: string) =>
+      selectedTypeRef.current === 'pane' && selectedIdRef.current === kid;
+    // removePanel can collapse a branch, re-parenting + blurring the survivor. If
+    // selection is unchanged (background kill), TerminalPane's effect won't heal it,
+    // so re-assert here; for a selected-pane kill the tail's selectPane changes
+    // selection, so the rAF gate no-ops (harmless).
+    const focusId = selectedTypeRef.current === 'pane' ? selectedIdRef.current : null;
+    orchestrateKill(api, id, isSelectedPane, selectPane, setSelectedId, killInProgressRef, overlayElRef, programmaticActivationRef, focusId ? () => reassertPaneFocus(focusId) : undefined);
     clearLocalSurfaceActivity(id);
     fireEvent({ type: 'kill', id });
-  }, [fireEvent, selectPane]);
+  }, [fireEvent, selectPane, reassertPaneFocus]);
 
   const acceptKill = useCallback(() => {
     const ck = confirmKillRef.current;
@@ -660,13 +766,16 @@ export function Wall({
     // preventing dockview from stealing focus back from xterm
     requestAnimationFrame(() => focusSession(id, true));
     const panel = apiRef.current?.getPanel(id);
-    if (panel) panel.api.setActive();
+    // Same as selectPane: the echo of our own setActive is not user intent; the
+    // refs+mode written above already neutralized it, and the tag makes that
+    // ordering non-load-bearing.
+    if (panel) withProgrammaticActivation(programmaticActivationRef, () => panel.api.setActive());
   }, []);
   const enterTerminalModeRef = useRef(enterTerminalMode);
   enterTerminalModeRef.current = enterTerminalMode;
 
   /** Minimize a pane: capture neighbor context, remove from dockview, add to doors state */
-  const minimizePane = useCallback((id: string) => {
+  const minimizePane = useCallback((id: string, opts?: { select?: boolean }) => {
     const api = apiRef.current;
     if (!api) return;
     const panel = api.getPanel(id);
@@ -684,7 +793,12 @@ export function Wall({
       .map(p => p.id)
       .sort();
 
-    api.removePanel(panel);
+    // The removal's survivor-activation echo is not user intent — selection is
+    // settled explicitly right after (selectDoor on the user path; the
+    // focus-neutral `--minimize` path leaves selection per its `select: false`).
+    withProgrammaticActivation(programmaticActivationRef, () => {
+      api.removePanel(panel);
+    });
     clearSessionAttention(id);
     const layoutAtMinimizeSignature = getLayoutStructureSignature(api.toJSON());
     const nextDoors = [...doorsRef.current, {
@@ -703,9 +817,13 @@ export function Wall({
     setDoors(nextDoors);
 
     // Keep the minimized session selected as a door so the user can track where it went.
-    modeRef.current = 'command';
-    setMode('command');
-    selectDoor(id);
+    // A focus-neutral creation (`dor ensure --minimize`) opts out: it must leave the
+    // caller's mode and selection untouched (see createSplitSurface's focusNeutral).
+    if (opts?.select !== false) {
+      modeRef.current = 'command';
+      setMode('command');
+      selectDoor(id);
+    }
   }, [selectDoor]);
 
   /** Exit terminal mode */
@@ -736,6 +854,7 @@ export function Wall({
     doorsRef,
     freshlySpawnedRef,
     killInProgressRef,
+    programmaticActivationRef,
     selectedIdRef,
     selectedTypeRef,
     modeRef,
@@ -785,50 +904,57 @@ export function Wall({
       currentLayoutSignature === item.layoutAtMinimizeSignature &&
       idsMatch(currentPaneIds, reattachPaneIds);
 
-    if (canReattachExactLayout) {
-      const currentTitles = new Map(
-        api.panels.map(panel => [panel.id, panel.title ?? panel.id] as const),
-      );
+    // Reattach mutations (the exact-layout fromJSON restore or the addPanel
+    // fallbacks) activate a pane as a side effect; selection is established
+    // explicitly right after (selectPane / enterTerminalMode below). Tag them so
+    // the listener treats the echo as programmatic — with the door guard gone,
+    // this tag is the only thing keeping the echo from reading as user intent.
+    withProgrammaticActivation(programmaticActivationRef, () => {
+      if (canReattachExactLayout) {
+        const currentTitles = new Map(
+          api.panels.map(panel => [panel.id, panel.title ?? panel.id] as const),
+        );
 
-      // reuseExistingPanels: keep existing panel component instances mounted
-      // rather than destroying and recreating them during deserialization.
-      api.fromJSON(cloneLayout(item.layoutAtMinimize!), { reuseExistingPanels: true });
+        // reuseExistingPanels: keep existing panel component instances mounted
+        // rather than destroying and recreating them during deserialization.
+        api.fromJSON(cloneLayout(item.layoutAtMinimize!), { reuseExistingPanels: true });
 
-      for (const [panelId, title] of currentTitles) {
-        if (panelId === item.id) continue;
-        api.getPanel(panelId)?.api.setTitle(title);
-      }
-    } else {
-      const currentIds = api.panels.map(p => p.id).sort();
-      const layoutUnchanged =
-        item.neighborId &&
-        api.getPanel(item.neighborId) &&
-        idsMatch(currentIds, item.remainingPaneIds);
-
-      if (layoutUnchanged) {
-        // Restore to original position next to the same neighbor
-        api.addPanel({
-          id: item.id,
-          component: item.component ?? 'terminal',
-          tabComponent: item.tabComponent ?? 'terminal',
-          title: item.title,
-          params: item.params,
-          position: { referencePanel: item.neighborId!, direction: item.direction },
-        });
+        for (const [panelId, title] of currentTitles) {
+          if (panelId === item.id) continue;
+          api.getPanel(panelId)?.api.setTitle(title);
+        }
       } else {
-        // Layout changed — split an existing panel based on its aspect ratio
-        const sid = selectedIdRef.current;
-        const refPanel = (sid && api.getPanel(sid)) ?? api.panels[0] ?? null;
-        api.addPanel({
-          id: item.id,
-          component: item.component ?? 'terminal',
-          tabComponent: item.tabComponent ?? 'terminal',
-          title: item.title,
-          params: item.params,
-          position: refPanel ? { referencePanel: refPanel.id, direction: pickSplitDirection(refPanel) } : undefined,
-        });
+        const currentIds = api.panels.map(p => p.id).sort();
+        const layoutUnchanged =
+          item.neighborId &&
+          api.getPanel(item.neighborId) &&
+          idsMatch(currentIds, item.remainingPaneIds);
+
+        if (layoutUnchanged) {
+          // Restore to original position next to the same neighbor
+          api.addPanel({
+            id: item.id,
+            component: item.component ?? 'terminal',
+            tabComponent: item.tabComponent ?? 'terminal',
+            title: item.title,
+            params: item.params,
+            position: { referencePanel: item.neighborId!, direction: item.direction },
+          });
+        } else {
+          // Layout changed — split an existing panel based on its aspect ratio
+          const sid = selectedIdRef.current;
+          const refPanel = (sid && api.getPanel(sid)) ?? api.panels[0] ?? null;
+          api.addPanel({
+            id: item.id,
+            component: item.component ?? 'terminal',
+            tabComponent: item.tabComponent ?? 'terminal',
+            title: item.title,
+            params: item.params,
+            position: refPanel ? { referencePanel: refPanel.id, direction: pickSplitDirection(refPanel) } : undefined,
+          });
+        }
       }
-    }
+    });
 
     const nextDoors = doorsRef.current.filter(p => p.id !== item.id);
     doorsRef.current = nextDoors;
@@ -850,15 +976,22 @@ export function Wall({
         } else if (typeof afterRestore === 'object' && afterRestore.type === 'replace-terminal') {
           const panel = apiRef.current?.getPanel(item.id);
           if (!panel) return;
-          apiRef.current?.addPanel({
-            id: afterRestore.newId,
-            component: 'terminal',
-            tabComponent: 'terminal',
-            title: UNNAMED_PANEL_TITLE,
-            position: { referencePanel: panel, direction: 'within' },
+          // Add the replacement then drop the reattached pane. Both mutations
+          // activate a pane, and the explicit selectPane(newId) right after is the
+          // real selection intent, so tag the add+remove pair — the removePanel's
+          // activate-the-survivor echo is redundant when selectPane immediately
+          // follows. (disposeSession is synchronous and unrelated to activation.)
+          withProgrammaticActivation(programmaticActivationRef, () => {
+            apiRef.current?.addPanel({
+              id: afterRestore.newId,
+              component: 'terminal',
+              tabComponent: 'terminal',
+              title: UNNAMED_PANEL_TITLE,
+              position: { referencePanel: panel, direction: 'within' },
+            });
+            disposeSession(item.id);
+            apiRef.current?.removePanel(panel);
           });
-          disposeSession(item.id);
-          apiRef.current?.removePanel(panel);
           selectPane(afterRestore.newId);
           if (afterRestore.announce) {
             showShellSpawnNotice(afterRestore.newId, `Switched to ${afterRestore.shellName}`);
@@ -944,6 +1077,33 @@ export function Wall({
     return ids.find((id) => surfaceRunsCommand(getTerminalPaneState(id), command, cwdPath)) ?? null;
   }, []);
 
+  // Run a surface-adding `add`, focus-neutrally when asked — the shared machinery
+  // behind focus-neutral `dor ensure` / `dor iframe` / `dor ab` (vs. plain `dor
+  // split`). When not focus-neutral, `add` runs directly with no caller. When it
+  // is: dockview renders a pane only once it becomes its group's active panel, so
+  // `add` must activate the new pane and the onDidActivePanelChange listener would
+  // follow it — we run `add` inside withProgrammaticActivation so the listener
+  // ignores that activation churn for the duration, and pass `add` the caller
+  // panel (the active pane at entry) purely as the activation hand-back target (via
+  // settleFocusAfterAdd, which reactivates it); selection policy is decided
+  // separately there from the user's selection (selectionReplaced), not the caller.
+  // Adding the pane re-parents the selected pane's grid subtree, blurring its focus;
+  // since selection never moved, TerminalPane's effect won't reclaim it, so we
+  // re-assert focus through the shared reassertPaneFocus helper (keyed on the user's
+  // selection, not the caller — matching the selection-based policy; its rAF gate
+  // re-checks selection, so a legitimate selection move like selectionReplaced makes
+  // it a no-op). See docs/specs/layout.md corner case #12.
+  const runSurfaceAdd = useCallback((
+    focusNeutral: boolean | undefined,
+    add: (caller: IDockviewPanel | undefined) => void,
+  ) => {
+    if (!focusNeutral) { add(undefined); return; }
+    const caller = apiRef.current?.activePanel ?? undefined;
+    const focusId = selectedTypeRef.current === 'pane' ? selectedIdRef.current : null;
+    withProgrammaticActivation(programmaticActivationRef, () => add(caller));
+    if (focusId) reassertPaneFocus(focusId);
+  }, [reassertPaneFocus]);
+
   const createSplitSurface = useCallback(({
     command,
     direction,
@@ -951,6 +1111,7 @@ export function Wall({
     referenceId,
     cwd,
     requireIntegration,
+    focusNeutral,
   }: {
     command?: string;
     direction: DorResolvedSplitDirection;
@@ -958,6 +1119,10 @@ export function Wall({
     referenceId: string;
     cwd?: string;
     requireIntegration?: boolean;
+    // `dor ensure` must never move focus: activate the new pane only transiently
+    // to force a render, then hand activation back to the caller, leaving the
+    // caller's selection, mode, and DOM focus intact.
+    focusNeutral?: boolean;
   }): ParseResult<{
     id: string;
     ref: string;
@@ -999,25 +1164,32 @@ export function Wall({
 
     const dockDirection = dockviewDirectionForDor(direction);
     freshlySpawnedRef.current.set(newId, spawnDirectionForDockview(dockDirection));
-    api.addPanel({
-      id: newId,
-      component: 'terminal',
-      tabComponent: 'terminal',
-      title: UNNAMED_PANEL_TITLE,
-      position: { referencePanel: referencePanel.id, direction: dockDirection },
-    });
-    selectPane(newId);
-    onEventRef.current?.({
-      type: 'split',
-      direction: direction === 'left' || direction === 'right' ? 'horizontal' : 'vertical',
-      source: 'dor',
+
+    // dockview renders a pane only once active in its group, so we can't add it
+    // `inactive`; runSurfaceAdd adds it active and, when focus-neutral, hands the
+    // active group back to the caller (settleFocusAfterAdd) so it renders without
+    // stealing focus. `dor split` (not focus-neutral) just selects the new pane.
+    runSurfaceAdd(focusNeutral, (caller) => {
+      api.addPanel({
+        id: newId,
+        component: 'terminal',
+        tabComponent: 'terminal',
+        title: UNNAMED_PANEL_TITLE,
+        position: { referencePanel: referencePanel.id, direction: dockDirection },
+      });
+      const selectedNew = settleFocusAfterAdd(api, !!focusNeutral, caller, false, newId, selectPane);
+      onEventRef.current?.({
+        type: 'split',
+        direction: direction === 'left' || direction === 'right' ? 'horizontal' : 'vertical',
+        source: 'dor',
+      });
+      if (minimized) {
+        getOrCreateTerminal(newId);
+        minimizePane(newId, { select: selectedNew });
+      }
     });
-    if (minimized) {
-      getOrCreateTerminal(newId);
-      minimizePane(newId);
-    }
     return { ok: true, value: { id: newId, ref: surfaceRefForId(newId) } };
-  }, [generatePaneId, minimizePane, selectPane, surfaceRefForId]);
+  }, [runSurfaceAdd, generatePaneId, minimizePane, selectPane, surfaceRefForId]);
 
   /**
    * Create a non-terminal content surface (iframe, agent-browser) next to a
@@ -1029,11 +1201,15 @@ export function Wall({
     params,
     reference,
     title,
+    focusNeutral,
   }: {
     minimized: boolean;
     params: Record<string, unknown>;
     reference: DorSurface;
     title: string;
+    // `dor iframe` / `dor ab` pass this to open the surface in the background
+    // without moving focus off the caller, matching `dor ensure`.
+    focusNeutral?: boolean;
   }): ParseResult<{
     id: string;
     ref: string;
@@ -1050,46 +1226,52 @@ export function Wall({
     const newId = generatePaneId();
     const replaceUntouchedTerminal = reference.type === 'terminal' && isUntouched(reference.id);
 
+    // Shared panel spec for both paths; they differ only in position.direction.
+    const panelSpec = {
+      id: newId,
+      component,
+      tabComponent: 'surface',
+      title,
+      params,
+      // Keep iframes mounted across (de)activation — dockview's default
+      // onlyWhenVisible renderer detaches/reattaches panel DOM, and moving an
+      // <iframe> in the DOM reloads it (docs/specs/dor-browser.md).
+      renderer,
+    } as const;
+
     if (replaceUntouchedTerminal) {
-      api.addPanel({
-        id: newId,
-        component,
-        tabComponent: 'surface',
-        title,
-        params,
-        // Keep iframes mounted across (de)activation — dockview's default
-        // onlyWhenVisible renderer detaches/reattaches panel DOM, and moving an
-        // <iframe> in the DOM reloads it (docs/specs/dor-browser.md).
-        renderer,
-        position: { referencePanel: referencePanel.id, direction: 'within' },
+      // Whether the user's current selection sits on the pane being replaced.
+      const selectionReplaced = selectedTypeRef.current === 'pane' && selectedIdRef.current === reference.id;
+      runSurfaceAdd(focusNeutral, (caller) => {
+        api.addPanel({ ...panelSpec, position: { referencePanel: referencePanel.id, direction: 'within' } });
+        disposeSession(reference.id);
+        api.removePanel(referencePanel);
+        // Replacing the pane the user is selected on forces selection onto the
+        // replacement (settleFocusAfterAdd selects it); replacing any other pane
+        // leaves the user's selection — including a door selection — untouched.
+        const selectedNew = settleFocusAfterAdd(api, !!focusNeutral, caller, selectionReplaced, newId, selectPane);
+        // When we did move selection onto the new pane, a minimize must carry it
+        // onto the resulting door rather than leave selectedType='pane' pointing
+        // at a door id (the overlay would keep a stale rect).
+        if (minimized) minimizePane(newId, { select: selectedNew });
       });
-      disposeSession(reference.id);
-      api.removePanel(referencePanel);
-      selectPane(newId);
-      if (minimized) minimizePane(newId);
       return { ok: true, value: { id: newId, ref: surfaceRefForId(newId), status: 'replaced' } };
     }
 
     const dockDirection = pickSplitDirection(referencePanel);
     freshlySpawnedRef.current.set(newId, dockDirection === 'below' ? 'top' : 'left');
-    api.addPanel({
-      id: newId,
-      component,
-      tabComponent: 'surface',
-      title,
-      params,
-      renderer,
-      position: { referencePanel: referencePanel.id, direction: dockDirection },
-    });
-    selectPane(newId);
-    onEventRef.current?.({
-      type: 'split',
-      direction: dockDirection === 'right' ? 'horizontal' : 'vertical',
-      source: 'dor',
+    runSurfaceAdd(focusNeutral, (caller) => {
+      api.addPanel({ ...panelSpec, position: { referencePanel: referencePanel.id, direction: dockDirection } });
+      const selectedNew = settleFocusAfterAdd(api, !!focusNeutral, caller, false, newId, selectPane);
+      onEventRef.current?.({
+        type: 'split',
+        direction: dockDirection === 'right' ? 'horizontal' : 'vertical',
+        source: 'dor',
+      });
+      if (minimized) minimizePane(newId, { select: selectedNew });
     });
-    if (minimized) minimizePane(newId);
     return { ok: true, value: { id: newId, ref: surfaceRefForId(newId), status: 'created' } };
-  }, [generatePaneId, minimizePane, selectPane, surfaceRefForId]);
+  }, [runSurfaceAdd, generatePaneId, minimizePane, selectPane, surfaceRefForId]);
 
   // The last binary path a `dor ab` surface resolved on a terminal's PATH.
   // Re-used to spawn an agent-browser when swapping an iframe embed up to a
@@ -1374,6 +1556,8 @@ export function Wall({
           referenceId: resolved.target.id,
           cwd,
           requireIntegration: true,
+          // ensure never steals focus from the caller, matched or freshly created.
+          focusNeutral: true,
         });
         if (!result.ok) {
           detail.respond({ ok: false, error: result.message });
@@ -1391,6 +1575,11 @@ export function Wall({
           INTEGRATION_DETECT_TIMEOUT_MS,
         );
         if (!integrated) {
+          // Tear down the throwaway split. The focus-neutral create never selected
+          // it, so orchestrateKill's live selection check leaves the caller's
+          // selection where ensure found it. A `--minimize` create is already a
+          // door; killPaneImmediately tears the door down too — disposing the
+          // session and removing it from the baseboard.
           killPaneImmediately(result.value.id);
           detail.respond({ ok: false, error: missingIntegrationError(ensureShell) });
           return;
@@ -1513,6 +1702,8 @@ export function Wall({
           params: { surfaceType: 'browser', renderMode: 'iframe', url },
           reference: target.value,
           title: hostPathDisplay(url, true),
+          // `dor iframe` opens the embed in the background; caller keeps focus.
+          focusNeutral: true,
         });
         if (!result.ok) {
           detail.respond({ ok: false, error: result.message });
@@ -1590,6 +1781,8 @@ export function Wall({
           },
           reference: target.value,
           title: key ?? session,
+          // `dor ab` opens the screencast in the background; caller keeps focus.
+          focusNeutral: true,
         });
         if (!result.ok) {
           detail.respond({ ok: false, error: result.message });
diff --git a/lib/src/components/wall/use-dockview-ready.ts b/lib/src/components/wall/use-dockview-ready.ts
index acb09547..a24febb6 100644
--- a/lib/src/components/wall/use-dockview-ready.ts
+++ b/lib/src/components/wall/use-dockview-ready.ts
@@ -8,6 +8,7 @@ import type {
 } from 'dockview-react';
 import { getDefaultShellOpts, setPendingShellOpts, swapTerminals, UNNAMED_PANEL_TITLE } from '../../lib/terminal-registry';
 import { prefersReducedMotion } from '../../lib/ui-geometry';
+import { withProgrammaticActivation } from '../../lib/programmatic-activation';
 import type { DooredItem, WallMode, WallSelectionKind, SpawnDirection } from './wall-types';
 import { pickSplitDirection, swapPanelTitles } from './dockview-helpers';
 
@@ -19,6 +20,7 @@ export function useDockviewReady({
   doorsRef,
   freshlySpawnedRef,
   killInProgressRef,
+  programmaticActivationRef,
   selectedIdRef,
   selectedTypeRef,
   modeRef,
@@ -37,6 +39,7 @@ export function useDockviewReady({
   doorsRef: RefObject<DooredItem[]>;
   freshlySpawnedRef: RefObject<Map<string, SpawnDirection>>;
   killInProgressRef: RefObject<boolean>;
+  programmaticActivationRef: RefObject<number>;
   selectedIdRef: RefObject<string | null>;
   selectedTypeRef: RefObject<WallSelectionKind>;
   modeRef: RefObject<WallMode>;
@@ -147,14 +150,21 @@ export function useDockviewReady({
     });
 
     e.api.onDidActivePanelChange((panel) => {
-      if (panel) {
-        if (selectedTypeRef.current === 'door') return;
-        if (modeRef.current === 'passthrough' && selectedIdRef.current !== panel.id) {
-          enterTerminalModeRef.current(panel.id);
-          return;
-        }
-        setSelectedId(panel.id);
+      if (!panel) return;
+      // A tagged mutation is mid-flight; its caller applies selection policy
+      // explicitly at the mutation site (see programmatic-activation.ts).
+      if (programmaticActivationRef.current > 0) return;
+      // Every untagged activation is a dockview-native user interaction that the
+      // React click handlers don't cover — a panel drag, or DOM focus landing in
+      // a surface (an embed focusing itself adopts like a click). Adopt it through
+      // the real dispatchers so the (kind, id) selection pair stays consistent;
+      // never a bare setSelectedId, which can shear the pair (a door-type id
+      // pointing at a pane was corner case #11's desync).
+      if (modeRef.current === 'passthrough') {
+        if (selectedIdRef.current !== panel.id) enterTerminalModeRef.current(panel.id);
+        return;
       }
+      selectPane(panel.id);
     });
 
     e.api.onDidRemovePanel(() => {
@@ -165,10 +175,18 @@ export function useDockviewReady({
         const id = generatePaneId();
         primeDefaultShell(id);
         freshlySpawnedRef.current.set(id, 'top-left');
-        e.api.addPanel({ id, component: 'terminal', tabComponent: 'terminal', title: UNNAMED_PANEL_TITLE });
-        if (selectedIdRef.current === null) {
-          selectPane(id);
-        }
+        withProgrammaticActivation(programmaticActivationRef, () => {
+          e.api.addPanel({ id, component: 'terminal', tabComponent: 'terminal', title: UNNAMED_PANEL_TITLE });
+        });
+        // Adopt the replacement only when the current selection no longer points at
+        // anything real: null (the kill tail cleared it) or dangling (selection still
+        // names the removed pane — the 0ms kill timer can beat React's flush of
+        // setSelectedId(null) into selectedIdRef). A valid selection keeps it: a door
+        // (just-minimized last pane, corner case #11) or a live pane stays selected —
+        // the auto-spawn exists to keep a pane visible, not to steal selection.
+        const sel = selectedIdRef.current;
+        const selDangling = sel !== null && selectedTypeRef.current === 'pane' && !e.api.getPanel(sel);
+        if (sel === null || selDangling) selectPane(id);
       };
       setTimeout(spawn, delay);
     });
@@ -188,6 +206,7 @@ export function useDockviewReady({
     resolvedRef,
     restoredLayoutRef,
     selectPane,
+    programmaticActivationRef,
     selectedIdRef,
     selectedTypeRef,
     setDockviewApi,
diff --git a/lib/src/lib/kill-animation.test.ts b/lib/src/lib/kill-animation.test.ts
index 8817aa16..99415791 100644
--- a/lib/src/lib/kill-animation.test.ts
+++ b/lib/src/lib/kill-animation.test.ts
@@ -76,6 +76,11 @@ function dispatchAnimationEnd(el: HTMLElement, animationName: string): void {
 
 // Non-last-pane fade animation name; matched by the animationend handler.
 const FADE = 'pane-fade-out';
+// Last-pane fade animation name; the only remaining pane shrinks toward BR.
+const FADE_LAST = 'pane-fade-and-shrink-to-br';
+
+// isSelected readers: kill tests pass a live function, not a snapshot.
+const sel = (v: boolean) => () => v;
 
 describe('orchestrateKill', () => {
   beforeEach(() => {
@@ -99,8 +104,8 @@ describe('orchestrateKill', () => {
 
     // Two confirm keydowns processed before a re-render: both invocations arm a
     // listener on the same killed group element.
-    orchestrateKill(api, 'a', selectPane, setSelectedId, killInProgressRef, { current: null });
-    orchestrateKill(api, 'a', selectPane, setSelectedId, killInProgressRef, { current: null });
+    orchestrateKill(api, 'a', sel(true), selectPane, setSelectedId, killInProgressRef, { current: null }, { current: 0 });
+    orchestrateKill(api, 'a', sel(true), selectPane, setSelectedId, killInProgressRef, { current: null }, { current: 0 });
 
     // One real animationend fires BOTH listeners → two finalizes race.
     dispatchAnimationEnd(killedEl, FADE);
@@ -119,7 +124,7 @@ describe('orchestrateKill', () => {
     const setSelectedId = vi.fn();
     const killInProgressRef = { current: false };
 
-    orchestrateKill(api, 'a', selectPane, setSelectedId, killInProgressRef, { current: null });
+    orchestrateKill(api, 'a', sel(true), selectPane, setSelectedId, killInProgressRef, { current: null }, { current: 0 });
 
     // A CLI kill / replaceSurface removes the panel before the animation ends.
     evict('a');
@@ -143,7 +148,7 @@ describe('orchestrateKill', () => {
     const setSelectedId = vi.fn();
     const killInProgressRef = { current: false };
 
-    orchestrateKill(api, 'a', selectPane, setSelectedId, killInProgressRef, { current: null });
+    orchestrateKill(api, 'a', sel(true), selectPane, setSelectedId, killInProgressRef, { current: null }, { current: 0 });
     dispatchAnimationEnd(killedEl, FADE);
 
     expect(removePanel).toHaveBeenCalledTimes(1);
@@ -152,6 +157,174 @@ describe('orchestrateKill', () => {
     expect(selectPane).toHaveBeenCalledWith('b');
   });
 
+  it('onRemoved fires once on the animated path, only after removePanel', () => {
+    const { api, removePanel, elementOf } = makeApi(['a', 'b']);
+    const killedEl = elementOf('a');
+    const selectPane = vi.fn();
+    const setSelectedId = vi.fn();
+    const killInProgressRef = { current: false };
+    // Assert ordering from inside the spy: removePanel must have run before this.
+    let removedCountAtCallback = -1;
+    const onRemoved = vi.fn(() => { removedCountAtCallback = removePanel.mock.calls.length; });
+
+    orchestrateKill(api, 'a', sel(true), selectPane, setSelectedId, killInProgressRef, { current: null }, { current: 0 }, onRemoved);
+
+    // The animated path defers removal to animationend: onRemoved must wait too.
+    expect(onRemoved).not.toHaveBeenCalled();
+
+    dispatchAnimationEnd(killedEl, FADE);
+
+    expect(onRemoved).toHaveBeenCalledTimes(1);
+    // removePanel had already been called by the time onRemoved ran.
+    expect(removedCountAtCallback).toBe(1);
+  });
+
+  it('killing an unselected pane removes it but leaves selection untouched, still firing onRemoved', () => {
+    const { api, removePanel, elementOf, panelOf } = makeApi(['a', 'b']);
+    const killedEl = elementOf('a');
+    const killedPanel = panelOf('a');
+    const selectPane = vi.fn();
+    const setSelectedId = vi.fn();
+    const killInProgressRef = { current: false };
+    const onRemoved = vi.fn();
+
+    // `dor kill surface:a` while the user is on 'b': isSelected('a') is false.
+    orchestrateKill(api, 'a', sel(false), selectPane, setSelectedId, killInProgressRef, { current: null }, { current: 0 }, onRemoved);
+    dispatchAnimationEnd(killedEl, FADE);
+
+    expect(removePanel).toHaveBeenCalledWith(killedPanel);
+    // Selection tail is skipped — the user's selection stays where it was.
+    expect(selectPane).not.toHaveBeenCalled();
+    expect(setSelectedId).not.toHaveBeenCalled();
+    // onRemoved runs before the selection gate, so a background kill still heals focus.
+    expect(onRemoved).toHaveBeenCalledTimes(1);
+  });
+
+  it('live re-read: navigating AWAY from the dying selected pane mid-fade skips the tail', () => {
+    const { api, elementOf } = makeApi(['a', 'b']);
+    const killedEl = elementOf('a');
+    const selectPane = vi.fn();
+    const setSelectedId = vi.fn();
+    const killInProgressRef = { current: false };
+
+    // Selected at fade start, but the user navigates away before the fade ends.
+    let selected = true;
+    const isSelected = () => selected;
+
+    orchestrateKill(api, 'a', isSelected, selectPane, setSelectedId, killInProgressRef, { current: null }, { current: 0 });
+    selected = false; // mid-fade selection move onto some other surface
+    dispatchAnimationEnd(killedEl, FADE);
+
+    // Live read at removal time is false → the tail must not yank selection.
+    expect(selectPane).not.toHaveBeenCalled();
+    expect(setSelectedId).not.toHaveBeenCalled();
+  });
+
+  it('live re-read: navigating ONTO the dying pane mid-fade runs the tail and adopts a survivor', () => {
+    const { api, elementOf } = makeApi(['a', 'b']);
+    const killedEl = elementOf('a');
+    const selectPane = vi.fn();
+    const setSelectedId = vi.fn();
+    const killInProgressRef = { current: false };
+
+    // Not selected at fade start, but the user navigates onto the dying pane.
+    let selected = false;
+    const isSelected = () => selected;
+
+    orchestrateKill(api, 'a', isSelected, selectPane, setSelectedId, killInProgressRef, { current: null }, { current: 0 });
+    selected = true; // mid-fade selection move onto the dying pane
+    dispatchAnimationEnd(killedEl, FADE);
+
+    // Live read at removal time is true → the tail adopts the survivor 'b'.
+    expect(selectPane).toHaveBeenCalledWith('b');
+  });
+
+  it('ring uses the at-fade-start read even if selection flips before animationend', () => {
+    // Single pane → isLastPane. Selected when the fade starts, so the ring shrinks;
+    // a later selection flip must not retroactively change that at-start decision.
+    const { api, elementOf } = makeApi(['a']);
+    const killedEl = elementOf('a');
+    const overlayEl = document.createElement('div');
+    const selectPane = vi.fn();
+    const setSelectedId = vi.fn();
+    const killInProgressRef = { current: false };
+
+    let selected = true;
+    const isSelected = () => selected;
+
+    orchestrateKill(api, 'a', isSelected, selectPane, setSelectedId, killInProgressRef, { current: overlayEl }, { current: 0 });
+    // Ring added at fade start using the at-start read.
+    expect(overlayEl.classList.contains('ring-shrinking-to-br')).toBe(true);
+
+    selected = false; // flips before the fade ends
+    dispatchAnimationEnd(killedEl, FADE_LAST);
+    // finalize peels the class regardless.
+    expect(overlayEl.classList.contains('ring-shrinking-to-br')).toBe(false);
+  });
+
+  it('tags the removal: the programmatic-activation depth is 1 during removePanel, 0 after finalize', () => {
+    const { api, removePanel, elementOf } = makeApi(['a', 'b']);
+    const killedEl = elementOf('a');
+    const selectPane = vi.fn();
+    const setSelectedId = vi.fn();
+    const killInProgressRef = { current: false };
+    const ref = { current: 0 };
+
+    // Capture the tag depth at the exact moment removePanel is invoked, while
+    // preserving the real deletion so the identity re-check and tail behave.
+    let depthDuringRemove = -1;
+    const realRemove = removePanel.getMockImplementation()!;
+    removePanel.mockImplementation((panel) => {
+      depthDuringRemove = ref.current;
+      return realRemove(panel);
+    });
+
+    orchestrateKill(api, 'a', sel(true), selectPane, setSelectedId, killInProgressRef, { current: null }, ref);
+    dispatchAnimationEnd(killedEl, FADE);
+
+    // removePanel ran inside withProgrammaticActivation (depth 1); the wrapper's
+    // finally restored the depth to 0.
+    expect(depthDuringRemove).toBe(1);
+    expect(ref.current).toBe(0);
+  });
+
+  it('last-pane kill with an unselected pane never shrinks the overlay ring', () => {
+    // Only 'a' remains, so isLastPane is true. The overlay renders the current
+    // selection's ring; here the user's selection sits on a surviving door, so an
+    // unselected last-pane kill must leave that ring alone.
+    const { api, elementOf } = makeApi(['a']);
+    const killedEl = elementOf('a');
+    const overlayEl = document.createElement('div');
+    const selectPane = vi.fn();
+    const setSelectedId = vi.fn();
+    const killInProgressRef = { current: false };
+
+    orchestrateKill(api, 'a', sel(false), selectPane, setSelectedId, killInProgressRef, { current: overlayEl }, { current: 0 });
+    // Not added during the fade...
+    expect(overlayEl.classList.contains('ring-shrinking-to-br')).toBe(false);
+
+    dispatchAnimationEnd(killedEl, FADE_LAST);
+    // ...nor left behind after finalize.
+    expect(overlayEl.classList.contains('ring-shrinking-to-br')).toBe(false);
+  });
+
+  it('last-pane kill with a selected pane shrinks the overlay ring, then peels it', () => {
+    const { api, elementOf } = makeApi(['a']);
+    const killedEl = elementOf('a');
+    const overlayEl = document.createElement('div');
+    const selectPane = vi.fn();
+    const setSelectedId = vi.fn();
+    const killInProgressRef = { current: false };
+
+    // The killed pane owned the selection, so its ring shrinks during the fade.
+    orchestrateKill(api, 'a', sel(true), selectPane, setSelectedId, killInProgressRef, { current: overlayEl }, { current: 0 });
+    expect(overlayEl.classList.contains('ring-shrinking-to-br')).toBe(true);
+
+    // finalize peels the class so a reused overlay doesn't render at scale 0.
+    dispatchAnimationEnd(killedEl, FADE_LAST);
+    expect(overlayEl.classList.contains('ring-shrinking-to-br')).toBe(false);
+  });
+
   it('reduced-motion sync path removes the panel synchronously', () => {
     vi.mocked(prefersReducedMotion).mockReturnValue(true);
     const { api, removePanel, panelOf } = makeApi(['a', 'b']);
@@ -161,7 +334,7 @@ describe('orchestrateKill', () => {
     const killInProgressRef = { current: false };
 
     // No animationend needed: reduced motion finalizes inline.
-    orchestrateKill(api, 'a', selectPane, setSelectedId, killInProgressRef, { current: null });
+    orchestrateKill(api, 'a', sel(true), selectPane, setSelectedId, killInProgressRef, { current: null }, { current: 0 });
 
     expect(removePanel).toHaveBeenCalledTimes(1);
     expect(removePanel).toHaveBeenCalledWith(killedPanel);
diff --git a/lib/src/lib/kill-animation.ts b/lib/src/lib/kill-animation.ts
index d5e5ac4d..2a2701ff 100644
--- a/lib/src/lib/kill-animation.ts
+++ b/lib/src/lib/kill-animation.ts
@@ -1,6 +1,7 @@
 import type { DockviewApi } from 'dockview-react';
 import { disposeSession } from './terminal-registry';
 import { prefersReducedMotion } from './ui-geometry';
+import { withProgrammaticActivation, type ProgrammaticActivationRef } from './programmatic-activation';
 
 /**
  * Run the kill animation: fade out the killed pane, then animate the
@@ -10,32 +11,67 @@ import { prefersReducedMotion } from './ui-geometry';
  * killInProgressRef is set across api.removePanel so the onDidRemovePanel
  * auto-spawn handler skips its own 440ms delay — otherwise a last-pane kill
  * stacks two 440ms waits.
+ *
+ * isSelected is a LIVE reader — `isSelected(killedId)` is evaluated twice, not
+ * snapshotted at call time: once at fade start (for the overlay ring) and again at
+ * removal time up to ~1s later (for the selection tail). Only when the killed pane
+ * is the selected one does selection move to a survivor; killing a background
+ * surface leaves selection where the user left it. Reading live at removal means a
+ * mid-fade selection move is honored: navigating AWAY from a dying selected pane
+ * means the tail no longer yanks selection to panels[0], and navigating ONTO a
+ * dying pane means the tail adopts a survivor instead of leaving selection dangling
+ * on the removed panel. The removal is tagged with withProgrammaticActivation (see
+ * programmatic-activation.ts): dockview's survivor-activation echo previously
+ * covered these two edges by accident; the live read now covers them by design, so
+ * the echo is muted. Mouse kills always arrive selected — clicking a pane header
+ * activates it (dockview's pointerdown → doSetGroupActive) before the kill button's
+ * click handler runs — so the not-selected case comes only from CLI kills
+ * (`dor kill surface:3`) and ensure's throwaway teardown.
+ *
+ * onRemoved runs once, on every path, immediately after removePanel: collapsing a
+ * branch can re-parent the surviving selected pane's subtree and blur it, so the
+ * caller uses this hook to re-assert focus (Wall passes its guarded rAF helper).
  */
 export function orchestrateKill(
   api: DockviewApi,
   killedId: string,
+  isSelected: (id: string) => boolean,
   selectPane: (id: string) => void,
   setSelectedId: (id: string | null) => void,
   killInProgressRef: { current: boolean },
   overlayElRef: { current: HTMLElement | null },
+  programmaticActivationRef: ProgrammaticActivationRef,
+  onRemoved?: () => void,
 ): void {
   const panel = api.getPanel(killedId);
   if (!panel) return;
 
   const bareRemove = () => {
+    // Sample selection live, BEFORE removePanel mutates dockview — the removal can
+    // change the active panel out from under us.
+    const wasSelected = isSelected(killedId);
     killInProgressRef.current = true;
     try {
       disposeSession(killedId);
       // A competing remover can beat this finalize to the panel — a double-fired
       // confirm kill's second orchestrateKill, a dor-CLI kill, or a render swap.
       // Removing a stale panel throws deep in dockview ('invalid operation'), so
-      // re-resolve by id and only remove the exact object we captured.
-      if (api.getPanel(killedId) === panel) api.removePanel(panel);
+      // re-resolve by id and only remove the exact object we captured. Tag the
+      // removal so dockview's activate-the-survivor echo doesn't read as user
+      // intent — the selection tail below applies our policy explicitly.
+      withProgrammaticActivation(programmaticActivationRef, () => {
+        if (api.getPanel(killedId) === panel) api.removePanel(panel);
+      });
     } finally {
       // A throw must not strand this flag: it gates the auto-spawn delay skip in
       // onDidRemovePanel, and a stuck true skips that delay forever after.
       killInProgressRef.current = false;
     }
+    // Re-assert focus once the branch has collapsed — before the selection gate so
+    // it runs on every path (background kill included), where selection is unchanged.
+    onRemoved?.();
+    // Killing a pane the user wasn't on must not steal their selection.
+    if (!wasSelected) return;
     if (api.panels.length > 0) selectPane(api.panels[0].id);
     else setSelectedId(null);
   };
@@ -53,7 +89,13 @@ export function orchestrateKill(
   const fadeAnimationName = isLastPane ? 'pane-fade-and-shrink-to-br' : 'pane-fade-out';
   killedGroupEl.style.pointerEvents = 'none';
   killedGroupEl.classList.add(fadeClass);
-  const overlayEl = isLastPane ? overlayElRef.current : null;
+  // The overlay renders the *current* selection's ring. On an unselected kill
+  // that selection (e.g. a surviving door) is not the killed pane, so its ring
+  // must not shrink away — only claim the overlay when the killed pane is it.
+  // The ring shows the dying selection shrinking, so this at-fade-start read is
+  // the right one even though the selection tail re-reads live later.
+  const ringSelected = isSelected(killedId);
+  const overlayEl = isLastPane && ringSelected ? overlayElRef.current : null;
   if (overlayEl) overlayEl.classList.add('ring-shrinking-to-br');
 
   let finalized = false;
diff --git a/lib/src/lib/programmatic-activation.test.ts b/lib/src/lib/programmatic-activation.test.ts
new file mode 100644
index 00000000..781b3abe
--- /dev/null
+++ b/lib/src/lib/programmatic-activation.test.ts
@@ -0,0 +1,41 @@
+import { describe, expect, it } from 'vitest';
+import { withProgrammaticActivation, type ProgrammaticActivationRef } from './programmatic-activation';
+
+describe('withProgrammaticActivation', () => {
+  it('returns the value the wrapped fn returns', () => {
+    const ref: ProgrammaticActivationRef = { current: 0 };
+    expect(withProgrammaticActivation(ref, () => 42)).toBe(42);
+  });
+
+  it('increments the depth during fn and restores it after', () => {
+    const ref: ProgrammaticActivationRef = { current: 0 };
+    let depthInside = -1;
+    withProgrammaticActivation(ref, () => {
+      depthInside = ref.current;
+    });
+    expect(depthInside).toBe(1);
+    expect(ref.current).toBe(0);
+  });
+
+  it('keeps depth > 0 across nesting until the outermost exits', () => {
+    const ref: ProgrammaticActivationRef = { current: 0 };
+    const seen: number[] = [];
+    withProgrammaticActivation(ref, () => {
+      seen.push(ref.current);
+      withProgrammaticActivation(ref, () => {
+        seen.push(ref.current);
+      });
+      // Inner finally decremented, but the outer scope is still tagged.
+      seen.push(ref.current);
+    });
+    expect(seen).toEqual([1, 2, 1]);
+    expect(ref.current).toBe(0);
+  });
+
+  it('decrements even when fn throws, and rethrows', () => {
+    const ref: ProgrammaticActivationRef = { current: 0 };
+    const boom = new Error('boom');
+    expect(() => withProgrammaticActivation(ref, () => { throw boom; })).toThrow(boom);
+    expect(ref.current).toBe(0);
+  });
+});
diff --git a/lib/src/lib/programmatic-activation.ts b/lib/src/lib/programmatic-activation.ts
new file mode 100644
index 00000000..a3dbfcdd
--- /dev/null
+++ b/lib/src/lib/programmatic-activation.ts
@@ -0,0 +1,47 @@
+/**
+ * "Programmatic activation" tag — the single mechanism the Wall uses to tell a
+ * programmatic dockview mutation apart from a genuine user activation.
+ *
+ * Why this exists: dockview fires `onDidActivePanelChange` for programmatic
+ * `setActive`/`addPanel`/`fromJSON` exactly like it does for user activation
+ * (click/drag/tab). The Wall's listener (`use-dockview-ready.ts`) must only
+ * treat USER activation as selection intent, so programmatic mutations run
+ * inside `withProgrammaticActivation` and the listener ignores any activation
+ * while the depth is > 0.
+ *
+ * Depth counter, not a boolean: tagged operations nest — e.g. `runSurfaceAdd`'s
+ * `add` → `settleFocusAfterAdd` → `caller.api.setActive` each activate a panel,
+ * and an inner scope may open a further tagged mutation. A boolean cleared in an
+ * inner `finally` would unmute the outer scope early; incrementing/decrementing a
+ * counter keeps the tag asserted until the outermost wrapper exits.
+ *
+ * Synchronicity assumption — the one place to re-verify on dockview upgrades:
+ * dockview 5.2 fires these activation events synchronously, inside the mutation
+ * call, so the synchronous wrap window below is airtight. A dockview version that
+ * deferred activation events (microtask/timeout) would fire them after `finally`
+ * has already decremented, escaping the tag; that upgrade must revisit this.
+ *
+ * Coverage is now total: every programmatic dockview mutation runs tagged — the
+ * focus-neutral surface adds, `selectPane`/`enterTerminalMode`'s own `setActive`,
+ * reattach's restore mutations, the kill removal (`kill-animation.ts`),
+ * `minimizePane`'s removal, and the empty-pane auto-spawn's `addPanel`
+ * (`use-dockview-ready.ts`). So an untagged activation IS a dockview-native user
+ * interaction the React click handlers don't cover — a panel drag, or DOM focus
+ * landing in a surface (an embed focusing itself) — and the listener adopts it
+ * unconditionally through the real dispatchers. Selection policy lives at each
+ * mutation site instead of in the listener: the kill tail's live read at removal
+ * time, the auto-spawn's adopt-only-when-null-or-dangling, minimize's
+ * `selectDoor`, and reattach's explicit `selectPane`/`enterTerminalMode`. The
+ * self-healing a removal echo used to provide now lives inside those explicit
+ * policies.
+ */
+export type ProgrammaticActivationRef = { current: number };
+
+export function withProgrammaticActivation<T>(ref: ProgrammaticActivationRef, fn: () => T): T {
+  ref.current++;
+  try {
+    return fn();
+  } finally {
+    ref.current--;
+  }
+}