Refresh slash popup in place instead of close+reopen

openSlashCommands closed and reopened the palette overlay on every
filter keystroke, and closeSlashPopup routes through closeInsetOverlay
which fires notifyOverlayClosed — releasing the host long enough for a
queued permission/operator gate to drain onto it mid-typing. Mirror the
@-mention popup fix (PR #515): when the slash popup is already open,
refresh its items via setOverlayItems instead, leaving priorOverlay
stacking untouched.

Author: TheGreatAxios

src/tui/shell.ts

@@ -5199,6 +5199,39 @@ export function openSlashCommands(shell: AppShell): boolean {
     closeSlashPopup(shell)
     return false
   }
+
+  // Every keystroke lands here while the popup is already open. Closing and
+  // reopening released the overlay host between the two calls (closeSlashPopup
+  // routes through closeInsetOverlay, which fires notifyOverlayClosed) — long
+  // enough for a queued permission/operator gate to drain onto it. Refreshing
+  // the open palette in place never releases the host, so a queued gate has
+  // nothing to drain into. priorOverlay stacking is untouched here (it is only
+  // ever written by openListOverlay's stack-on-open path), so a palette
+  // stacked over a prior overlay keeps that snapshot across the refresh.
+  if (isSlashPopupOpen(shell) && shell.overlayKind === "palette") {
+    shell.paletteCommands = matches
+    const bag = internals.get(shell)
+    if (bag) {
+      bag.paletteFilter = {
+        query: bag.paletteFilter?.query ?? "",
+        title: "commands · /",
+        catalog: matches,
+        typeToFilter: false,
+      }
+      bag.overlayDescribe = (id) => {
+        const cmd = matches.find((c) => c.id === id)
+        const what = cmd?.description?.trim()
+        return what ? { what } : null
+      }
+    }
+    setOverlayItems(
+      shell,
+      paletteLabels(matches),
+      matches.map((c) => c.id),
+    )
+    return true
+  }
+
   closeSlashPopup(shell)
   openPalette(shell, { catalog: matches, title: "commands · /" })
   slashPopups.add(shell)

src/tui/slash-popup-gate.test.ts

@@ -0,0 +1,115 @@
+/**
+ * CL-6699: a queued permission/operator gate must not open onto the host in
+ * the middle of a `/` command filter session. The old close-then-reopen
+ * refresh (closeSlashPopup -> closeInsetOverlay -> notifyOverlayClosed)
+ * released the host between the two calls, and a gate queued behind the
+ * popup drained into that gap.
+ */
+import { EventEmitter } from "node:events"
+import { describe, expect, test } from "bun:test"
+
+import { withTestRenderer } from "./harness"
+import type { PaletteCommand } from "./command-catalog"
+import { wireGates } from "./gate-wire"
+import {
+  createAppShell,
+  isSlashPopupOpen,
+  type AppShell,
+} from "./shell"
+
+const CATALOG: readonly PaletteCommand[] = [
+  {
+    id: "model",
+    label: "/model",
+    description: "Open model picker",
+    keywords: ["model", "Open model picker", "slash", "command"],
+  },
+  { id: "mcp", label: "/mcp" },
+  { id: "compact", label: "/compact" },
+]
+
+type Ctx = {
+  readonly shell: AppShell
+  readonly press: (key: string) => void
+  readonly render: () => Promise<void>
+}
+
+function withShell(fn: (ctx: Ctx) => Promise<void>): Promise<void> {
+  return withTestRenderer(
+    async (h) => {
+      const shell = createAppShell(h.renderer, {
+        terminal: { columns: 80, rows: 24 },
+        wireKeys: true,
+        run: "idle",
+        paletteCatalog: CATALOG,
+      })
+      try {
+        await fn({
+          shell,
+          press: (key) => h.pressKey(key as Parameters<typeof h.pressKey>[0]),
+          render: h.renderOnce,
+        })
+      } finally {
+        shell.dispose()
+      }
+    },
+    { width: 80, height: 24 },
+  )
+}
+
+describe("/ popup keeps a queued gate queued across a filter refresh", () => {
+  test("filter keystroke while a gate is queued", async () => {
+    await withShell(async ({ shell, press }) => {
+      const emitter = new EventEmitter()
+      const dispose = wireGates(emitter, shell)
+      try {
+        press("/")
+        expect(isSlashPopupOpen(shell)).toBe(true)
+        expect(shell.overlayKind).toBe("palette")
+
+        let resolved: unknown
+        emitter.emit("permission.gate", {
+          request: {
+            tool: "run_shell",
+            action: "Run shell command",
+            subject: "bun test",
+            scopes: [],
+          },
+          resolve: (outcome: unknown) => {
+            resolved = outcome
+          },
+        })
+
+        // Queued, not opened — the slash popup still owns the host.
+        expect(shell.overlayKind).toBe("palette")
+        expect(resolved).toBeUndefined()
+
+        // Refreshing the filter must not release the host to the queued gate.
+        press("m")
+        expect(shell.prompt.value).toBe("/m")
+        expect(shell.overlayKind).toBe("palette")
+        expect(isSlashPopupOpen(shell)).toBe(true)
+        expect(shell.paletteCommands.map((c) => c.id)).toEqual([
+          "model",
+          "mcp",
+        ])
+        expect(resolved).toBeUndefined()
+
+        // Filtering keeps working after the refresh.
+        press("o")
+        expect(shell.prompt.value).toBe("/mo")
+        expect(shell.paletteCommands.map((c) => c.id)).toEqual(["model"])
+        expect(isSlashPopupOpen(shell)).toBe(true)
+        expect(resolved).toBeUndefined()
+
+        // A true dismiss still drains the queue as before.
+        press("Escape")
+        await Bun.sleep(60)
+        expect(shell.overlayKind).toBe("permissions")
+        expect(resolved).toBeUndefined()
+      } finally {
+        dispose()
+      }
+    })
+  })
+})