Query dialogs: reopening Search/Select shows the same results right away

Reopening the Search or Select dialog restored the session's mode, term, and
filters, but the result list didn't come back: the content area sat on the empty
state until the user made one edit or pressed Enter, which re-ran the query. The
fix makes reopen show "the same results in the same order" immediately.

Root cause: `hasSearched` in `QueryDialog.svelte` was a component-local
`$state(false)`, reset on every mount, and nothing re-triggered a run on reopen.
So even though the surviving `QueryFilterState` singleton still held the prior
results, the render chain fell back to the idle/empty state.

Two levers, both in `QueryDialog.svelte`:
- Seed `hasSearched` from `getLastRunQuery() !== null` (the precise "a prior run
  exists" flag, nulled by `⌘N`/`clearCore`) so persisted results render on mount.
- For a restored NON-AI session (prior run + a non-empty query or active filter),
  `onMount` sets the existing `runOnMount` one-shot so the query re-runs: Select
  re-derives the matcher against the freshly-snapshotted current folder (more
  correct than rendering rows from the old folder), Search re-hits the index.

AI restored sessions are deliberately excluded from the re-run gate so reopen
never re-calls the cloud (cost); the seeded `hasSearched` renders the persisted
results as-is. A first-ever open (no prior run) still rests on the empty state,
and `⌘N` still clears to the empty state.

Unified the prefill and reopen "is there anything to run?" check behind one
`hasRestorableQuery()` predicate (now also counts a type-only filter, matching
Selection's `hasActiveFilter`).

Tests: `SearchDialog` reopen re-runs once on mount, AI reopen makes no translate
call, first-ever open and post-`⌘N` reopen don't auto-run; `SelectionDialog`
reopen re-derives against the CURRENT folder (proven by reopening on a different
folder and asserting the committed indices), plus a first-open empty-state guard.
Red verified by reverting the `QueryDialog` change.

Author: vdavid

apps/desktop/src/lib/query-ui/CLAUDE.md

@@ -42,6 +42,14 @@ popover, and the `createQueryFilterState()` factory. Filter-chip internals live
 - **Don't wipe state from `onDestroy` / any lifecycle hook.** The dialog mounts on open and unmounts on close; state
   survives unmount by design. The ONLY sanctioned reset is `⌘N` (the consumer's clear hook). Wiping on unmount turns
   every close+reopen into lost work.
+- **Reopen re-derives results so they show immediately, not the empty state.** `hasSearched` is component-local (resets
+  to `false` each mount), so it's seeded from `getLastRunQuery() !== null` (the precise "a prior run exists" flag,
+  nulled by `⌘N`/`clearCore`) so persisted results render on mount. For a restored NON-AI session (a prior run + a
+  non-empty query or active filter, via `hasRestorableQuery()`), `onMount` sets `runOnMount` so the query re-runs:
+  Select re-derives against the freshly-snapshotted current folder (more correct than showing rows from the old folder),
+  Search re-hits the index. AI restored sessions must NOT re-run (cloud cost): the `onMount` gate excludes
+  `mode === 'ai'`, so the seeded `hasSearched` renders the persisted results without re-calling translate. A first-ever
+  open (no prior run) still rests on the empty state.
 - **⌘⏎ and ⇧⏎ are explicit no-ops** (swallowed with `preventDefault`); bare Enter is the only key that runs a search or
   opens the cursor row, dispatched via `enterAction`. `⌘N` is captured before the dialog's `stopPropagation` so it
   doesn't reach the route-level new-tab handler.

apps/desktop/src/lib/query-ui/DETAILS.md

@@ -81,8 +81,18 @@ thin centered bar; it's NOT a `<header>` landmark, which would collide with the
 The orchestrator's `$effect` block on `state.getRunOnMount()` consumes the one-shot prefill flag. It clears the flag
 BEFORE dispatching so downstream state writes can't re-trigger the effect. Cold-open (dialog mounts with the flag
 pre-set, e.g. MCP `open_search_dialog`) and hot-prefill (the flag flips while the dialog is already open, e.g. a
-recent-search activation) flow through the same path. AI mode honors the explicit-trigger contract because the prefill
-caller's `autoRun: true` IS the explicit trigger.
+recent-search activation) flow through the same path. The effect dispatches when there's anything runnable, via the
+shared `hasRestorableQuery()` predicate (non-empty query OR size/date/type filter active). AI mode honors the
+explicit-trigger contract because the prefill caller's `autoRun: true` IS the explicit trigger.
+
+A third producer of `runOnMount` is the reopen path. `onMount` sets the flag when the surviving state holds a restorable
+NON-AI session (`getLastRunQuery() !== null` AND `hasRestorableQuery()` AND `mode !== 'ai'`), so the dialog re-derives
+results on reopen instead of resting on the empty state: Select re-runs the matcher against the freshly-snapshotted
+current folder (more correct than rendering rows from the old folder), Search re-hits the index. AI restored sessions
+are excluded from this gate (cloud cost); they render the persisted results because `hasSearched` is seeded from
+`getLastRunQuery() !== null` at component init. For Search the index may not be ready when `onMount` fires; the effect's
+`config.isIndexReady` guard skips the run, and Search's own `search-index-ready` listener re-sets `runOnMount` once the
+index loads, so the re-run still lands.
 
 ### Test coverage
 
@@ -344,7 +354,10 @@ still typing their query.
 
 **State preservation across close + reopen**: The factory's `$state` survives dialog unmount. Closing the dialog (Escape
 or overlay click) does NOT wipe query, mode, filters, scope, results, or cursor. The only reset path is `⌘N` inside the
-dialog, which calls the consumer's clear hook.
+dialog, which calls the consumer's clear hook. On reopen the dialog shows those results immediately rather than the
+empty state: `hasSearched` is seeded from `getLastRunQuery() !== null`, and a restored non-AI session re-runs on mount
+(see the `runOnMount` consumer section) so the rows reflect the folder open now. AI sessions render the persisted
+results without re-calling the cloud.
 
 **`⌘N` shortcut**: Hard-coded in the dialog's `handleModifierShortcuts`. Captured before the dialog's global
 `stopPropagation` would let it reach the route-level `⌘N` (new tab) handler. The choice of `⌘N` matches the macOS "new

apps/desktop/src/lib/query-ui/QueryDialog.svelte

@@ -72,7 +72,16 @@
     let debounceTimer: ReturnType<typeof setTimeout> | undefined
     let unlistenAutoApply: (() => void) | undefined
     let highlightedFields: SvelteSet<string> = new SvelteSet<string>()
-    let hasSearched = $state(false)
+    /**
+     * Whether a run's results are the current content. Seeded from the surviving state so a
+     * close + reopen shows the SAME results immediately, not the empty state. `lastRunQuery`
+     * is non-null exactly when a run has landed and hasn't been cleared by `⌘N` (`clearCore`
+     * nulls it), so it's the precise "a prior run exists" signal. On a first-ever open it's
+     * null, so we still start on the empty state. For non-AI restored sessions we additionally
+     * re-run on mount (see `onMount`) so Select re-derives against the current folder; AI
+     * restored sessions render these persisted results WITHOUT re-calling the cloud.
+     */
+    let hasSearched = $state(config.state.getLastRunQuery() !== null)
     /**
      * IME composition flag. While true, `scheduleSearch` is a no-op so we don't fire
      * mid-character on Chinese/Japanese/Korean input. On `compositionend` the bar
@@ -185,6 +194,21 @@
         }
     })
 
+    /**
+     * Whether the current state has anything runnable: a non-empty query OR an active filter
+     * (size ≠ any, date ≠ any, or type ≠ both). The single source of truth for "is there a
+     * session worth running?", shared by the `runOnMount` effect and the reopen re-run gate in
+     * `onMount`. Type counts: a "Folders"-only Selection run is a valid filter-only query.
+     */
+    function hasRestorableQuery(): boolean {
+        return (
+            config.state.getQuery().trim() !== '' ||
+            config.state.getSizeFilter() !== 'any' ||
+            config.state.getDateFilter() !== 'any' ||
+            config.state.getTypeFilter() !== 'both'
+        )
+    }
+
     /**
      * Single consumer for the `runOnMount` one-shot flag. Fires both on cold-open
      * (dialog mounts with the flag pre-set, e.g. MCP `open_search_dialog`) and on
@@ -203,11 +227,9 @@
         // the prefilled query runs.
         hasSearched = false
         const trimmed = config.state.getQuery().trim()
-        const hasFilters =
-            config.state.getSizeFilter() !== 'any' || config.state.getDateFilter() !== 'any'
         if (trimmed && config.state.getMode() === 'ai' && config.aiEnabled) {
             void runAiSearch(trimmed)
-        } else if (config.isIndexReady && (trimmed || hasFilters)) {
+        } else if (config.isIndexReady && hasRestorableQuery()) {
             void executeQuery()
         }
         // Otherwise: prefill arrived but nothing to run. The dialog rests on the empty
@@ -254,6 +276,21 @@
         // until the user edits the query/filters or results arrive.
         config.state.setLastDialogEvent('opened')
 
+        // Reopen-with-results: when the surviving state holds a restorable session (a prior
+        // run, plus a non-empty query or an active filter) re-derive it on mount so the user
+        // sees the same results immediately, not the empty state. For non-AI modes we re-run
+        // the query (cheap: Select re-derives against the freshly-snapshotted current folder,
+        // which is MORE correct than showing rows from the old folder; Search re-hits the
+        // index). AI mode never auto-runs (cloud cost): `hasSearched` was already seeded from
+        // the prior run, so its persisted results render as-is without re-calling translate.
+        if (
+            config.state.getLastRunQuery() !== null &&
+            config.state.getMode() !== 'ai' &&
+            hasRestorableQuery()
+        ) {
+            config.state.setRunOnMount(true)
+        }
+
         // Live-mirror `search.autoApply`. Shared key across consumers (no separate
         // `selection.autoApply` setting; the auto-apply contract is the same one).
         unlistenAutoApply = onSpecificSettingChange('search.autoApply', (_id, value) => {

apps/desktop/src/lib/search/SearchDialog.svelte.test.ts

@@ -213,6 +213,108 @@ describe('SearchDialog state preservation and ⌘N', () => {
   })
 })
 
+describe('SearchDialog reopen re-runs so results show', () => {
+  beforeEach(() => {
+    clearSearchState()
+    aiProvider = 'off'
+    autoApplySetting = false // run only on explicit Enter so we count runs precisely
+    autoApplyListeners.clear()
+    searchFilesMock.mockClear()
+    translateSearchQueryMock.mockClear()
+  })
+
+  it('a restored non-AI session re-runs the query on reopen (results, not the empty state)', async () => {
+    // First open: type a query and run it once.
+    const first = await mountDialog()
+    setQuery('*.png')
+    dispatchKey(first.overlay, 'Enter')
+    await tick()
+    await new Promise((r) => setTimeout(r, 0))
+    await tick()
+    expect(searchFilesMock).toHaveBeenCalledTimes(1)
+
+    // Close and reopen. The reopen must re-derive results on mount WITHOUT the user
+    // touching anything: pre-fix, `hasSearched` reset to false and nothing re-ran, so the
+    // content area sat on the empty state until a manual edit / Enter.
+    first.cleanup()
+    searchFilesMock.mockClear()
+    const second = await mountDialog()
+    await tick()
+    await new Promise((r) => setTimeout(r, 0))
+    await tick()
+    expect(searchFilesMock).toHaveBeenCalledTimes(1)
+    second.cleanup()
+  })
+
+  it('a restored AI session shows persisted results WITHOUT re-calling the cloud on reopen', async () => {
+    aiProvider = 'cloud'
+    translateSearchQueryMock.mockResolvedValueOnce({
+      display: { namePattern: '*.png', patternType: 'glob' },
+      query: {},
+      caveat: null,
+    } as unknown as TranslateResult)
+    // First open: run an AI search (one translate + one searchFiles).
+    const first = await mountDialog()
+    setMode('ai')
+    setQuery('all screenshots')
+    dispatchKey(first.overlay, 'Enter')
+    await new Promise((r) => setTimeout(r, 0))
+    await tick()
+    await new Promise((r) => setTimeout(r, 0))
+    await tick()
+    expect(translateSearchQueryMock).toHaveBeenCalledTimes(1)
+
+    // Reopen. AI mode must NOT re-call translate (cloud cost); the persisted results render
+    // from the surviving state instead.
+    first.cleanup()
+    translateSearchQueryMock.mockClear()
+    searchFilesMock.mockClear()
+    const second = await mountDialog()
+    await tick()
+    await new Promise((r) => setTimeout(r, 0))
+    await tick()
+    expect(translateSearchQueryMock).not.toHaveBeenCalled()
+    expect(searchFilesMock).not.toHaveBeenCalled()
+    second.cleanup()
+  })
+
+  it('a first-ever open (no prior run) shows the empty state and does not auto-run', async () => {
+    const { overlay, cleanup } = await mountDialog()
+    await tick()
+    await new Promise((r) => setTimeout(r, 0))
+    await tick()
+    // Nothing ran, and the empty state is visible.
+    expect(searchFilesMock).not.toHaveBeenCalled()
+    expect(overlay.querySelector('.empty-state, [data-testid="empty-state"]') ?? overlay.textContent).toBeTruthy()
+    cleanup()
+  })
+
+  it('⌘N returns to the empty state and clears the prior-run marker (no re-run on next reopen)', async () => {
+    const first = await mountDialog()
+    setQuery('*.png')
+    dispatchKey(first.overlay, 'Enter')
+    await tick()
+    await new Promise((r) => setTimeout(r, 0))
+    await tick()
+    expect(searchFilesMock).toHaveBeenCalledTimes(1)
+
+    // ⌘N clears the session (query + the prior-run marker `lastRunQuery`).
+    dispatchKey(first.overlay, 'n', true)
+    await tick()
+    expect(getQuery()).toBe('')
+
+    // Reopen: with no query and no prior run, nothing re-runs and the empty state stands.
+    first.cleanup()
+    searchFilesMock.mockClear()
+    const second = await mountDialog()
+    await tick()
+    await new Promise((r) => setTimeout(r, 0))
+    await tick()
+    expect(searchFilesMock).not.toHaveBeenCalled()
+    second.cleanup()
+  })
+})
+
 describe('SearchDialog mode shortcuts (AI on)', () => {
   beforeEach(() => {
     clearSearchState()

apps/desktop/src/lib/selection-dialog/SelectionDialog.svelte.test.ts

@@ -605,6 +605,54 @@ describe('SelectionDialog', () => {
     second.cleanup()
   })
 
+  it('reopen re-derives results against the CURRENT folder (not stale rows from the first folder)', async () => {
+    // Live-smoke fix: reopening a restored session must show the same query's results
+    // immediately, re-derived against the folder open NOW. We prove the re-run happened by
+    // reopening on a DIFFERENT folder and asserting Enter commits indices computed against
+    // the new folder. Pre-fix, nothing re-ran on mount: the content sat idle until an edit.
+    const matched: number[][] = []
+
+    // First folder: two PNGs at indices 0 and 2.
+    const first = await mountDialog({
+      entries: [buildEntry('a.png'), buildEntry('b.txt'), buildEntry('c.png')],
+      onCommit: (idxs) => matched.push(idxs),
+    })
+    const firstInput = first.overlay.querySelector('input[type="text"], input:not([type])') as HTMLInputElement
+    firstInput.value = '*.png'
+    firstInput.dispatchEvent(new Event('input', { bubbles: true }))
+    await tick()
+    await new Promise((r) => setTimeout(r, 1100)) // auto-apply debounce → a run lands
+    await tick()
+    first.cleanup()
+
+    // Second folder, DIFFERENT shape: a single PNG, now at index 1.
+    const second = await mountDialog({
+      entries: [buildEntry('x.txt'), buildEntry('y.png'), buildEntry('z.txt')],
+      onCommit: (idxs) => matched.push(idxs),
+    })
+    // Let the reopen re-run settle (no typing).
+    await tick()
+    await new Promise((r) => setTimeout(r, 0))
+    await tick()
+    // Enter commits immediately — the result set is already re-derived against the new folder.
+    dispatchKey(second.overlay, 'Enter')
+    await tick()
+    expect(matched).toHaveLength(1)
+    expect(matched[0]).toEqual([1]) // y.png in the SECOND folder, not [0, 2] from the first
+    second.cleanup()
+  })
+
+  it('first-ever open shows the empty state and does not auto-run', async () => {
+    // A clean session (after ⌘N / first launch) must rest on the empty state with examples,
+    // never an auto-run. `clearSelectionState()` in beforeEach gives us the clean slate.
+    const { overlay, cleanup } = await mountDialog()
+    await tick()
+    await new Promise((r) => setTimeout(r, 0))
+    await tick()
+    expect(overlay.querySelector('.empty-state')).toBeTruthy()
+    cleanup()
+  })
+
   it('matches on a size filter alone when the name bar is empty', async () => {
     // The headline M2 fix: a `≥ 1 MB` size filter with an EMPTY name pattern must
     // select every file ≥ 1 MB. Before the fix, `buildMatchQuery` returned null on