Search: David's fix-up rounds 2 part B, 3, and 4

Round 2 part B (the 17 items the round 2 first agent left): the Size and Modified filter popovers became list-style column grids ("any/>=/<=/between" plus a preset list plus a dynamic unit column); "Use current folder" gained a smart fallback that walks the active pane's history past any search-results entry; the result list got header alignment, ResizeObserver-driven path pill measurement, and per-row context menu fixes; the snapshot pane got the full keyboard set (PgUp/PgDn, Home/End, Space, Shift+Up/Down, F3/F4) plus a regression test for the Cmd+A off-by-one that round 2 had quietly fixed without one.

Round 3 (David's next pass after running it): "Search ⏎" instead of "⏎Search⏎", AI search now overwrites the matching hand-typed buffer, filter chip respects kB vs KB, path pill widths re-measure after RAF to stop the late-collapse, Modified popover's Custom row is only selected when the user explicitly clicks it, the snapshot pane's breadcrumb shows "Search results / <label>" with the volume selector and the path the right way round, recent searches strip uses a greedy layout with always-on left label and trailing All searches button, Modified preset labels read as concrete dates ("today 0:00", "this Monday 0:00", "1st of May 0:00") with first-day-of-week from Intl.Locale, "Hide system folders" became "Hide boring folders" with the full exclude list in the tooltip, path column matches the filename font size, and the snapshot pane focuses itself when Show all in main window lands it.

Round 4 (David's screenshot review): the "Search results no longer available" pane was a real bug. The fresh logs caught it: `read_directory_with_progress: ..., volume_id=search-results, path=/Library/...` and the matching "Dropping stale onPathChange" warning. When the user activated a real folder from a snapshot pane (or the search dialog's exit landed on a real path while the active pane was still on the snapshot volume), FilePane.handleNavigate and DualPaneExplorer.navigateToPath were setting currentPath to a real filesystem location without switching volumeId off `search-results`. The pane then tried to render SearchResultsView against a path that wasn't a snapshot URL, the snapshot-id extractor returned null, and the user saw the friendly error pane.

The fix routes both call sites through the volume-change machinery. A new pure helper `isCrossVolumeNavigation(currentVolumeId, targetPath)` (in `pane/snapshot-pane-navigation.ts`) decides whether we're leaving the snapshot volume; when it returns true the caller resolves the real volume via `resolvePathVolume` and reconfigures the pane via `onVolumeChange` / `handleVolumeChange` BEFORE loading the target path. Tests pin the decision with the exact `/Library/Developer/CommandLineTools/...` path that reproduced the user bug.

Also in round 4: the "Loading drive index..." status bar duplicate goes away (status bar stays empty whenever the content area is the source of truth, same rule as Searching and No-files-match). Cmd+Enter and Shift+Enter are explicit no-ops in the dialog; the earlier "Cmd+Enter runs AI" shortcut is gone, bare Enter is the only key that runs a search or opens the cursor row.

The eject-volume worktree apparently churns the same files; left it alone.

Author: vdavid

apps/desktop/src/lib/file-explorer/CLAUDE.md

@@ -182,6 +182,17 @@ Navigation:
   the underlying path. ⌘[ returns to the snapshot view; the snapshot's still pinned by the history entry, so the view
   re-renders from memory with no re-query.
 
+R4 cross-volume bug fix (`pane/snapshot-pane-navigation.ts::isCrossVolumeNavigation`): when the user activates a real
+folder from a snapshot pane (or the search dialog's "Go to file" exit lands on a real path while the active pane is
+still on the snapshot volume), the navigation MUST route through the volume-change machinery. Two call sites:
+`FilePane.handleNavigate` (Enter / double-click on a row) calls `resolvePathVolume` and then `onVolumeChange`;
+`DualPaneExplorer.navigateToPath` (the dialog's exit + MCP `nav_to_path`) does the same via the internal
+`handleVolumeChange`. Without this, the pane ends up with `volumeId === 'search-results'` while `path` points at a real
+filesystem location, and `SearchResultsView` shows "Search results no longer available" (the snapshot-id extractor
+returns null because the path doesn't start with `search-results://`). The fresh-logs symptom was
+`read_directory_with_progress: …, volume_id=search-results, path=/Library/…` followed by
+`Dropping stale onPathChange on search-results pane: /Library/…`.
+
 DualPaneExplorer extensions:
 
 - `applyPathChange` extends its virtual-volume branch from `currentVolumeId === 'network'` to also accept
@@ -198,12 +209,48 @@ FilePane suppresses the trailing path segments entirely for search-results panes
 
 Source-side operations (M8d): selection works in the snapshot pane (Space, Insert, Shift+click range, Cmd+click toggle,
 Cmd+A / Cmd+Shift+A). `effectiveTotalCount` returns the snapshot's entry count so range selection spans the result set.
-Cmd+C / Cmd+X call the paths-by-value clipboard IPCs (`copy_paths_to_clipboard` / `cut_paths_to_clipboard`) instead of
-the listing-id-keyed family. F5 / F6 (the unified transfer dialog) detect `volumeId === 'search-results'` and call
-`transfer-operations::buildTransferPropsFromSnapshot` with paths resolved from `snapshot-store::resolveSnapshotPaths`;
-the existing `copy_files` / `move_files` IPCs already accept paths-by-value, so no IPC change was needed for the
-transfer path. Drag-out uses the new `'paths'` drag context (see `drag/CLAUDE.md`) which routes through
-`start_drag_paths`. Post-move snapshot cleanup is the M8c hook in `dialog-state::handleTransferComplete`.
+
+Round 2 P-series keyboard contract: `FilePane.handleSearchResultsKeyDown` routes through the pure
+`pane/search-results-keys.ts::computeSearchPaneKeyAction` helper, which translates each keypress into an action enum
+(`move-cursor`, `open-cursor`, `toggle-selection-at-cursor`, `toggle-selection-and-advance`, `view-file`, `edit-file`,
+`noop`). Splitting dispatch from side effects keeps the keyboard contract unit-testable without spinning up the whole
+pane. Covered: PgUp / PgDn (visible-page step), Home / End, Shift+Up / Shift+Down (extends selection via the same
+toggle-and-fill helper the regular pane uses), Space (toggle), Insert (toggle + advance), F3 (view), F4 (edit). Left /
+Right return `noop` (no parent-folder semantics in a flat snapshot; the caller still calls `preventDefault` so the
+regular full-pane handler can't jump to first / last row underneath). Cmd+A flows through the unified command dispatch
+in `command-dispatch.ts` as before.
+
+Round 2 P6 fix: `hasParent` now `false` for `search-results` panes. Previously the path comparison
+`currentPath !== effectiveVolumeRoot` was true (a `search-results://sr-N` URL never matches a real volume root), so
+`selection.selectAll(hasParent=true, ...)` skipped index 0. Setting `hasParent = false` for snapshot panes restores the
+off-by-one and keeps `..` row handling untouched for real panes.
+
+R3 T1: the round-2 fix was correct but had no test. The derivation now lives in `pane/has-parent.ts` as
+`computeHasParent({ isSearchResultsView, currentPath, effectiveVolumeRoot })` and is pinned by
+`pane/has-parent.test.ts`, which also covers the integration with `selection.selectAll` (snapshot pane → all 5 indices
+selected; non-snapshot pane with hasParent → indices 1..4, skipping the `..` row at 0).
+
+R3 B6: the search-results breadcrumb shape changed. The volume selector reads the static "Search results" label (set by
+`VolumeBreadcrumb.svelte::currentVolume`) and `FilePane.svelte::breadcrumbDisplayPath` renders the snapshot's friendly
+label (`*.svelte`, the AI title, ...) as the path. The `breadcrumbSegments` derived produces a single-segment list for
+search-results panes so a label containing `/` (regex mode like `/foo\/bar/`) doesn't get broken into path-style
+segments. Round 2 had these inverted (label in the volume slot, empty path).
+
+Round 2 P8 / P9 / P10 (context-menu wiring):
+
+- `DualPaneExplorer.getFileAndPathUnderCursor()` now prefers the pane-reported `getPathUnderCursor()` over the round-1
+  `${currentPath}/${filename}` concatenation. Without this fix, `file.showInFinder` / `file.copyPath` / `file.edit` on a
+  snapshot pane built a `search-results://sr-N/<name>` path that downstream IPCs couldn't act on.
+- `SearchResultsView.svelte::onContextMenu` now hands the Rust menu builder the path's basename, not the adapted entry's
+  `name` (which is the friendly full path like `~/Library/.../test.md`). Without this, the menu label read
+  `Copy ~/Library/.../test.md` instead of `Copy test.md`. The action itself was already correct because
+  `entryUnderCursor.name` on a snapshot pane mirrors the raw `SearchResultEntry.name` (a basename). Cmd+C / Cmd+X call
+  the paths-by-value clipboard IPCs (`copy_paths_to_clipboard` / `cut_paths_to_clipboard`) instead of the
+  listing-id-keyed family. F5 / F6 (the unified transfer dialog) detect `volumeId === 'search-results'` and call
+  `transfer-operations::buildTransferPropsFromSnapshot` with paths resolved from `snapshot-store::resolveSnapshotPaths`;
+  the existing `copy_files` / `move_files` IPCs already accept paths-by-value, so no IPC change was needed for the
+  transfer path. Drag-out uses the new `'paths'` drag context (see `drag/CLAUDE.md`) which routes through
+  `start_drag_paths`. Post-move snapshot cleanup is the M8c hook in `dialog-state::handleTransferComplete`.
 
 For the dialog-side wiring see [`apps/desktop/src/lib/search/CLAUDE.md`](../../search/CLAUDE.md).
 

apps/desktop/src/lib/file-explorer/navigation/VolumeBreadcrumb.svelte

@@ -35,7 +35,6 @@
         requestVolumeRefresh,
     } from '$lib/stores/volume-store.svelte'
     import { groupByCategory, getIconForVolume } from './volume-grouping'
-    import { getSnapshot } from '$lib/search/snapshot-store.svelte'
     import { createVolumeSpaceManager } from './volume-space-manager.svelte'
     import {
         createBreadcrumbPopupController,
@@ -99,8 +98,12 @@
             ? { id: 'network', name: 'Network', path: 'smb://', category: 'network' as const, isEjectable: false }
             : volumeId === 'search-results'
               ? {
+                    // R3 B6: the volume selector reads "Search results", a
+                    // generic noun matching every other volume's slot. The
+                    // search-specific label (the AI title / pattern) moved to
+                    // the path slot in `FilePane.svelte::breadcrumbDisplayPath`.
                     id: 'search-results',
-                    name: 'Search',
+                    name: 'Search results',
                     path: 'search-results://',
                     category: 'network' as const,
                     isEjectable: false,
@@ -110,20 +113,16 @@
     )
 
     /**
-     * Search-results breadcrumb label: extract the snapshot id from `currentPath`
-     * (`search-results://<id>`) and look up the snapshot's friendly label. Falls
-     * back to "Search" when the snapshot is missing — same defensive posture as
-     * the SearchResultsView itself. Re-derives reactively on path / volume changes.
+     * R3 B6: the snapshot's friendly label is now rendered as the trailing
+     * path text (in `FilePane.svelte`'s `breadcrumbDisplayPath`). The volume
+     * selector here reads the static "Search results" label so the
+     * volume-selector slot describes the KIND of volume (matching every
+     * other volume: "Network", "Macintosh HD", an MTP device name) and the
+     * path slot carries the QUERY-specific label. Round 2 had these
+     * inverted, which David flagged in the round 3 brief (the snapshot
+     * label was the volume name and the path was empty).
      */
-    const searchResultsLabel = $derived.by(() => {
-        if (volumeId !== 'search-results') return null
-        const prefix = 'search-results://'
-        if (!currentPath.startsWith(prefix)) return null
-        const id = currentPath.slice(prefix.length)
-        return getSnapshot(id)?.label ?? 'Search'
-    })
-
-    const currentVolumeName = $derived(searchResultsLabel ?? currentVolume?.name ?? 'Volume')
+    const currentVolumeName = $derived(currentVolume?.name ?? 'Volume')
     const currentVolumeIcon = $derived(getIconForVolume(currentVolume))
 
     // Generic macOS folder icon used as fallback when a volume has no icon (for example,

apps/desktop/src/lib/file-explorer/pane/DualPaneExplorer.svelte

@@ -3,6 +3,7 @@
     import { pluralize } from '$lib/utils/pluralize'
     import FilePane from './FilePane.svelte'
     import type { FilePaneAPI } from './types'
+    import { isCrossVolumeNavigation } from './snapshot-pane-navigation'
     import PaneResizer from './PaneResizer.svelte'
     import LoadingIcon from '$lib/ui/LoadingIcon.svelte'
     import DialogManager from './DialogManager.svelte'
@@ -51,6 +52,7 @@
     import { resolveValidPath } from '../navigation/path-resolution'
     import { getSnapshot, resolveSnapshotPaths } from '$lib/search/snapshot-store.svelte'
     import { SEARCH_RESULTS_NOT_A_FOLDER_TOAST } from '$lib/search/capabilities'
+    import { resolveSearchableFolder } from '$lib/search/searchable-folder'
 
     import {
         createHistory,
@@ -2293,14 +2295,24 @@
 
     /**
      * Get the path and filename of the file under the cursor in the focused pane.
+     *
+     * For the search-results virtual pane the underlying entries carry their own absolute
+     * `path`, and `currentPath` is the opaque `search-results://<id>` URL — concatenating
+     * the two would produce `search-results://sr-1/test.md`, which downstream commands
+     * (`showInFinder`, `openInEditor`, `copyToClipboard`) can't act on. Round-2 P8 / P9.
+     * We prefer the pane-reported path under the cursor when present and fall back to the
+     * legacy `${currentPath}/${filename}` form for regular panes.
      */
     export function getFileAndPathUnderCursor(): { path: string; filename: string } | null {
         const paneRef = getPaneRef(focusedPane)
-        const currentPath = getPanePath(focusedPane)
         const filename = paneRef?.getFilenameUnderCursor()
         if (!filename || filename === '..') return null
-        const path = `${currentPath}/${filename}`
-        return { path, filename }
+        const cursorPath = paneRef?.getPathUnderCursor()
+        if (cursorPath) {
+            return { path: cursorPath, filename }
+        }
+        const currentPath = getPanePath(focusedPane)
+        return { path: `${currentPath}/${filename}`, filename }
     }
 
     /**
@@ -2398,6 +2410,26 @@
         return getPanePath(focusedPane)
     }
 
+    /**
+     * Returns the "current folder" the Search dialog's `Search in → Use current folder`
+     * action should act on. Round-2 D12: when the focused pane is a `search-results://`
+     * snapshot, walks back through history for the most recent real folder; when none is
+     * available, surfaces a disabled state with a tooltip. See
+     * `lib/search/searchable-folder.ts` for the pure helper this delegates to.
+     */
+    // noinspection JSUnusedGlobalSymbols -- consumed by +page.svelte via explorerRef
+    export function getFocusedPaneSearchableFolder(): {
+        path: string | null
+        disabled: boolean
+        disabledReason: string
+    } {
+        const history = getPaneHistory(focusedPane)
+        return resolveSearchableFolder({
+            currentPath: getPanePath(focusedPane),
+            history: history.stack.map((e) => e.path),
+        })
+    }
+
     /** Volume id of the focused pane's active tab. Used by Quick Look's IPC gate. */
     export function getFocusedPaneVolumeId(): string {
         return getPaneVolumeId(focusedPane)
@@ -2571,6 +2603,30 @@
             return `Pane is on the ${volumeName ?? volumeId} volume. Use select_volume to switch to a local volume first.`
         }
 
+        // R4: when the pane is on the snapshot volume and the caller asks us to navigate
+        // to a real path (the search dialog's "Go to file" exit path is the common
+        // case: `+page.svelte::handleSearchNavigate` calls us with the file's parent
+        // directory). Resolve the real volume and route through `handleVolumeChange`
+        // so the pane reconfigures BEFORE it tries to load a real path. Without this,
+        // the FilePane would loadDirectory the real path while volumeId stays as
+        // `search-results`, leaving `SearchResultsView` rendering "Search results no
+        // longer available" against a path that isn't a snapshot URL.
+        if (isCrossVolumeNavigation(volumeId, path)) {
+            return (async () => {
+                try {
+                    const result = await resolvePathVolume(path)
+                    const volume = result.volume
+                    if (!volume) {
+                        log.warn(`navigateToPath: no volume resolved for ${path}; cannot leave snapshot pane`)
+                        return
+                    }
+                    handleVolumeChange(pane, volume.id, volume.path, path)
+                } catch (err) {
+                    log.error(`navigateToPath: resolvePathVolume failed for ${path}: ${String(err)}`)
+                }
+            })()
+        }
+
         const mtpError = validateMtpNavigation(path, volumeId, volumeName)
         if (mtpError) return mtpError