Bugfix: cursor lands on new folder, not the row below

- After F7/Shift+F4, `create_directory`/`create_file` queue a synthetic `directory-diff` with 50 ms trailing-window coalesce (diff_emitter). The optimistic `setCursorIndex` in `moveCursorToNewFolder` landed correctly, but when the deferred diff fired, `FilePane`'s diff handler ran the new entry's index through `adjustSelectionIndices` and shifted the cursor +1 (an `add` at the cursor's index pushes the cursor down).
- Fix: `moveCursorToNewFolder` now also calls `paneRef.setPendingCursorName(name)`. The diff handler already reads `pendingCursorName` for the rename flow — when the diff lands, it re-pins the cursor by name and `return`s before the structural shift runs. Reuses the existing channel rather than adding a parallel one.
- New `FilePaneAPI.setPendingCursorName(name)` exposes the field; current call site is `moveCursorToNewFolder`, also used by mkfile via the shared helper.
- E2E regression guard: `file-operations.spec.ts › Create folder round-trip › cursor lands on the newly created folder` — picks a name that sorts between two existing dirs (`bulk` < `mid-cursor-…` < `sub-dir`) so an off-by-one shift surfaces as a different filename. Asserts cursor name 5× at 80 ms intervals.
- `CLAUDE.md` gotcha added so the next agent doesn't re-introduce the race.

Author: vdavid

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

@@ -553,6 +553,17 @@
         return cursorIndex
     }
 
+    /**
+     * Sets the "land the cursor on this name when the next diff applies" marker.
+     * The diff handler already reads `renameFlow.pendingCursorName` for the rename
+     * flow; mkdir/mkfile reuse the same channel so a freshly-created entry can
+     * dodge the structural cursor shift `adjustSelectionIndices` would otherwise
+     * apply when an `add` lands at or above the cursor's index.
+     */
+    export function setPendingCursorName(name: string | null): void {
+        renameFlow.pendingCursorName = name
+    }
+
     /**
      * Handles one keystroke for the type-to-jump feature. Appends to the buffer,
      * fires the IPC match, and (on the response) moves the cursor.

apps/desktop/src/lib/file-explorer/pane/types.ts

@@ -29,6 +29,13 @@ export interface FilePaneAPI {
   getNetworkCursorEntry(): NetworkCursorEntry | null
   setCursorIndex(index: number): Promise<void>
   getCursorIndex(): number
+  /**
+   * Queues a "land the cursor on this filename once the next directory-diff
+   * applies" intent. Used by mkdir/mkfile/rename to defeat the structural
+   * cursor-shift the diff handler would otherwise apply when an entry is
+   * inserted at or above the cursor's index.
+   */
+  setPendingCursorName(name: string | null): void
   isInNetworkView(): boolean
   hasParentEntry(): boolean
   getCurrentPath(): string

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

@@ -186,3 +186,11 @@ When directory has parent entry shown at index 0, frontend indices are offset by
   `await`. Both paths converge on a local `kickOff()` helper guarded by a `started` flag, so `startOperation()`
   dispatches exactly once. The scan-error and scan-cancelled listeners also flip `started = true` as a terminal signal,
   so a late `scan-preview-complete` event can't dispatch an operation after we've errored or cancelled.
+- **mkdir/mkfile must set `paneRef.setPendingCursorName(name)` before the optimistic `setCursorIndex`**:
+  `create_directory` / `create_file` queue a synthetic `directory-diff` through `diff_emitter::enqueue_diff` (50 ms
+  trailing-window coalesce). The optimistic `setCursorIndex` in `moveCursorToNewFolder` lands the cursor correctly at
+  the moment, but when the deferred diff fires, `FilePane`'s diff handler runs the new entry's index through
+  `adjustSelectionIndices` and shifts the cursor +1 (an `add` at the cursor's index always pushes the cursor down).
+  `setPendingCursorName` writes to the same `pendingCursorName` field the diff handler already checks for the rename
+  flow: when the diff lands, it re-pins the cursor by name and `return`s before the structural shift runs. Regression
+  guard: `file-operations.spec.ts › Create folder round-trip › cursor lands on the newly created folder`.

apps/desktop/src/lib/file-operations/mkdir/new-folder-operations.ts

@@ -38,6 +38,14 @@ export async function moveCursorToNewFolder(
   listen: ListenFn,
   findFileIndex: FindFileIndexFn,
 ): Promise<void> {
+  // Mark the new entry as the cursor target for the next directory-diff. When
+  // the diff lands (~50 ms later via diff_emitter's trailing-window coalesce),
+  // FilePane re-pins the cursor by name and skips the structural shift that
+  // `adjustSelectionIndices` would otherwise apply for an `add` at the cursor's
+  // index. Without this, the optimistic setCursorIndex below ends up shifted
+  // one row down by the time the diff arrives.
+  paneRef?.setPendingCursorName(folderName)
+
   // Try to find the folder immediately: the directory-diff event often fires
   // before this listener is set up (the folder is created before onCreated runs).
   const tryMoveCursor = async (): Promise<boolean> => {

apps/desktop/test/e2e-playwright/file-operations.spec.ts

@@ -211,6 +211,43 @@ test.describe('Create folder round-trip', () => {
     expect(fs.existsSync(folderPath)).toBe(true)
     expect(fs.statSync(folderPath).isDirectory()).toBe(true)
   })
+
+  test('cursor lands on the newly created folder', async ({ tauriPage }) => {
+    // The synthetic directory-diff for the new entry is emitted with a 50 ms
+    // trailing-window coalesce (see listing/diff_emitter.rs). After mkdir, the
+    // optimistic setCursorIndex landed the cursor correctly, but the deferred
+    // diff then ran through the structural cursor-adjustment path and shifted
+    // it one row down. This assertion is the regression guard for that race.
+    await ensureAppReady(tauriPage)
+
+    // Pick a name that sorts in the middle of the existing dirs so an off-by-one
+    // cursor shift produces a different filename. Fixture dirs sorted Asc:
+    // bulk, sub-dir. "mid-..." sorts between them.
+    const folderName = `mid-cursor-folder-${String(Date.now())}`
+
+    await tauriPage.keyboard.press('F7')
+    await tauriPage.waitForSelector(MKDIR_DIALOG, 5000)
+    await tauriPage.waitForSelector(`${MKDIR_DIALOG} .name-input`, 3000)
+    await tauriPage.fill(`${MKDIR_DIALOG} .name-input`, folderName)
+    await pollUntil(tauriPage, async () => tauriPage.isEnabled(`${MKDIR_DIALOG} .btn-primary`), 2000)
+    await tauriPage.click(`${MKDIR_DIALOG} .btn-primary`)
+
+    // Dialog closes and the listing renders the new folder. fileExistsInFocusedPane
+    // polls the DOM, so by the time it returns true the diff has been applied.
+    await pollUntil(tauriPage, async () => !(await tauriPage.isVisible('.modal-overlay')), 5000)
+    await pollUntil(tauriPage, async () => fileExistsInFocusedPane(tauriPage, folderName), 5000)
+
+    // Cursor must be on the new folder and stay there. Five checks at 80 ms
+    // intervals cover both the immediate-post-diff window and any later
+    // re-render that might shift the cursor.
+    for (let i = 0; i < 5; i++) {
+      const cursorName = await tauriPage.evaluate<string>(
+        `document.querySelector('.file-pane.is-focused .file-entry.is-under-cursor')?.getAttribute('data-filename') || ''`,
+      )
+      expect(cursorName, `cursor moved off ${folderName} on iteration ${String(i)}`).toBe(folderName)
+      if (i < 4) await new Promise((r) => setTimeout(r, 80))
+    }
+  })
 })
 
 test.describe('View mode toggle', () => {