File list: Insert toggles selection and advances cursor

- Add `selection.toggleAndDown` command on the `Insert` shortcut (Total Commander style). `..` isn't selectable, but the cursor still advances; at the last row it toggles without moving.
- Drive-by: wire the existing `selection.toggle` palette entry to the actual handler — clicking "Toggle selection" in the palette previously did nothing.
- Bugfix: `selection.toggleAt`, `handleShiftNavigation`, and `selectRange` weren't firing `onChanged`, so Space / Insert / Shift+arrows / range-click silently mutated selection without notifying MCP. `cmdr://state` reported `selected: 0` while the UI showed selected rows.
- Bugfix: cursor changes via keyboard nav (arrows, Home/End, PageUp/Down, Insert-advance) bypassed MCP sync — only `setCursorIndex` (the MCP `move_cursor` path) synced. Now a single `$effect` on `cursorIndex` in `FilePane` calls `debouncedSyncMcp.call()` so every mutation surfaces.
- Tests: 3 new Insert behavior cases in `selection-consistency.test.ts` (regular file, `..`, last row), plus `onChanged`-fires assertions in `selection-state.test.ts` for `toggleAt`, `selectRange`, and `handleShiftNavigation`.
- Stops Space/Insert event propagation past the FilePane handler so the new dispatch case doesn't double-fire on keypress.
- Docs: update file-explorer `CLAUDE.md` selection bullet and roadmap copy.

Author: vdavid

apps/desktop/src/lib/commands/command-registry.ts

@@ -423,6 +423,14 @@ export const commands: Command[] = [
     showInPalette: true,
     shortcuts: ['Space'],
   },
+  {
+    id: 'selection.toggleAndDown',
+    name: 'Toggle selection and move down',
+    scope: 'Main window/File list',
+    showInPalette: true,
+    shortcuts: ['Insert'],
+    description: 'Selects or deselects the file under the cursor, then moves down (Total Commander style)',
+  },
   {
     id: 'selection.selectAll',
     name: 'Select all',

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

@@ -7,6 +7,9 @@ Dual-pane file explorer with keyboard-driven navigation, file selection, sorting
 ### User interaction
 
 - **Space**: toggle selection at cursor
+- **Insert**: toggle selection at cursor and move cursor down (Total Commander style). `..` isn't selectable, but the
+  cursor still advances. At the last row the cursor stays put. No physical Insert key on Apple keyboards — users can
+  remap via Karabiner-Elements, plug in a PC USB keyboard, or rebind in Settings → Shortcuts.
 - **Shift+click / Shift+arrow**: range selection with anchor (A) and end (B). If anchor already selected, range
   deselects.
 - **Cmd+A / Cmd+Shift+A**: select all / deselect all

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

@@ -2079,7 +2079,7 @@
 
     /**
      * Handle selection action from MCP.
-     * @param action - The selection action (clear, selectAll, deselectAll, toggleAtCursor, selectRange)
+     * @param action - The selection action (clear, selectAll, deselectAll, toggleAtCursor, toggleAtCursorAndMoveDown, selectRange)
      * @param startIndex - Start index for range selection
      * @param endIndex - End index for range selection
      */
@@ -2098,6 +2098,9 @@
             case 'toggleAtCursor':
                 paneRef.toggleSelectionAtCursor()
                 break
+            case 'toggleAtCursorAndMoveDown':
+                paneRef.toggleSelectionAndMoveDownAtCursor()
+                break
             case 'selectRange':
                 if (startIndex !== undefined && endIndex !== undefined) {
                     paneRef.selectRange(startIndex, endIndex)

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

@@ -611,6 +611,20 @@
         selection.toggleAt(cursorIndex, hasParent)
     }
 
+    /**
+     * Toggle selection at cursor, then move cursor down by one row. Mirrors
+     * the Total Commander Insert-key behavior. `toggleAt` no-ops on `..` (the
+     * parent entry isn't selectable); the cursor still advances. At the last
+     * row the selection toggles but the cursor stays put (no wrap-around).
+     */
+    export function toggleSelectionAndMoveDownAtCursor(): void {
+        selection.toggleAt(cursorIndex, hasParent)
+        if (cursorIndex < effectiveTotalCount - 1) {
+            const listRef = viewMode === 'brief' ? briefListRef : fullListRef
+            applyNavigation(cursorIndex + 1, listRef, false)
+        }
+    }
+
     export function selectRange(startIndex: number, endIndex: number): void {
         selection.selectRange(startIndex, endIndex, hasParent)
     }
@@ -1573,10 +1587,22 @@
         // Space - toggle selection at cursor
         if (e.key === ' ') {
             e.preventDefault()
+            // Stop propagation so the document-level centralized dispatch doesn't
+            // re-fire `selection.toggle` (whose case in command-dispatch.ts exists
+            // for palette/MCP triggers).
+            e.stopPropagation()
             selection.toggleAt(cursorIndex, hasParent)
 
             return true
         }
+        // Insert - toggle selection at cursor and move cursor down (Total Commander style)
+        if (e.key === 'Insert') {
+            e.preventDefault()
+            // See Space note above re: stopPropagation.
+            e.stopPropagation()
+            toggleSelectionAndMoveDownAtCursor()
+            return true
+        }
         // Cmd+A - select all (Cmd+Shift+A - deselect all)
         if (e.key === 'a' && e.metaKey) {
             e.preventDefault()
@@ -1835,11 +1861,15 @@
         }
     })
 
-    // Re-fetch entry under the cursor when cursorIndex changes (debounced: status bar info can lag one frame)
+    // Re-fetch entry under the cursor when cursorIndex changes (debounced: status bar info can lag one frame).
+    // Also sync to MCP so cmdr://state reflects keyboard nav (arrows, Insert, PageUp/Down, Home/End, click-to-position).
+    // Previously, only listing changes and visible-range scrolls triggered the sync, so cursor moves within an
+    // already-rendered window stayed invisible to MCP-driven agents.
     $effect(() => {
         void cursorIndex // Track
         if (listingId && !loading) {
             debouncedFetchEntry.call()
+            debouncedSyncMcp.call()
         }
     })
 

apps/desktop/src/lib/file-explorer/pane/selection-consistency.test.ts

@@ -9,6 +9,7 @@ import { describe, it, expect, vi } from 'vitest'
 import { mount, tick } from 'svelte'
 import FilePane from './FilePane.svelte'
 import { waitForUpdates, useMountTarget } from './integration-test-utils'
+import { findFileIndex } from '$lib/tauri-commands'
 
 // ============================================================================
 // Mock setup (must be in each test file; Vitest hoists vi.mock calls)
@@ -93,13 +94,15 @@ vi.mock('$lib/tauri-commands', () => ({
   notifyDialogOpened: vi.fn().mockResolvedValue(undefined),
   notifyDialogClosed: vi.fn().mockResolvedValue(undefined),
   watchVolumeSpace: vi.fn().mockResolvedValue(undefined),
+  getDirStatsBatch: vi.fn().mockResolvedValue({}),
 }))
 
 vi.mock('$lib/icon-cache', async () => {
   const { writable } = await import('svelte/store')
   return {
     getCachedIcon: vi.fn().mockReturnValue('/icons/file.png'),
     iconCacheVersion: writable(0),
+    iconCacheCleared: writable(0),
     prefetchIcons: vi.fn().mockResolvedValue(undefined),
   }
 })
@@ -130,6 +133,11 @@ vi.mock('$lib/settings/reactive-settings.svelte', () => ({
   getUseAppIconsForDocuments: vi.fn().mockReturnValue(true),
   getSizeDisplayMode: vi.fn().mockReturnValue('smart'),
   getNetworkEnabled: vi.fn().mockReturnValue(true),
+  getSizeMismatchWarning: vi.fn().mockReturnValue(false),
+  getStripedRows: vi.fn().mockReturnValue(false),
+  getBriefColumnWidthMode: vi.fn().mockReturnValue('auto'),
+  getBriefColumnWidthMaxPx: vi.fn().mockReturnValue(400),
+  getIsCmdrGold: vi.fn().mockReturnValue(false),
 }))
 
 vi.mock('$lib/drag-drop', () => ({ startDragTracking: vi.fn() }))
@@ -348,6 +356,186 @@ describe('Selection state consistency', () => {
     expect(getSelectedIndices()).toEqual([])
   })
 
+  it('Insert key toggles selection and moves cursor down', async () => {
+    const component = mount(FilePane, {
+      target: getTarget(),
+      props: {
+        initialPath: '/',
+        volumeId: 'root',
+        volumePath: '/',
+        isFocused: true,
+        showHiddenFiles: true,
+        viewMode: 'brief',
+      },
+    })
+
+    await waitForUpdates(100)
+
+    type Api = {
+      handleKeyDown: (e: KeyboardEvent) => void
+      adoptListing: (s: {
+        currentPath: string
+        listingId: string
+        totalCount: number
+        cursorIndex: number
+        selectedIndices: number[]
+        lastSequence: number
+      }) => void
+      getSelectedIndices: () => number[]
+      getCursorIndex: () => number
+    }
+    const c = component as unknown as Api
+
+    // Test mocks don't drive the `listing-complete` event, so totalCount stays
+    // at 0 unless we adopt a listing. Seed: 10 rows, no parent, cursor at 0.
+    c.adoptListing({
+      currentPath: '/',
+      listingId: 'mock-listing',
+      totalCount: 10,
+      cursorIndex: 0,
+      selectedIndices: [],
+      lastSequence: 0,
+    })
+    // Let the listingId-driven $effect (refetch totalCount + clamp cursor) settle
+    // before we exercise the handler — otherwise its async chain races with the keypress.
+    await waitForUpdates(50)
+
+    expect(c.getSelectedIndices()).toEqual([])
+    expect(c.getCursorIndex()).toBe(0)
+
+    const insertEvent = new KeyboardEvent('keydown', { key: 'Insert', bubbles: true })
+    c.handleKeyDown(insertEvent)
+    await tick()
+
+    // Cursor row 0 is selected, cursor advanced to row 1
+    expect(c.getSelectedIndices()).toEqual([0])
+    expect(c.getCursorIndex()).toBe(1)
+
+    // Press again at row 1: select row 1, advance to row 2
+    c.handleKeyDown(insertEvent)
+    await tick()
+    expect(c.getSelectedIndices().sort()).toEqual([0, 1])
+    expect(c.getCursorIndex()).toBe(2)
+  })
+
+  it('Insert on ".." advances cursor without selecting the parent entry', async () => {
+    // initialPath !== volumePath produces a ".." entry at index 0
+    const component = mount(FilePane, {
+      target: getTarget(),
+      props: {
+        initialPath: '/test',
+        volumeId: 'root',
+        volumePath: '/',
+        isFocused: true,
+        showHiddenFiles: true,
+        viewMode: 'brief',
+      },
+    })
+
+    await waitForUpdates(100)
+
+    type Api = {
+      handleKeyDown: (e: KeyboardEvent) => void
+      adoptListing: (s: {
+        currentPath: string
+        listingId: string
+        totalCount: number
+        cursorIndex: number
+        selectedIndices: number[]
+        lastSequence: number
+      }) => void
+      getSelectedIndices: () => number[]
+      getCursorIndex: () => number
+    }
+    const c = component as unknown as Api
+
+    // 10 backend rows + ".." = 11 frontend rows; cursor on ".." (index 0).
+    // Same race as the "last row" test: the listingId-driven $effect calls
+    // findFileIndex (mocked to 0) and would yank the cursor off ".." onto
+    // the first real row. Return null so the effect leaves cursor alone.
+    vi.mocked(findFileIndex).mockResolvedValueOnce(null)
+    c.adoptListing({
+      currentPath: '/test',
+      listingId: 'mock-listing',
+      totalCount: 10,
+      cursorIndex: 0,
+      selectedIndices: [],
+      lastSequence: 0,
+    })
+    await waitForUpdates(50)
+
+    expect(c.getCursorIndex()).toBe(0) // sitting on ".."
+    expect(c.getSelectedIndices()).toEqual([])
+
+    const insertEvent = new KeyboardEvent('keydown', { key: 'Insert', bubbles: true })
+    c.handleKeyDown(insertEvent)
+    await tick()
+
+    // ".." stayed unselected; cursor moved down anyway
+    expect(c.getSelectedIndices()).toEqual([])
+    expect(c.getCursorIndex()).toBe(1)
+  })
+
+  it('Insert at last row toggles but does not move cursor past end', async () => {
+    const component = mount(FilePane, {
+      target: getTarget(),
+      props: {
+        initialPath: '/',
+        volumeId: 'root',
+        volumePath: '/',
+        isFocused: true,
+        showHiddenFiles: true,
+        viewMode: 'brief',
+      },
+    })
+
+    await waitForUpdates(100)
+
+    type Api = {
+      handleKeyDown: (e: KeyboardEvent) => void
+      adoptListing: (s: {
+        currentPath: string
+        listingId: string
+        totalCount: number
+        cursorIndex: number
+        selectedIndices: number[]
+        lastSequence: number
+      }) => void
+      getSelectedIndices: () => number[]
+      getCursorIndex: () => number
+    }
+    const c = component as unknown as Api
+
+    // 10 rows, no parent, cursor on the last row (index 9).
+    // The listingId-driven $effect would otherwise call findFileIndex (mocked to 0)
+    // and yank the cursor back to 0 after we adopt cursor: 9.
+    vi.mocked(findFileIndex).mockResolvedValueOnce(8)
+    c.adoptListing({
+      currentPath: '/',
+      listingId: 'mock-listing',
+      totalCount: 10,
+      cursorIndex: 9,
+      selectedIndices: [],
+      lastSequence: 0,
+    })
+    await waitForUpdates(50)
+    // After the effect settles, cursor lands wherever findFileIndex pointed.
+    // We just need it pinned to the last row before pressing Insert.
+    const setCursorIndex = (component as unknown as { setCursorIndex: (i: number) => Promise<void> }).setCursorIndex
+    await setCursorIndex(9)
+    await tick()
+
+    expect(c.getCursorIndex()).toBe(9)
+
+    const insertEvent = new KeyboardEvent('keydown', { key: 'Insert', bubbles: true })
+    c.handleKeyDown(insertEvent)
+    await tick()
+
+    // Last row toggled; cursor stayed put
+    expect(c.getSelectedIndices()).toEqual([9])
+    expect(c.getCursorIndex()).toBe(9)
+  })
+
   it('handleKeyUp export exists and handles Shift release', async () => {
     const component = mount(FilePane, {
       target: getTarget(),

apps/desktop/src/lib/file-explorer/pane/selection-state.svelte.ts

@@ -90,13 +90,16 @@ export function createSelectionState(options?: { onChanged?: () => void }) {
     // Can't select ".." entry
     if (hasParent && index === 0) return false
 
+    let result: boolean
     if (selectedIndices.has(index)) {
       selectedIndices.delete(index)
-      return false
+      result = false
     } else {
       selectedIndices.add(index)
-      return true
+      result = true
     }
+    onChanged?.()
+    return result
   }
 
   function handleShiftNavigation(newIndex: number, cursorIndex: number, hasParent: boolean) {
@@ -109,6 +112,7 @@ export function createSelectionState(options?: { onChanged?: () => void }) {
 
     // Apply the range selection
     applyRangeSelection(newIndex, hasParent)
+    onChanged?.()
   }
 
   function selectAll(hasParent: boolean, effectiveTotalCount: number) {
@@ -133,6 +137,7 @@ export function createSelectionState(options?: { onChanged?: () => void }) {
       selectedIndices.add(i)
     }
     clearRangeState()
+    onChanged?.()
   }
 
   function isAllSelected(hasParent: boolean, effectiveTotalCount: number): boolean {