Command palette: Recents on empty query (last 10, LRU)

- Empty-query view leads with the user's recently executed commands, most-recent first. Cursor defaults to index 0, so Enter re-runs the last command.
- Recents persist in the Tauri store (`recentCommandIds`); capped at 10; dedup-and-prepend on every Enter / click.
- Replaces the old "persist last query across opens" behavior — single mechanism covers the same reopen case AND gives the previous 9 commands one arrow press away.
- New API in `app-status-store`: `loadRecentCommands` / `pushRecentCommand` (plus pure `dedupAndPrependRecent` for unit testing). Old `loadPaletteQuery` / `savePaletteQuery` removed.
- `searchCommands(query, recentCommandIds?)` filters stale IDs through `getPaletteCommands()` so removed/renamed entries drop silently.

Author: vdavid

apps/desktop/src/lib/app-status-store.recents.test.ts

@@ -0,0 +1,25 @@
+import { describe, it, expect } from 'vitest'
+import { dedupAndPrependRecent, RECENT_COMMANDS_LIMIT } from './app-status-store'
+
+describe('dedupAndPrependRecent', () => {
+  it('prepends a new ID to the front', () => {
+    expect(dedupAndPrependRecent(['b', 'c'], 'a')).toEqual(['a', 'b', 'c'])
+  })
+
+  it('moves an existing ID to the front (LRU)', () => {
+    expect(dedupAndPrependRecent(['a', 'b', 'c'], 'c')).toEqual(['c', 'a', 'b'])
+  })
+
+  it('keeps the list at most RECENT_COMMANDS_LIMIT entries', () => {
+    const existing = Array.from({ length: RECENT_COMMANDS_LIMIT }, (_, i) => `cmd${i}`)
+    const next = dedupAndPrependRecent(existing, 'new')
+    expect(next).toHaveLength(RECENT_COMMANDS_LIMIT)
+    expect(next[0]).toBe('new')
+    // The oldest entry was dropped.
+    expect(next).not.toContain(`cmd${RECENT_COMMANDS_LIMIT - 1}`)
+  })
+
+  it('starts a new list from an empty input', () => {
+    expect(dedupAndPrependRecent([], 'a')).toEqual(['a'])
+  })
+})

apps/desktop/src/lib/app-status-store.ts

@@ -222,33 +222,48 @@ export async function saveLastUsedPathForVolume(volumeId: string, path: string):
 }
 
 // ============================================================================
-// Command palette query persistence
+// Command palette recents persistence
 // ============================================================================
 
+export const RECENT_COMMANDS_LIMIT = 10
+
 /**
- * Loads the last used command palette query.
- * Returns empty string if not previously saved.
+ * Pure update step for the recents list: move `commandId` to the front,
+ * drop any prior occurrence, cap at RECENT_COMMANDS_LIMIT. Exposed for testing.
  */
-export async function loadPaletteQuery(): Promise<string> {
+export function dedupAndPrependRecent(existing: string[], commandId: string): string[] {
+  return [commandId, ...existing.filter((id) => id !== commandId)].slice(0, RECENT_COMMANDS_LIMIT)
+}
+
+/**
+ * Loads the list of recently executed command IDs, most-recent first.
+ * Returns an empty array if nothing was saved or parsing fails.
+ */
+export async function loadRecentCommands(): Promise<string[]> {
   try {
     const store = await getStore()
-    const query = await store.get('paletteQuery')
-    return typeof query === 'string' ? query : ''
+    const raw = await store.get('recentCommandIds')
+    if (!Array.isArray(raw)) return []
+    return raw.filter((id): id is string => typeof id === 'string').slice(0, RECENT_COMMANDS_LIMIT)
   } catch {
-    return ''
+    return []
   }
 }
 
 /**
- * Saves the current command palette query for next time.
+ * Records a command execution. The given ID is moved to the front; if it was
+ * already in the list, the previous entry is dropped (no duplicates). The list
+ * is capped at RECENT_COMMANDS_LIMIT entries.
  */
-export async function savePaletteQuery(query: string): Promise<void> {
+export async function pushRecentCommand(commandId: string): Promise<void> {
   try {
     const store = await getStore()
-    await store.set('paletteQuery', query)
+    const existing = await loadRecentCommands()
+    const next = dedupAndPrependRecent(existing, commandId)
+    await store.set('recentCommandIds', next)
     await store.save()
   } catch {
-    // Silently fail
+    // Silently fail - persistence is nice-to-have
   }
 }
 

apps/desktop/src/lib/command-palette/CLAUDE.md

@@ -4,21 +4,21 @@ VS Code/Spotlight-style modal for searching and executing app commands via fuzzy
 
 ## Files
 
-| File                     | Purpose                                                                           |
-| ------------------------ | --------------------------------------------------------------------------------- |
-| `CommandPalette.svelte`  | Modal UI: keyboard nav, mouse hover, fuzzy-highlighted results, query persistence |
-| `CommandPalette.test.ts` | Vitest tests with mocked `$lib/commands` and `$lib/app-status-store`              |
+| File                     | Purpose                                                                          |
+| ------------------------ | -------------------------------------------------------------------------------- |
+| `CommandPalette.svelte`  | Modal UI: keyboard nav, mouse hover, fuzzy-highlighted results, recents on empty |
+| `CommandPalette.test.ts` | Vitest tests with mocked `$lib/commands` and `$lib/app-status-store`             |
 
 ## Data flow
 
 ```
 User presses ⌘⇧P
   → +page.svelte sets showCommandPalette = true
-  → CommandPalette mounts, loads persisted query from app-status-store, focuses input
-  → searchCommands(query) returns CommandMatch[] (reactive via $derived)
+  → CommandPalette mounts, loads recentCommandIds from app-status-store, focuses input
+  → searchCommands(query, recentCommandIds) returns CommandMatch[] (reactive via $derived)
   → User navigates with ↑/↓ (keyboard cursor) or mouse (hover cursor)
-  → Enter / click → onExecute(commandId) → handleCommandExecute() in command-dispatch.ts
-  → Escape / overlay click → query saved, onClose() called
+  → Enter / click → pushRecentCommand(id), onExecute(commandId) → handleCommandExecute()
+  → Escape / overlay click → onClose() called
 ```
 
 ## Key patterns
@@ -31,8 +31,12 @@ overlay).
 **Event propagation**: `stopPropagation()` is called on every `keydown` in the overlay `div`'s handler. This prevents
 the file list from scrolling or handling shortcuts behind the modal.
 
-**Query persistence**: `loadPaletteQuery` / `savePaletteQuery` from `$lib/app-status-store` (Tauri store). Query is
-loaded on mount; saved on Escape, Enter, and overlay-click close.
+**Recents on empty query**: `loadRecentCommands` / `pushRecentCommand` from `$lib/app-status-store` (Tauri store). On
+mount, the palette loads the recent command IDs and passes them to `searchCommands(query, recentCommandIds)`. When the
+query is empty, recents lead the result (most-recent first), then the rest of the palette commands in registry order. On
+every Enter / click, `pushRecentCommand(id)` records the execution: the ID moves to the front, duplicates are removed,
+the list is capped at 10. The query itself is not persisted across opens — the palette always opens empty so the user's
+last-executed command sits at index 0 (cursor default), making Enter re-run it.
 
 **Own overlay, no shared ModalDialog**: `CommandPalette` manages its own `position: fixed` overlay and `role="dialog"`
 ARIA attributes. It does not use the shared `ModalDialog` component.
@@ -61,9 +65,12 @@ Spotlight both have this behavior: arrow keys move a "hard" cursor, while mouse
 doesn't interfere with keyboard navigation. Arrow keys clear `hoveredIndex` so there's never two items highlighted at
 the same intensity. Without this separation, moving the mouse would fight keyboard navigation.
 
-**Decision**: Query persisted across open/close via `app-status-store`. **Why**: Users often open the palette, run a
-command, then reopen to run a related command. Preserving the query saves retyping. Saved on every close path (Escape,
-Enter, overlay click) to ensure nothing is lost.
+**Decision**: Empty-query view shows recents (last 10 executed commands, most-recent first) instead of persisting the
+last query. **Why**: Users tend to reach for the same handful of commands. Persisting the query only helped the "run a
+related command" reopen case; recents covers that AND every other reopen (the last-executed command is at index 0, so
+Enter re-runs it just like the old query-persist behavior, but the previous 9 commands are also one arrow press away).
+Single mechanism replaces two. Recents update on every Enter / click via `pushRecentCommand`, which dedups and caps
+at 10.
 
 **Decision**: `$derived` for search results instead of debounced input. **Why**: `searchCommands()` via uFuzzy is fast
 enough for ~60 commands that debouncing would only add latency. The `$derived` reactive binding reruns the search
@@ -100,5 +107,5 @@ Add the command to `$lib/commands/command-registry.ts` and handle the ID in the
 ## Dependencies
 
 - `$lib/commands` — `searchCommands`, `CommandMatch`
-- `$lib/app-status-store` — `loadPaletteQuery`, `savePaletteQuery`
+- `$lib/app-status-store` — `loadRecentCommands`, `pushRecentCommand`
 - CSS variables from `app.css` (`--z-modal`, `--color-accent-subtle`, `--color-bg-secondary`, etc.)

apps/desktop/src/lib/command-palette/CommandPalette.a11y.test.ts

@@ -12,8 +12,8 @@ import CommandPalette from './CommandPalette.svelte'
 import { expectNoA11yViolations } from '$lib/test-a11y'
 
 vi.mock('$lib/app-status-store', () => ({
-  loadPaletteQuery: vi.fn(() => Promise.resolve('')),
-  savePaletteQuery: vi.fn(() => Promise.resolve()),
+  loadRecentCommands: vi.fn(() => Promise.resolve([])),
+  pushRecentCommand: vi.fn(() => Promise.resolve()),
 }))
 
 vi.mock('$lib/commands', () => ({

apps/desktop/src/lib/command-palette/CommandPalette.svelte

@@ -5,12 +5,12 @@
      * Features:
      * - Fuzzy search with highlighted matches
      * - Keyboard navigation (↑/↓/Enter/Escape)
-     * - Persists last query across app restarts
+     * - Empty-query view lists recently executed commands, most-recent first
      * - Blocks keyboard events from propagating to file explorer
      */
     import { onDestroy, onMount, tick } from 'svelte'
     import { searchCommands, type CommandMatch } from '$lib/commands'
-    import { loadPaletteQuery, savePaletteQuery } from '$lib/app-status-store'
+    import { loadRecentCommands, pushRecentCommand } from '$lib/app-status-store'
 
     interface Props {
         /** Called when user selects a command */
@@ -22,6 +22,7 @@
     const { onExecute, onClose }: Props = $props()
 
     let query = $state('')
+    let recentCommandIds = $state<string[]>([])
     let cursorIndex = $state(0)
     let hoveredIndex = $state<number | null>(null)
     let inputElement: HTMLInputElement | undefined = $state()
@@ -34,8 +35,10 @@
      */
     let previousActiveElement: HTMLElement | null = null
 
-    // Derived: filtered and ranked results
-    const results = $derived(searchCommands(query))
+    // Derived: filtered and ranked results. When the query is empty, recents
+    // lead the list (most-recent first) so the cursor at index 0 lands on the
+    // user's last-executed command — Enter re-runs it.
+    const results = $derived(searchCommands(query, recentCommandIds))
 
     // Reset cursor position when query changes
     $effect(() => {
@@ -46,14 +49,11 @@
 
     onMount(() => {
         previousActiveElement = document.activeElement instanceof HTMLElement ? document.activeElement : null
-        // Load persisted query and focus input
-        void loadPaletteQuery().then((savedQuery) => {
-            query = savedQuery
-            void tick().then(() => {
-                inputElement?.focus()
-                inputElement?.select()
-            })
+        // Load recents so the empty-query view leads with the user's last-executed commands.
+        void loadRecentCommands().then((ids) => {
+            recentCommandIds = ids
         })
+        inputElement?.focus()
     })
 
     onDestroy(() => {
@@ -72,7 +72,6 @@
         switch (e.key) {
             case 'Escape':
                 e.preventDefault()
-                void savePaletteQuery(query)
                 onClose()
                 break
             case 'ArrowDown':
@@ -90,8 +89,9 @@
             case 'Enter':
                 e.preventDefault()
                 if (results[cursorIndex]) {
-                    void savePaletteQuery(query)
-                    onExecute(results[cursorIndex].command.id)
+                    const id = results[cursorIndex].command.id
+                    void pushRecentCommand(id)
+                    onExecute(id)
                 }
                 break
         }
@@ -105,14 +105,14 @@
     }
 
     function handleResultClick(index: number) {
-        void savePaletteQuery(query)
-        onExecute(results[index].command.id)
+        const id = results[index].command.id
+        void pushRecentCommand(id)
+        onExecute(id)
     }
 
     function handleOverlayClick(e: MouseEvent) {
         // Only close if clicking the overlay itself, not the modal content
         if (e.target === e.currentTarget) {
-            void savePaletteQuery(query)
             onClose()
         }
     }

apps/desktop/src/lib/command-palette/CommandPalette.test.ts

@@ -2,16 +2,17 @@ import { describe, it, expect, vi, beforeEach } from 'vitest'
 import { mount, unmount } from 'svelte'
 import { tick } from 'svelte'
 import CommandPalette from './CommandPalette.svelte'
+import { loadRecentCommands, pushRecentCommand } from '$lib/app-status-store'
 
 // Mock the app-status-store to avoid Tauri dependency in tests
 vi.mock('$lib/app-status-store', () => ({
-  loadPaletteQuery: vi.fn().mockResolvedValue(''),
-  savePaletteQuery: vi.fn().mockResolvedValue(undefined),
+  loadRecentCommands: vi.fn().mockResolvedValue([]),
+  pushRecentCommand: vi.fn().mockResolvedValue(undefined),
 }))
 
 // Mock the commands module to provide test data
 vi.mock('$lib/commands', () => ({
-  searchCommands: vi.fn((query: string) => {
+  searchCommands: vi.fn((query: string, recentIds: string[] = []) => {
     const allCommands = [
       { command: { id: 'app.quit', name: 'Quit Cmdr', scope: 'App', shortcuts: ['⌘Q'] }, matchedIndices: [] },
       { command: { id: 'app.about', name: 'About Cmdr', scope: 'App', shortcuts: [] }, matchedIndices: [] },
@@ -29,7 +30,18 @@ vi.mock('$lib/commands', () => ({
         matchedIndices: [],
       },
     ]
-    if (!query.trim()) return allCommands
+    if (!query.trim()) {
+      // Mirror the real implementation's recents-first ordering so tests can
+      // exercise the wiring without depending on the real fuzzy module.
+      const byId = new Map(allCommands.map((m) => [m.command.id, m]))
+      const recents = recentIds.flatMap((id) => {
+        const match = byId.get(id)
+        return match ? [match] : []
+      })
+      const recentSet = new Set(recents.map((m) => m.command.id))
+      const rest = allCommands.filter((m) => !recentSet.has(m.command.id))
+      return [...recents, ...rest]
+    }
     return allCommands.filter((c) => c.command.name.toLowerCase().includes(query.toLowerCase()))
   }),
 }))
@@ -43,6 +55,8 @@ describe('CommandPalette', () => {
     mockOnClose = vi.fn()
     // Mock scrollIntoView which isn't available in jsdom
     Element.prototype.scrollIntoView = vi.fn()
+    vi.mocked(loadRecentCommands).mockResolvedValue([])
+    vi.mocked(pushRecentCommand).mockClear()
   })
 
   it('renders the modal with search input', async () => {
@@ -290,6 +304,60 @@ describe('CommandPalette', () => {
     target.remove()
   })
 
+  it('leads the empty-query list with recents, most-recent first', async () => {
+    vi.mocked(loadRecentCommands).mockResolvedValue(['file.copyPath', 'app.about'])
+
+    const target = document.createElement('div')
+    mount(CommandPalette, {
+      target,
+      props: { onExecute: mockOnExecute, onClose: mockOnClose },
+    })
+
+    // Two ticks: one for onMount to start, one for the resolved recents to land.
+    await tick()
+    await tick()
+
+    const input = target.querySelector('input')
+    input?.focus()
+    input?.dispatchEvent(new KeyboardEvent('keydown', { key: 'Enter', bubbles: true }))
+    await tick()
+
+    expect(mockOnExecute).toHaveBeenCalledWith('file.copyPath')
+  })
+
+  it('records the executed command on Enter', async () => {
+    const target = document.createElement('div')
+    mount(CommandPalette, {
+      target,
+      props: { onExecute: mockOnExecute, onClose: mockOnClose },
+    })
+    await tick()
+
+    const input = target.querySelector('input')
+    input?.focus()
+    input?.dispatchEvent(new KeyboardEvent('keydown', { key: 'Enter', bubbles: true }))
+    await tick()
+
+    expect(pushRecentCommand).toHaveBeenCalledWith('app.quit')
+  })
+
+  it('records the executed command on click', async () => {
+    const target = document.createElement('div')
+    mount(CommandPalette, {
+      target,
+      props: { onExecute: mockOnExecute, onClose: mockOnClose },
+    })
+    await tick()
+
+    const items = target.querySelectorAll('[class*="result-item"]')
+    expect(items.length).toBeGreaterThan(1)
+    ;(items[1] as HTMLElement).dispatchEvent(new MouseEvent('click', { bubbles: true }))
+    await tick()
+
+    expect(pushRecentCommand).toHaveBeenCalledWith('app.about')
+    expect(mockOnExecute).toHaveBeenCalledWith('app.about')
+  })
+
   it('does not throw if the previously focused element is no longer in the DOM', async () => {
     const trigger = document.createElement('button')
     document.body.appendChild(trigger)

apps/desktop/src/lib/commands/CLAUDE.md

@@ -8,7 +8,7 @@ Centralized command registry and fuzzy search engine for the command palette.
 | ---------------------- | ---------------------------------------------------------------------------------------- |
 | `types.ts`             | `Command`, `CommandMatch`, `CommandScope` types                                          |
 | `command-registry.ts`  | The `commands` array — single source of truth. `getPaletteCommands()` filter.            |
-| `fuzzy-search.ts`      | `searchCommands(query)` using `@leeoniya/ufuzzy`                                         |
+| `fuzzy-search.ts`      | `searchCommands(query, recentCommandIds?)` using `@leeoniya/ufuzzy`                      |
 | `index.ts`             | Barrel re-export                                                                         |
 | `fuzzy-search.test.ts` | Vitest tests: empty query, exact/fuzzy matches, ranking, index bounds, palette filtering |
 
@@ -46,14 +46,16 @@ keyboard routing is handled by each UI component.
 
 ## Fuzzy search
 
-`searchCommands(query)` wraps `@leeoniya/ufuzzy`:
+`searchCommands(query, recentCommandIds?)` wraps `@leeoniya/ufuzzy`:
 
 ```
-query empty → return all getPaletteCommands() with matchedIndices: []
+query empty →
+  recents (filtered through getPaletteCommands to drop stale IDs) first,
+  then the rest of getPaletteCommands() in registry order
 query non-empty →
   haystack = paletteCommands.map(c => c.name)
   [idxs, info, order] = fuzzy.search(haystack, query)
-  order.map(...) → CommandMatch[] ranked by relevance
+  order.map(...) → CommandMatch[] ranked by relevance (recents argument ignored)
 ```
 
 uFuzzy configuration: