Search: rebuild dialog shell, no reset on close

- Bump dialog width 900 -> 1080 px to fit upcoming chip rows and path-pill column
- Replace heavy row borders with tonal-surface separation, hairlines only where needed
- Taller search input (larger font, more padding) on the pattern row
- Soften column header to match the FullList pattern
- Drop resetSearchState on unmount: close + reopen now preserves query, filters, scope, results, cursor
- Add clearSearchState; wire Cmd+N to it and refocus the active input
- Cover Cmd+N and state preservation with Vitest
- Update lib/search/CLAUDE.md with the new contract and a Gotcha against unmount-time resets

Author: vdavid

apps/desktop/src/lib/search/AiSearchRow.svelte

@@ -73,13 +73,14 @@
     .input-row {
         display: flex;
         align-items: center;
-        padding: var(--spacing-sm) var(--spacing-md);
-        border-bottom: 1px solid var(--color-border-strong);
+        padding: var(--spacing-md) var(--spacing-lg);
         background: var(--color-bg-primary);
         gap: var(--spacing-sm);
     }
 
-    /* AI prompt row styling: subtle left accent border */
+    /* AI prompt row styling: subtle left accent border on a slightly elevated tonal surface.
+       The hairline below sits against the next .input-row in SearchInputArea, which carries
+       its own border-top via the adjacent-sibling rule there. */
     .ai-prompt-row {
         border-left: 2px solid var(--color-accent);
         background: var(--color-bg-secondary);
@@ -151,7 +152,7 @@
         flex-shrink: 0;
         padding: var(--spacing-xxs) var(--spacing-sm);
         font-size: var(--font-size-sm);
-        border: 1px solid var(--color-border-strong);
+        border: 1px solid var(--color-border);
         border-radius: var(--radius-sm);
         background: var(--color-bg-secondary);
         color: var(--color-text-secondary);

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

@@ -6,6 +6,9 @@ include/exclude) filters. Optional AI mode translates natural language queries i
 Backend: `src-tauri/src/search/` (index, engine, query, AI pipeline), `src-tauri/src/commands/search.rs` (thin IPC
 wrappers).
 
+Dialog width: 1080 px (was 900 px). Internal layout is fluid; no fixed inner widths. The bump leaves room for the filter
+chip row and path-pill column landing in later milestones.
+
 ## Files
 
 | File                     | Purpose                                                                                 |
@@ -63,6 +66,15 @@ pass. The previous two-pass system caused ~15% regressions; deterministic struct
 triggered a search while the index is still loading. On initial open, the results area is empty (no loading message)
 since the user is still typing their query.
 
+**State preservation across close + reopen**: The module-level `$state` in `search-state.svelte.ts` survives dialog
+unmount. Closing the dialog (Escape or overlay click) does NOT wipe query, filters, scope, results, or cursor. Reopening
+the dialog lands the user back where they left off. The only reset path is `⌘N` ("new search") inside the dialog, which
+calls `clearSearchState()` and refocuses the active input.
+
+**`⌘N` shortcut**: Hard-coded in `SearchDialog.svelte`'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
+X" idiom (new tab, new document) for the same reason the user reads "fresh search" the same way.
+
 ## Key decisions
 
 **Decision**: Dialog, not a panel or sidebar. **Why**: Search is a focused, transient task. A command-palette-style
@@ -80,6 +92,11 @@ the dialog and trigger quick-search or navigation.
 `get_read_pool()` returns `None` (indexing disabled or not started). The dialog catches this and enters the disabled
 state.
 
+**Gotcha**: Don't call `clearSearchState()` from `onDestroy`. **Why**: The dialog's lifecycle (mount on open, unmount on
+close) doesn't match the user's mental model of "the search I was working on." Wiping state on unmount turned every
+close + reopen into a lost-work moment. The only sanctioned reset path is `⌘N`. If you find yourself wanting to wipe
+state from a lifecycle hook, you probably want a user-initiated action instead.
+
 ## References
 
 - [AI search eval history](../../../../../docs/notes/ai-search-eval-history.md) -- Four rounds of prompt tuning for the

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

@@ -77,7 +77,7 @@
         getCaveat,
         setCaveat,
         buildSearchQuery,
-        resetSearchState,
+        clearSearchState,
     } from './search-state.svelte'
     import AiSearchRow from './AiSearchRow.svelte'
     import SearchInputArea from './SearchInputArea.svelte'
@@ -246,7 +246,8 @@
         // Clean up any in-progress column drag
         document.removeEventListener('mousemove', handleColumnDragMove)
         document.removeEventListener('mouseup', handleColumnDragEnd)
-        resetSearchState()
+        // State is intentionally NOT cleared here. Close + reopen preserves the user's last
+        // query, filters, scope, results, and cursor. Explicit reset lives behind ⌘N.
     })
 
     function scheduleSearch(): void {
@@ -478,28 +479,52 @@
         return document.activeElement === patternInputElement
     }
 
-    /** Handles modifier-key shortcuts (⌥F, ⌥D, ⌘Enter). Returns true if handled. */
+    /** Matches a plain modifier-key combo (one of cmd/alt, no others, no shift). */
+    function matchKey(e: KeyboardEvent, key: string, mod: 'meta' | 'alt'): boolean {
+        if (e.key !== key || e.shiftKey) return false
+        return mod === 'meta' ? e.metaKey && !e.altKey : e.altKey && !e.metaKey
+    }
+
+    /** Clears all dialog state (⌘N "new search") and refocuses the active input. */
+    function clearAndRefocus(): void {
+        clearSearchState()
+        void tick().then(() => {
+            focusActiveInput()
+        })
+    }
+
+    /** Runs an AI search from the current prompt; no-op when AI is off or the prompt is empty. */
+    function runAiFromPrompt(): void {
+        if (!aiEnabled) return
+        const prompt = getAiPrompt().trim()
+        if (prompt) void executeAiSearch(prompt)
+    }
+
+    /** Handles modifier-key shortcuts (⌘N, ⌥F, ⌥D, ⌘Enter). Returns true if handled. */
     function handleModifierShortcuts(e: KeyboardEvent): boolean {
-        // ⌥F: set scope to current folder path
-        if (e.altKey && !e.metaKey && !e.shiftKey && e.key === 'f') {
+        // ⌘N: clear search state and start fresh. Captured here so the global ⌘N (new tab) doesn't
+        // fire while the dialog is open. The dialog already calls stopPropagation on every keydown,
+        // but this handler is also the source of truth for the in-dialog "new search" affordance.
+        if (matchKey(e, 'n', 'meta')) {
+            e.preventDefault()
+            clearAndRefocus()
+            return true
+        }
+        if (matchKey(e, 'f', 'alt')) {
             e.preventDefault()
             setScope(currentFolderPath)
             scheduleSearch()
             return true
         }
-        // ⌥D: clear scope (search entire drive)
-        if (e.altKey && !e.metaKey && !e.shiftKey && e.key === 'd') {
+        if (matchKey(e, 'd', 'alt')) {
             e.preventDefault()
             setScope('')
             scheduleSearch()
             return true
         }
-        // ⌘Enter triggers AI search
-        if (e.key === 'Enter' && e.metaKey && !e.shiftKey && !e.altKey) {
+        if (matchKey(e, 'Enter', 'meta')) {
             e.preventDefault()
-            if (!aiEnabled) return true
-            const prompt = getAiPrompt().trim()
-            if (prompt) void executeAiSearch(prompt)
+            runAiFromPrompt()
             return true
         }
         return false
@@ -670,9 +695,9 @@
 
     .search-dialog {
         background: var(--color-bg-secondary);
-        border: 1px solid var(--color-border-strong);
+        border: 1px solid var(--color-border-subtle);
         border-radius: var(--radius-lg);
-        width: 900px;
+        width: 1080px;
         display: flex;
         flex-direction: column;
         box-shadow: var(--shadow-lg);

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

@@ -0,0 +1,144 @@
+/**
+ * Behavior tests for `SearchDialog.svelte`.
+ *
+ * Covers M1's two new contracts:
+ *   1. `⌘N` inside the dialog clears state (and the active input is refocused).
+ *   2. Close + reopen preserves state (the dialog no longer wipes state on unmount).
+ *
+ * State preservation is the load-bearing change behind the new "search-state stays alive
+ * across dialog close/reopen" UX. The module-level `$state` in `search-state.svelte.ts`
+ * already outlives the component; we just verify nothing in the dialog secretly wipes it.
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import { mount, unmount, tick } from 'svelte'
+import { writable } from 'svelte/store'
+import SearchDialog from './SearchDialog.svelte'
+import {
+  clearSearchState,
+  getNamePattern,
+  setNamePattern,
+  getScope,
+  setScope,
+  getAiPrompt,
+  setAiPrompt,
+  getCursorIndex,
+  setCursorIndex,
+} from './search-state.svelte'
+
+vi.mock('$lib/tauri-commands', () => ({
+  notifyDialogOpened: vi.fn(() => Promise.resolve()),
+  notifyDialogClosed: vi.fn(() => Promise.resolve()),
+  prepareSearchIndex: vi.fn(() => Promise.resolve({ ready: true, entryCount: 1234 })),
+  searchFiles: vi.fn(() => Promise.resolve({ entries: [], totalCount: 0 })),
+  releaseSearchIndex: vi.fn(() => Promise.resolve()),
+  translateSearchQuery: vi.fn(() => Promise.resolve({ display: {}, query: {} })),
+  parseSearchScope: vi.fn(() => Promise.resolve({ includePaths: [], excludePatterns: [] })),
+  getSystemDirExcludes: vi.fn(() => Promise.resolve([])),
+  onSearchIndexReady: vi.fn(() => Promise.resolve(() => {})),
+  formatBytes: vi.fn((n: number) => `${String(n)} B`),
+}))
+
+vi.mock('$lib/settings', () => ({
+  getSetting: vi.fn(() => 'off'),
+}))
+
+vi.mock('$lib/indexing', () => ({
+  isScanning: vi.fn(() => false),
+  getEntriesScanned: vi.fn(() => 0),
+}))
+
+vi.mock('$lib/icon-cache', () => ({
+  iconCacheVersion: writable(0),
+  getCachedIcon: vi.fn(() => undefined),
+}))
+
+function dispatchKey(target: Element, key: string, meta = false): KeyboardEvent {
+  const event = new KeyboardEvent('keydown', {
+    key,
+    metaKey: meta,
+    bubbles: true,
+    cancelable: true,
+  })
+  target.dispatchEvent(event)
+  return event
+}
+
+describe('SearchDialog state preservation and ⌘N', () => {
+  beforeEach(() => {
+    clearSearchState()
+  })
+
+  it('preserves state across close and reopen', async () => {
+    const target = document.createElement('div')
+    document.body.appendChild(target)
+
+    const component = mount(SearchDialog, {
+      target,
+      props: {
+        onNavigate: () => {},
+        onClose: () => {},
+        currentFolderPath: '/Users/test',
+      },
+    })
+    await tick()
+
+    setNamePattern('*.pdf')
+    setScope('~/Documents')
+    setCursorIndex(3)
+
+    void unmount(component)
+    target.remove()
+    await tick()
+
+    expect(getNamePattern()).toBe('*.pdf')
+    expect(getScope()).toBe('~/Documents')
+    expect(getCursorIndex()).toBe(3)
+
+    const target2 = document.createElement('div')
+    document.body.appendChild(target2)
+    mount(SearchDialog, {
+      target: target2,
+      props: {
+        onNavigate: () => {},
+        onClose: () => {},
+        currentFolderPath: '/Users/test',
+      },
+    })
+    await tick()
+
+    expect(getNamePattern()).toBe('*.pdf')
+    expect(getScope()).toBe('~/Documents')
+    expect(getCursorIndex()).toBe(3)
+  })
+
+  it('⌘N clears state inside the dialog', async () => {
+    const target = document.createElement('div')
+    document.body.appendChild(target)
+
+    mount(SearchDialog, {
+      target,
+      props: {
+        onNavigate: () => {},
+        onClose: () => {},
+        currentFolderPath: '/Users/test',
+      },
+    })
+    await tick()
+
+    setNamePattern('*.pdf')
+    setScope('~/Documents')
+    setAiPrompt('large screenshots')
+    setCursorIndex(5)
+
+    const overlay = target.querySelector('.search-overlay')
+    expect(overlay).toBeTruthy()
+    dispatchKey(overlay as Element, 'n', true)
+    await tick()
+
+    expect(getNamePattern()).toBe('')
+    expect(getScope()).toBe('')
+    expect(getAiPrompt()).toBe('')
+    expect(getCursorIndex()).toBe(0)
+  })
+})