Feature: copy path between panes with ⌘← / ⌘→

- Two new commands ("Copy path from left to right pane" / "right to left"), customizable in Settings → Shortcuts.
- When fired from the source pane with the cursor on a folder, opens that folder on the target. Otherwise opens the source pane's current dir on the target.
- Symlinks-to-directories are followed; symlinks-to-files are treated as files.
- Works across volumes; target switches volume automatically.
- Network browser is mirrored: cursor-on-server opens that server's share list on the target, cursor-on-share auto-mounts the share on the target (full credential flow if needed).
- Focus stays on the source pane after the action — user keeps working where they were.
- `⌘←` / `⌘→` pass through to text inputs (rename editor, palette search, etc.) so macOS line-start/end still works there.
- Plain `←` / `→` keep their existing cursor behavior; only ⌘+arrows are reserved for the new commands.

Bugfix: drop stale `onPathChange` events that arrive on a pane after it was switched to the virtual `network` volume. Without the gate, a slow listing-complete from the prior SMB folder corrupted `panePath` and `lastUsedPathForVolume('network')` (visible as "Network ▸ /Volumes/<share>/<subdir>" in the breadcrumb). Pre-existing, unmasked by the new feature's volume-switching flow.

`ShareBrowser` auto-mount gate now fires once per distinct prop value (was once per component instance) so the new cursor-on-share path can mount a different share on the same host without forcing a remount.

Author: vdavid

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

@@ -152,6 +152,24 @@ export const commands: Command[] = [
     showInPalette: true,
     shortcuts: ['⌥F2'],
   },
+  {
+    id: 'pane.copyPathLeftToRight',
+    name: 'Copy path from left to right pane',
+    scope: 'Main window',
+    showInPalette: true,
+    shortcuts: ['⌘→'],
+    description:
+      'Open the left pane’s location on the right. When the left pane is focused and the cursor is on a folder, that folder opens on the right instead.',
+  },
+  {
+    id: 'pane.copyPathRightToLeft',
+    name: 'Copy path from right to left pane',
+    scope: 'Main window',
+    showInPalette: true,
+    shortcuts: ['⌘←'],
+    description:
+      'Open the right pane’s location on the left. When the right pane is focused and the cursor is on a folder, that folder opens on the left instead.',
+  },
 
   // ============================================================================
   // Main window - Tab commands

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

@@ -357,6 +357,15 @@ finished importing during the rebuild. This is a SvelteKit bug (sveltejs/kit#152
 crash and forces a clean page reload. The recovery listener is imported from `+layout.ts` (a stable module that survives
 layout component re-evaluation). If sveltejs/kit#15287 gets fixed, the workaround can be removed.
 
+**Stale `onPathChange` from a slow listing can poison a pane after a volume switch.** `FilePane.onPathChange` fires on
+`listing-complete` for whatever path the pane was loading. If the user (or a command like "Copy path between panes")
+flips the pane to a different volume — especially the virtual `network` volume — between `listing-start` and
+`listing-complete`, the stale callback lands on a pane whose `volumeId` no longer matches the path it carries.
+`applyPathChange` in `DualPaneExplorer` guards against the `network` case (drops paths that don't start with `smb://`)
+because `pushPath` inherits the current `volumeId` and would otherwise write a malformed `{network, /Volumes/...}`
+history entry plus a corrupted `lastUsedPathForVolume('network')`. If you introduce another virtual-volume namespace
+with its own non-filesystem prefix, extend the guard.
+
 ## Views (`views/`)
 
 `BriefList` and `FullList` virtual-scrolling components. Brief-mode column widths come from the

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

@@ -106,6 +106,10 @@ row. Clicking it calls `forgetCredentials` and clears `authenticatedCredentials`
 
 Shares displayed sorted case-insensitively. Escape/Backspace go back to host list.
 
+The `autoMountShare` prop fires once per distinct value (tracked via `lastAutoMountAttempt`), not once per
+`ShareBrowser` instance. This lets the "Copy path between panes" command auto-mount a different share without forcing a
+remount when the source pane's cursor moves to another share on the same host.
+
 ## `NetworkLoginForm.svelte`
 
 Props: `host`, `shareName?`, `authMode`, `errorMessage?`, `isConnecting?`, `onConnect`, `onCancel`.

apps/desktop/src/lib/file-explorer/network/NetworkBrowser.svelte

@@ -205,6 +205,18 @@
         return hosts.findIndex((h) => h.name.toLowerCase() === name.toLowerCase())
     }
 
+    /**
+     * Returns the host under the cursor, or `null` when the cursor sits on the
+     * "Connect to server…" pseudo-row or the list is empty. Consumed by the
+     * "Copy path between panes" command so cursor-on-server mirrors that server.
+     */
+    // noinspection JSUnusedGlobalSymbols -- used dynamically by NetworkMountView
+    export function getHostUnderCursor(): NetworkHost | null {
+        if (isCursorOnConnectRow) return null
+        if (cursorIndex < 0 || cursorIndex >= hosts.length) return null
+        return hosts[cursorIndex]
+    }
+
     /** Opens the host (or "Connect to server…" row) under the cursor — same action Enter triggers. */
     // noinspection JSUnusedGlobalSymbols -- used dynamically by NetworkMountView / MCP
     export function openCursorItem(): void {
@@ -289,6 +301,11 @@
             return true
         }
 
+        // ⌘← / ⌘→ are reserved for "Copy path between panes" (document-level
+        // dispatch), so let them bubble instead of jumping the cursor.
+        if (e.metaKey && (e.key === 'ArrowLeft' || e.key === 'ArrowRight')) {
+            return false
+        }
         if (handleArrowAndEnter(e.key)) {
             e.preventDefault()
             return true

apps/desktop/src/lib/file-explorer/network/ShareBrowser.svelte

@@ -78,8 +78,10 @@
     // Track authenticated credentials for mounting
     let authenticatedCredentials = $state<{ username: string; password: string } | null>(null)
 
-    // Auto-mount tracking (for smb://host/share URLs)
-    let autoMountAttempted = $state(false)
+    // Auto-mount tracking: track the last share we tried so the same prop value
+    // doesn't re-fire, but a new value (for example via "Copy path between panes"
+    // with cursor on a different share) does.
+    let lastAutoMountAttempt = $state<string | undefined>(undefined)
 
     // Container tracking for PageUp/PageDown
     let listContainer: HTMLDivElement | undefined = $state()
@@ -98,11 +100,12 @@
         void syncPaneStateToMcp()
     })
 
-    // Auto-mount a share if requested (from smb://host/share URL)
+    // Auto-mount a share if requested (from smb://host/share URL, or "Copy path
+    // between panes" with cursor on a share). Fires once per distinct prop value.
     $effect(() => {
         const shareName = autoMountShare
-        if (autoMountAttempted || !shareName || loading || sortedShares.length === 0) return
-        autoMountAttempted = true
+        if (!shareName || shareName === lastAutoMountAttempt || loading || sortedShares.length === 0) return
+        lastAutoMountAttempt = shareName
 
         const match = sortedShares.find(
             (s) => s.name.localeCompare(shareName, undefined, { sensitivity: 'base' }) === 0,
@@ -317,6 +320,19 @@
         return sortedShares.findIndex((s) => s.name.toLowerCase() === name.toLowerCase())
     }
 
+    /**
+     * Returns the share under the cursor, or `null` when nothing valid is highlighted
+     * (login form, empty list, out-of-range index). Consumed by the
+     * "Copy path between panes" command so cursor-on-share mounts that share on the
+     * target pane.
+     */
+    // noinspection JSUnusedGlobalSymbols -- used dynamically by NetworkMountView
+    export function getShareUnderCursor(): ShareInfo | null {
+        if (showLoginForm) return null
+        if (cursorIndex < 0 || cursorIndex >= sortedShares.length) return null
+        return sortedShares[cursorIndex]
+    }
+
     /** Opens the share under the cursor — same action Enter triggers. */
     // noinspection JSUnusedGlobalSymbols -- used dynamically by NetworkMountView / MCP
     export function openCursorItem(): void {
@@ -368,6 +384,11 @@
         return true
     }
 
+    /** `⌘←` / `⌘→` belong to "Copy path between panes" (document-level dispatch). */
+    function isCopyPathBetweenPanesShortcut(e: KeyboardEvent): boolean {
+        return e.metaKey && (e.key === 'ArrowLeft' || e.key === 'ArrowRight')
+    }
+
     export function handleKeyDown(e: KeyboardEvent): boolean {
         if (showLoginForm) {
             // Login form handles its own keyboard events
@@ -394,7 +415,7 @@
             return true
         }
 
-        // Handle arrow keys
+        if (isCopyPathBetweenPanesShortcut(e)) return false
         if (['ArrowDown', 'ArrowUp', 'ArrowLeft', 'ArrowRight'].includes(e.key)) {
             e.preventDefault()
             return handleArrowKey(e.key)

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

@@ -464,6 +464,17 @@
 
     /** Applies a path change to the active tab in-place (the normal non-pinned flow). */
     function applyPathChange(pane: 'left' | 'right', path: string) {
+        // Drop stale `onPathChange` events that arrive after the pane was
+        // switched to the virtual `network` volume. Without this gate, a
+        // listing-complete from the previous SMB folder lands after the user
+        // (or a command like "Copy path between panes") flips to Network, and
+        // `pushPath` inherits `volumeId='network'` while writing a real path
+        // — corrupting both `pane.path` and `lastUsedPathForVolume('network')`.
+        const currentVolumeId = getPaneVolumeId(pane)
+        if (currentVolumeId === 'network' && !path.startsWith('smb://')) {
+            log.debug('Dropping stale onPathChange on network pane: {path}', { path })
+            return
+        }
         setPanePath(pane, path)
         setPaneHistory(pane, pushPath(getPaneHistory(pane), path))
         saveAppStatus({ [paneKey(pane, 'path')]: path })
@@ -2377,6 +2388,103 @@
         return false
     }
 
+    /**
+     * "Copy path from <source> to <target> pane" command. Mirrors the source
+     * pane's location (volume + path + network state) into the target pane,
+     * without shifting keyboard focus. When the source pane is focused, the
+     * cursor refines the destination: cursor-on-folder uses the folder's path;
+     * cursor-on-server (network browser) sets the target's selected host;
+     * cursor-on-share (share browser) queues auto-mount on the target.
+     */
+    export function copyPathBetweenPanes(source: 'left' | 'right', target: 'left' | 'right'): void {
+        if (source === target) return
+        const sourcePaneRef = getPaneRef(source)
+        if (!sourcePaneRef) return
+
+        const sourceVolumeId = getPaneVolumeId(source)
+        const sourcePath = getPanePath(source)
+        const sourceHistoryEntry = getCurrentEntry(getPaneHistory(source))
+        const sourceHost = sourceHistoryEntry.networkHost ?? null
+        const sourceFocused = focusedPane === source
+
+        // Normal listing on the source: cursor-on-folder refines the path.
+        if (sourceVolumeId !== 'network') {
+            let destPath = sourcePath
+            if (sourceFocused) {
+                const entry = sourcePaneRef.getCursorEntry()
+                if (entry && entry.isDirectory && entry.name !== '..') {
+                    destPath = entry.path
+                }
+            }
+            mirrorLocalStateToPane(target, sourceVolumeId, destPath)
+            return
+        }
+
+        // Source is on the network volume (host list or share list).
+        let destHost: NetworkHost | null = sourceHost
+        let destAutoMountShare: string | undefined
+        if (sourceFocused) {
+            const cursor = sourcePaneRef.getNetworkCursorEntry()
+            if (cursor?.kind === 'host') {
+                destHost = cursor.host
+            } else if (cursor?.kind === 'share' && sourceHost) {
+                destAutoMountShare = cursor.share.name
+            }
+        }
+        mirrorNetworkStateToPane(target, destHost, destAutoMountShare)
+    }
+
+    /** Helper: mirror a {volumeId, path} state to a target pane without shifting focus. */
+    function mirrorLocalStateToPane(target: 'left' | 'right', volumeId: string, path: string): void {
+        const originalFocused = focusedPane
+        const targetVolumeId = getPaneVolumeId(target)
+        if (targetVolumeId !== volumeId) {
+            const volumePath = volumes.find((v) => v.id === volumeId)?.path ?? path
+            handleVolumeChange(target, volumeId, volumePath, path)
+        } else if (getPanePath(target) === path) {
+            // Already on the same volume and path; nothing to do.
+        } else {
+            setPanePath(target, path)
+            setPaneHistory(target, pushPath(getPaneHistory(target), path))
+            saveAppStatus({ [paneKey(target, 'path')]: path })
+            saveTabsForPaneSide(target)
+            void getPaneRef(target)?.navigateToPath(path)
+        }
+        restoreFocus(originalFocused)
+    }
+
+    /** Helper: mirror a network state ({host, autoMountShare}) to a target pane without shifting focus. */
+    function mirrorNetworkStateToPane(
+        target: 'left' | 'right',
+        host: NetworkHost | null,
+        autoMountShare: string | undefined,
+    ): void {
+        const originalFocused = focusedPane
+        const targetPaneRef = getPaneRef(target)
+        if (getPaneVolumeId(target) !== 'network') {
+            handleVolumeChange(target, 'network', 'smb://', 'smb://')
+        }
+        targetPaneRef?.setNetworkHost(host)
+        setPaneHistory(
+            target,
+            push(getPaneHistory(target), {
+                volumeId: 'network',
+                path: 'smb://',
+                networkHost: host ?? undefined,
+            }),
+        )
+        targetPaneRef?.setNetworkAutoMount(autoMountShare)
+        restoreFocus(originalFocused)
+    }
+
+    /** Restore focus to a pane after a target-pane state change so the user keeps working where they were. */
+    function restoreFocus(pane: 'left' | 'right'): void {
+        if (focusedPane !== pane) {
+            focusedPane = pane
+            saveAppStatus({ focusedPane: pane })
+        }
+    }
+
     /**
      * Refresh the focused pane.
      * Used by MCP refresh tool.

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

@@ -239,7 +239,7 @@
     // Disk space info for the current volume (fetched on mount, volume change, and after file ops)
     let volumeSpace: VolumeSpaceInfo | null = $state(null)
 
-    import type { ListViewAPI, VolumeBreadcrumbAPI, NetworkMountViewAPI } from './types'
+    import type { ListViewAPI, VolumeBreadcrumbAPI, NetworkMountViewAPI, NetworkCursorEntry } from './types'
 
     // Component refs for keyboard navigation
     let fullListRef: ListViewAPI | undefined = $state()
@@ -436,6 +436,9 @@
 
     // Network browsing state - tracked here for history navigation integration
     let currentNetworkHost = $state<NetworkHost | null>(null)
+    // Pending share to auto-mount on the network host. Set by "Copy path between
+    // panes" when the source pane has the cursor on a share. Cleared on volume leave.
+    let pendingAutoMountShare = $state<string | undefined>(undefined)
 
     // Clear the selected network host whenever the pane leaves the network
     // volume so that re-entering Network always lands on the host list, not on
@@ -453,6 +456,9 @@
         if (!isNetworkView && currentNetworkHost !== null) {
             currentNetworkHost = null
         }
+        if (!isNetworkView && pendingAutoMountShare !== undefined) {
+            pendingAutoMountShare = undefined
+        }
     })
 
     // noinspection JSUnusedGlobalSymbols -- Used dynamically
@@ -504,6 +510,28 @@
         return entryUnderCursor?.path
     }
 
+    /**
+     * The full `FileEntry` under the cursor (or `null`). Used by the
+     * "Copy path between panes" command to detect whether the cursor sits on
+     * a directory (incl. symlinks-to-directories) vs. a file or `..`.
+     * `..` is reported as-is (as a synthetic parent entry); callers should
+     * filter on `name === '..'` if needed.
+     */
+    // noinspection JSUnusedGlobalSymbols -- used by DualPaneExplorer.copyPathBetweenPanes
+    export function getCursorEntry(): FileEntry | null {
+        return entryUnderCursor
+    }
+
+    /**
+     * The network browser's cursor target (host or share), or `null` when
+     * this pane is not in the network view or nothing valid is under the cursor.
+     */
+    // noinspection JSUnusedGlobalSymbols -- used by DualPaneExplorer.copyPathBetweenPanes
+    export function getNetworkCursorEntry(): NetworkCursorEntry | null {
+        if (!isNetworkView) return null
+        return networkMountViewRef?.getNetworkCursorEntry() ?? null
+    }
+
     /** Also scrolls to make the cursor visible and syncs state to MCP. */
     export async function setCursorIndex(index: number): Promise<void> {
         if (isNetworkView) {
@@ -833,6 +861,17 @@
         networkMountViewRef?.setNetworkHost(host)
     }
 
+    /**
+     * Queues a share to auto-mount once `NetworkMountView`'s `ShareBrowser` is ready.
+     * Survives a not-yet-mounted view because the value is held here and re-passed
+     * via the `initialAutoMountShare` prop. Cleared automatically when the pane
+     * leaves the network volume.
+     */
+    // noinspection JSUnusedGlobalSymbols -- used by DualPaneExplorer.copyPathBetweenPanes
+    export function setNetworkAutoMount(shareName: string | undefined): void {
+        pendingAutoMountShare = shareName
+    }
+
     /** Navigates up and selects the folder we came from. Returns false if already at root. */
     export async function navigateToParent(): Promise<boolean> {
         if (currentPath === '/' || currentPath === volumePath) {
@@ -1557,8 +1596,19 @@
         // fetchEntryUnderCursor is handled by the $effect tracking cursorIndex
     }
 
+    /**
+     * `⌘←` / `⌘→` belong to "Copy path between panes" (document-level dispatch).
+     * Bail so the local pane handlers don't also move the cursor when those
+     * shortcuts fire. Other modifier + arrow combos keep their existing behavior.
+     */
+    function isShortcutModifierArrow(e: KeyboardEvent): boolean {
+        if (!e.metaKey) return false
+        return e.key === 'ArrowLeft' || e.key === 'ArrowRight'
+    }
+
     // Helper: Handle brief mode key navigation
     function handleBriefModeKeys(e: KeyboardEvent): boolean {
+        if (isShortcutModifierArrow(e)) return false
         const result = briefListRef?.handleKeyNavigation?.(e.key, e)
         if (result !== undefined) {
             e.preventDefault()
@@ -1570,6 +1620,7 @@
 
     // Helper: Handle full mode key navigation
     function handleFullModeKeys(e: KeyboardEvent): boolean {
+        if (isShortcutModifierArrow(e)) return false
         const visibleItems: number = fullListRef?.getVisibleItemsCount?.() ?? 20
         const shortcutResult = handleNavigationShortcut(e, {
             currentIndex: cursorIndex,
@@ -2355,6 +2406,7 @@
                 {paneId}
                 {isFocused}
                 initialNetworkHost={currentNetworkHost}
+                initialAutoMountShare={pendingAutoMountShare}
                 {onVolumeChange}
                 onNetworkHostChange={handleNetworkHostChange}
             />