Add per-pane tab support

- Independent tab bar per pane (always visible, Chrome-style shrinking, max 10)
- ⌘T creates instant new tab (clone trick — no reload), ⌘W closes, ⌃Tab/⌃⇧Tab cycles
- {#key} destroy/recreate for clean tab switches, cursor restored by filename
- Native context menu: pin/unpin, close others (skips pinned), close with confirmation for pinned
- Top menu too
- Persistence with migration from old scalar keys, debounced saveAppStatus
- MCP: activate_tab and pin_tab tools, tab list in cmdr://state YAML, debounced frontend→backend sync
- Rust: menu items replace "Close Window", tab context menu popup, update_pane_tabs command

Collateral:
- Sort is per-tab now (removed global columnSortOrders)
- Confirmation dialog now cancels on ESC

Author: vdavid

AGENTS.md

@@ -143,6 +143,9 @@ There are two MCP servers available to you:
 - When getting oriented, consider the docs: `docs` folder and `CLAUDE.md` files in each directory.
 - When coming up with a plan for a development, save it to `docs/specs/{feature}-plan.md` in this repo (we clean out old
   plans every few weeks/months, git history remembers them).
+- When writing a plan, always capture the INTENTION behind the plan, not just the steps. That way, the implementing
+  agent or human will know the "why"s behind the decisions and can adapt dynamically if it makes an unexpected discovery
+  during implementation.
 - Also create an accompanying task list that fully covers but doesn't duplicate the plan on a high level.
   If all items on the task list are honestly marked as done, the plan is fully implemented in great quality.
   Tasks should be one-liners, grouped by milestones. Include docs, testing, and running all necessary checks.

apps/desktop/coverage-allowlist.json

@@ -162,6 +162,12 @@
         },
         "indexing/index-state.svelte.ts": {
             "reason": "Reactive Svelte state, depends on Tauri event listeners"
+        },
+        "file-explorer/tabs/TabBar.svelte": {
+            "reason": "UI component, tab interactions tested via DualPaneExplorer integration"
+        },
+        "tauri-commands/tab.ts": {
+            "reason": "Tauri command wrappers, tested via integration"
         }
     }
 }

apps/desktop/src-tauri/capabilities/default.json

@@ -34,6 +34,7 @@
         "fs:allow-temp-write",
         "fs:allow-remove",
         "updater:default",
-        "process:allow-restart"
+        "process:allow-restart",
+        "dialog:allow-ask"
     ]
 }

apps/desktop/src-tauri/src/commands/file_system.rs

@@ -9,8 +9,8 @@ use crate::file_system::write_operations::{
 use crate::file_system::{
     DirectorySortMode, FileEntry, ListingStartResult, ListingStats, OperationStatus, OperationSummary, ResortResult,
     ScanConflict, SortColumn, SortOrder, StreamingListingStartResult, VolumeCopyConfig, VolumeCopyScanResult,
-    WriteOperationConfig, WriteOperationError, WriteOperationStartResult, cancel_listing as ops_cancel_listing,
-    cancel_all_write_operations as ops_cancel_all_write_operations,
+    WriteOperationConfig, WriteOperationError, WriteOperationStartResult,
+    cancel_all_write_operations as ops_cancel_all_write_operations, cancel_listing as ops_cancel_listing,
     cancel_write_operation as ops_cancel_write_operation, copy_between_volumes as ops_copy_between_volumes,
     copy_files_start as ops_copy_files_start, delete_files_start as ops_delete_files_start,
     find_file_index as ops_find_file_index, get_file_at as ops_get_file_at, get_file_range as ops_get_file_range,

apps/desktop/src-tauri/src/commands/ui.rs

@@ -1,5 +1,5 @@
 use crate::ignore_poison::IgnorePoison;
-use crate::menu::{MenuState, build_context_menu};
+use crate::menu::{MenuState, build_context_menu, build_tab_context_menu};
 #[cfg(target_os = "macos")]
 use std::process::Command;
 use tauri::menu::ContextMenu;
@@ -175,6 +175,40 @@ pub fn open_in_editor(_path: String) -> Result<(), String> {
     Err("Open in editor is only available on macOS".to_string())
 }
 
+/// Shows a native context menu for a tab (fire-and-forget).
+/// The selected action is delivered asynchronously via a `tab-context-action` Tauri event
+/// from `on_menu_event`, because `popup()` returns before the event loop processes the
+/// `MenuEvent` from muda. A synchronous channel approach doesn't work here — the wakeup
+/// signal posted during the popup's NSEvent tracking loop gets consumed, so `recv` always
+/// times out.
+#[tauri::command]
+pub fn show_tab_context_menu(
+    window: Window<tauri::Wry>,
+    is_pinned: bool,
+    can_close: bool,
+    has_other_unpinned_tabs: bool,
+) -> Result<(), String> {
+    let app = window.app_handle().clone();
+
+    let menu =
+        build_tab_context_menu(&app, is_pinned, can_close, has_other_unpinned_tabs).map_err(|e| e.to_string())?;
+    menu.popup(window).map_err(|e| e.to_string())?;
+
+    Ok(())
+}
+
+/// Updates the File menu "Pin tab" / "Unpin tab" label based on the active tab's pin state.
+#[tauri::command]
+pub fn update_pin_tab_menu<R: Runtime>(app: AppHandle<R>, is_pinned: bool) -> Result<(), String> {
+    let menu_state = app.state::<MenuState<R>>();
+    let guard = menu_state.pin_tab.lock_ignore_poison();
+    let Some(item) = guard.as_ref() else {
+        return Err("Menu not initialized".to_string());
+    };
+    let label = if is_pinned { "Unpin tab" } else { "Pin tab" };
+    item.set_text(label).map_err(|e| e.to_string())
+}
+
 /// Executes a menu action for the current context.
 pub fn execute_menu_action<R: Runtime>(app: &AppHandle<R>, id: &str) {
     let state = app.state::<MenuState<R>>();

apps/desktop/src-tauri/src/lib.rs

@@ -82,9 +82,10 @@ mod volumes;
 mod stubs;
 
 use menu::{
-    ABOUT_ID, COMMAND_PALETTE_ID, ENTER_LICENSE_KEY_ID, GO_BACK_ID, GO_FORWARD_ID, GO_PARENT_ID, MenuState, RENAME_ID,
-    SETTINGS_ID, SHOW_HIDDEN_FILES_ID, SORT_ASCENDING_ID, SORT_BY_CREATED_ID, SORT_BY_EXTENSION_ID,
-    SORT_BY_MODIFIED_ID, SORT_BY_NAME_ID, SORT_BY_SIZE_ID, SORT_DESCENDING_ID, SWAP_PANES_ID, SWITCH_PANE_ID,
+    ABOUT_ID, CLOSE_TAB_ID, COMMAND_PALETTE_ID, ENTER_LICENSE_KEY_ID, GO_BACK_ID, GO_FORWARD_ID, GO_PARENT_ID,
+    MenuState, NEW_TAB_ID, PIN_TAB_MENU_ID, RENAME_ID, SETTINGS_ID, SHOW_HIDDEN_FILES_ID, SORT_ASCENDING_ID,
+    SORT_BY_CREATED_ID, SORT_BY_EXTENSION_ID, SORT_BY_MODIFIED_ID, SORT_BY_NAME_ID, SORT_BY_SIZE_ID,
+    SORT_DESCENDING_ID, SWAP_PANES_ID, SWITCH_PANE_ID, TAB_CLOSE_ID, TAB_CLOSE_OTHERS_ID, TAB_PIN_ID,
     VIEW_MODE_BRIEF_ID, VIEW_MODE_FULL_ID, VIEWER_WORD_WRAP_ID, ViewMode,
 };
 use tauri::{Emitter, Manager};
@@ -254,6 +255,7 @@ pub fn run() {
             *menu_state.view_submenu.lock_ignore_poison() = Some(menu_items.view_submenu);
             *menu_state.view_mode_full_position.lock_ignore_poison() = menu_items.view_mode_full_position;
             *menu_state.view_mode_brief_position.lock_ignore_poison() = menu_items.view_mode_brief_position;
+            *menu_state.pin_tab.lock_ignore_poison() = Some(menu_items.pin_tab);
             app.manage(menu_state);
 
             // Set window title based on license status
@@ -380,6 +382,26 @@ pub fn run() {
             } else if id == SWAP_PANES_ID {
                 // Emit event to swap panes (main window only)
                 let _ = app.emit_to("main", "swap-panes", ());
+            } else if id == NEW_TAB_ID {
+                // Emit event to create a new tab (main window only)
+                let _ = app.emit_to("main", "new-tab", ());
+            } else if id == CLOSE_TAB_ID {
+                // Close the active tab if main window is focused, otherwise close the focused window
+                if let Some(main_window) = app.get_webview_window("main")
+                    && main_window.is_focused().unwrap_or(false)
+                {
+                    let _ = app.emit_to("main", "close-tab", ());
+                } else {
+                    for (_label, window) in app.webview_windows() {
+                        if window.is_focused().unwrap_or(false) {
+                            let _ = window.close();
+                            break;
+                        }
+                    }
+                }
+            } else if id == PIN_TAB_MENU_ID {
+                // Emit event to toggle pin on the active tab (main window only)
+                let _ = app.emit_to("main", "toggle-pin-tab", ());
             } else if id == SORT_BY_NAME_ID
                 || id == SORT_BY_EXTENSION_ID
                 || id == SORT_BY_SIZE_ID
@@ -417,6 +439,9 @@ pub fn run() {
                         break;
                     }
                 }
+            } else if id == TAB_PIN_ID || id == TAB_CLOSE_OTHERS_ID || id == TAB_CLOSE_ID {
+                // Tab context menu: emit event to frontend (async — popup returns before this fires)
+                let _ = app.emit_to("main", "tab-context-action", serde_json::json!({ "action": id }));
             } else {
                 // Handle file actions
                 commands::ui::execute_menu_action(app, id);
@@ -476,6 +501,8 @@ pub fn run() {
             commands::icons::clear_extension_icon_cache,
             commands::icons::clear_directory_icon_cache,
             commands::ui::show_file_context_menu,
+            commands::ui::show_tab_context_menu,
+            commands::ui::update_pin_tab_menu,
             commands::ui::show_main_window,
             commands::ui::update_menu_context,
             commands::ui::toggle_hidden_files,
@@ -488,6 +515,7 @@ pub fn run() {
             mcp::pane_state::update_left_pane_state,
             mcp::pane_state::update_right_pane_state,
             mcp::pane_state::update_focused_pane,
+            mcp::pane_state::update_pane_tabs,
             mcp::dialog_state::notify_dialog_opened,
             mcp::dialog_state::notify_dialog_closed,
             mcp::dialog_state::register_known_dialogs,

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

@@ -21,11 +21,12 @@ Expose Cmdr functionality to AI agents via the Model Context Protocol (MCP). Age
 
 ### Tools (`tools.rs`)
 
-19 semantic tools grouped by category:
+20 semantic tools grouped by category:
 - Navigation (6): `select_volume`, `nav_to_path`, `move_cursor`, etc.
 - Cursor/Selection (3): `move_cursor`, `open_under_cursor`, `select`
 - File operations (3): `copy`, `mkdir`, `refresh`
 - View (3): `sort`, `toggle_hidden`, `set_view_mode`
+- Tabs (2): `activate_tab` (switch to a specific tab by pane + tab ID), `pin_tab` (pin/unpin a tab)
 - Dialogs (1): `dialog` (unified open/focus/close)
 - App (3): `switch_pane`, `swap_panes`, `quit`
 
@@ -48,17 +49,17 @@ Constants and configuration for the MCP server (port, bind address, transport se
 
 ### State stores
 
-- `PaneStateStore`: Current state of left/right panes (path, files, cursor, selection)
+- `PaneStateStore`: Current state of left/right panes (path, files, cursor, selection, tabs)
 - `SoftDialogTracker`: Which dialogs MCP thinks are open (in `dialog_state.rs`)
 - `SettingsStateStore`: Current settings window state (section, settings, shortcuts)
 
-Frontend syncs state to these stores via Tauri commands (`update_left_pane_state`, `mcp_update_settings_sections`, etc.).
+Frontend syncs state to these stores via Tauri commands (`update_left_pane_state`, `update_pane_tabs`, `mcp_update_settings_sections`, etc.).
 
 ## Key decisions
 
 ### Why agent-centric API?
 
-The original design mirrored keyboard shortcuts (43 tools like `nav_up`, `nav_down`). This forced agents to make dozens of calls to find a file. The agent-centric redesign (Jan 2026) consolidated to 19 semantic tools (`move_cursor(index=42)`, `nav_to_path("/Users")`). This reduced round-trips from 6+ reads to 1 (`cmdr://state` resource).
+The original design mirrored keyboard shortcuts (43 tools like `nav_up`, `nav_down`). This forced agents to make dozens of calls to find a file. The agent-centric redesign (Jan 2026) consolidated to 20 semantic tools (`move_cursor(index=42)`, `nav_to_path("/Users")`). This reduced round-trips from 6+ reads to 1 (`cmdr://state` resource).
 
 ### Why YAML over JSON for resources?
 
@@ -132,6 +133,10 @@ This separation keeps main window overhead minimal.
 
 `INVALID_PARAMS = -32602`, `INTERNAL_ERROR = -32603`, etc. These are defined by the JSON-RPC spec, not MCP. Don't change them.
 
+### Tab state is synced separately from pane state
+
+Tab info (id, path, pinned, active) is synced to `PaneState.tabs` via a separate `update_pane_tabs` command, debounced at ~100ms in the frontend. The `cmdr://state` resource shows a `tabs:` section per pane only when tabs are synced (non-empty). The `activate_tab` tool emits an `mcp-activate-tab` Tauri event that the frontend handles by switching to the specified tab.
+
 ### Schema version doesn't apply to MCP state
 
 MCP state stores don't have `_schemaVersion` fields. They're runtime-only, not persisted. If the state format changes, just restart the app.

apps/desktop/src-tauri/src/mcp/executor.rs

@@ -61,6 +61,9 @@ pub fn execute_tool<R: Runtime>(app: &AppHandle<R>, name: &str, params: &Value)
         "select_volume" | "nav_to_path" | "move_cursor" | "scroll_to" => {
             execute_nav_command_with_params(app, name, params)
         }
+        // Tab commands
+        "activate_tab" => execute_activate_tab(app, params),
+        "pin_tab" => execute_pin_tab(app, params),
         // File operation commands
         "copy" => execute_copy(app),
         "mkdir" => execute_mkdir(app),
@@ -105,6 +108,85 @@ fn execute_swap_panes<R: Runtime>(app: &AppHandle<R>) -> ToolResult {
     Ok(json!("OK: Swapped left and right panes"))
 }
 
+/// Execute activate_tab command.
+fn execute_activate_tab<R: Runtime>(app: &AppHandle<R>, params: &Value) -> ToolResult {
+    let pane = params
+        .get("pane")
+        .and_then(|v| v.as_str())
+        .ok_or_else(|| ToolError::invalid_params("Missing 'pane' parameter"))?;
+    let tab_id = params
+        .get("tab_id")
+        .and_then(|v| v.as_str())
+        .ok_or_else(|| ToolError::invalid_params("Missing 'tab_id' parameter"))?;
+
+    if !["left", "right"].contains(&pane) {
+        return Err(ToolError::invalid_params("pane must be 'left' or 'right'"));
+    }
+
+    // Validate that the tab ID exists in the pane's synced tab list
+    if let Some(store) = app.try_state::<PaneStateStore>() {
+        let pane_state = match pane {
+            "left" => store.get_left(),
+            "right" => store.get_right(),
+            _ => unreachable!(),
+        };
+        if !pane_state.tabs.is_empty() && !pane_state.tabs.iter().any(|t| t.id == tab_id) {
+            let available_ids: Vec<&str> = pane_state.tabs.iter().map(|t| t.id.as_str()).collect();
+            return Err(ToolError::invalid_params(format!(
+                "Tab '{}' not found in {} pane. Available tabs: {}",
+                tab_id,
+                pane,
+                available_ids.join(", ")
+            )));
+        }
+    }
+
+    app.emit("mcp-activate-tab", json!({"pane": pane, "tabId": tab_id}))?;
+    Ok(json!(format!("OK: Switched to tab {} in {} pane", tab_id, pane)))
+}
+
+/// Execute pin_tab command.
+fn execute_pin_tab<R: Runtime>(app: &AppHandle<R>, params: &Value) -> ToolResult {
+    let pane = params
+        .get("pane")
+        .and_then(|v| v.as_str())
+        .ok_or_else(|| ToolError::invalid_params("Missing 'pane' parameter"))?;
+    let tab_id = params
+        .get("tab_id")
+        .and_then(|v| v.as_str())
+        .ok_or_else(|| ToolError::invalid_params("Missing 'tab_id' parameter"))?;
+    let pinned = params
+        .get("pinned")
+        .and_then(|v| v.as_bool())
+        .ok_or_else(|| ToolError::invalid_params("Missing 'pinned' parameter (boolean)"))?;
+
+    if !["left", "right"].contains(&pane) {
+        return Err(ToolError::invalid_params("pane must be 'left' or 'right'"));
+    }
+
+    // Validate that the tab ID exists in the pane's synced tab list
+    if let Some(store) = app.try_state::<PaneStateStore>() {
+        let pane_state = match pane {
+            "left" => store.get_left(),
+            "right" => store.get_right(),
+            _ => unreachable!(),
+        };
+        if !pane_state.tabs.is_empty() && !pane_state.tabs.iter().any(|t| t.id == tab_id) {
+            let available_ids: Vec<&str> = pane_state.tabs.iter().map(|t| t.id.as_str()).collect();
+            return Err(ToolError::invalid_params(format!(
+                "Tab '{}' not found in {} pane. Available tabs: {}",
+                tab_id,
+                pane,
+                available_ids.join(", ")
+            )));
+        }
+    }
+
+    let action = if pinned { "Pinned" } else { "Unpinned" };
+    app.emit("mcp-pin-tab", json!({"pane": pane, "tabId": tab_id, "pinned": pinned}))?;
+    Ok(json!(format!("OK: {} tab {} in {} pane", action, tab_id, pane)))
+}
+
 /// Execute toggle_hidden command.
 fn execute_toggle_hidden<R: Runtime>(app: &AppHandle<R>) -> ToolResult {
     let result = toggle_hidden_files(app.clone()).map_err(ToolError::internal)?;

apps/desktop/src-tauri/src/mcp/pane_state.rs

@@ -6,6 +6,16 @@ use serde::{Deserialize, Serialize};
 use std::sync::RwLock;
 use tauri::{AppHandle, Manager};
 
+/// Represents a tab in a pane (for MCP state reporting).
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct TabInfo {
+    pub id: String,
+    pub path: String,
+    pub pinned: bool,
+    pub active: bool,
+}
+
 /// Represents a file entry in a pane.
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
@@ -46,6 +56,8 @@ pub struct PaneState {
     pub loaded_end: usize,
     #[serde(default)]
     pub show_hidden: bool,
+    #[serde(default)]
+    pub tabs: Vec<TabInfo>,
 }
 
 /// Shared state for both panes.
@@ -91,17 +103,25 @@ impl PaneStateStore {
 }
 
 /// Tauri command to update left pane state from frontend.
+/// Preserves `tabs` — those are synced separately via `update_pane_tabs`.
 #[tauri::command]
 pub fn update_left_pane_state(app: AppHandle, state: PaneState) {
     if let Some(store) = app.try_state::<PaneStateStore>() {
+        let tabs = store.left.read().unwrap().tabs.clone();
+        let mut state = state;
+        state.tabs = tabs;
         store.set_left(state);
     }
 }
 
 /// Tauri command to update right pane state from frontend.
+/// Preserves `tabs` — those are synced separately via `update_pane_tabs`.
 #[tauri::command]
 pub fn update_right_pane_state(app: AppHandle, state: PaneState) {
     if let Some(store) = app.try_state::<PaneStateStore>() {
+        let tabs = store.right.read().unwrap().tabs.clone();
+        let mut state = state;
+        state.tabs = tabs;
         store.set_right(state);
     }
 }
@@ -114,6 +134,19 @@ pub fn update_focused_pane(app: AppHandle, pane: String) {
     }
 }
 
+/// Tauri command to update tab list for a pane from frontend (for MCP state reporting).
+#[tauri::command]
+pub fn update_pane_tabs(app: AppHandle, pane: String, tabs: Vec<TabInfo>) {
+    if let Some(store) = app.try_state::<PaneStateStore>() {
+        let pane_state = match pane.as_str() {
+            "left" => &store.left,
+            "right" => &store.right,
+            _ => return,
+        };
+        pane_state.write().unwrap().tabs = tabs;
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -142,6 +175,7 @@ mod tests {
             loaded_start: 0,
             loaded_end: 1,
             show_hidden: false,
+            tabs: vec![],
         };
 
         store.set_left(state.clone());