From f5388731dd261fe9948a7935dd3de23c915a421b Mon Sep 17 00:00:00 2001
From: Julius Olsson <julius.olsson05@gmail.com>
Date: Sun, 26 Jul 2026 23:22:13 +0200
Subject: [PATCH 1/7] docs: plan uniform command activation semantics

Six classification agents swept all 99 catalog commands and the surface
wiring after a user report that Alt+P does nothing.

The rule this establishes: invoking a command that shows a surface makes it
visible; invoking it again dismisses it -- from EVERY invocation source, not
just from inside the palette.

Three independent layers break that today, and no single-layer fix is
sufficient. A toggle written in a command body is unreachable if the router
refuses the second keypress; a router fix is pointless if the command has no
way to ask whether it is already open.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 ...2026-07-26-command-activation-semantics.md | 217 ++++++++++++++++++
 1 file changed, 217 insertions(+)
 create mode 100644 docs/superpowers/plans/2026-07-26-command-activation-semantics.md

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..7bfb4eb7
--- /dev/null
+++ b/docs/superpowers/plans/2026-07-26-command-activation-semantics.md
@@ -0,0 +1,217 @@
+# 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.

From 1319dbba348c627a9b650046c8d650d7947dc45b Mon Sep 17 00:00:00 2001
From: Julius Olsson <julius.olsson05@gmail.com>
Date: Sun, 26 Jul 2026 23:26:02 +0200
Subject: [PATCH 2/7] fix(commands): un-transpose the editor guards, scope
 buried admission, drop dead bridge members

Seven discrete defects the classification sweep turned up. Independent of
the three activation layers the plan describes; landing first because one
of them is a regression.

THE EDITOR GUARDS WERE SWAPPED. `save-editor-file` carried
`globalEditorOpen || focusedCwd` plus a comment describing Cmd+Alt+E
fullscreen, and `toggle-editor-fullscreen` carried `when: globalEditorOpen`.
Each broke in its own direction:

  - Cmd+Alt+E with the editor CLOSED was a silent no-op. `when` runs during
    admission, before `run`, so the branch that opens the editor straight
    into fullscreen was unreachable from all four invocation sources. That
    branch is the intended behavior -- the migrated comment says so
    outright: "the chord has always meant 'give me a big editor' as ONE
    gesture... or routing would silently drop half the feature." Routing
    did. This is a regression from the governance PR, which moved the chord
    off a hard-coded keybind branch onto the command.
  - File -> Save with the editor closed was ADMITTED and did nothing.
    `requestSaveActiveEditorFile` dispatches a window event whose only
    listener is EditorWorkbench, which does not mount until the editor is
    open.

Each guard now sits on the command it describes, with the comment.

OPEN-IF-CLOSED IS NOW IDEMPOTENT. `ui.toggleGlobalEditor` was the only
editor primitive on the command bridge, so four call sites wanting "make
sure the editor is up" each wrote read-then-toggle against `flags
.globalEditorOpen` -- a value snapshotted when the CommandContext memo was
built. A stale `true` CLOSES the editor the user just asked to open.
`openGlobalEditor`/`closeGlobalEditor` already existed on the store; they
are now on the bridge, and all four sites use them.

BURIED ADMISSION AGREES WITH THE LIST. `revive-pane` and `kill-buried-pane`
checked `state.buried.length > 0` across the whole workspace while the
picker filters by `sourceTabId`, so both could be admitted from a tab with
nothing buried and land on an empty list.

DEAD BRIDGE MEMBERS REMOVED. Eight members of `CommandContext.ui` had zero
command call sites: openResumePicker, openAgentStatusPanel,
closeAgentStatusPanel, toggleStatusMode, toggleWorktreeBadges,
toggleUsageHeader, cycleUsageHeaderLevel, setDangerousAgentsEnabled. Their
store subscriptions, object-literal entries and memo deps went with them --
removing the type alone would have left exactly the mechanism-with-no-
consumer shape this whole sweep exists to find. Plus a dead
`toggleCommandPalette` subscription in App.tsx and three unused
commandState imports.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 src/renderer/src/app/App.tsx                  |  1 -
 .../commands/agentStatusCommands.ts           |  2 +-
 .../src/features/command-palette/types.ts     | 13 +++---
 .../command-palette/ui/CommandPalette.tsx     | 34 ++++-----------
 .../commands/globalEditorCommands.ts          | 42 ++++++++++++++-----
 .../settings/commands/settingsCommands.ts     |  2 +-
 .../workspace/commands/paneCommands.ts        | 25 ++++++++++-
 7 files changed, 69 insertions(+), 50 deletions(-)

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/types.ts b/src/renderer/src/features/command-palette/types.ts
index 2894a28a..7c4c5eed 100644
--- a/src/renderer/src/features/command-palette/types.ts
+++ b/src/renderer/src/features/command-palette/types.ts
@@ -186,7 +186,6 @@ export type CommandContext = {
   workspace: Workspace
   ui: {
     openNewTabPicker: () => void
-    openResumePicker: (defaultCwd: string) => void
     openTileTabs: () => void
     openReorderTabs: () => void
     openSettings: () => void
@@ -215,12 +214,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 +249,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
diff --git a/src/renderer/src/features/command-palette/ui/CommandPalette.tsx b/src/renderer/src/features/command-palette/ui/CommandPalette.tsx
index 57b944e0..d55c57d3 100644
--- a/src/renderer/src/features/command-palette/ui/CommandPalette.tsx
+++ b/src/renderer/src/features/command-palette/ui/CommandPalette.tsx
@@ -269,20 +269,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 +297,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],
@@ -557,7 +549,6 @@ function OpenCommandPalette({
       workspace,
       ui: {
         openNewTabPicker: onNewTabRequest,
-        openResumePicker: onResumeRequest,
         openTileTabs: onTileTabsRequest,
         openReorderTabs: onReorderTabsRequest,
         openSettings: onSettingsRequest,
@@ -585,12 +576,12 @@ function OpenCommandPalette({
         toggleRenderingDebugMode,
         toggleTailAllMode,
         toggleDevDebugPanel,
-        openAgentStatusPanel,
-        closeAgentStatusPanel,
         toggleAgentStatusPanel,
         togglePerformancePanel,
         toggleRemotePanel,
         toggleCaffeinate,
+        openGlobalEditor: openGlobalEditorAction,
+        closeGlobalEditor: closeGlobalEditorAction,
         toggleGlobalEditor,
         toggleFileTreeVisible,
         enterDispatchMode,
@@ -600,11 +591,6 @@ function OpenCommandPalette({
         openDispatchAttach,
         openLinkedAgent,
         openPinAgents,
-        toggleStatusMode,
-        toggleWorktreeBadges,
-        toggleUsageHeader,
-        cycleUsageHeaderLevel,
-        setDangerousAgentsEnabled,
         setAggressiveDebugPersistence,
         enterResumeMode,
         enterBuriedMode,
@@ -676,12 +662,12 @@ function OpenCommandPalette({
       toggleRenderingDebugMode,
       toggleTailAllMode,
       toggleDevDebugPanel,
-      openAgentStatusPanel,
-      closeAgentStatusPanel,
       toggleAgentStatusPanel,
       togglePerformancePanel,
       toggleRemotePanel,
       toggleCaffeinate,
+      openGlobalEditorAction,
+      closeGlobalEditorAction,
       toggleGlobalEditor,
       toggleFileTreeVisible,
       enterDispatchMode,
@@ -691,11 +677,6 @@ function OpenCommandPalette({
       openDispatchAttach,
       openLinkedAgent,
       openPinAgents,
-      toggleStatusMode,
-      toggleWorktreeBadges,
-      toggleUsageHeader,
-      cycleUsageHeaderLevel,
-      setDangerousAgentsEnabled,
       setAggressiveDebugPersistence,
       enterResumeMode,
       enterBuriedMode,
@@ -1110,7 +1091,8 @@ 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],
diff --git a/src/renderer/src/features/global-editor/commands/globalEditorCommands.ts b/src/renderer/src/features/global-editor/commands/globalEditorCommands.ts
index abe1477e..758863d3 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
       }
diff --git a/src/renderer/src/features/settings/commands/settingsCommands.ts b/src/renderer/src/features/settings/commands/settingsCommands.ts
index b4af157a..0aa5dd6e 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[] = [
   {
diff --git a/src/renderer/src/features/workspace/commands/paneCommands.ts b/src/renderer/src/features/workspace/commands/paneCommands.ts
index 32056fc5..be645d3e 100644
--- a/src/renderer/src/features/workspace/commands/paneCommands.ts
+++ b/src/renderer/src/features/workspace/commands/paneCommands.ts
@@ -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',
@@ -386,7 +400,14 @@ 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,
+    // 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 }) => ui.enterBuriedMode(),
   },
   {
@@ -398,7 +419,7 @@ 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,
+    when: ({ workspace }) => buriedInActiveTab(workspace) > 0,
     run: ({ ui }) => ui.enterKillBuriedMode(),
   },
   {

From 34c600c2b1fbf376e6cd07431721872714facea7 Mon Sep 17 00:00:00 2001
From: Julius Olsson <julius.olsson05@gmail.com>
Date: Sun, 26 Jul 2026 23:31:19 +0200
Subject: [PATCH 3/7] fix(palette): move the sub-mode into the store so chords
 can reach it
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Nine commands did nothing when invoked by a keybinding or the native menu.
Two of them ship default chords, so they were dead from the keyboard in the
shipped app: Resume Session (Cmd+Shift+R) and Prompt Template (Alt+P). The
user reported Alt+P; the sweep found the other eight.

The family is every command whose `run` calls `ui.enterXMode()` — the two
buried commands, the three prompt-template ones, the three AI-workspace
ones, and Resume Session.

WHY THEY FAILED. A chord does not open the palette. It sets
`pendingCommandInvocation`, which mounts the palette host INVISIBLY
(`visible={false}`), runs the command, and unmounts it in the same commit.
`ui.enterXMode` was a `useState` setter on that host, so the mode was
written to a component that was already invisible and about to be
destroyed.

A second mechanism would have killed it even if the host had survived: the
mount-time reset effect calls `setMode('commands')`, and passive effects
run AFTER layout effects in the same commit, so 'commands' was queued last
and won. StrictMode double-invokes it for good measure.

`keepPaletteOpen: true` never helped and was never going to. It is read
only by the palette's OWN executeCommand; the chord path goes through
`dispatchCommand`, which has no such branch. Nine commands have been
declaring a flag that does nothing outside the palette.

THE FIX. `paletteMode` becomes uiShell state, and `setPaletteMode` also
sets `commandPaletteOpen: true` — the open is the correctness fix, not a
convenience, because a sub-mode is only meaningful rendered and every
caller wanted the palette up. Coupling them in the action means a future
mode-entry point cannot forget it. Closing resets the mode, so reopening
never resumes an abandoned sub-flow.

Store state has no component lifecycle, so neither mechanism can reach it.
That is the whole argument -- there is no effect-ordering claim to get
wrong. The tempting three-edit alternative (open the palette in `run`,
extend the excluded-id set, skip the reset when an invocation was pending)
was rejected for the opposite reason: omitting any one part leaves the bug,
and its correctness rests entirely on React's effect ordering.

Two consequences worth noting. The mount reset now skips entirely when the
mount was caused by a pending invocation, because that command may have
seeded state synchronously and the passive reset would wipe it. And the
close-after-run rule now asks the LIVE flag — "did this command turn the
palette on?" — instead of consulting a hardcoded id list that held only
`open-command-palette` and could never have covered these nine.

Tests drive the store rather than the component, deliberately: the bug was
not a rendering bug, it was state having a lifecycle it should not have had.
Verified they fail when `setPaletteMode` stops opening the palette.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 src/renderer/src/app-state/store.test.ts      | 93 +++++++++++++++++++
 src/renderer/src/app-state/types.ts           |  3 +
 src/renderer/src/app-state/uiShell/slice.ts   | 27 +++++-
 src/renderer/src/app-state/uiShell/types.ts   | 19 ++++
 .../features/command-palette/paletteMode.ts   | 41 ++++++++
 .../command-palette/ui/CommandPalette.tsx     | 54 ++++++-----
 6 files changed, 210 insertions(+), 27 deletions(-)
 create mode 100644 src/renderer/src/features/command-palette/paletteMode.ts

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..9dbfa53f 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,
@@ -39,6 +40,8 @@ export type UiShellSlice = UiShellState & {
   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..336f202c 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,30 @@ 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'),
+    set({ commandPaletteOpen: false, paletteMode: DEFAULT_PALETTE_MODE }, false, 'uiShell/closeCommandPalette'),
   toggleCommandPalette: () =>
-    set(state => ({ commandPaletteOpen: !state.commandPaletteOpen }), false, 'uiShell/toggleCommandPalette'),
+    set(state => ({
+      commandPaletteOpen: !state.commandPaletteOpen,
+      paletteMode: DEFAULT_PALETTE_MODE,
+    }), false, 'uiShell/toggleCommandPalette'),
+
+  /**
+   * 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/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/ui/CommandPalette.tsx b/src/renderer/src/features/command-palette/ui/CommandPalette.tsx
index d55c57d3..6682ce8b 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,7 @@ 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 { useAppStore } from '@renderer/app-state/hooks'
 import { useCaffeinateStore } from '@renderer/features/caffeinate/store'
 import { useDevDebugConfig } from '@renderer/features/debug/devDebugConfig'
@@ -98,20 +98,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
@@ -332,7 +318,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[]>([])
@@ -862,10 +852,20 @@ function OpenCommandPalette({
     return paletteCommands[selectedIndex] ?? null
   }, [mode, paletteCommands, selectedIndex])
 
+  // Mount reset. Deliberately SKIPPED when this mount was caused by a pending
+  // command invocation: a chord mounts this component in order to run a
+  // command, and that command may have just seeded the mode (store) and the
+  // template form (local) synchronously inside the layout effect above. This
+  // effect is passive, so it runs AFTER that — resetting here would wipe the
+  // very state the invocation existed to produce.
+  //
+  // `mode` is no longer reset here at all; `closeCommandPalette` owns that, so
+  // reopening starts clean without this effect racing a mode-entering command.
+  const mountedForPendingCommand = useRef(pendingMenuCommand !== null)
   useEffect(() => {
+    if (mountedForPendingCommand.current) return
     setQuery('')
     setSelectedIndex(0)
-    setMode('commands')
     setSessions([])
     setSessionsLoading(false)
     setAiWorkspaces([])
@@ -958,13 +958,19 @@ 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.
+    //
+    // 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])

From f342a6fdb4d5f5a84511c515f9254e125295e653 Mon Sep 17 00:00:00 2001
From: Julius Olsson <julius.olsson05@gmail.com>
Date: Sun, 26 Jul 2026 23:34:23 +0200
Subject: [PATCH 4/7] feat(keybindings): let a chord dismiss the surface its
 own command owns

`useKeybinds` bails out of the entire key handler while any Radix dialog is
mounted. That gate is correct and load-bearing -- without it, Cmd+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 up.

That is the whole explanation for why some chords round-trip and some do
not, and none of it was in the commands:

  Alt+R Reader, Alt+S Spotlight   round-trip   render inline, no owner marker
  Agent Status                    round-trips  plain <aside>
  Cmd+Shift+U Usage               dead         Radix dialog
  Remote Panel                    dead         Radix dialog, though its store
                                               action is already a correct toggle

Without this commit, every toggle written in a command body would be
unreachable by keyboard: the second press never reaches the binding router,
so `run` is never called.

THE EXEMPTION IS ONE CASE. A chord crosses the gate only when it maps to
the command that owns the surface currently holding the interaction.
Pressing Cmd+Shift+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 that command controls. Context is restricted to 'global': a surface
owns the screen, so a grid- or dispatch-scoped binding has no business
firing underneath it.

WHY A TABLE rather than asking the command via `getState(ctx)?.value ===
'on'`, which would be derived and could not drift: evaluating `getState`
needs a CommandContext, and building one assembles ~76 workspace actions.
Deferring exactly that cost is why 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 traded for a keyboard nicety. Drift is bounded by types instead:
the value is `keyof UiShellState`, and the commands read the same flag
through `CommandContext.flags`.

The table deliberately excludes per-target pickers (a second press should
RE-TARGET, not close), the two commands that write something on the way in
(Save Debug Logs, Attach Recording Note), the Settings page (a destination,
not a peek), and the palette itself. Those exclusions are pinned by a test,
so dropping one later is a decision rather than an accident.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 .../keybindingBaseline.test.ts                | 59 ++++++++++++++
 .../command-palette/surfaceOwnership.ts       | 81 +++++++++++++++++++
 .../src/workspace/tile-tree/useKeybinds.ts    | 27 +++++++
 3 files changed, 167 insertions(+)
 create mode 100644 src/renderer/src/features/command-palette/surfaceOwnership.ts

diff --git a/src/renderer/src/features/command-palette/keybindingBaseline.test.ts b/src/renderer/src/features/command-palette/keybindingBaseline.test.ts
index 6071de7c..e4d76f5d 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 { 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,61 @@ 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', () => {
+    // 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('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)
+    }
+  })
+})
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..b8fe8cd8
--- /dev/null
+++ b/src/renderer/src/features/command-palette/surfaceOwnership.ts
@@ -0,0 +1,81 @@
+import type { UiShellState } from '@renderer/app-state/uiShell/types'
+
+// ---------------------------------------------------------------------------
+// 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.
+// ---------------------------------------------------------------------------
+
+/**
+ * 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',
+  'new-tab': 'pathPickerOpen',
+} as const satisfies Record<string, keyof UiShellState>
+
+export type SurfaceOwningCommandId = keyof typeof SURFACE_OWNER_FLAGS
+
+/**
+ * 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]>,
+): boolean {
+  const flag = SURFACE_OWNER_FLAGS[commandId as SurfaceOwningCommandId]
+  if (!flag) return false
+  return state[flag] === true
+}
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
       }

From 8ac304b36098c550b09c5dd94a4985a2c0efcedd Mon Sep 17 00:00:00 2001
From: Julius Olsson <julius.olsson05@gmail.com>
Date: Sun, 26 Jul 2026 23:38:50 +0200
Subject: [PATCH 5/7] feat(commands): let surface commands see their own
 surface, and dismiss it

Ten surfaces were open-only: invoking the command again did nothing,
because the command had no way to ask whether it was already open. The
store knew, and every `close*` action already existed -- neither was
reachable from a command. Only `closePalette` was on the bridge.

Usage, Keyboard Shortcuts, Agent Activity, Close Old Agents, Switch Agents,
Prompt Search, Remote Panel, Reorder Tabs, Pin Agents and the New Tab path
picker now round-trip, each following the `tiled-tabs` pattern that was
already in the tree: 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.

Every 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 -- so all three are done for all
ten, and the count is visible in the diff.

WHAT IS DELIBERATELY NOT HERE. The nine per-target surfaces store a
`SessionId | null`, not a boolean, and collapsing that would lose the case
that matters: pressing the chord while View Prompts is open for a DIFFERENT
session must re-target, not close. 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. The palette itself would
flicker on a double-tap. Those exclusions are pinned by a test rather than
left implicit.

`toggle-remote-panel` needed only the badge: its store action was already a
correct toggle, but `remotePanelOpen` was the one panel flag missing from
`flags`, making it the sole panel command in the app with no Open/Closed
state while eleven siblings had one.

The new test asserts every command in the surface-ownership table has a
`getState`. It failed on first run and caught a real gap -- `usage.open`
toggled but reported nothing -- which is the point: the table lets a chord
cross the interaction gate, and the command's own state and run are what
dismiss once it does. A command listed there without a badge is one whose
second press reaches a `run` that may still only open, which is precisely
the reported bug wearing a different hat.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 .../keybindingBaseline.test.ts                | 12 ++++
 .../src/features/command-palette/types.ts     | 50 ++++++++++++++++
 .../command-palette/ui/CommandPalette.tsx     | 57 +++++++++++++++++++
 .../remote/commands/remoteCommands.ts         |  6 ++
 .../settings/commands/settingsCommands.ts     |  9 ++-
 .../features/usage/commands/usageCommands.ts  | 13 ++++-
 .../workspace/commands/paneCommands.ts        | 11 +++-
 .../workspace/commands/sessionCommands.ts     | 30 ++++++++--
 .../workspace/commands/tabCommands.ts         | 19 ++++++-
 9 files changed, 196 insertions(+), 11 deletions(-)

diff --git a/src/renderer/src/features/command-palette/keybindingBaseline.test.ts b/src/renderer/src/features/command-palette/keybindingBaseline.test.ts
index e4d76f5d..df809752 100644
--- a/src/renderer/src/features/command-palette/keybindingBaseline.test.ts
+++ b/src/renderer/src/features/command-palette/keybindingBaseline.test.ts
@@ -428,6 +428,18 @@ describe('surface ownership', () => {
     expect(commandOwnsOpenSurface('split-vertical', { usageModalOpen: true } as never)).toBe(false)
   })
 
+  it('gives every listed 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.
+    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('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
diff --git a/src/renderer/src/features/command-palette/types.ts b/src/renderer/src/features/command-palette/types.ts
index 7c4c5eed..7b8558ff 100644
--- a/src/renderer/src/features/command-palette/types.ts
+++ b/src/renderer/src/features/command-palette/types.ts
@@ -259,6 +259,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: {
@@ -268,6 +284,40 @@ 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 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 6682ce8b..1cc0d510 100644
--- a/src/renderer/src/features/command-palette/ui/CommandPalette.tsx
+++ b/src/renderer/src/features/command-palette/ui/CommandPalette.tsx
@@ -245,6 +245,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)
@@ -299,6 +308,16 @@ function OpenCommandPalette({
   const usageHeaderLevel = settings.usageHeaderLevel
   const dangerousAgentsEnabled = settings.dangerousAgentsEnabled
   const aggressiveDebugPersistenceEnabled = settings.aggressiveDebugPersistence
+  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)
@@ -556,6 +575,15 @@ function OpenCommandPalette({
         openRewindPrompt,
         openAgentViewModePicker,
         openColorFlagPicker,
+        closeUsageModal,
+        closeKeyboardShortcuts,
+        closeAgentActivity,
+        closeCloseOldAgents,
+        closeBulkProviderSwitch,
+        closePromptSearch,
+        closeReorderTabs,
+        closePinAgents,
+        closePathPicker,
         openUsageModal,
         toggleGitBar,
         toggleWorktreesBar,
@@ -600,6 +628,16 @@ function OpenCommandPalette({
         usageHeaderLevel,
         dangerousAgentsEnabled,
         aggressiveDebugPersistenceEnabled,
+        usageModalOpen,
+        keyboardShortcutsOpen,
+        agentActivityOpen,
+        closeOldAgentsOpen,
+        bulkProviderSwitchOpen,
+        promptSearchOpen,
+        remotePanelOpen,
+        reorderTabsOpen,
+        pinAgentsOpen,
+        pathPickerOpen,
         gitBarOpen,
         worktreesBarOpen,
         debugPanelOpen,
@@ -642,6 +680,15 @@ function OpenCommandPalette({
       openBulkProviderSwitch,
       openRewindPrompt,
       openAgentViewModePicker,
+      closeUsageModal,
+      closeKeyboardShortcuts,
+      closeAgentActivity,
+      closeCloseOldAgents,
+      closeBulkProviderSwitch,
+      closePromptSearch,
+      closeReorderTabs,
+      closePinAgents,
+      closePathPicker,
       openUsageModal,
       toggleGitBar,
       toggleWorktreesBar,
@@ -684,6 +731,16 @@ function OpenCommandPalette({
       usageHeaderLevel,
       dangerousAgentsEnabled,
       aggressiveDebugPersistenceEnabled,
+      usageModalOpen,
+      keyboardShortcutsOpen,
+      agentActivityOpen,
+      closeOldAgentsOpen,
+      bulkProviderSwitchOpen,
+      promptSearchOpen,
+      remotePanelOpen,
+      reorderTabsOpen,
+      pinAgentsOpen,
+      pathPickerOpen,
       gitBarOpen,
       worktreesBarOpen,
       debugPanelOpen,
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 0aa5dd6e..09106394 100644
--- a/src/renderer/src/features/settings/commands/settingsCommands.ts
+++ b/src/renderer/src/features/settings/commands/settingsCommands.ts
@@ -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 be645d3e..f631bb98 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,
@@ -176,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
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..072501be 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,7 +8,14 @@ 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.',
-    run: ({ ui }) => ui.openNewTabPicker(),
+    getState: ({ flags }) => panel(flags.pathPickerOpen),
+    run: ({ ui, flags }) => {
+      if (flags.pathPickerOpen) {
+        ui.closePathPicker()
+        return
+      }
+      ui.openNewTabPicker()
+    },
   },
   {
     id: 'close-tab',
@@ -44,7 +52,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',

From 3830badd5d5e24dd2de6176d246afcb7305256d4 Mon Sep 17 00:00:00 2001
From: Julius Olsson <julius.olsson05@gmail.com>
Date: Sun, 26 Jul 2026 23:39:19 +0200
Subject: [PATCH 6/7] docs: record the activation-semantics outcome and the
 decisions taken

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 ...2026-07-26-command-activation-semantics.md | 65 +++++++++++++++++++
 1 file changed, 65 insertions(+)

diff --git a/docs/superpowers/plans/2026-07-26-command-activation-semantics.md b/docs/superpowers/plans/2026-07-26-command-activation-semantics.md
index 7bfb4eb7..c5774024 100644
--- a/docs/superpowers/plans/2026-07-26-command-activation-semantics.md
+++ b/docs/superpowers/plans/2026-07-26-command-activation-semantics.md
@@ -215,3 +215,68 @@ toggle action exists.
 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.

From 2b3ef4edd029352cc91218966c5fb5f649e24e9b Mon Sep 17 00:00:00 2001
From: Julius Olsson <julius.olsson05@gmail.com>
Date: Mon, 27 Jul 2026 13:15:49 +0200
Subject: [PATCH 7/7] fix(commands): resolve both reviewers' findings

Two orchestrated reviewers read the branch independently. Codex: 2 high, 0
critical. Claude: 10 findings, none breaking types or tests. All valid, all
fixed.

THE RULE WAS DELIVERED FOR HALF THE BUG REPORT. Phase 1 turned Alt+P and
Cmd+Shift+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 -- so Phase 2, which exists precisely to make a dialog-backed
surface dismissable by its own chord, skipped the two chords the whole change
started from. Alt+P's second press was worse than inert: Alt chords over a text
target are not preventDefault-ed, so macOS composed a pi into the palette query.

The nine now compare `flags.paletteMode` and dismiss. They live in a SECOND
table, and that split was found by a failing test rather than by design: merging
both kinds of ownership into one map type-checked, and implied Resume Session
should carry an Open/Closed badge. It should not -- "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 TABLE'S TYPE DID NOT DO WHAT ITS COMMENT CLAIMED. `keyof UiShellState`
accepts any of ~40 keys including the nine `SessionId | null` ones, where
`=== true` is permanently false -- silent, and exactly the failure the module's
own test says it guards. Narrowed to boolean-valued keys; sabotage-verified that
a nullable flag now fails to compile.

THE MOUNT-RESET EFFECT WAS UNREACHABLE. `mountedForPendingCommand` is never
false: `openCommandPalette`'s only caller is a command, and commands run from
inside an already-mounted host. Its state resets were redundant on a fresh
mount, but its focus call was not -- focus now keys on `visible`.

new-tab REMOVED from the toggle set: `pathPickerOpen` means "the shared path
modal is open", not "the new-tab picker is open", which is the same
boolean-loses-information problem the session-scoped surfaces were kept out for.
Live consequences settled it -- Cmd+T dismissed the picker mid-submit during a
slow spawn, and a create action had started rendering an Open/Closed badge.

Plus: `toggleCommandPalette` deleted (Phase 5 removed its only reader and Phase 1
then gave it new behavior -- mechanism-with-no-consumer, inside the sweep for
that shape); `openResumePicker`'s removal had left a destructure and a memo dep
behind; the live-flag close rule holds only for a synchronous open and now says
so; one dep array was wrong and misindented, in the commit about dep arrays.

New test: nothing proved a toggle's `run` closed the RIGHT surface. It 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*`.

tsc -b --force clean, check:keybindings OK (39 sets), 246/246 test files.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 ...2026-07-26-command-activation-semantics.md | 72 +++++++++++++++++
 src/renderer/src/app-state/types.ts           |  1 -
 src/renderer/src/app-state/uiShell/slice.ts   |  6 --
 .../keybindingBaseline.test.ts                | 58 ++++++++++++-
 .../command-palette/surfaceOwnership.ts       | 72 ++++++++++++++++-
 .../src/features/command-palette/types.ts     | 12 +++
 .../command-palette/ui/CommandPalette.tsx     | 81 +++++++++++--------
 .../commands/globalEditorCommands.ts          | 33 +++++++-
 .../commands/promptTemplateCommands.ts        | 31 ++++++-
 .../workspace/commands/paneCommands.ts        | 22 ++++-
 .../workspace/commands/tabCommands.ts         | 23 +++---
 11 files changed, 347 insertions(+), 64 deletions(-)

diff --git a/docs/superpowers/plans/2026-07-26-command-activation-semantics.md b/docs/superpowers/plans/2026-07-26-command-activation-semantics.md
index c5774024..e2180d7d 100644
--- a/docs/superpowers/plans/2026-07-26-command-activation-semantics.md
+++ b/docs/superpowers/plans/2026-07-26-command-activation-semantics.md
@@ -280,3 +280,75 @@ 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/types.ts b/src/renderer/src/app-state/types.ts
index 9dbfa53f..a08852c7 100644
--- a/src/renderer/src/app-state/types.ts
+++ b/src/renderer/src/app-state/types.ts
@@ -39,7 +39,6 @@ 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
diff --git a/src/renderer/src/app-state/uiShell/slice.ts b/src/renderer/src/app-state/uiShell/slice.ts
index 336f202c..2b0cc3e2 100644
--- a/src/renderer/src/app-state/uiShell/slice.ts
+++ b/src/renderer/src/app-state/uiShell/slice.ts
@@ -77,12 +77,6 @@ export const createUiShellSlice: StateCreator<
     set({ commandPaletteOpen: true, paletteMode: DEFAULT_PALETTE_MODE }, false, 'uiShell/openCommandPalette'),
   closeCommandPalette: () =>
     set({ commandPaletteOpen: false, paletteMode: DEFAULT_PALETTE_MODE }, false, 'uiShell/closeCommandPalette'),
-  toggleCommandPalette: () =>
-    set(state => ({
-      commandPaletteOpen: !state.commandPaletteOpen,
-      paletteMode: DEFAULT_PALETTE_MODE,
-    }), false, 'uiShell/toggleCommandPalette'),
-
   /**
    * Enter a sub-mode, MAKING THE PALETTE VISIBLE.
    *
diff --git a/src/renderer/src/features/command-palette/keybindingBaseline.test.ts b/src/renderer/src/features/command-palette/keybindingBaseline.test.ts
index df809752..ce464382 100644
--- a/src/renderer/src/features/command-palette/keybindingBaseline.test.ts
+++ b/src/renderer/src/features/command-palette/keybindingBaseline.test.ts
@@ -1,6 +1,6 @@
 import { describe, expect, it } from 'vitest'
 
-import { SURFACE_OWNER_FLAGS, commandOwnsOpenSurface } from '@renderer/features/command-palette/surfaceOwnership'
+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'
 
@@ -408,6 +408,9 @@ 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)) {
@@ -428,18 +431,68 @@ describe('surface ownership', () => {
     expect(commandOwnsOpenSurface('split-vertical', { usageModalOpen: true } as never)).toBe(false)
   })
 
-  it('gives every listed command a state badge that reports its surface', () => {
+  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
@@ -456,6 +509,7 @@ describe('surface ownership', () => {
       '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/surfaceOwnership.ts b/src/renderer/src/features/command-palette/surfaceOwnership.ts
index b8fe8cd8..004a363e 100644
--- a/src/renderer/src/features/command-palette/surfaceOwnership.ts
+++ b/src/renderer/src/features/command-palette/surfaceOwnership.ts
@@ -1,4 +1,5 @@
 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.
@@ -41,8 +42,37 @@ import type { UiShellState } from '@renderer/app-state/uiShell/types'
 // (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".
  *
@@ -60,11 +90,39 @@ export const SURFACE_OWNER_FLAGS = {
   'toggle-remote-panel': 'remotePanelOpen',
   'reorder-tabs': 'reorderTabsOpen',
   'pin-agents': 'pinAgentsOpen',
-  'new-tab': 'pathPickerOpen',
-} as const satisfies Record<string, keyof UiShellState>
+} 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?
  *
@@ -73,8 +131,16 @@ export type SurfaceOwningCommandId = keyof typeof SURFACE_OWNER_FLAGS
  */
 export function commandOwnsOpenSurface(
   commandId: string,
-  state: Pick<UiShellState, (typeof SURFACE_OWNER_FLAGS)[SurfaceOwningCommandId]>,
+  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 7b8558ff..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'
@@ -298,6 +299,17 @@ export type CommandContext = {
      * 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. */
diff --git a/src/renderer/src/features/command-palette/ui/CommandPalette.tsx b/src/renderer/src/features/command-palette/ui/CommandPalette.tsx
index 1cc0d510..7987b46b 100644
--- a/src/renderer/src/features/command-palette/ui/CommandPalette.tsx
+++ b/src/renderer/src/features/command-palette/ui/CommandPalette.tsx
@@ -65,6 +65,7 @@ import { commandTargetSessionId } from '@renderer/workspace/hook/selectors/comma
 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'
@@ -166,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
@@ -225,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(() => {
@@ -308,6 +319,7 @@ 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)
@@ -628,6 +640,8 @@ function OpenCommandPalette({
         usageHeaderLevel,
         dangerousAgentsEnabled,
         aggressiveDebugPersistenceEnabled,
+        commandPaletteOpen: commandPaletteOpenFlag,
+        paletteMode: mode,
         usageModalOpen,
         keyboardShortcutsOpen,
         agentActivityOpen,
@@ -669,7 +683,6 @@ function OpenCommandPalette({
     [
       workspace,
       onNewTabRequest,
-      onResumeRequest,
       onTileTabsRequest,
       onReorderTabsRequest,
       onSettingsRequest,
@@ -731,6 +744,8 @@ function OpenCommandPalette({
       usageHeaderLevel,
       dangerousAgentsEnabled,
       aggressiveDebugPersistenceEnabled,
+      commandPaletteOpenFlag,
+      mode,
       usageModalOpen,
       keyboardShortcutsOpen,
       agentActivityOpen,
@@ -909,38 +924,26 @@ function OpenCommandPalette({
     return paletteCommands[selectedIndex] ?? null
   }, [mode, paletteCommands, selectedIndex])
 
-  // Mount reset. Deliberately SKIPPED when this mount was caused by a pending
-  // command invocation: a chord mounts this component in order to run a
-  // command, and that command may have just seeded the mode (store) and the
-  // template form (local) synchronously inside the layout effect above. This
-  // effect is passive, so it runs AFTER that — resetting here would wipe the
-  // very state the invocation existed to produce.
+  // Focus the search input whenever the palette becomes VISIBLE.
   //
-  // `mode` is no longer reset here at all; `closeCommandPalette` owns that, so
-  // reopening starts clean without this effect racing a mode-entering command.
-  const mountedForPendingCommand = useRef(pendingMenuCommand !== null)
+  // 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(() => {
-    if (mountedForPendingCommand.current) return
-    setQuery('')
-    setSelectedIndex(0)
-    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)))
@@ -1020,6 +1023,14 @@ function OpenCommandPalette({
     // 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
@@ -1155,10 +1166,10 @@ function OpenCommandPalette({
     (workspaceId: string) => {
       useGlobalEditorStore.getState().openAiWorkspace(workspaceId)
       // Idempotent open — see the note on `ui.openGlobalEditor`.
-    openGlobalEditorAction()
+      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 758863d3..726dc9a3 100644
--- a/src/renderer/src/features/global-editor/commands/globalEditorCommands.ts
+++ b/src/renderer/src/features/global-editor/commands/globalEditorCommands.ts
@@ -163,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',
@@ -175,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',
@@ -187,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/workspace/commands/paneCommands.ts b/src/renderer/src/features/workspace/commands/paneCommands.ts
index f631bb98..14e523d7 100644
--- a/src/renderer/src/features/workspace/commands/paneCommands.ts
+++ b/src/renderer/src/features/workspace/commands/paneCommands.ts
@@ -415,7 +415,16 @@ export const paneCommands: CommandDef[] = [
     // 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 }) => ui.enterBuriedMode(),
+    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',
@@ -427,7 +436,16 @@ export const paneCommands: CommandDef[] = [
     keywords: ['kill', 'buried', 'hidden', 'pane', 'session', 'pane'],
     keepPaletteOpen: true,
     when: ({ workspace }) => buriedInActiveTab(workspace) > 0,
-    run: ({ ui }) => ui.enterKillBuriedMode(),
+    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/tabCommands.ts b/src/renderer/src/features/workspace/commands/tabCommands.ts
index 072501be..9412700f 100644
--- a/src/renderer/src/features/workspace/commands/tabCommands.ts
+++ b/src/renderer/src/features/workspace/commands/tabCommands.ts
@@ -8,14 +8,10 @@ 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.',
-    getState: ({ flags }) => panel(flags.pathPickerOpen),
-    run: ({ ui, flags }) => {
-      if (flags.pathPickerOpen) {
-        ui.closePathPicker()
-        return
-      }
-      ui.openNewTabPicker()
-    },
+    // 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(),
   },
   {
     id: 'close-tab',
@@ -68,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()
+    },
   },
 ]