diff --git a/docs/superpowers/plans/2026-07-26-command-activation-semantics.md b/docs/superpowers/plans/2026-07-26-command-activation-semantics.md
new file mode 100644
index 00000000..e2180d7d
--- /dev/null
+++ b/docs/superpowers/plans/2026-07-26-command-activation-semantics.md
@@ -0,0 +1,354 @@
+# Command activation semantics
+
+**Status:** planned, 2026-07-26
+**Origin:** user reported that ⌥P (Prompt Template…) does nothing. Six classification
+agents then swept all 99 catalog commands and the surface/store wiring.
+
+---
+
+## The one-sentence rule this establishes
+
+> Invoking a command that shows a surface makes that surface visible; invoking it
+> again dismisses it. That must be true from **every** invocation source, not just
+> from inside the palette.
+
+Nothing in the app enforces this today. Three independent layers break it, and no
+single-layer fix is sufficient — a toggle written in a command body is unreachable
+if the router refuses the second keypress, and a router fix is pointless if the
+command has no way to ask "am I already open?".
+
+---
+
+## Layer 1 — the interaction-ownership gate makes dialogs un-dismissable by chord
+
+`useKeybinds.ts:333` returns out of the entire key handler when
+`hasAppInteractionOwner()` is true. That marker is stamped by **every** Radix
+`DialogContent` (`components/ui/dialog.tsx:57`). The binding router lives at
+`useKeybinds.ts:579`, well after the bail.
+
+Consequence: **any surface built as a Dialog makes its own chord unreachable while
+it is open.** The command's `run` is never called. This is not an admission
+refusal — nothing in `when`, `resolveCommandAvailability` or the gateway is
+involved, and no change confined to a `commands/*.ts` file can fix it.
+
+This is why the user's chords split the way they do:
+
+| Round-trips today | Dead second press |
+|---|---|
+| ⌥R Reader, ⌥S Spotlight (`MainSurface` inline) | ⌘⇧U Usage (Dialog) |
+| Agent Status (plain `<aside>`) | ⌘⇧P Palette (Dialog, and `KeyP` is in `BLOCKED_META_CODES`) |
+| `tiled-tabs` (asymmetric but complete) | Remote Panel (Dialog despite being registered as a side panel) |
+
+`toggle-remote-panel` is the clean illustration: its store action is *already* a
+correct toggle and its `getState` would work — it fails purely because
+`RemotePanel.tsx:127` renders a `Dialog` where its sibling `AgentStatusPanel`
+renders an `<aside>`.
+
+**Fix:** resolve `routedCommandForEvent` BEFORE the ownership bail, and let the
+chord through when the resolved command is the one that owns the currently-open
+surface. Anything less leaves every toggle we write unreachable.
+
+Do NOT "fix" this by making surfaces stop being dialogs. Modality is a real
+property — Usage and the palette genuinely should trap focus. `RemotePanel` is a
+separate, legitimate cleanup, but it is not the mechanism.
+
+---
+
+## Layer 2 — nine commands are silent no-ops from chord and native menu
+
+The `enterXMode` family sets React `useState` on the palette component:
+
+```
+resume-session (⌘⇧R)   prompt-template (⌥P)   manage-prompt-templates
+revive-pane            kill-buried-pane       save-composer-as-prompt-template
+open-ai-workspace      create-ai-workspace    clear-ai-workspace
+```
+
+Two of these ship default chords and are dead from the keyboard TODAY:
+`resume-session` (⌘⇧R, `defaults.ts:88`) and `prompt-template` (⌥P,
+`defaults.ts:225`).
+
+`resume-session` is a REGRESSION introduced by the governance PR: the old router
+had a hard-coded ⌘⇧R branch that opened the resume picker directly, and routing
+the chord through the command dropped the behavior on the floor.
+
+### Two independent kill mechanisms — this is why the obvious fix is not enough
+
+A chord sets `pendingCommandInvocation`, which mounts the palette host
+**invisibly** (`visible={false}`, `CommandPalette.tsx:206-209`).
+
+1. **Unmount.** The layout effect at `:967-989` dispatches, then synchronously
+   calls `onMenuCommandHandled()` (clears the pending invocation) and `onClose()`.
+   Next render the outer gate returns `null` and every `useState` — including
+   `mode` — is destroyed.
+
+2. **Mount reset.** Even if the host stayed mounted, the `deps: []` effect at
+   `:884-905` calls `setMode('commands')`. Passive effects run AFTER layout
+   effects in the same commit, so `'commands'` is queued last and wins over the
+   `'resume'` queued inside the layout effect. StrictMode double-invokes it.
+
+`keepPaletteOpen: true` does not help and never has on this path: it is read only
+by the palette's OWN `executeCommand` (`:942-947`). The chord path goes through
+`dispatchCommand`, which has no `keepPaletteOpen` branch at all. Nine commands
+have been declaring a flag that does nothing outside the palette.
+
+**Fix — move the mode into the store.** Add `paletteMode` to `uiShell` with a
+`setPaletteMode(mode)` action that also sets `commandPaletteOpen: true`. Then
+`ui.enterXMode` is an ordinary store write, immune to both mechanisms, and the
+reset moves from mount-time to close-time.
+
+The tempting three-edit patch — open the palette in `run`, extend the
+self-excluded id set, skip the reset when an invocation was pending — was
+considered and REJECTED. Omitting any one of its three parts leaves the bug, and
+its correctness rests entirely on React effect ordering. The store-backed version
+has no ordering argument to get wrong.
+
+Moving the mode also fixes a latent problem: `enterResumeMode` and
+`enterAiWorkspaceOpenMode` kick off async loads that currently re-run on every
+mount.
+
+---
+
+## Layer 3 — commands cannot see their own surface
+
+25 surfaces have a visibility flag in the store that is NOT on
+`CommandContext.flags`, so the command cannot ask "am I already open?".
+Separately, almost every `close*` action exists in the store but is not exposed
+on `ctx.ui` — today only `closePalette` and `closeAgentStatusPanel` are reachable.
+
+Nine of the 25 store a `SessionId | null` rather than a boolean
+(`viewPromptsSessionId`, `rewindPromptSessionId`,
+`agentViewModePickerSessionId`, `colorFlagPickerSessionId`, …). **A boolean
+toggle is WRONG for these**: pressing ⌥⇧P while View Prompts is open for a
+different session should re-target, not close. Expose the id, not just a
+predicate.
+
+One is genuinely derived and must not become a single field: the placement
+overlay's visibility is
+`newAgentPlacementOpen || dispatchAttachIntent !== null || linkedAgentParentId !== null`
+(`usePlacementOverlay.ts:30`), and closing it means calling all three actions.
+
+Mechanically each flag is THREE edits — the `flags` type, the context object
+literal, and the memo dependency array. **Missing the third is a silent staleness
+bug**: the flag is read once and never updates.
+
+### Commands that must NOT become toggles
+
+Verified individually; blanket-toggling would have broken all of these.
+
+- `save-debug-logs`, `attach-recording-note` — each WRITES something (a bundle, a
+  marker) before its prompt opens. A second press legitimately writes a second one.
+- `open-settings` — a destination page, not a peek. (Its real bug is that Escape
+  does not dismiss it: `useKeybinds.ts:537-541` is dead code behind the ownership
+  gate, and the only exit is the Close button.)
+- `open-command-palette` — a blind toggle makes double-taps flicker. The useful
+  behavior is: in a sub-mode, return to command mode and clear the query; close
+  only when already clean.
+- `linked-agent`, `attach-detached-to-grid`, `bury-pane` — per-target modals with
+  no toggle meaning.
+
+---
+
+## Discrete bugs found during the sweep
+
+Independent of the three layers. Each is small and each is real.
+
+1. **⌘⌥E Editor Fullscreen is a silent no-op when the editor is closed.**
+   `when: flags.globalEditorOpen` runs in admission before `run`, making the
+   branch that opens the editor straight into fullscreen unreachable from all
+   four invocation sources. The branch is the intended behavior — an orphaned
+   comment on `save-editor-file`'s `when` describes exactly it ("the chord has
+   always meant 'give me a big editor' as ONE gesture… or routing would silently
+   drop half the feature"). Routing did. Delete the `when`, keep the branch, move
+   the comment. **Regression from the governance PR.**
+
+2. **File → Save with the editor closed is admitted and does nothing.**
+   `save-editor-file`'s `when` admits on `globalEditorOpen || focusedCwd`, but its
+   window event has no listener until `EditorWorkbench` mounts. Tighten to
+   `flags.globalEditorOpen`.
+
+3. **Four commands re-implement open-if-closed against a snapshotted flag.**
+   `ui.toggleGlobalEditor` is the only editor primitive on the bridge, so
+   `quick-open-file`, `search-in-files`, `toggle-editor-fullscreen` and
+   `CommandPalette.tsx:1113` each do read-then-toggle. A stale `true` CLOSES the
+   editor the user asked to open. `openGlobalEditor`/`closeGlobalEditor` already
+   exist on the store; expose them.
+
+4. **`revive-pane` / `kill-buried-pane` admission disagrees with their list.**
+   `when` checks `state.buried.length > 0` while the list is filtered to the
+   active tab, so both can be admitted onto an empty mode.
+
+5. **Eight dead members on `CommandContext.ui`** — `openResumePicker`,
+   `openAgentStatusPanel`, `closeAgentStatusPanel`, `toggleStatusMode`,
+   `toggleWorktreeBadges`, `toggleUsageHeader`, `cycleUsageHeaderLevel`,
+   `setDangerousAgentsEnabled`. Note `openResumePicker` is the ready-made
+   store-backed path for `resume-session` if we prefer it to the palette mode.
+
+6. **`toggleCommandPalette` is dead** — one reader in `App.tsx:60`, never used.
+
+7. **Unused imports**: `value` in `settingsCommands.ts`, `panel` in
+   `globalEditorCommands.ts`, `panel`/`value` in `agentStatusCommands.ts`.
+
+---
+
+## What is already correct — copy these
+
+`tiled-tabs` (`tileTabsCommands.ts:5-22`) is the template for a surface whose
+open and close go through *different* actions: read state, branch, call the
+right one-directional action. Every modal in Layer 3 needs exactly this shape.
+
+`dispatch-mode` (`layoutCommands.ts:5-28`) is the same with a non-boolean state.
+`toggle-git-bar` (`sessionCommands.ts:913-921`) is the trivial case when a real
+toggle action exists.
+
+---
+
+## Phases
+
+1. **Palette mode → store.** Fixes the 9 no-ops, including ⌥P and ⌘⇧R.
+2. **Ownership-gate escape** for a chord whose command owns the open surface.
+   Without this, nothing in phase 4 is reachable by keyboard.
+3. **Flags + close actions** on the command context — the 25 gaps, ids not just
+   predicates for the 9 session-scoped ones.
+4. **Toggle conversions + `getState`** for the surface commands that should
+   round-trip, honouring the must-not-toggle list.
+5. **The seven discrete bugs.**
+
+Phase 5 is independent and can land first. Phases 2 and 4 are useless apart.
+
+---
+
+## Outcome (2026-07-26)
+
+All five phases landed. Commits `1319dbba`, `34c600c2`, `f342a6fd`, `8ac304b3`
+on top of this plan.
+
+Verification: `tsc -b` clean on both projects after `rm -rf .tsc-out`,
+`check:keybindings` OK (39 binding sets, 13 reserved, 5 approved overlaps),
+246/246 vitest files.
+
+### Decisions taken during implementation
+
+**Phase 1 chose store-backed mode over the three-edit patch**, as planned. Worth
+recording why the alternative kept looking attractive: it touches fewer files.
+It also has three parts that must all be present, and its correctness argument
+is "passive effects run after layout effects". The store version has no ordering
+argument at all, which is the entire reason to prefer it.
+
+**Phase 2 used a table, not a derived predicate.** Asking the command
+(`getState(ctx)?.value === 'on'`) would be impossible to drift, and was
+rejected anyway: building a `CommandContext` assembles ~76 workspace actions,
+and deferring that is why the router forwards an id instead of dispatching
+inline (#494). Paying it on every keystroke that lands while a dialog is open
+trades a real regression for a keyboard nicety. Drift is bounded by
+`keyof UiShellState` instead.
+
+**The close-after-run exemption became a live-flag read** rather than a longer
+id list. `PALETTE_SELF_EXCLUDED_COMMAND_IDS` held only `open-command-palette`
+and would have needed all nine mode-entering commands added to it — an
+enumeration someone has to remember. "Did this command turn the palette on?"
+answers for all of them and for anything added later. The set survives for its
+original, separate purpose: keeping "Command Palette" out of its own list.
+
+### What the tests actually pin
+
+The store tests drive `setPaletteMode` / `closeCommandPalette` /
+`requestCommandInvocation` rather than rendering the palette, deliberately: the
+bug was never a rendering bug, it was state carrying a component lifecycle it
+should not have had. Verified by sabotage — removing the `commandPaletteOpen`
+coupling from `setPaletteMode` fails two cases.
+
+The surface-ownership test asserts every listed command has a `getState`. It
+failed on its first run and caught `usage.open` toggling with no badge, which
+is the failure mode worth guarding: the table lets a chord cross the
+interaction gate, and the command's state and run are what dismiss once it
+does. Listed-but-not-toggling is the reported bug wearing a different hat.
+
+### Not done, and why
+
+`RemotePanel` still renders a Radix `Dialog` while being registered as a side
+panel, unlike its sibling `AgentStatusPanel` (`<aside>`). Phase 2's exemption
+makes its chord round-trip regardless, so the inconsistency is now cosmetic
+rather than functional — but it is still the wrong component for a non-modal
+panel, and worth its own change.
+
+Escape does not dismiss the Settings page: `useKeybinds.ts:537-541` is dead code
+behind the ownership gate, and the only exit is the Close button. Left alone
+because Settings is deliberately excluded from the toggle set, so fixing it is
+about Escape rather than about activation semantics.
+
+`save-editor-file`'s `when` is now correct, but the underlying design — a window
+event with a listener that exists only while the editor is mounted — is still
+the reason the guard has to be so precise.
+
+
+---
+
+## Review round (2026-07-27)
+
+Two orchestrated reviewers (Claude + Codex) read the branch independently.
+Codex: 0 critical, 2 high. Claude: 10 findings, none breaking types or tests.
+Both ran `tsc -b` (Claude also `--force`), `check:keybindings` and the full
+suite, all exit 0. Every finding was judged valid and fixed.
+
+### The two that mattered
+
+**The headline rule was delivered for half the bug report.** Phase 1 turned ⌥P
+and ⌘⇧R from *nothing* into *opens*; the second press still did nothing, because
+the palette is itself a dialog and no palette-mode command was in the ownership
+table. Worse, ⌥P's second press typed `π` into the query — Alt chords over a
+text target are not preventDefault-ed, so the keystroke composed. The nine
+commands now compare `flags.paletteMode` and dismiss, via a SECOND table
+(`PALETTE_MODE_COMMANDS`).
+
+That split was itself found by a failing test. Merging the two kinds of
+ownership into one map type-checked and was wrong: it implied Resume Session
+should carry an Open/Closed badge, when "the palette is open" is not a property
+of Resume Session. These commands do not own a surface with its own flag — they
+own a MODE of one shared surface.
+
+**Phase 2 only exempted keybindings.** The native-menu handler had its own copy
+of the ownership bail, so File → New Tab twice left the picker up. "Every
+invocation source" was false for the menu — in a PR whose title is that phrase.
+
+### The rest
+
+- The table's `keyof UiShellState` accepted any of ~40 keys, including the nine
+  `SessionId | null` ones where `=== true` is permanently false — silent, and
+  exactly the failure its own test claimed to guard. Narrowed to boolean-valued
+  keys only; verified by sabotage that a nullable flag now fails to compile.
+- The mount-reset effect was UNREACHABLE (`mountedForPendingCommand` is never
+  false, because `openCommandPalette`'s only caller is a command, and commands
+  run from inside an already-mounted host). Its state resets were redundant, but
+  its `requestAnimationFrame` focus call was not — focus now keys on `visible`.
+- `new-tab` was REMOVED from the toggle set. `pathPickerOpen` means "the shared
+  path modal is open", not "the new-tab picker is open" — the same
+  boolean-loses-information problem the session-scoped surfaces were kept out
+  for. Live consequences: ⌘T dismissed the picker mid-submit during a slow
+  spawn, and a create action had started rendering an Open/Closed badge.
+- `toggleCommandPalette` was deleted. Phase 5 removed its only reader and Phase 1
+  then added new behavior to it — mechanism-with-no-consumer, in the sweep whose
+  whole purpose is finding that shape.
+- `openResumePicker`'s removal had left `onResumeRequest` destructured and in a
+  memo dep array.
+- The live-flag close rule holds only for a command that opens the palette in its
+  SYNCHRONOUS prefix; the comment asserted it unconditionally. Now stated.
+- One dep array was wrong and misindented — in the commit whose stated
+  discipline is that missing a dep is a silent staleness bug.
+
+### Test added
+
+Nothing proved a toggle's `run` closed the RIGHT surface — a copy-paste closing
+someone else's would have passed. The new case drives every listed command with
+its own flag true and asserts exactly one dismissal and no open. It caught a real
+distinction on first run (Remote Panel legitimately uses a `toggle*` rather than
+a `close*`), and is sabotage-verified.
+
+### Accepted, not fixed
+
+`executePromptTemplate` sets its mode after an `await`, so a dismissal during
+that window could resurrect the palette into a mode whose component-local data
+is gone. Unreachable today — both built-in templates declare `variables: []`, so
+the awaiting branch cannot be entered. It is the structural cost of Phase 1 that
+this plan did not name: the mode is store state while everything the mode needs
+is still component state. Recorded here rather than papered over.
diff --git a/src/renderer/src/app-state/store.test.ts b/src/renderer/src/app-state/store.test.ts
index d8cf6047..bfe8de37 100644
--- a/src/renderer/src/app-state/store.test.ts
+++ b/src/renderer/src/app-state/store.test.ts
@@ -77,3 +77,96 @@ describe('useAppStore prompt template migration', () => {
     expect(useAppStore.getState().settings.defaultBuiltInMcpDomains).toEqual([])
   })
 })
+
+// ---------------------------------------------------------------------------
+// Palette sub-mode as store state.
+//
+// This is the invariant that fixes nine commands which did nothing from a
+// keybinding or the native menu — Resume Session (Cmd+Shift+R) and Prompt
+// Template (Alt+P) shipped default chords that were silent no-ops.
+//
+// The mode used to be `useState` on the palette component. A chord does not
+// open the palette; it sets a pending invocation, which mounts the palette
+// INVISIBLY, runs the command, and unmounts it in the same commit. Two
+// independent mechanisms then destroyed the mode: the unmount itself, and the
+// mount-time reset effect, which is passive and therefore runs AFTER the layout
+// effect that dispatched.
+//
+// Testing the STORE rather than the component is deliberate. The old bug was
+// not a rendering bug — it was that this state had a component lifecycle it
+// should never have had. State without that lifecycle cannot be lost the same
+// way, and that property is what these cases pin.
+// ---------------------------------------------------------------------------
+describe('palette sub-mode', () => {
+  beforeEach(() => {
+    vi.resetModules()
+    vi.stubGlobal('localStorage', createStorageMock())
+  })
+
+  afterEach(() => {
+    vi.unstubAllGlobals()
+  })
+
+  it('starts in the command list', async () => {
+    const { useAppStore } = await import('@renderer/app-state/store')
+    expect(useAppStore.getState().paletteMode).toBe('commands')
+  })
+
+  it('makes the palette visible when a mode is entered', async () => {
+    // THE fix. Every mode-entering command wanted the palette up; the ones
+    // invoked by chord had no way to say so. Coupling the two in the action
+    // means a future mode cannot forget it.
+    const { useAppStore } = await import('@renderer/app-state/store')
+    useAppStore.getState().closeCommandPalette()
+    expect(useAppStore.getState().commandPaletteOpen).toBe(false)
+
+    useAppStore.getState().setPaletteMode('prompt-template')
+
+    expect(useAppStore.getState().paletteMode).toBe('prompt-template')
+    expect(useAppStore.getState().commandPaletteOpen).toBe(true)
+  })
+
+  it('resets to the command list on close, so reopening never resumes a sub-flow', async () => {
+    const { useAppStore } = await import('@renderer/app-state/store')
+    useAppStore.getState().setPaletteMode('resume')
+    useAppStore.getState().closeCommandPalette()
+    expect(useAppStore.getState().paletteMode).toBe('commands')
+
+    useAppStore.getState().openCommandPalette()
+    expect(useAppStore.getState().paletteMode).toBe('commands')
+  })
+
+  it('survives the close-after-run rule that used to kill it', async () => {
+    // The chord sequence, in store terms. `closeAfterRun` is captured as
+    // `!commandPaletteOpen` when the invocation is requested, so it is true
+    // here. The palette host now skips the close when the command turned the
+    // palette on — it previously consulted a hardcoded id list holding only
+    // `open-command-palette`, which could never have covered these nine.
+    const { useAppStore } = await import('@renderer/app-state/store')
+    useAppStore.getState().closeCommandPalette()
+    useAppStore.getState().requestCommandInvocation('prompt-template', 'keybinding')
+    const pending = useAppStore.getState().pendingCommandInvocation
+    expect(pending?.closeAfterRun).toBe(true)
+
+    // What the command's `run` does.
+    useAppStore.getState().setPaletteMode('prompt-template')
+    useAppStore.getState().clearCommandInvocation()
+
+    const shouldClose = pending!.closeAfterRun && !useAppStore.getState().commandPaletteOpen
+    expect(shouldClose).toBe(false)
+    expect(useAppStore.getState().paletteMode).toBe('prompt-template')
+  })
+
+  it('still closes after a command that opened nothing', async () => {
+    // The rule must not become "never close" — an ordinary chord still returns
+    // the user to where they were.
+    const { useAppStore } = await import('@renderer/app-state/store')
+    useAppStore.getState().closeCommandPalette()
+    useAppStore.getState().requestCommandInvocation('split-vertical', 'keybinding')
+    const pending = useAppStore.getState().pendingCommandInvocation
+    useAppStore.getState().clearCommandInvocation()
+
+    const shouldClose = pending!.closeAfterRun && !useAppStore.getState().commandPaletteOpen
+    expect(shouldClose).toBe(true)
+  })
+})
diff --git a/src/renderer/src/app-state/types.ts b/src/renderer/src/app-state/types.ts
index 58022a3f..a08852c7 100644
--- a/src/renderer/src/app-state/types.ts
+++ b/src/renderer/src/app-state/types.ts
@@ -1,3 +1,4 @@
+import type { PaletteMode } from '@renderer/features/command-palette/paletteMode'
 import type { Settings } from '@renderer/app-state/settings/types'
 import type {
   DispatchAttachIntent,
@@ -38,7 +39,8 @@ export type UiShellSlice = UiShellState & {
   clearCommandInvocation: () => void
   openCommandPalette: () => void
   closeCommandPalette: () => void
-  toggleCommandPalette: () => void
+  /** Enter a palette sub-mode and make the palette visible. */
+  setPaletteMode: (mode: PaletteMode) => void
   openPathPicker: (defaultValue?: string) => void
   closePathPicker: () => void
   setPathPickerDefault: (value: string) => void
diff --git a/src/renderer/src/app-state/uiShell/slice.ts b/src/renderer/src/app-state/uiShell/slice.ts
index bb0a45cb..2b0cc3e2 100644
--- a/src/renderer/src/app-state/uiShell/slice.ts
+++ b/src/renderer/src/app-state/uiShell/slice.ts
@@ -1,3 +1,5 @@
+import { DEFAULT_PALETTE_MODE } from '@renderer/features/command-palette/paletteMode'
+import type { PaletteMode } from '@renderer/features/command-palette/paletteMode'
 import type { StateCreator } from 'zustand'
 
 import type { AppStore, UiShellSlice } from '@renderer/app-state/types'
@@ -10,6 +12,7 @@ export const createUiShellSlice: StateCreator<
   UiShellSlice
 > = set => ({
   commandPaletteOpen: false,
+  paletteMode: DEFAULT_PALETTE_MODE,
   pathPickerOpen: false,
   pathPickerDefault: '',
   tileTabsModalOpen: false,
@@ -68,12 +71,24 @@ export const createUiShellSlice: StateCreator<
   clearCommandInvocation: () =>
     set({ pendingCommandInvocation: null }, false, 'uiShell/clearCommandInvocation'),
 
+  // Opening always lands in the command list. Reopening should never resume a
+  // half-finished sub-flow the user abandoned.
   openCommandPalette: () =>
-    set({ commandPaletteOpen: true }, false, 'uiShell/openCommandPalette'),
+    set({ commandPaletteOpen: true, paletteMode: DEFAULT_PALETTE_MODE }, false, 'uiShell/openCommandPalette'),
   closeCommandPalette: () =>
-    set({ commandPaletteOpen: false }, false, 'uiShell/closeCommandPalette'),
-  toggleCommandPalette: () =>
-    set(state => ({ commandPaletteOpen: !state.commandPaletteOpen }), false, 'uiShell/toggleCommandPalette'),
+    set({ commandPaletteOpen: false, paletteMode: DEFAULT_PALETTE_MODE }, false, 'uiShell/closeCommandPalette'),
+  /**
+   * Enter a sub-mode, MAKING THE PALETTE VISIBLE.
+   *
+   * The open is not a convenience — it is the correctness fix. A sub-mode is
+   * only meaningful rendered, so every caller wanted the palette up; the ones
+   * invoked from a chord simply had no way to say so, because `setMode` was
+   * component-local and the host they were mutating was invisible.
+   *
+   * Coupling the two here means a future mode-entry point cannot forget it.
+   */
+  setPaletteMode: (mode: PaletteMode) =>
+    set({ paletteMode: mode, commandPaletteOpen: true }, false, 'uiShell/setPaletteMode'),
 
   openPathPicker: (defaultValue = '') =>
     set({
diff --git a/src/renderer/src/app-state/uiShell/types.ts b/src/renderer/src/app-state/uiShell/types.ts
index 46258137..cd275947 100644
--- a/src/renderer/src/app-state/uiShell/types.ts
+++ b/src/renderer/src/app-state/uiShell/types.ts
@@ -1,3 +1,4 @@
+import type { PaletteMode } from '@renderer/features/command-palette/paletteMode'
 import type { TabId, SessionId } from '@renderer/workspace/types'
 
 export type DispatchAttachIntent = {
@@ -23,6 +24,24 @@ export type PendingCommandInvocation = {
 
 export type UiShellState = {
   commandPaletteOpen: boolean
+  /**
+   * The palette's active sub-mode (Resume list, Prompt Templates, …).
+   *
+   * WHY this is store state and not `useState` on the palette component, where
+   * it lived until now: a chord never opens the palette. It sets
+   * `pendingCommandInvocation`, which mounts the palette INVISIBLY, runs the
+   * command, and unmounts it in the same commit. A mode set with the local
+   * `setMode` was therefore written to a component already invisible and about
+   * to be destroyed, and a second mechanism finished the job — the mount-time
+   * reset effect runs as a passive effect, i.e. AFTER the layout effect that
+   * dispatched, so it queued 'commands' last and won regardless.
+   *
+   * The result was nine commands that did nothing from any source but the
+   * palette, two of them shipping default chords (Cmd+Shift+R, Alt+P).
+   *
+   * Store state has no component lifecycle, so neither mechanism can reach it.
+   */
+  paletteMode: PaletteMode
   /**
    * A command id waiting to be dispatched, with the source that asked for it.
    *
diff --git a/src/renderer/src/app/App.tsx b/src/renderer/src/app/App.tsx
index 1dc19516..40ca1bdf 100644
--- a/src/renderer/src/app/App.tsx
+++ b/src/renderer/src/app/App.tsx
@@ -57,7 +57,6 @@ export default function App() {
   const defaultBuiltInMcpDomains = useAppStore(
     state => state.settings.defaultBuiltInMcpDomains,
   )
-  const toggleCommandPalette = useAppStore(state => state.toggleCommandPalette)
 
   useThemeSync()
   useAiWorkspaceOpenRequests()
diff --git a/src/renderer/src/features/agent-status/commands/agentStatusCommands.ts b/src/renderer/src/features/agent-status/commands/agentStatusCommands.ts
index f8751424..7eed10f3 100644
--- a/src/renderer/src/features/agent-status/commands/agentStatusCommands.ts
+++ b/src/renderer/src/features/agent-status/commands/agentStatusCommands.ts
@@ -1,7 +1,7 @@
 import { DEFAULT_PROVIDER, isAgentProviderKind } from '@shared/types/providerKind'
 import type { CommandContext, CommandDef } from '@renderer/features/command-palette/types'
 import { commandTargetSessionId } from '@renderer/workspace/hook/selectors/commandTargetSessionId'
-import { panel, toggle, value } from '@renderer/features/command-palette/commandState'
+import { toggle } from '@renderer/features/command-palette/commandState'
 
 function focusedAgentSessionId(ctx: CommandContext): string | null {
   const sessionId = commandTargetSessionId(ctx.workspace)
diff --git a/src/renderer/src/features/command-palette/keybindingBaseline.test.ts b/src/renderer/src/features/command-palette/keybindingBaseline.test.ts
index 6071de7c..ce464382 100644
--- a/src/renderer/src/features/command-palette/keybindingBaseline.test.ts
+++ b/src/renderer/src/features/command-palette/keybindingBaseline.test.ts
@@ -1,5 +1,6 @@
 import { describe, expect, it } from 'vitest'
 
+import { PALETTE_MODE_COMMANDS, SURFACE_OWNER_FLAGS, commandOwnsOpenSurface } from '@renderer/features/command-palette/surfaceOwnership'
 import { builtInCommandCatalog } from '@renderer/features/command-palette/catalog'
 import { resolveEffectiveKeybindings } from '@renderer/features/command-keybindings/resolve'
 
@@ -388,3 +389,127 @@ describe('recorded authority drift (pre-migration history)', () => {
     expect(undisclosed).toEqual(['⌘⇧E', '⌘⇧P', '⌥W', '⌥←', '⌥↑', '⌥→', '⌥↓'])
   })
 })
+
+// ---------------------------------------------------------------------------
+// Surface ownership — the narrow exemption to the interaction-owner gate.
+//
+// `useKeybinds` bails out of the whole key handler while any Radix dialog is
+// mounted, which is correct (⌘W must not close a pane behind a confirmation)
+// but means a dialog-based surface makes its own chord unreachable. That is the
+// entire reason ⌘⇧U could open Usage and never dismiss it, while ⌥R Reader
+// round-tripped fine — Reader renders inline and stamps no owner marker.
+//
+// The exemption lets a chord cross the gate when it maps to the command that
+// owns the surface currently in front of the user. These cases pin the two
+// properties that keep it narrow: the table names real commands, and the
+// predicate only ever answers for those.
+// ---------------------------------------------------------------------------
+describe('surface ownership', () => {
+  const catalogIds = new Set(builtInCommandCatalog.map(command => command.id))
+
+  it('names only commands that exist', () => {
+    for (const commandId of Object.keys(PALETTE_MODE_COMMANDS)) {
+      expect(catalogIds.has(commandId)).toBe(true)
+    }
+    // A stale id here is worse than useless: the chord silently stops being
+    // exempt and the surface becomes undismissable again, with nothing failing.
+    for (const commandId of Object.keys(SURFACE_OWNER_FLAGS)) {
+      expect(catalogIds.has(commandId)).toBe(true)
+    }
+  })
+
+  it('reports ownership only when that command’s own surface is open', () => {
+    expect(commandOwnsOpenSurface('usage.open', { usageModalOpen: true } as never)).toBe(true)
+    expect(commandOwnsOpenSurface('usage.open', { usageModalOpen: false } as never)).toBe(false)
+  })
+
+  it('refuses every command not in the table', () => {
+    // The gate's default is still "bail". Only a listed command may cross it,
+    // so an unrelated chord cannot reach a workspace action while a modal owns
+    // the screen — which is the bug the gate exists to prevent.
+    expect(commandOwnsOpenSurface('close-pane', { usageModalOpen: true } as never)).toBe(false)
+    expect(commandOwnsOpenSurface('split-vertical', { usageModalOpen: true } as never)).toBe(false)
+  })
+
+  it('lets a palette-mode command through whenever the palette is open', () => {
+    // Wider than strict dismissal on purpose: pressing ⌥P while the palette
+    // sits in Resume mode should SWITCH to prompt templates, not be swallowed.
+    // The command compares flags.paletteMode and decides; the table only
+    // decides whether it gets the chance.
+    expect(commandOwnsOpenSurface('prompt-template', { commandPaletteOpen: true } as never)).toBe(true)
+    expect(commandOwnsOpenSurface('prompt-template', { commandPaletteOpen: false } as never)).toBe(false)
+  })
+
+  it('gives every flag-backed command a state badge that reports its surface', () => {
+    // The two halves of the round-trip have to agree. The table lets the chord
+    // CROSS the interaction gate; the command's own state and run are what
+    // dismiss once it does. A command listed here without a `getState` is one
+    // whose second press reaches a `run` that may still only open — the chord
+    // would look like it does nothing, which is exactly the reported bug.
+    // Scoped to SURFACE_OWNER_FLAGS. Palette-mode commands are deliberately
+    // excluded: they dismiss by comparing `flags.paletteMode`, and an
+    // Open/Closed badge on Resume Session would report a property of the
+    // palette rather than of the command. Merging the two tables made this
+    // assertion demand exactly that, which is how the split was found.
+    for (const commandId of Object.keys(SURFACE_OWNER_FLAGS)) {
+      const command = builtInCommandCatalog.find(candidate => candidate.id === commandId)
+      expect(command?.getState, `${commandId} has no getState`).toBeDefined()
+    }
+  })
+
+  it('actually calls the matching close action when its surface is open', () => {
+    // The assertion that was missing, and the one a copy-paste defeats: a
+    // `getState` proving a command CAN see its surface says nothing about the
+    // `run` closing the RIGHT one. Driving each run with its own flag true and
+    // asserting the matching `close*` fired — and that no other one did — is
+    // what pins the pairing.
+    for (const [commandId, flag] of Object.entries(SURFACE_OWNER_FLAGS)) {
+      const command = builtInCommandCatalog.find(candidate => candidate.id === commandId)
+      if (!command) throw new Error(`${commandId} is not in the catalog`)
+
+      const calls: string[] = []
+      const ui = new Proxy({}, {
+        get: (_target, prop: string) => () => calls.push(prop),
+      })
+      command.run({
+        ui,
+        flags: { [flag]: true },
+        workspace: { state: { sessions: {}, tabs: [], activeTabId: '' } },
+      } as never)
+
+      // Two legitimate shapes, and the distinction is real rather than
+      // cosmetic: most of these surfaces have separate open/close actions and
+      // the command must branch, but Remote Panel has a genuine `toggle*` that
+      // is already correct in both directions. Both dismiss when the flag is
+      // true; only "opened anyway" is a defect.
+      const dismissed = calls.filter(name =>
+        (name.startsWith('close') && name !== 'closePalette') || name.startsWith('toggle'),
+      )
+      expect(dismissed, `${commandId} (flag ${flag}) did not dismiss`).toHaveLength(1)
+      expect(
+        calls.some(name => name.startsWith('open')),
+        `${commandId} opened its surface while it was already open`,
+      ).toBe(false)
+    }
+  })
+
+  it('excludes surfaces where a second press must not mean dismiss', () => {
+    // Recorded as a decision, not an omission. Per-target pickers should
+    // RE-TARGET on a second press; Save Debug Logs and Attach Recording Note
+    // each write something on the way in, so a second press legitimately writes
+    // a second one; Settings is a destination, not a peek.
+    for (const excluded of [
+      'view-prompts',
+      'rewind-to-prompt',
+      'set-agent-view-mode',
+      'dispatch.color-flag.set',
+      'save-debug-logs',
+      'attach-recording-note',
+      'open-settings',
+      'open-command-palette',
+    ]) {
+      expect(Object.keys(SURFACE_OWNER_FLAGS)).not.toContain(excluded)
+      expect(Object.keys(PALETTE_MODE_COMMANDS)).not.toContain(excluded)
+    }
+  })
+})
diff --git a/src/renderer/src/features/command-palette/paletteMode.ts b/src/renderer/src/features/command-palette/paletteMode.ts
new file mode 100644
index 00000000..1abde10d
--- /dev/null
+++ b/src/renderer/src/features/command-palette/paletteMode.ts
@@ -0,0 +1,41 @@
+// ---------------------------------------------------------------------------
+// The palette's sub-mode.
+//
+// WHY this type lives in its own module rather than beside the component that
+// renders it: the mode is STORE state (see `uiShell.paletteMode`), and
+// `app-state/uiShell/types.ts` needs the type. Importing it from
+// `command-palette/types.ts` would drag the whole `CommandContext` graph —
+// which reaches the workspace store — into the app-state layer that
+// `CommandContext` itself depends on. A five-line module breaks the cycle.
+//
+// WHY the mode is store state at all, when it was `useState` on the palette
+// component for most of this app's life: a chord does not open the palette. It
+// sets a pending invocation, which mounts the palette INVISIBLY, runs the
+// command, and unmounts it in the same commit. Any mode a command set with
+// `setMode` was therefore written to a component that was already invisible and
+// about to be destroyed — nine commands (Resume Session, Prompt Template, the
+// buried pair, the three AI-workspace ones, and two prompt-template siblings)
+// were silent no-ops from every source except the palette itself, two of them
+// with shipped default chords.
+//
+// Store state has no lifecycle tied to the component, so it cannot be lost that
+// way. That is the whole argument; there is no ordering subtlety to get wrong.
+// ---------------------------------------------------------------------------
+
+export type PaletteMode =
+  | 'commands'
+  | 'resume'
+  | 'buried'
+  | 'kill-buried'
+  | 'prompt-template'
+  | 'manage-prompt-template'
+  | 'fill-prompt-template'
+  | 'save-prompt-template'
+  | 'edit-prompt-template'
+  | 'ai-workspace-open'
+  | 'ai-workspace-create'
+  | 'ai-workspace-clear'
+
+/** The mode a freshly-opened palette starts in. Also what closing resets to —
+ *  reopening should never resume a half-finished sub-flow. */
+export const DEFAULT_PALETTE_MODE: PaletteMode = 'commands'
diff --git a/src/renderer/src/features/command-palette/surfaceOwnership.ts b/src/renderer/src/features/command-palette/surfaceOwnership.ts
new file mode 100644
index 00000000..004a363e
--- /dev/null
+++ b/src/renderer/src/features/command-palette/surfaceOwnership.ts
@@ -0,0 +1,147 @@
+import type { UiShellState } from '@renderer/app-state/uiShell/types'
+import type { PaletteMode } from '@renderer/features/command-palette/paletteMode'
+
+// ---------------------------------------------------------------------------
+// Which command owns which on-screen surface.
+//
+// THE PROBLEM. `useKeybinds` bails out of the entire key handler when
+// `hasAppInteractionOwner()` is true, and every Radix `DialogContent` stamps
+// that marker. The gate is correct and load-bearing: without it, ⌘W closes a
+// pane behind an open confirmation dialog. But it also means a surface built as
+// a dialog makes ITS OWN chord unreachable while it is open — press ⌘⇧U to open
+// Usage, press it again, nothing happens, because the router never reaches the
+// binding index.
+//
+// That is why some chords round-trip today and some do not, and the split has
+// nothing to do with the commands: ⌥R Reader and ⌥S Spotlight work because they
+// render inline in MainSurface, Agent Status works because it is a plain
+// `<aside>`, and Usage / the palette / Remote Panel fail because they are
+// dialogs. No change confined to a `commands/*.ts` file can fix that.
+//
+// THE NARROW EXEMPTION. A chord may cross the gate when it maps to the command
+// that owns the surface currently holding the interaction. Pressing ⌘⇧U while
+// Usage is up is unambiguously "dismiss Usage" — it cannot be a stray shortcut
+// leaking into a modal, because the modal is the thing the command controls.
+// Everything else still bails.
+//
+// WHY A TABLE, and not `command.getState(ctx)?.value === 'on'`, which would be
+// derived and unable to drift: evaluating `getState` needs a `CommandContext`,
+// and building one assembles ~76 workspace actions. Deferring exactly that cost
+// is the entire reason the router forwards an id through
+// `requestCommandInvocation` instead of dispatching inline (#494). Paying it on
+// every keystroke that lands while a dialog is open would be a real regression
+// to fix a keyboard nicety.
+//
+// The drift risk is bounded by types: the value is `keyof UiShellState`, and the
+// Phase 4 commands read the SAME flag through `CommandContext.flags`. A typo is
+// a compile error, and a surface whose flag is renamed breaks here loudly.
+//
+// WHAT DOES NOT BELONG HERE. Only surfaces whose command should DISMISS them on
+// a second press. Not per-target pickers (re-pressing with a different target
+// should re-target, not close), not surfaces that write something on the way in
+// (Save Debug Logs, Attach Recording Note — a second press legitimately writes a
+// second one), and not the Settings page, which is a destination rather than a
+// peek.
+//
+// `new-tab` was listed here and has been REMOVED. `pathPickerOpen` does not
+// mean "the new-tab picker is open", it means "the shared path modal is open" —
+// the same modal the resume flow opens with a pre-filled cwd. So the boolean
+// loses exactly the information the nine session-scoped surfaces were kept out
+// for. Two live consequences settled it: `PathPickerSurface` awaits
+// `workspace.newTab(...)` before closing, so during a slow spawn ⌘T dismissed
+// the picker mid-submit; and a create action had started rendering an
+// Open/Closed badge, which is not what New Tab is.
+//
+// `open-command-palette` is also absent, for a different reason: a blind toggle
+// makes a double-tap flicker the surface. The useful second-press behavior is
+// "if in a sub-mode, return to the command list; close only when already
+// clean", which Escape's back-out ladder already provides. Revisit that as its
+// own change rather than folding it in here.
+// ---------------------------------------------------------------------------
+
+/**
+ * Only the BOOLEAN fields of the store.
+ *
+ * `keyof UiShellState` was not enough, and the module claimed a safety it did
+ * not have: it accepts any of ~40 keys, so `'view-prompts': 'viewPromptsSessionId'`
+ * compiled — and `state[flag] === true` against a `SessionId | null` is
+ * permanently false, which is silent. The chord stops being exempt, the surface
+ * becomes undismissable again, and nothing fails. Narrowing the type is what
+ * makes "a typo is a compile error" true rather than aspirational.
+ */
+type BooleanUiShellFlag = {
+  [K in keyof UiShellState]: UiShellState[K] extends boolean ? K : never
+}[keyof UiShellState]
+
+/**
+ * Command id → the uiShell flag whose truth means "my surface is on screen".
+ *
+ * Presence in this table is a claim with teeth: it lets the command's chord
+ * cross the interaction-owner gate. Add an entry only when a second press
+ * genuinely means dismiss.
+ */
+export const SURFACE_OWNER_FLAGS = {
+  'usage.open': 'usageModalOpen',
+  'open-keyboard-shortcuts': 'keyboardShortcutsOpen',
+  'open-agent-activity': 'agentActivityOpen',
+  'close-old-agents': 'closeOldAgentsOpen',
+  'switch-agents-provider': 'bulkProviderSwitchOpen',
+  'search-conversation-prompts': 'promptSearchOpen',
+  'toggle-remote-panel': 'remotePanelOpen',
+  'reorder-tabs': 'reorderTabsOpen',
+  'pin-agents': 'pinAgentsOpen',
+} as const satisfies Record<string, BooleanUiShellFlag>
+
+export type SurfaceOwningCommandId = keyof typeof SURFACE_OWNER_FLAGS
+
+/**
+ * Command id → the palette sub-mode it owns.
+ *
+ * A SECOND table rather than more rows in the first, because the two express
+ * different things and the first attempt at merging them showed it: these
+ * commands do not own a surface with its own visibility flag — they own a MODE
+ * of one shared surface. Keying them on `commandPaletteOpen` type-checked and
+ * was wrong in a way a test caught immediately: it implied each should carry an
+ * Open/Closed badge, when "the palette is open" is not a property of Resume
+ * Session.
+ *
+ * The chord is admitted whenever the palette is open — deliberately wider than
+ * dismissal, so pressing ⌥P while the palette sits in Resume mode SWITCHES to
+ * prompt templates instead of being swallowed. The command compares
+ * `flags.paletteMode` against its own entry here and decides; this table only
+ * decides whether it gets the chance.
+ */
+export const PALETTE_MODE_COMMANDS = {
+  'resume-session': 'resume',
+  'revive-pane': 'buried',
+  'kill-buried-pane': 'kill-buried',
+  'prompt-template': 'prompt-template',
+  'manage-prompt-templates': 'manage-prompt-template',
+  'save-composer-as-prompt-template': 'save-prompt-template',
+  'open-ai-workspace': 'ai-workspace-open',
+  'create-ai-workspace': 'ai-workspace-create',
+  'clear-ai-workspace': 'ai-workspace-clear',
+} as const satisfies Record<string, PaletteMode>
+
+/**
+ * Is this command the owner of a surface that is open right now?
+ *
+ * Takes the store snapshot rather than reading it, so the caller controls when
+ * the read happens and this stays a pure predicate.
+ */
+export function commandOwnsOpenSurface(
+  commandId: string,
+  state: Pick<
+    UiShellState,
+    (typeof SURFACE_OWNER_FLAGS)[SurfaceOwningCommandId] | 'commandPaletteOpen'
+  >,
+): boolean {
+  // A palette-mode command owns the palette whenever it is open, whatever mode
+  // it currently shows — see PALETTE_MODE_COMMANDS for why that is wider than
+  // strict dismissal.
+  if (commandId in PALETTE_MODE_COMMANDS) return state.commandPaletteOpen === true
+
+  const flag = SURFACE_OWNER_FLAGS[commandId as SurfaceOwningCommandId]
+  if (!flag) return false
+  return state[flag] === true
+}
diff --git a/src/renderer/src/features/command-palette/types.ts b/src/renderer/src/features/command-palette/types.ts
index 2894a28a..9731b05f 100644
--- a/src/renderer/src/features/command-palette/types.ts
+++ b/src/renderer/src/features/command-palette/types.ts
@@ -1,3 +1,4 @@
+import type { PaletteMode } from '@renderer/features/command-palette/paletteMode'
 import type { Workspace } from '@renderer/workspace/workspaceStore'
 import type { AgentViewMode, UsageHeaderLevel } from '@renderer/app-state/settings/types'
 import type { RenderedViewPolicy } from '@renderer/workspace/agentDisplayMode'
@@ -186,7 +187,6 @@ export type CommandContext = {
   workspace: Workspace
   ui: {
     openNewTabPicker: () => void
-    openResumePicker: (defaultCwd: string) => void
     openTileTabs: () => void
     openReorderTabs: () => void
     openSettings: () => void
@@ -215,12 +215,15 @@ export type CommandContext = {
     /** Flip workspace-wide feed auto-follow (every visible agent pane). */
     toggleTailAllMode: () => void
     toggleDevDebugPanel: () => void
-    openAgentStatusPanel: () => void
-    closeAgentStatusPanel: () => void
     toggleAgentStatusPanel: () => void
     togglePerformancePanel: () => void
     toggleRemotePanel: () => void
     toggleCaffeinate: () => Promise<void> | void
+    /** Idempotent open. Prefer this over `toggleGlobalEditor` whenever the
+     *  intent is "make sure the editor is up" — a toggle driven by a
+     *  snapshotted flag closes the editor when the snapshot is stale. */
+    openGlobalEditor: () => void
+    closeGlobalEditor: () => void
     toggleGlobalEditor: () => void
     /** Toggle visibility of the Global Editor's in-editor file tree.
      *  Only meaningful when the overlay is open — the command's
@@ -247,11 +250,6 @@ export type CommandContext = {
      *  transient flag — the draft selection state is owned by the
      *  modal itself, not the store. */
     openPinAgents: () => void
-    toggleStatusMode: () => void
-    toggleWorktreeBadges: () => void
-    toggleUsageHeader: () => void
-    cycleUsageHeaderLevel: () => void
-    setDangerousAgentsEnabled: (enabled: boolean) => void
     setAggressiveDebugPersistence: (enabled: boolean) => void
     enterResumeMode: () => void
     enterBuriedMode: () => void
@@ -262,6 +260,22 @@ export type CommandContext = {
     enterAiWorkspaceOpenMode: () => void
     enterAiWorkspaceCreateMode: () => void
     enterAiWorkspaceClearMode: () => void
+    /**
+     * Dismissal for the surfaces above.
+     *
+     * These actions all existed on the store already; they simply were not
+     * reachable from a command, so every one of those surfaces was open-only.
+     * `closePalette` and nothing else used to be here.
+     */
+    closeUsageModal: () => void
+    closeKeyboardShortcuts: () => void
+    closeAgentActivity: () => void
+    closeCloseOldAgents: () => void
+    closeBulkProviderSwitch: () => void
+    closePromptSearch: () => void
+    closeReorderTabs: () => void
+    closePinAgents: () => void
+    closePathPicker: () => void
     closePalette: () => void
   }
   flags: {
@@ -271,6 +285,51 @@ export type CommandContext = {
     usageHeaderLevel: UsageHeaderLevel
     dangerousAgentsEnabled: boolean
     aggressiveDebugPersistenceEnabled: boolean
+    /**
+     * Visibility of the surfaces a command can dismiss.
+     *
+     * These exist so a command can ask "am I already open?" and branch, which
+     * is what makes a chord round-trip instead of only ever opening. Without
+     * them a command literally cannot tell — which is why every one of these
+     * surfaces used to be open-only.
+     *
+     * Kept as plain booleans deliberately. The per-TARGET surfaces (View
+     * Prompts, Rewind, Agent View, Colour Flag) are NOT here: their store field
+     * is a `SessionId | null`, and collapsing that to a boolean would lose the
+     * case that matters — pressing the chord while the surface is open for a
+     * DIFFERENT session must re-target, not close.
+     */
+    /** The palette is on screen. */
+    commandPaletteOpen: boolean
+    /**
+     * The palette's active sub-mode.
+     *
+     * Exposed so a mode-entering command can tell "open me" from "I am already
+     * the thing on screen" and dismiss instead. Without it those nine commands
+     * could only ever re-enter the mode they were already in, which reads as a
+     * dead key.
+     */
+    paletteMode: PaletteMode
+    /** The Usage modal is on screen. */
+    usageModalOpen: boolean
+    /** The Keyboard Shortcuts reference is on screen. */
+    keyboardShortcutsOpen: boolean
+    /** The Agent Activity modal is on screen. */
+    agentActivityOpen: boolean
+    /** The Close Old Agents modal is on screen. */
+    closeOldAgentsOpen: boolean
+    /** The Switch Agents modal is on screen. */
+    bulkProviderSwitchOpen: boolean
+    /** The Prompt Search modal is on screen. */
+    promptSearchOpen: boolean
+    /** The Remote Control panel is on screen. */
+    remotePanelOpen: boolean
+    /** The Reorder Tabs modal is on screen. */
+    reorderTabsOpen: boolean
+    /** The Pin Agents modal is on screen. */
+    pinAgentsOpen: boolean
+    /** The path picker (New Tab / Resume) is on screen. */
+    pathPickerOpen: boolean
     gitBarOpen: boolean
     worktreesBarOpen: boolean
     debugPanelOpen: boolean
diff --git a/src/renderer/src/features/command-palette/ui/CommandPalette.tsx b/src/renderer/src/features/command-palette/ui/CommandPalette.tsx
index 57b944e0..7987b46b 100644
--- a/src/renderer/src/features/command-palette/ui/CommandPalette.tsx
+++ b/src/renderer/src/features/command-palette/ui/CommandPalette.tsx
@@ -15,7 +15,6 @@ import {
   dispatchCommand,
   dispatchResolvedRow,
 } from '@renderer/features/command-palette/executeCommand'
-import { PALETTE_SELF_EXCLUDED_COMMAND_IDS } from '@renderer/features/command-palette/commands/paletteCommands'
 import { buildAgentIndexCommand } from '@renderer/features/command-palette/lib/agentIndexCommand'
 import {
   buildHistoryScoreMap,
@@ -65,6 +64,8 @@ import type {
 import { commandTargetSessionId } from '@renderer/workspace/hook/selectors/commandTargetSessionId'
 import { resolveAgentPaneLabel } from '@renderer/workspace/tile-tree/paneLabels'
 import { useWorkspaceContext } from '@renderer/workspace/WorkspaceContext'
+import type { PaletteMode } from '@renderer/features/command-palette/paletteMode'
+import { commandOwnsOpenSurface } from '@renderer/features/command-palette/surfaceOwnership'
 import { useAppStore } from '@renderer/app-state/hooks'
 import { useCaffeinateStore } from '@renderer/features/caffeinate/store'
 import { useDevDebugConfig } from '@renderer/features/debug/devDebugConfig'
@@ -98,20 +99,6 @@ type BuriedPaneInfo = {
   buriedAt: number
 }
 
-type PaletteMode =
-  | 'commands'
-  | 'resume'
-  | 'buried'
-  | 'kill-buried'
-  | 'prompt-template'
-  | 'manage-prompt-template'
-  | 'fill-prompt-template'
-  | 'save-prompt-template'
-  | 'edit-prompt-template'
-  | 'ai-workspace-open'
-  | 'ai-workspace-create'
-  | 'ai-workspace-clear'
-
 type PromptTemplateFillState = {
   template: PromptTemplate
   values: PromptTemplateVariableValueMap
@@ -180,7 +167,17 @@ export function CommandPalette() {
         // correctly blocked. When the command palette itself is open it also owns
         // this marker, so menu commands wait instead of competing with its current
         // search/navigation turn.
-        if (hasAppInteractionOwner()) return
+        // ONE exemption, matching the keybinding router: the command that owns
+        // the surface currently holding the interaction may dismiss it. Without
+        // this, File → New Tab twice left the path picker up, and the rule this
+        // change exists to establish — "invoking again dismisses it, from every
+        // invocation source" — was true for chords and false for the menu.
+        if (
+          hasAppInteractionOwner()
+          && !commandOwnsOpenSurface(commandId, useAppStore.getState())
+        ) {
+          return
+        }
         // WHY this temporarily mounts the open implementation: command
         // definitions need live workspace actions, but keeping that registry
         // subscribed while the palette is closed made every session delta
@@ -239,7 +236,7 @@ function OpenCommandPalette({
   const onClose = useAppStore(state => state.closeCommandPalette)
   const settings = useAppStore(state => state.settings)
   const setSettings = useAppStore(state => state.setSettings)
-  const { onNewTabRequest, onResumeRequest } = usePathPickerRequests()
+  const { onNewTabRequest } = usePathPickerRequests()
 
   const openTileTabsModal = useAppStore(state => state.openTileTabsModal)
   const onTileTabsRequest = useCallback(() => {
@@ -259,6 +256,15 @@ function OpenCommandPalette({
   const openRewindPrompt = useAppStore(state => state.openRewindPrompt)
   const openAgentViewModePicker = useAppStore(state => state.openAgentViewModePicker)
   const openColorFlagPicker = useAppStore(state => state.openColorFlagPicker)
+  const closeUsageModal = useAppStore(state => state.closeUsageModal)
+  const closeKeyboardShortcuts = useAppStore(state => state.closeKeyboardShortcuts)
+  const closeAgentActivity = useAppStore(state => state.closeAgentActivity)
+  const closeCloseOldAgents = useAppStore(state => state.closeCloseOldAgents)
+  const closeBulkProviderSwitch = useAppStore(state => state.closeBulkProviderSwitch)
+  const closePromptSearch = useAppStore(state => state.closePromptSearch)
+  const closeReorderTabs = useAppStore(state => state.closeReorderTabs)
+  const closePinAgents = useAppStore(state => state.closePinAgents)
+  const closePathPicker = useAppStore(state => state.closePathPicker)
   const openUsageModal = useAppStore(state => state.openUsageModal)
   const toggleGitBar = useAppStore(state => state.toggleGitBar)
   const toggleWorktreesBar = useAppStore(state => state.toggleWorktreesBar)
@@ -269,20 +275,16 @@ function OpenCommandPalette({
   const toggleRenderingDebugMode = useAppStore(state => state.toggleRenderingDebugMode)
   const toggleTailAllMode = useAppStore(state => state.toggleTailAllMode)
   const toggleDevDebugPanel = useAppStore(state => state.toggleDevDebugPanel)
-  const openAgentStatusPanel = useAppStore(state => state.openAgentStatusPanel)
-  const closeAgentStatusPanel = useAppStore(state => state.closeAgentStatusPanel)
   const toggleAgentStatusPanel = useAppStore(state => state.toggleAgentStatusPanel)
   const togglePerformancePanel = useAppStore(state => state.togglePerformancePanel)
   const toggleRemotePanel = useAppStore(state => state.toggleRemotePanel)
+  const openGlobalEditorAction = useAppStore(state => state.openGlobalEditor)
+  const closeGlobalEditorAction = useAppStore(state => state.closeGlobalEditor)
   const toggleGlobalEditor = useAppStore(state => state.toggleGlobalEditor)
   const openTiledDispatchPrompt = useAppStore(state => state.openTiledDispatchPrompt)
   const openDispatchAttach = useAppStore(state => state.openDispatchAttach)
   const openLinkedAgent = useAppStore(state => state.openLinkedAgent)
   const openPinAgents = useAppStore(state => state.openPinAgents)
-  const toggleStatusMode = useAppStore(state => state.toggleStatusMode)
-  const toggleWorktreeBadges = useAppStore(state => state.toggleWorktreeBadges)
-  const toggleUsageHeader = useAppStore(state => state.toggleUsageHeader)
-  const cycleUsageHeaderLevel = useAppStore(state => state.cycleUsageHeaderLevel)
   const toggleCaffeinate = useCaffeinateStore(state => state.toggle)
   const caffeinateStatus = useCaffeinateStore(state => state.status)
   const devDebugEnabled = useDevDebugConfig(state => state.enabled)
@@ -301,10 +303,6 @@ function OpenCommandPalette({
       workspace.setDispatchScope(workspace.dispatchMode?.scope === 'global' ? 'project' : 'global'),
     [workspace],
   )
-  const setDangerousAgentsEnabled = useCallback(
-    (enabled: boolean) => setSettings({ dangerousAgentsEnabled: enabled }),
-    [setSettings],
-  )
   const setAggressiveDebugPersistence = useCallback(
     (enabled: boolean) => setSettings({ aggressiveDebugPersistence: enabled }),
     [setSettings],
@@ -321,6 +319,17 @@ function OpenCommandPalette({
   const usageHeaderLevel = settings.usageHeaderLevel
   const dangerousAgentsEnabled = settings.dangerousAgentsEnabled
   const aggressiveDebugPersistenceEnabled = settings.aggressiveDebugPersistence
+  const commandPaletteOpenFlag = useAppStore(state => state.commandPaletteOpen)
+  const usageModalOpen = useAppStore(state => state.usageModalOpen)
+  const keyboardShortcutsOpen = useAppStore(state => state.keyboardShortcutsOpen)
+  const agentActivityOpen = useAppStore(state => state.agentActivityOpen)
+  const closeOldAgentsOpen = useAppStore(state => state.closeOldAgentsOpen)
+  const bulkProviderSwitchOpen = useAppStore(state => state.bulkProviderSwitchOpen)
+  const promptSearchOpen = useAppStore(state => state.promptSearchOpen)
+  const remotePanelOpen = useAppStore(state => state.remotePanelOpen)
+  const reorderTabsOpen = useAppStore(state => state.reorderTabsOpen)
+  const pinAgentsOpen = useAppStore(state => state.pinAgentsOpen)
+  const pathPickerOpen = useAppStore(state => state.pathPickerOpen)
   const gitBarOpen = useAppStore(state => state.gitBarOpen)
   const worktreesBarOpen = useAppStore(state => state.worktreesBarOpen)
   const debugPanelOpen = useAppStore(state => state.debugPanelOpen)
@@ -340,7 +349,11 @@ function OpenCommandPalette({
 
   const [query, setQuery] = useState('')
   const [selectedIndex, setSelectedIndex] = useState(0)
-  const [mode, setMode] = useState<PaletteMode>('commands')
+  // Store-backed, not `useState` — see the note on `uiShell.paletteMode`. The
+  // local version could not survive a chord invocation, which mounts this
+  // component invisibly and destroys it in the same commit.
+  const mode = useAppStore(state => state.paletteMode)
+  const setMode = useAppStore(state => state.setPaletteMode)
   const [sessions, setSessions] = useState<SessionInfo[]>([])
   const [sessionsLoading, setSessionsLoading] = useState(false)
   const [aiWorkspaces, setAiWorkspaces] = useState<AiWorkspaceSummary[]>([])
@@ -557,7 +570,6 @@ function OpenCommandPalette({
       workspace,
       ui: {
         openNewTabPicker: onNewTabRequest,
-        openResumePicker: onResumeRequest,
         openTileTabs: onTileTabsRequest,
         openReorderTabs: onReorderTabsRequest,
         openSettings: onSettingsRequest,
@@ -575,6 +587,15 @@ function OpenCommandPalette({
         openRewindPrompt,
         openAgentViewModePicker,
         openColorFlagPicker,
+        closeUsageModal,
+        closeKeyboardShortcuts,
+        closeAgentActivity,
+        closeCloseOldAgents,
+        closeBulkProviderSwitch,
+        closePromptSearch,
+        closeReorderTabs,
+        closePinAgents,
+        closePathPicker,
         openUsageModal,
         toggleGitBar,
         toggleWorktreesBar,
@@ -585,12 +606,12 @@ function OpenCommandPalette({
         toggleRenderingDebugMode,
         toggleTailAllMode,
         toggleDevDebugPanel,
-        openAgentStatusPanel,
-        closeAgentStatusPanel,
         toggleAgentStatusPanel,
         togglePerformancePanel,
         toggleRemotePanel,
         toggleCaffeinate,
+        openGlobalEditor: openGlobalEditorAction,
+        closeGlobalEditor: closeGlobalEditorAction,
         toggleGlobalEditor,
         toggleFileTreeVisible,
         enterDispatchMode,
@@ -600,11 +621,6 @@ function OpenCommandPalette({
         openDispatchAttach,
         openLinkedAgent,
         openPinAgents,
-        toggleStatusMode,
-        toggleWorktreeBadges,
-        toggleUsageHeader,
-        cycleUsageHeaderLevel,
-        setDangerousAgentsEnabled,
         setAggressiveDebugPersistence,
         enterResumeMode,
         enterBuriedMode,
@@ -624,6 +640,18 @@ function OpenCommandPalette({
         usageHeaderLevel,
         dangerousAgentsEnabled,
         aggressiveDebugPersistenceEnabled,
+        commandPaletteOpen: commandPaletteOpenFlag,
+        paletteMode: mode,
+        usageModalOpen,
+        keyboardShortcutsOpen,
+        agentActivityOpen,
+        closeOldAgentsOpen,
+        bulkProviderSwitchOpen,
+        promptSearchOpen,
+        remotePanelOpen,
+        reorderTabsOpen,
+        pinAgentsOpen,
+        pathPickerOpen,
         gitBarOpen,
         worktreesBarOpen,
         debugPanelOpen,
@@ -655,7 +683,6 @@ function OpenCommandPalette({
     [
       workspace,
       onNewTabRequest,
-      onResumeRequest,
       onTileTabsRequest,
       onReorderTabsRequest,
       onSettingsRequest,
@@ -666,6 +693,15 @@ function OpenCommandPalette({
       openBulkProviderSwitch,
       openRewindPrompt,
       openAgentViewModePicker,
+      closeUsageModal,
+      closeKeyboardShortcuts,
+      closeAgentActivity,
+      closeCloseOldAgents,
+      closeBulkProviderSwitch,
+      closePromptSearch,
+      closeReorderTabs,
+      closePinAgents,
+      closePathPicker,
       openUsageModal,
       toggleGitBar,
       toggleWorktreesBar,
@@ -676,12 +712,12 @@ function OpenCommandPalette({
       toggleRenderingDebugMode,
       toggleTailAllMode,
       toggleDevDebugPanel,
-      openAgentStatusPanel,
-      closeAgentStatusPanel,
       toggleAgentStatusPanel,
       togglePerformancePanel,
       toggleRemotePanel,
       toggleCaffeinate,
+      openGlobalEditorAction,
+      closeGlobalEditorAction,
       toggleGlobalEditor,
       toggleFileTreeVisible,
       enterDispatchMode,
@@ -691,11 +727,6 @@ function OpenCommandPalette({
       openDispatchAttach,
       openLinkedAgent,
       openPinAgents,
-      toggleStatusMode,
-      toggleWorktreeBadges,
-      toggleUsageHeader,
-      cycleUsageHeaderLevel,
-      setDangerousAgentsEnabled,
       setAggressiveDebugPersistence,
       enterResumeMode,
       enterBuriedMode,
@@ -713,6 +744,18 @@ function OpenCommandPalette({
       usageHeaderLevel,
       dangerousAgentsEnabled,
       aggressiveDebugPersistenceEnabled,
+      commandPaletteOpenFlag,
+      mode,
+      usageModalOpen,
+      keyboardShortcutsOpen,
+      agentActivityOpen,
+      closeOldAgentsOpen,
+      bulkProviderSwitchOpen,
+      promptSearchOpen,
+      remotePanelOpen,
+      reorderTabsOpen,
+      pinAgentsOpen,
+      pathPickerOpen,
       gitBarOpen,
       worktreesBarOpen,
       debugPanelOpen,
@@ -881,28 +924,26 @@ function OpenCommandPalette({
     return paletteCommands[selectedIndex] ?? null
   }, [mode, paletteCommands, selectedIndex])
 
+  // Focus the search input whenever the palette becomes VISIBLE.
+  //
+  // This replaced a mount-time reset effect that also did the focusing. That
+  // effect had a `mountedForPendingCommand` guard which, on inspection, is never
+  // false: `openCommandPalette` has exactly one caller — the
+  // `open-command-palette` command — and commands only run from inside this
+  // host, which is already mounted when they do. So every mount carries a
+  // pending invocation, the guard always returned early, and the focus call
+  // went with it. A comment described a distinction with no other branch.
+  //
+  // The state resets it also performed were redundant on a fresh mount (the
+  // `useState` initializers already give those values) and are gone. Focus is
+  // not redundant, so it moves here, keyed on `visible` rather than on mount —
+  // which is the moment it actually matters, and is correct for both paths:
+  // opened directly, or opened into a sub-mode by a chord.
   useEffect(() => {
-    setQuery('')
-    setSelectedIndex(0)
-    setMode('commands')
-    setSessions([])
-    setSessionsLoading(false)
-    setAiWorkspaces([])
-    setAiWorkspacesLoading(false)
-    setAiWorkspaceError(null)
-    setAiWorkspacePending(null)
-    setArmedAiWorkspaceClearId(null)
-    setPromptTemplateForm({
-      id: null,
-      title: '',
-      description: '',
-      body: '',
-      insertMode: 'replace',
-      variables: [],
-    })
-    setPromptTemplateFillState(null)
-    requestAnimationFrame(() => inputRef.current?.focus())
-  }, [])
+    if (!visible) return
+    const frame = requestAnimationFrame(() => inputRef.current?.focus())
+    return () => cancelAnimationFrame(frame)
+  }, [visible])
 
   useEffect(() => {
     setSelectedIndex(prev => Math.min(prev, Math.max(0, filteredLength - 1)))
@@ -977,13 +1018,27 @@ function OpenCommandPalette({
       reportError: message => showToast(message, 6000),
     })
     onMenuCommandHandled()
-    // A command whose whole purpose IS the palette must not be closed by the
-    // "return to where you were" rule. Cmd+Shift+P arrives here with
-    // closeAfterRun=true (the palette was shut when the chord fired), so
-    // honouring it blindly would open the palette and shut it in the same
-    // frame — the chord would look broken.
-    if (pendingMenuCommand.closeAfterRun
-      && !PALETTE_SELF_EXCLUDED_COMMAND_IDS.has(pendingMenuCommand.id)) {
+    // A command that OPENED the palette must not be closed by the "return to
+    // where you were" rule. `closeAfterRun` records that the palette was shut
+    // when the invocation was requested; honouring it blindly would open the
+    // palette and shut it in the same frame, and the chord would look broken.
+    //
+    // CAVEAT, because the rule is not unconditional: `dispatchCommand` is not
+    // awaited, so this reads the flag at the first `await` inside `run`. A
+    // command that opens the palette only AFTER an await would be closed in the
+    // same frame. All nine mode-entering commands set the mode in their
+    // synchronous prefix (`enterResumeMode` sets 'resume' before its await), so
+    // the property holds today — but a future command must open the palette
+    // before its first await for it to keep holding.
+    //
+    // The test is the LIVE flag, read after `run`, rather than a hardcoded id
+    // list. That list held only `open-command-palette`, and it could only ever
+    // have held ids someone remembered to add — it would not have covered the
+    // nine mode-entering commands, which need exactly the same exemption for
+    // exactly the same reason. "Did this command turn the palette on?" answers
+    // for all of them, and for anything added later, without an enumeration to
+    // keep in sync.
+    if (pendingMenuCommand.closeAfterRun && !useAppStore.getState().commandPaletteOpen) {
       onClose()
     }
   }, [commandContext, onClose, onMenuCommandHandled, pendingMenuCommand, showToast])
@@ -1110,10 +1165,11 @@ function OpenCommandPalette({
   const openAiWorkspace = useCallback(
     (workspaceId: string) => {
       useGlobalEditorStore.getState().openAiWorkspace(workspaceId)
-      if (!globalEditorOpen) toggleGlobalEditor()
+      // Idempotent open — see the note on `ui.openGlobalEditor`.
+      openGlobalEditorAction()
       onClose()
     },
-    [globalEditorOpen, onClose, toggleGlobalEditor],
+    [onClose, openGlobalEditorAction],
   )
 
   const createAiWorkspace = useCallback(async () => {
diff --git a/src/renderer/src/features/global-editor/commands/globalEditorCommands.ts b/src/renderer/src/features/global-editor/commands/globalEditorCommands.ts
index abe1477e..726dc9a3 100644
--- a/src/renderer/src/features/global-editor/commands/globalEditorCommands.ts
+++ b/src/renderer/src/features/global-editor/commands/globalEditorCommands.ts
@@ -1,6 +1,6 @@
 import type { CommandDef } from '@renderer/features/command-palette/types'
 import { useGlobalEditorStore } from '@renderer/features/global-editor/store'
-import { panel, toggle } from '@renderer/features/command-palette/commandState'
+import { toggle } from '@renderer/features/command-palette/commandState'
 import {
   requestSaveActiveEditorFile,
   requestSaveAllEditorFiles,
@@ -48,12 +48,18 @@ export const globalEditorCommands: CommandDef[] = [
     description:
       '**What it does:** Saves the active file in the visible Global Editor or AI Workspace.\n\n**Use when:** You edited a file and want to persist it without leaving the command palette.\n\n**Notes:** Conflict checks and recovery are owned by the active editor surface.\n\n**Shortcut:** ⌘S.',
     keywords: ['save', 'write', 'editor', 'file'],
-    // Requires a project, NOT an open editor. The ⌘⌥E chord has always meant
-    // "give me a big editor" as ONE gesture — it opens the editor straight into
-    // fullscreen when closed. That behaviour used to live in a hard-coded
-    // keybind branch; now that the chord routes through this command, the
-    // command has to own it, or routing would silently drop half the feature.
-    when: ({ flags }) => Boolean(flags.globalEditorOpen || flags.focusedCwd),
+    // Requires an OPEN editor, not merely a project.
+    //
+    // `requestSaveActiveEditorFile` dispatches a window event whose only
+    // listener is EditorWorkbench, which does not mount until the editor is
+    // open. Admitting on `focusedCwd` therefore produced a File → Save menu
+    // item that was enabled and did nothing.
+    //
+    // That looser predicate arrived here by accident, carrying the ⌘⌥E comment
+    // now sitting on `toggle-editor-fullscreen` — the two commands' `when`
+    // clauses were transposed, and each broke in its own direction: this one
+    // admitted a no-op, and fullscreen refused the state it exists to handle.
+    when: ({ flags }) => flags.globalEditorOpen,
     run: requestSaveActiveEditorFile,
   },
   {
@@ -85,7 +91,11 @@ export const globalEditorCommands: CommandDef[] = [
       if (editor.activeCwd !== targetCwd) cancelAllPendingGlobalEditorFileOpens()
       editor.setActiveCwd(targetCwd)
       editor.showProjectEditor()
-      if (!flags.globalEditorOpen) ui.toggleGlobalEditor()
+      // `openGlobalEditor`, not a read-then-toggle against `flags`. That flag
+      // is snapshotted when the CommandContext memo is built, so a stale `true`
+      // used to CLOSE the editor the user just asked to open. An idempotent
+      // open cannot express the wrong intent.
+      ui.openGlobalEditor()
       editor.setQuickOpenOpen(true)
     },
   },
@@ -107,7 +117,7 @@ export const globalEditorCommands: CommandDef[] = [
       if (editor.activeCwd !== targetCwd) cancelAllPendingGlobalEditorFileOpens()
       editor.setActiveCwd(targetCwd)
       editor.showProjectEditor()
-      if (!flags.globalEditorOpen) ui.toggleGlobalEditor()
+      ui.openGlobalEditor()
       editor.setContentSearchOpen(true)
     },
   },
@@ -119,14 +129,24 @@ export const globalEditorCommands: CommandDef[] = [
     description:
       '**What it does:** Expands the **Global Editor** to fill the whole workspace area. The normal workspace stays alive underneath (hidden, not unmounted — terminals and feeds keep running).\n\n**Use when:** You want maximum reading/editing room for a while.\n\n**Notes:** Esc exits fullscreen; the previous split ratio is restored.\n\n**Shortcut:** ⌥⌘E.',
     keywords: ['fullscreen', 'maximize', 'editor', 'zen', 'focus'],
-    when: ({ flags }) => flags.globalEditorOpen,
+    // NO `when`. The ⌘⌥E chord has always meant "give me a big editor" as ONE
+    // gesture — it opens the editor straight into fullscreen when closed. That
+    // behaviour used to live in a hard-coded keybind branch; now that the chord
+    // routes through this command, the command has to own it, or routing
+    // silently drops half the feature.
+    //
+    // Routing did drop it. A `when: flags.globalEditorOpen` sat here and runs
+    // during ADMISSION, before `run` — so the closed-editor branch below was
+    // unreachable from all four invocation sources, and ⌘⌥E with the editor
+    // closed was a silent no-op. The guard belonged on `save-editor-file`,
+    // where it now is.
     getState: ({ flags }) => toggle(flags.editorFullscreen),
     run: ({ ui, flags }) => {
       const editor = useGlobalEditorStore.getState()
       if (!flags.globalEditorOpen) {
         // Closed → open it already fullscreen, rather than opening windowed and
         // making the user press again.
-        ui.toggleGlobalEditor()
+        ui.openGlobalEditor()
         editor.setEditorFullscreen(true)
         return
       }
@@ -143,7 +163,16 @@ export const globalEditorCommands: CommandDef[] = [
       '**What it does:** Opens a curated **AI Workspace** file set in the Global Editor surface.\n\n**Use when:** An agent has attached plans, notes, or review artifacts from multiple worktrees and you want one focused review view.\n\n**Notes:** If more than one AI Workspace exists, you choose which one to open.',
     keywords: ['ai workspace', 'mcp', 'workspace', 'files', 'review', 'worktree', 'global editor'],
     keepPaletteOpen: true,
-    run: ({ ui }) => ui.enterAiWorkspaceOpenMode(),
+    run: ({ ui, flags }) => {
+      // Already showing this mode? Dismiss. A mode-entering command whose
+      // second press re-enters the mode it is already in reads as a dead key,
+      // which is the same complaint that started this whole change.
+      if (flags.paletteMode === 'ai-workspace-open') {
+        ui.closePalette()
+        return
+      }
+      ui.enterAiWorkspaceOpenMode()
+    },
   },
   {
     id: 'create-ai-workspace',
@@ -155,7 +184,16 @@ export const globalEditorCommands: CommandDef[] = [
       '**What it does:** Creates an empty named **AI Workspace** and opens it in the Global Editor surface.\n\n**Use when:** You want a curated file set ready before an agent starts attaching files.\n\n**Notes:** Agents can also create AI Workspaces through MCP.',
     keywords: ['ai workspace', 'mcp', 'create', 'workspace', 'review'],
     keepPaletteOpen: true,
-    run: ({ ui }) => ui.enterAiWorkspaceCreateMode(),
+    run: ({ ui, flags }) => {
+      // Already showing this mode? Dismiss. A mode-entering command whose
+      // second press re-enters the mode it is already in reads as a dead key,
+      // which is the same complaint that started this whole change.
+      if (flags.paletteMode === 'ai-workspace-create') {
+        ui.closePalette()
+        return
+      }
+      ui.enterAiWorkspaceCreateMode()
+    },
   },
   {
     id: 'clear-ai-workspace',
@@ -167,7 +205,16 @@ export const globalEditorCommands: CommandDef[] = [
       '**What it does:** Removes every file reference from an **AI Workspace** without deleting files from disk.\n\n**Use when:** A curated review set is stale but you want to keep the workspace itself.\n\n**Notes:** This only clears Agent Code metadata.',
     keywords: ['ai workspace', 'mcp', 'clear', 'delete', 'files'],
     keepPaletteOpen: true,
-    run: ({ ui }) => ui.enterAiWorkspaceClearMode(),
+    run: ({ ui, flags }) => {
+      // Already showing this mode? Dismiss. A mode-entering command whose
+      // second press re-enters the mode it is already in reads as a dead key,
+      // which is the same complaint that started this whole change.
+      if (flags.paletteMode === 'ai-workspace-clear') {
+        ui.closePalette()
+        return
+      }
+      ui.enterAiWorkspaceClearMode()
+    },
   },
   {
     // WHY a dedicated command rather than a setting:
diff --git a/src/renderer/src/features/prompt-templates/commands/promptTemplateCommands.ts b/src/renderer/src/features/prompt-templates/commands/promptTemplateCommands.ts
index 13154f20..d76f4f5f 100644
--- a/src/renderer/src/features/prompt-templates/commands/promptTemplateCommands.ts
+++ b/src/renderer/src/features/prompt-templates/commands/promptTemplateCommands.ts
@@ -20,7 +20,16 @@ export const promptTemplateCommands: CommandDef[] = [
     description: '**What it does:** Opens the **prompt template manager** for creating, editing, duplicating, and deleting reusable prompts.\n\n**Use when:** You want to organize or author custom templates.\n\n**Notes:** Built-ins stay read-only; duplicate them to customize.',
     keywords: ['prompt', 'template', 'manage', 'custom', 'variables', 'snippets'],
     keepPaletteOpen: true,
-    run: ({ ui }) => ui.enterManagePromptTemplateMode(),
+    run: ({ ui, flags }) => {
+      // Already showing this mode? Dismiss. A mode-entering command whose
+      // second press re-enters the mode it is already in reads as a dead key,
+      // which is the same complaint that started this whole change.
+      if (flags.paletteMode === 'manage-prompt-template') {
+        ui.closePalette()
+        return
+      }
+      ui.enterManagePromptTemplateMode()
+    },
   },
   {
     id: 'prompt-template',
@@ -32,7 +41,16 @@ export const promptTemplateCommands: CommandDef[] = [
     keepPaletteOpen: true,
     renderedViewPolicy: { kind: 'opens-rendered-feed' },
     when: ({ workspace }) => focusedAgentSessionId(workspace) !== null,
-    run: ({ ui }) => ui.enterPromptTemplateMode(),
+    run: ({ ui, flags }) => {
+      // Already showing this mode? Dismiss. A mode-entering command whose
+      // second press re-enters the mode it is already in reads as a dead key,
+      // which is the same complaint that started this whole change.
+      if (flags.paletteMode === 'prompt-template') {
+        ui.closePalette()
+        return
+      }
+      ui.enterPromptTemplateMode()
+    },
   },
   {
     id: 'save-composer-as-prompt-template',
@@ -49,7 +67,14 @@ export const promptTemplateCommands: CommandDef[] = [
       if (!sessionId) return false
       return workspace.getRuntime(sessionId).draftInput.trim().length > 0
     },
-    run: ({ workspace, ui }) => {
+    run: ({ workspace, ui, flags }) => {
+      // Already showing this mode? Dismiss. A mode-entering command whose
+      // second press re-enters the mode it is already in reads as a dead key,
+      // which is the same complaint that started this whole change.
+      if (flags.paletteMode === 'save-prompt-template') {
+        ui.closePalette()
+        return
+      }
       const sessionId = focusedAgentSessionId(workspace)
       if (!sessionId) return
       ui.enterSavePromptTemplateMode()
diff --git a/src/renderer/src/features/remote/commands/remoteCommands.ts b/src/renderer/src/features/remote/commands/remoteCommands.ts
index 1649abe6..53a01e53 100644
--- a/src/renderer/src/features/remote/commands/remoteCommands.ts
+++ b/src/renderer/src/features/remote/commands/remoteCommands.ts
@@ -1,3 +1,4 @@
+import { panel } from '@renderer/features/command-palette/commandState'
 import type { CommandDef } from '@renderer/features/command-palette/types'
 
 export const remoteCommands: CommandDef[] = [
@@ -10,6 +11,11 @@ export const remoteCommands: CommandDef[] = [
     description:
       '**What it does:** Opens the **Remote Control** panel — enable the LAN server, pair your phone with a QR code, and manage paired devices.\n\n**Use when:** You want to watch agents, send prompts, or answer permission dialogs from your phone.\n\n**Notes:** Off by default. Phones can never run shell commands or start/stop sessions.',
     keywords: ['remote', 'phone', 'mobile', 'qr', 'pair', 'companion', 'lan'],
+    // The store action was already a correct toggle. What was missing is the
+    // badge — `remotePanelOpen` was the one panel flag absent from
+    // CommandContext.flags, so this was the only panel command in the app
+    // without an Open/Closed state while eleven siblings had one.
+    getState: ({ flags }) => panel(flags.remotePanelOpen),
     run: ({ ui }) => ui.toggleRemotePanel(),
   },
 ]
diff --git a/src/renderer/src/features/settings/commands/settingsCommands.ts b/src/renderer/src/features/settings/commands/settingsCommands.ts
index b4af157a..09106394 100644
--- a/src/renderer/src/features/settings/commands/settingsCommands.ts
+++ b/src/renderer/src/features/settings/commands/settingsCommands.ts
@@ -1,5 +1,5 @@
 import type { CommandDef } from '@renderer/features/command-palette/types'
-import { panel, toggle, value } from '@renderer/features/command-palette/commandState'
+import { panel, toggle } from '@renderer/features/command-palette/commandState'
 
 export const settingsCommands: CommandDef[] = [
   {
@@ -43,7 +43,14 @@ export const settingsCommands: CommandDef[] = [
       'reference',
       'help',
     ],
-    run: ({ ui }) => ui.openKeyboardShortcuts(),
+    getState: ({ flags }) => panel(flags.keyboardShortcutsOpen),
+    run: ({ ui, flags }) => {
+      if (flags.keyboardShortcutsOpen) {
+        ui.closeKeyboardShortcuts()
+        return
+      }
+      ui.openKeyboardShortcuts()
+    },
   },
   {
     // Persistent Aggressive Debug Logs — developer-mode switch for
diff --git a/src/renderer/src/features/usage/commands/usageCommands.ts b/src/renderer/src/features/usage/commands/usageCommands.ts
index 3d2aa02c..54564410 100644
--- a/src/renderer/src/features/usage/commands/usageCommands.ts
+++ b/src/renderer/src/features/usage/commands/usageCommands.ts
@@ -1,3 +1,4 @@
+import { panel } from '@renderer/features/command-palette/commandState'
 import type { CommandDef } from '@renderer/features/command-palette/types'
 
 export const usageCommands: CommandDef[] = [
@@ -8,7 +9,17 @@ export const usageCommands: CommandDef[] = [
     description: 'Open provider usage for Claude and Codex.',
     surface: 'app',
     keywords: ['quota', 'tokens', 'limits', 'claude', 'codex', 'usage'],
-    run: ({ ui }) => {
+    getState: ({ flags }) => panel(flags.usageModalOpen),
+    run: ({ ui, flags }) => {
+      // Round-trips. Everything below this line follows the same shape, and
+      // it is the `tiled-tabs` pattern: read the flag, branch, call the
+      // one-directional action. These surfaces have no toggle action of their
+      // own — open and close are separate store actions — so the command is
+      // where the decision has to live.
+      if (flags.usageModalOpen) {
+        ui.closeUsageModal()
+        return
+      }
       ui.openUsageModal()
       ui.closePalette()
     },
diff --git a/src/renderer/src/features/workspace/commands/paneCommands.ts b/src/renderer/src/features/workspace/commands/paneCommands.ts
index 32056fc5..14e523d7 100644
--- a/src/renderer/src/features/workspace/commands/paneCommands.ts
+++ b/src/renderer/src/features/workspace/commands/paneCommands.ts
@@ -2,7 +2,7 @@ import { AGENT_PROVIDER_KINDS, DEFAULT_PROVIDER, isAgentProviderKind } from '@sh
 import { getRendererProviderCapabilities } from '@providers/registry.renderer.capabilities'
 import { extractLastAssistantText } from '@renderer/lib/copyAssistant'
 import type { CommandContext, CommandDef } from '@renderer/features/command-palette/types'
-import { toggle } from '@renderer/features/command-palette/commandState'
+import { panel, toggle } from '@renderer/features/command-palette/commandState'
 import {
   commandTargetSessionId,
   commandTargetSessionIdForState,
@@ -17,6 +17,20 @@ import { resolveDispatchAttachTarget } from '@renderer/workspace/dispatch/dispat
 import { dispatchFocusedSessionId } from '@renderer/workspace/dispatch/tiledDispatchSelectors'
 import { collectLeaves } from '@renderer/workspace/tile-tree/treeOps'
 
+/**
+ * Buried panes visible from the CURRENT tab.
+ *
+ * The buried picker is deliberately tab-scoped (see the note in
+ * CommandPalette's `buried` memo: a buried Codex agent from project A listed
+ * beside a buried Claude agent from project B mixes contexts and invites
+ * revive-into-the-wrong-tab). Admission has to use the same scope, or the row
+ * appears for a tab with nothing to revive.
+ */
+function buriedInActiveTab(workspace: CommandContext['workspace']): number {
+  const activeTabId = workspace.state.activeTabId
+  return workspace.state.buried.filter(entry => entry.sourceTabId === activeTabId).length
+}
+
 export const paneCommands: CommandDef[] = [
   {
     id: 'new-agent',
@@ -162,7 +176,14 @@ export const paneCommands: CommandDef[] = [
     title: 'Pin Agents…',
     description: '**What it does:** Opens the multi-select Pin modal to choose which **Dispatch** agents stay pinned at the top of the agent list.\n\n**Use when:** You want a few favorite agents to always be one keystroke away regardless of project or scope.\n\n**Notes:** Space toggles, Enter commits, Esc cancels. The order you Space through the rows is the order pins render in. Pins survive project↔global scope toggles.',
     keywords: ['pin', 'pins', 'pinned', 'favorite', 'star', 'top', 'dispatch'],
-    run: ({ ui }) => ui.openPinAgents(),
+    getState: ({ flags }) => panel(flags.pinAgentsOpen),
+    run: ({ ui, flags }) => {
+      if (flags.pinAgentsOpen) {
+        ui.closePinAgents()
+        return
+      }
+      ui.openPinAgents()
+    },
   },
   {
     // Quick-remove counterpart to pin-agents. Targets the currently
@@ -386,8 +407,24 @@ export const paneCommands: CommandDef[] = [
     keywords: ['pane'],
     description: '**What it does:** Restores a **buried live pane**.\n\n**Use when:** You parked a session and want it back.\n\n**Notes:** Opens a picker when multiple buried panes exist.',
     keepPaletteOpen: true,
-    when: ({ workspace }) => workspace.state.buried.length > 0,
-    run: ({ ui }) => ui.enterBuriedMode(),
+    // Scoped to the ACTIVE TAB, matching the list the picker actually renders.
+    //
+    // This read `state.buried.length > 0` — the whole workspace — while the
+    // picker filters by `sourceTabId`, so both buried commands could be
+    // admitted from a tab with nothing buried and land the user on an empty
+    // list. Admission has to agree with what the command will show, or the
+    // command is advertising something it cannot deliver.
+    when: ({ workspace }) => buriedInActiveTab(workspace) > 0,
+    run: ({ ui, flags }) => {
+      // Already showing this mode? Dismiss. A mode-entering command whose
+      // second press re-enters the mode it is already in reads as a dead key,
+      // which is the same complaint that started this whole change.
+      if (flags.paletteMode === 'buried') {
+        ui.closePalette()
+        return
+      }
+      ui.enterBuriedMode()
+    },
   },
   {
     id: 'kill-buried-pane',
@@ -398,8 +435,17 @@ export const paneCommands: CommandDef[] = [
     description: '**What it does:** Permanently kills a **buried session**.\n\n**Use when:** You no longer need hidden background work.\n\n**Notes:** This is destructive.',
     keywords: ['kill', 'buried', 'hidden', 'pane', 'session', 'pane'],
     keepPaletteOpen: true,
-    when: ({ workspace }) => workspace.state.buried.length > 0,
-    run: ({ ui }) => ui.enterKillBuriedMode(),
+    when: ({ workspace }) => buriedInActiveTab(workspace) > 0,
+    run: ({ ui, flags }) => {
+      // Already showing this mode? Dismiss. A mode-entering command whose
+      // second press re-enters the mode it is already in reads as a dead key,
+      // which is the same complaint that started this whole change.
+      if (flags.paletteMode === 'kill-buried') {
+        ui.closePalette()
+        return
+      }
+      ui.enterKillBuriedMode()
+    },
   },
   {
     id: 'toggle-tail',
diff --git a/src/renderer/src/features/workspace/commands/sessionCommands.ts b/src/renderer/src/features/workspace/commands/sessionCommands.ts
index 9aadb590..c95c5844 100644
--- a/src/renderer/src/features/workspace/commands/sessionCommands.ts
+++ b/src/renderer/src/features/workspace/commands/sessionCommands.ts
@@ -1,7 +1,7 @@
 import { DEFAULT_PROVIDER, isAgentProviderKind } from '@shared/types/providerKind'
 import { getRendererProviderCapabilities } from '@providers/registry.renderer.capabilities'
 import { getProviderFeatures } from '@providers/shared/featureCapabilities'
-import { status, toggle, value } from '@renderer/features/command-palette/commandState'
+import { panel, status, toggle, value } from '@renderer/features/command-palette/commandState'
 import type {
   CommandContext,
   CommandDef,
@@ -217,7 +217,12 @@ export const sessionCommands: CommandDef[] = [
       'idle',
       'overview',
     ],
-    run: ({ ui }) => {
+    getState: ({ flags }) => panel(flags.agentActivityOpen),
+    run: ({ ui, flags }) => {
+      if (flags.agentActivityOpen) {
+        ui.closeAgentActivity()
+        return
+      }
       ui.openAgentActivity()
       ui.closePalette()
     },
@@ -249,7 +254,12 @@ export const sessionCommands: CommandDef[] = [
       'batch',
       'kill',
     ],
-    run: ({ ui }) => {
+    getState: ({ flags }) => panel(flags.closeOldAgentsOpen),
+    run: ({ ui, flags }) => {
+      if (flags.closeOldAgentsOpen) {
+        ui.closeCloseOldAgents()
+        return
+      }
       ui.openCloseOldAgents()
       ui.closePalette()
     },
@@ -287,7 +297,12 @@ export const sessionCommands: CommandDef[] = [
       'return',
       'all',
     ],
-    run: ({ ui }) => {
+    getState: ({ flags }) => panel(flags.bulkProviderSwitchOpen),
+    run: ({ ui, flags }) => {
+      if (flags.bulkProviderSwitchOpen) {
+        ui.closeBulkProviderSwitch()
+        return
+      }
       ui.openBulkProviderSwitch()
       ui.closePalette()
     },
@@ -316,7 +331,12 @@ export const sessionCommands: CommandDef[] = [
       'recent',
       'history',
     ],
-    run: ({ ui }) => {
+    getState: ({ flags }) => panel(flags.promptSearchOpen),
+    run: ({ ui, flags }) => {
+      if (flags.promptSearchOpen) {
+        ui.closePromptSearch()
+        return
+      }
       ui.openPromptSearch()
       ui.closePalette()
     },
diff --git a/src/renderer/src/features/workspace/commands/tabCommands.ts b/src/renderer/src/features/workspace/commands/tabCommands.ts
index 24c708af..9412700f 100644
--- a/src/renderer/src/features/workspace/commands/tabCommands.ts
+++ b/src/renderer/src/features/workspace/commands/tabCommands.ts
@@ -1,3 +1,4 @@
+import { panel } from '@renderer/features/command-palette/commandState'
 import type { CommandDef } from '@renderer/features/command-palette/types'
 
 export const tabCommands: CommandDef[] = [
@@ -7,6 +8,9 @@ export const tabCommands: CommandDef[] = [
     surface: 'app',
     title: 'New Tab',
     description: '**What it does:** Creates a **new tab** from a folder you choose.\n\n**Use when:** You want a separate project or workspace context.\n\n**Notes:** Starts a fresh agent in that folder.',
+    // NOT a toggle. `pathPickerOpen` is the SHARED path modal, not "the new-tab
+    // picker" — the resume flow opens the same one with a pre-filled cwd — so a
+    // boolean cannot say which request put it there. Escape dismisses it.
     run: ({ ui }) => ui.openNewTabPicker(),
   },
   {
@@ -44,7 +48,14 @@ export const tabCommands: CommandDef[] = [
     description: '**What it does:** Opens a picker to rearrange **tab order**.\n\n**Use when:** Your tabs are in the wrong order.\n\n**Notes:** Changes apply after you confirm the modal.',
     keywords: ['move tabs', 'arrange tabs', 'tab order'],
     when: ({ workspace }) => workspace.state.tabs.length > 1,
-    run: ({ ui }) => ui.openReorderTabs(),
+    getState: ({ flags }) => panel(flags.reorderTabsOpen),
+    run: ({ ui, flags }) => {
+      if (flags.reorderTabsOpen) {
+        ui.closeReorderTabs()
+        return
+      }
+      ui.openReorderTabs()
+    },
   },
   {
     id: 'resume-session',
@@ -53,6 +64,15 @@ export const tabCommands: CommandDef[] = [
     title: 'Resume Session',
     description: '**What it does:** Opens the **resume session** flow.\n\n**Use when:** You want to continue an old Claude or Codex session.\n\n**Notes:** Uses the focused project folder as the default.',
     keepPaletteOpen: true,
-    run: ({ ui }) => ui.enterResumeMode(),
+    run: ({ ui, flags }) => {
+      // Already showing this mode? Dismiss. A mode-entering command whose
+      // second press re-enters the mode it is already in reads as a dead key,
+      // which is the same complaint that started this whole change.
+      if (flags.paletteMode === 'resume') {
+        ui.closePalette()
+        return
+      }
+      ui.enterResumeMode()
+    },
   },
 ]
diff --git a/src/renderer/src/workspace/tile-tree/useKeybinds.ts b/src/renderer/src/workspace/tile-tree/useKeybinds.ts
index 67ba5721..fe80ab14 100644
--- a/src/renderer/src/workspace/tile-tree/useKeybinds.ts
+++ b/src/renderer/src/workspace/tile-tree/useKeybinds.ts
@@ -4,6 +4,7 @@ import { useAppStore } from '@renderer/app-state/hooks'
 import { buildDefaultKeybindings } from '@renderer/features/command-keybindings/defaults'
 import type { BindingContext } from '@renderer/features/command-keybindings/defaults'
 import { keybindingFromEvent } from '@renderer/features/command-keybindings/normalize'
+import { commandOwnsOpenSurface } from '@renderer/features/command-palette/surfaceOwnership'
 import { resolveEffectiveKeybindings } from '@renderer/features/command-keybindings/resolve'
 import { hasAppInteractionOwner } from '@renderer/lib/interaction-ownership'
 import type { Workspace } from '@renderer/workspace/workspaceStore'
@@ -230,6 +231,10 @@ function routedCommandForEvent(
   return null
 }
 
+/** The only context a chord may fire in while a surface owns the interaction.
+ *  See the exemption in the handler for why this is not the live context set. */
+const GLOBAL_CONTEXT_ONLY: ReadonlySet<BindingContext> = new Set<BindingContext>(['global'])
+
 /** Chord -> candidate commands, built once per override change. */
 function buildBindingIndex(
   overrides: Record<string, string[]>,
@@ -331,6 +336,28 @@ export function useKeybinds(
       // defaults for chords that Agent Code itself claims (Cmd+W is the
       // important one — otherwise macOS closes the window after we return).
       if (hasAppInteractionOwner()) {
+        // ONE exemption: the chord that owns the surface currently holding the
+        // interaction. Pressing ⌘⇧U while Usage is up is unambiguously "dismiss
+        // Usage" — it cannot be a stray shortcut leaking into a modal, because
+        // the modal is the thing this command controls.
+        //
+        // Without this, every toggle written in a command body is unreachable
+        // by keyboard: the second press never gets past this gate, so the
+        // command's `run` is never called. That is why ⌥R Reader and ⌥S
+        // Spotlight round-trip today while ⌘⇧U does not — the former render
+        // inline and stamp no owner marker, the latter is a Radix dialog. The
+        // difference was never in the commands.
+        //
+        // Context is deliberately 'global' only. A surface owns the screen, so
+        // a grid- or dispatch-scoped binding has no business firing underneath
+        // it; only an app-wide chord can mean "dismiss the thing in front of
+        // me".
+        const dismissCommandId = routedCommandForEvent(e, bindingIndex, GLOBAL_CONTEXT_ONLY)
+        if (dismissCommandId && commandOwnsOpenSurface(dismissCommandId, useAppStore.getState())) {
+          e.preventDefault()
+          requestCommandInvocation(dismissCommandId, 'keybinding')
+          return
+        }
         if (shouldPreventOwnedApplicationShortcut(e)) e.preventDefault()
         return
       }