Go to path: Backend file path, a11y, cleanup

- Make the `File` recents path backend-authoritative: `GoToPathResolution::File` now carries the canonical normalized `path`, so the handler records `resolution.path` directly instead of reconstructing `${parentDir}/${fileName}`.
- Drop the dead `getRecentPathsLoaded` helper (no callers); the internal `loaded` idempotency flag stays.
- Make the recents `[x]` remove button keyboard-accessible: removed its `tabindex="-1"` so it joins the natural tab order (textbox → each `[x]` → Cancel → Go to path), keeping the existing `aria-label` and `--shadow-focus` focus ring. Row body stays out of the tab order (digit keys cover jumping).
- Regenerated typed bindings; updated Rust + Vitest tests and the colocated CLAUDE.md docs.

Author: vdavid

apps/desktop/src-tauri/src/go_to_path/CLAUDE.md

@@ -12,8 +12,10 @@ all the path reasoning plus the recent-paths store. The IPC layer (`commands/go_
 
 ## `GoToPathResolution`
 
-The resolution outcome the frontend branches on. Four variants: `Directory { path }`, `File { parentDir, fileName }`,
-`NearestAncestor { requested, ancestorDir }`, `Invalid { reason }`. The tagged-enum attrs
+The resolution outcome the frontend branches on. Four variants: `Directory { path }`,
+`File { path, parentDir, fileName }`, `NearestAncestor { requested, ancestorDir }`, `Invalid { reason }`. The `File`
+variant carries the canonical normalized full `path` (the frontend records it into recents verbatim, no client-side
+reconstruction) alongside `parentDir` / `fileName` (which drive navigate-to-parent + select). The tagged-enum attrs
 (`#[serde(tag = "kind", rename_all = "camelCase", rename_all_fields = "camelCase")]`) are required so the tag and the
 struct-variant fields ship camelCase through tauri-specta (enforced by `ipc-enum-camelcase`).
 

apps/desktop/src-tauri/src/go_to_path/mod.rs

@@ -66,8 +66,14 @@ use crate::commands::file_system::expand_tilde;
 pub enum GoToPathResolution {
     /// The resolved path is an existing directory. Navigate into it.
     Directory { path: String },
-    /// The resolved path is an existing file. Navigate to its parent and select it.
-    File { parent_dir: String, file_name: String },
+    /// The resolved path is an existing file. `path` is the canonical normalized
+    /// full path (recorded into recents); `parent_dir` / `file_name` drive the
+    /// navigate-to-parent + select.
+    File {
+        path: String,
+        parent_dir: String,
+        file_name: String,
+    },
     /// The resolved path doesn't exist. `ancestor_dir` is the nearest existing
     /// ancestor (worst case `/`). Navigate there and fire an INFO toast.
     NearestAncestor { requested: String, ancestor_dir: String },
@@ -158,7 +164,11 @@ pub fn resolve(input: &str, base_dir: &str) -> GoToPathResolution {
                 .file_name()
                 .map(|n| n.to_string_lossy().to_string())
                 .unwrap_or_else(|| normalized_str.clone());
-            GoToPathResolution::File { parent_dir, file_name }
+            GoToPathResolution::File {
+                path: normalized_str,
+                parent_dir,
+                file_name,
+            }
         }
         Err(_) => {
             // Doesn't exist (or unreadable): fall back to the nearest ancestor.
@@ -201,6 +211,7 @@ mod tests {
         assert_eq!(
             res,
             GoToPathResolution::File {
+                path: file.to_string_lossy().to_string(),
                 parent_dir: dir.path().to_string_lossy().to_string(),
                 file_name: "notes.txt".to_string(),
             }
@@ -309,11 +320,13 @@ mod tests {
     #[test]
     fn resolution_serializes_with_camelcase_kind_and_fields() {
         let res = GoToPathResolution::File {
+            path: "/Users/x/a.txt".to_string(),
             parent_dir: "/Users/x".to_string(),
             file_name: "a.txt".to_string(),
         };
         let json = serde_json::to_string(&res).unwrap();
         assert!(json.contains("\"kind\":\"file\""), "got {json}");
+        assert!(json.contains("\"path\""), "got {json}");
         assert!(json.contains("\"parentDir\""), "got {json}");
         assert!(json.contains("\"fileName\""), "got {json}");
 

apps/desktop/src/lib/go-to-path/CLAUDE.md

@@ -53,6 +53,10 @@ actual jump — one source of truth, no drift.
   all three; the `$state` mirror re-reads the authoritative list after each write rather than guessing the new order.
 - Rows are middle-truncated for display (`useShortenMiddle`, `preferBreakAt: '/'`) with the full path in a `title`
   tooltip (`tooltipWhenTruncated`).
+- **Keyboard access.** The row body is out of the tab order (`tabindex="-1"`): the digit keys (1-9, 0) are the keyboard
+  path to jumping a recent, so tabbing every row body would be redundant. The `[x]` remove button keeps its natural tab
+  order (a real `<button>` with `aria-label="Remove from list"` and a `--shadow-focus` `:focus-visible` ring) so
+  keyboard-only users can remove a recent — digits can't express "remove." Removing the row refocuses the textbox.
 
 ## Key decisions
 
@@ -79,8 +83,8 @@ Matches the downloads toast snapshot rule.
 
 A command with a native menu accelerator AND a `command-registry` shortcut fires both paths on macOS. The
 `showGoToPathDialog` callback in `+page.svelte` guards with `if (show && showGoToPathDialog) return`, so a double-fire
-opens the dialog exactly once. (The native Go-menu item lands in M3; this guard is already in place so it'll be correct
-when it does.)
+opens the dialog exactly once. The native `Go to path…` menu item carries ⌘G as an accelerator, so this guard is what
+keeps a single ⌘G press from opening the dialog twice.
 
 ## v1 limitations
 

apps/desktop/src/lib/go-to-path/GoToPathDialog.svelte

@@ -223,6 +223,11 @@
             <ul class="recents" aria-label="Recent paths">
                 {#each recents as recent, index (recent.id)}
                     <li class="recent-row">
+                        <!-- Row body is out of the tab order on purpose: the digit
+                             keys (1-9, 0) are the keyboard path to jumping a recent,
+                             so tabbing through every row body would be redundant. The
+                             `[x]` remove button keeps its natural tab order so keyboard
+                             users can remove a recent (digits can't express that). -->
                         <button
                             type="button"
                             class="recent-main"
@@ -245,7 +250,6 @@
                             aria-label="Remove from list"
                             use:tooltip={'Remove from list'}
                             onclick={(event) => void handleRemoveRecent(event, recent.id)}
-                            tabindex="-1"
                         >
                             <XIcon />
                         </button>

apps/desktop/src/lib/go-to-path/GoToPathDialog.svelte.test.ts

@@ -163,6 +163,27 @@ describe('GoToPathDialog', () => {
     cleanup()
   })
 
+  it('the remove button is keyboard-reachable and operable', async () => {
+    getRecentPathsListMock.mockReturnValue([{ id: 'a', path: '/first', timestamp: 1 }])
+    const onGo = goMock({ kind: 'directory', path: '/x' })
+    const { target, cleanup } = setup({ onGo })
+    await tick()
+    const removeButton = target.querySelector('.remove-button') as HTMLButtonElement
+    // A real `<button>` in the natural tab order: no negative tabindex removing
+    // it. Keyboard-only users can focus and operate it (Enter/Space dispatch a
+    // native click on a button), so it must not be excluded from tabbing.
+    expect(removeButton.getAttribute('tabindex')).toBeNull()
+    expect(removeButton.getAttribute('aria-label')).toBe('Remove from list')
+    // Enter/Space on a focused native button fire a `click`; simulate that path.
+    removeButton.focus()
+    expect(target.contains(document.activeElement)).toBe(true)
+    removeButton.dispatchEvent(new MouseEvent('click', { bubbles: true }))
+    await tick()
+    expect(removeRecentPathMock).toHaveBeenCalledWith('a')
+    expect(onGo).not.toHaveBeenCalled()
+    cleanup()
+  })
+
   it('Enter confirms: jumps and closes on a directory outcome', async () => {
     const onGo = goMock({ kind: 'directory', path: '/typed' })
     const { target, onCancel, cleanup } = setup({ onGo })

apps/desktop/src/lib/go-to-path/go-to-path.test.ts

@@ -94,8 +94,8 @@ describe('goToPath handler', () => {
     expect(addRecentPathStateMock).toHaveBeenCalledWith(expect.objectContaining({ path: '/tmp/here' }))
   })
 
-  it('file → navigateToFileInPane + records the full file path', async () => {
-    okResolve({ kind: 'file', parentDir: '/tmp', fileName: 'a.txt' })
+  it('file → navigateToFileInPane + records the backend-authoritative path', async () => {
+    okResolve({ kind: 'file', path: '/tmp/a.txt', parentDir: '/tmp', fileName: 'a.txt' })
     await goToPath(makeExplorerStub(), '/tmp/a.txt')
     expect(navigateToFileMock).toHaveBeenCalledWith(expect.anything(), 'left', '/tmp', 'a.txt')
     expect(navigateToDirMock).not.toHaveBeenCalled()
@@ -184,7 +184,7 @@ describe('digitToRecentIndex', () => {
 describe('shouldPrefillClipboard', () => {
   it('is true for directory and file resolutions', () => {
     expect(shouldPrefillClipboard({ kind: 'directory', path: '/x' })).toBe(true)
-    expect(shouldPrefillClipboard({ kind: 'file', parentDir: '/x', fileName: 'a' })).toBe(true)
+    expect(shouldPrefillClipboard({ kind: 'file', path: '/x/a', parentDir: '/x', fileName: 'a' })).toBe(true)
   })
 
   it('is false for nearestAncestor and invalid resolutions', () => {

apps/desktop/src/lib/go-to-path/go-to-path.ts

@@ -69,7 +69,7 @@ export async function goToPath(
       return resolution
     case 'file':
       await navigateToFileInPane(explorer, pane, resolution.parentDir, resolution.fileName)
-      await recordRecent(`${resolution.parentDir}/${resolution.fileName}`.replace(/\/+/g, '/'))
+      await recordRecent(resolution.path)
       return resolution
     case 'nearestAncestor': {
       await navigateToDirInPane(explorer, pane, resolution.ancestorDir)

apps/desktop/src/lib/go-to-path/recent-paths-state.svelte.ts

@@ -28,11 +28,6 @@ export function getRecentPathsList(): RecentPathEntry[] {
   return entries
 }
 
-/** Whether `loadRecentPaths()` has completed at least once this session. */
-export function getRecentPathsLoaded(): boolean {
-  return loaded
-}
-
 /**
  * Loads the persisted recent paths from the backend. Idempotent: subsequent
  * calls in the same session are no-ops unless `force` is set. The dialog calls

apps/desktop/src/lib/go-to-path/recent-paths-state.test.ts

@@ -22,7 +22,6 @@ vi.mock('$lib/ipc/bindings', () => ({
 
 import {
   getRecentPathsList,
-  getRecentPathsLoaded,
   loadRecentPaths,
   addRecentPath,
   removeRecentPath,
@@ -67,12 +66,11 @@ describe('recent-paths-state mirror', () => {
     })
   })
 
-  it('load() pulls the backend list and marks loaded', async () => {
+  it('load() pulls the backend list', async () => {
     store = [makeEntry('/a'), makeEntry('/b')]
-    expect(getRecentPathsLoaded()).toBe(false)
+    expect(getRecentPathsList()).toEqual([])
     await loadRecentPaths()
     expect(getRecentPathsList().map((e) => e.path)).toEqual(['/a', '/b'])
-    expect(getRecentPathsLoaded()).toBe(true)
   })
 
   it('load() is idempotent unless forced', async () => {

apps/desktop/src/lib/ipc/bindings.ts

@@ -2703,8 +2703,12 @@ export type GoToLatestError =
 export type GoToPathResolution =
   // The resolved path is an existing directory. Navigate into it.
   | { kind: 'directory'; path: string }
-  // The resolved path is an existing file. Navigate to its parent and select it.
-  | { kind: 'file'; parentDir: string; fileName: string }
+  /**
+   *  The resolved path is an existing file. `path` is the canonical normalized
+   *  full path (recorded into recents); `parent_dir` / `file_name` drive the
+   *  navigate-to-parent + select.
+   */
+  | { kind: 'file'; path: string; parentDir: string; fileName: string }
   /**
    *  The resolved path doesn't exist. `ancestor_dir` is the nearest existing
    *  ancestor (worst case `/`). Navigate there and fire an INFO toast.