Search: auto-apply toggle + Settings > Search section

- New `search.autoApply` boolean setting (default on) under `Behavior > Search`, live-applied via the dialog's reactive `onSpecificSettingChange` subscription.
- `SearchSection.svelte` hosts the auto-apply switch and mirrors `search.recentSearches.maxCount` for discoverability, per the settings mirror pattern.
- Debounce bumped from 200 ms to 1 s via the new `SEARCH_AUTO_APPLY_DEBOUNCE_MS` constant in `search-state.svelte.ts`.
- AI mode never auto-applies regardless of the setting; the bar shows a subtle "Press Enter to search" hint in the right gutter when the query has drifted since the last run.
- IME composition guard: `oncompositionstart` suppresses scheduling, `oncompositionend` fires exactly one debounced search after composition completes so CJK input doesn't trigger mid-character searches.
- New `⏎` run button on the right end of the bar. Always visible; equivalent to pressing Enter.
- Updated the E2E sidebar-order test and the `lib/search/CLAUDE.md` + `lib/settings/CLAUDE.md` docs with the new section, mirror, IME guard, and run-hint rules.

Author: vdavid

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

@@ -118,9 +118,35 @@ for results, Tab between filters) that would fight `ModalDialog`'s focus managem
 **Two-cursor hover model**: Same as command palette. `cursorIndex` (keyboard) and `hoveredIndex` (mouse) are
 independent.
 
-**Live search with debounce**: 200ms debounce on filename/regex modes only. AI mode never auto-applies: the AI call
-costs money and the user must explicitly opt in via Enter / `⌘Enter` / the chip's Run action. Enter bypasses debounce
-for immediate search.
+**Live search with debounce**: 1 s debounce on filename/regex modes only, gated by the `search.autoApply` setting
+(default on, in `Settings > Behavior > Search`). AI mode never auto-applies regardless of the setting: AI calls cost
+money and the user must explicitly opt in via Enter / `⌘Enter` / the `⏎` run button on the right of the bar.
+
+The debounce constant lives in `search-state.svelte.ts` as `SEARCH_AUTO_APPLY_DEBOUNCE_MS = 1000`. All auto-apply
+callsites read it from there so changing the value is one edit. The bump from 200 ms to 1 s in M6 matches Spotlight's
+feel on a 10M-entry index: the user gets to finish a word before we react. Enter / ⌘Enter / the ⏎ button bypass the
+debounce for immediate search.
+
+**Auto-apply gates (M6)**: `scheduleSearch()` returns early in three cases:
+
+1. `mode === 'ai'`: AI never auto-applies.
+2. `search.autoApply === false`: the user runs every search explicitly.
+3. IME composition is in progress: we don't fire mid-character on Chinese / Japanese / Korean input. On
+   `compositionend`, the parent calls `scheduleSearch` again so the user gets one fire after the composed character
+   lands.
+
+The setting is mirrored into the dialog's local `autoApplyEnabled` state via
+`onSpecificSettingChange('search.autoApply', ...)`. Live-applied: toggling in the settings window updates the dialog
+immediately without reopening.
+
+**`⏎` run button**: Always visible on the right end of the bar. Clicking it is equivalent to pressing Enter in the
+input: AI mode runs `runAiFromQuery()`, every other mode runs `executeSearch()`. The button is the mouse-first path; the
+keyboard-first path is Enter.
+
+**"Press Enter to search" hint**: Appears in the right gutter of the bar in `--color-text-tertiary` when (a) the query
+is non-empty and (b) it has changed since the last actually-issued search and (c) auto-apply won't pick it up
+(`mode === 'ai'` OR `search.autoApply === false`). Tracked by `lastRunQuery`, set by `executeSearch()` after a
+successful backend call. `⌘N` resets `lastRunQuery` to `null` along with the rest of state.
 
 **Scope row**: Below the chips. Comma-separated folder paths with `!` prefix for exclusions. Parsed via
 `parseSearchScope()` IPC call in `executeSearch()` (async, so not part of `buildSearchQuery()`). ⌥F sets scope to the
@@ -152,6 +178,11 @@ contract as the Content mode chip: visible-disabled with an explanatory tooltip
 and the active mode is `ai`, the dialog quietly flips to `filename`. The user wouldn't be able to run a search
 otherwise.
 
+**IME composition guard**: The dialog tracks `imeComposing` via `oncompositionstart` / `oncompositionend` on the search
+bar input. While composing, `scheduleSearch()` is a no-op so we don't fire mid-character on Chinese / Japanese / Korean
+input. On `compositionend` the dialog calls `scheduleSearch()` once so the user gets exactly one auto-apply fire after
+the composed character lands. Non-negotiable for IME users: see search-redesign-plan §3.6.
+
 **Deferred loading indicator**: The "Loading drive index..." message in the results area only appears when the user has
 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.

apps/desktop/src/lib/search/SearchBar.a11y.test.ts

@@ -19,7 +19,11 @@ function baseProps(overrides: Partial<Props> = {}): Props {
     mode: 'filename',
     disabled: false,
     aiHighlight: false,
+    showRunHint: false,
     onInput: () => {},
+    onRun: () => {},
+    onCompositionStart: () => {},
+    onCompositionEnd: () => {},
     ...overrides,
   }
 }

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

@@ -6,11 +6,20 @@
      * so the user can see at a glance what kind of input the bar expects. Switching mode preserves
      * the typed query; this component is presentational, the parent owns `query` and `mode`.
      *
+     * The right gutter shows two things, both managed by the parent dialog:
+     *   - A subtle "Press Enter to search" hint when auto-apply is off (or AI mode) and the query
+     *     has changed since the last run. Visible state, not interactive.
+     *   - A small ⏎ run button. Always present; clicking it is equivalent to pressing Enter.
+     *
+     * IME composition is also surfaced: `oncompositionstart` and `oncompositionend` let the parent
+     * suppress auto-apply mid-composition and fire exactly once on completion (M6 addition).
+     *
      * Keyboard contract (handled by the parent dialog, not here):
      *   - Enter runs the search in the active mode.
      *   - ⌘Enter runs an AI search regardless (only when AI is enabled).
      *   - ⌘1/⌘2/⌘3 switch modes (numbering changes when AI is off).
      */
+    import IconCornerDownLeft from '~icons/lucide/corner-down-left'
     import type { SearchMode } from './search-state.svelte'
 
     interface Props {
@@ -20,11 +29,30 @@
         mode: SearchMode
         disabled: boolean
         aiHighlight: boolean
+        /** True when the bar should show the "Press Enter to search" hint. Owned by the parent. */
+        showRunHint?: boolean
         onInput: (value: string) => void
+        /** Click handler for the ⏎ run button. Equivalent to pressing Enter in the input. */
+        onRun: () => void
+        /** IME composition entry: parent suppresses auto-apply between start and end. */
+        onCompositionStart?: () => void
+        /** IME composition exit: parent fires exactly one debounced search after this. */
+        onCompositionEnd?: () => void
     }
 
     /* eslint-disable prefer-const -- $bindable() requires `let` destructuring */
-    let { inputElement = $bindable(), query, mode, disabled, aiHighlight, onInput }: Props = $props()
+    let {
+        inputElement = $bindable(),
+        query,
+        mode,
+        disabled,
+        aiHighlight,
+        showRunHint = false,
+        onInput,
+        onRun,
+        onCompositionStart,
+        onCompositionEnd,
+    }: Props = $props()
     /* eslint-enable prefer-const */
 
     /** Placeholder text per mode. Filenames are the workhorse, so we name the wildcards there. */
@@ -39,6 +67,9 @@
         if (mode === 'regex') return 'Regex search pattern'
         return 'Filename search pattern'
     })
+
+    /** AI mode runs only on explicit Enter / ⌘Enter / Run-button click. Show the hint title to match. */
+    const runTitle = $derived(mode === 'ai' ? 'Run AI search (Enter)' : 'Run search (Enter)')
 </script>
 
 <div class="search-bar" class:is-disabled={disabled}>
@@ -56,12 +87,31 @@
         oninput={(e: Event) => {
             onInput((e.target as HTMLInputElement).value)
         }}
+        oncompositionstart={() => {
+            onCompositionStart?.()
+        }}
+        oncompositionend={() => {
+            onCompositionEnd?.()
+        }}
         {disabled}
         aria-label={ariaLabel}
         spellcheck="false"
         autocomplete="off"
         autocapitalize="off"
     />
+    {#if showRunHint}
+        <span class="run-hint" aria-hidden="true">Press Enter to search</span>
+    {/if}
+    <button
+        type="button"
+        class="run-button"
+        {disabled}
+        onclick={onRun}
+        title={runTitle}
+        aria-label={runTitle}
+    >
+        <IconCornerDownLeft />
+    </button>
 </div>
 
 <style>
@@ -103,4 +153,40 @@
         border-radius: var(--radius-sm);
         transition: background 1.5s ease-out;
     }
+
+    .run-hint {
+        flex-shrink: 0;
+        color: var(--color-text-tertiary);
+        font-size: var(--font-size-xs);
+        white-space: nowrap;
+    }
+
+    .run-button {
+        flex-shrink: 0;
+        display: inline-flex;
+        align-items: center;
+        justify-content: center;
+        padding: var(--spacing-xxs) var(--spacing-xs);
+        background: transparent;
+        border: 1px solid var(--color-border-subtle);
+        border-radius: var(--radius-sm);
+        color: var(--color-text-secondary);
+        cursor: default;
+        line-height: 1;
+    }
+
+    .run-button:hover:not(:disabled) {
+        background: var(--color-bg-tertiary);
+        color: var(--color-text-primary);
+    }
+
+    .run-button:focus-visible {
+        outline: 2px solid var(--color-accent);
+        outline-offset: 1px;
+    }
+
+    .run-button:disabled {
+        opacity: 0.5;
+        cursor: default;
+    }
 </style>

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

@@ -11,14 +11,21 @@ import { mount, tick } from 'svelte'
 import SearchBar from './SearchBar.svelte'
 import type { SearchMode } from './search-state.svelte'
 
-function mountBar(overrides: Partial<{ query: string; mode: SearchMode }>): {
+function mountBar(overrides: Partial<{ query: string; mode: SearchMode; showRunHint: boolean }>): {
+  target: HTMLDivElement
   input: HTMLInputElement
   onInput: ReturnType<typeof vi.fn>
+  onRun: ReturnType<typeof vi.fn>
+  onCompositionStart: ReturnType<typeof vi.fn>
+  onCompositionEnd: ReturnType<typeof vi.fn>
   cleanup: () => void
 } {
   const target = document.createElement('div')
   document.body.appendChild(target)
   const onInput = vi.fn()
+  const onRun = vi.fn()
+  const onCompositionStart = vi.fn()
+  const onCompositionEnd = vi.fn()
   mount(SearchBar, {
     target,
     props: {
@@ -27,14 +34,22 @@ function mountBar(overrides: Partial<{ query: string; mode: SearchMode }>): {
       mode: overrides.mode ?? 'filename',
       disabled: false,
       aiHighlight: false,
+      showRunHint: overrides.showRunHint ?? false,
       onInput,
+      onRun,
+      onCompositionStart,
+      onCompositionEnd,
     },
   })
   const input = target.querySelector('input.query-input') as HTMLInputElement | null
   if (!input) throw new Error('input not found')
   return {
+    target,
     input,
     onInput,
+    onRun,
+    onCompositionStart,
+    onCompositionEnd,
     cleanup: () => {
       target.remove()
     },
@@ -78,4 +93,37 @@ describe('SearchBar', () => {
     expect(onInput).toHaveBeenCalledWith('photo*')
     cleanup()
   })
+
+  it('renders the ⏎ run button and calls onRun when clicked', async () => {
+    const { target, onRun, cleanup } = mountBar({})
+    await tick()
+    const button = target.querySelector('button.run-button') as HTMLButtonElement | null
+    expect(button).not.toBeNull()
+    button?.click()
+    expect(onRun).toHaveBeenCalledTimes(1)
+    cleanup()
+  })
+
+  it('shows the "Press Enter to search" hint only when showRunHint is true', async () => {
+    const { target, cleanup } = mountBar({ showRunHint: true })
+    await tick()
+    const hint = target.querySelector('.run-hint')
+    expect(hint?.textContent).toMatch(/Press Enter to search/i)
+    cleanup()
+
+    const { target: noHintTarget, cleanup: cleanup2 } = mountBar({ showRunHint: false })
+    await tick()
+    expect(noHintTarget.querySelector('.run-hint')).toBeNull()
+    cleanup2()
+  })
+
+  it('forwards compositionstart and compositionend to the parent (IME guard)', async () => {
+    const { input, onCompositionStart, onCompositionEnd, cleanup } = mountBar({})
+    await tick()
+    input.dispatchEvent(new CompositionEvent('compositionstart'))
+    expect(onCompositionStart).toHaveBeenCalledTimes(1)
+    input.dispatchEvent(new CompositionEvent('compositionend'))
+    expect(onCompositionEnd).toHaveBeenCalledTimes(1)
+    cleanup()
+  })
 })

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

@@ -34,8 +34,12 @@ let aiProvider: 'off' | 'local' | 'cloud' = 'off'
 vi.mock('$lib/settings', () => ({
   getSetting: vi.fn((key: string) => {
     if (key === 'ai.provider') return aiProvider
+    if (key === 'search.autoApply') return true
     return undefined
   }),
+  // SearchDialog subscribes to `search.autoApply` changes; the a11y suite doesn't toggle it, so a
+  // no-op unsubscribe is enough.
+  onSpecificSettingChange: vi.fn(() => () => {}),
 }))
 
 vi.mock('$lib/indexing', () => ({