Add delete/trash feature (F8)

- Trash by default (F8), permanent delete via ⇧F8
- Confirmation dialog with file list, scan preview, deep stats
- Volume fsType + supportsTrash detection via statfs (proactive no-trash warnings for FAT32, exFAT, network mounts)
- Batch trash backend with progress, cancellation, partial failure
- Extracted move_to_trash_sync to write_operations/trash.rs, fixed dangling symlink bug (symlink_metadata instead of exists)
- Extended TransferProgressDialog for delete/trash with 400ms minimum display, phase labels, optional transfer-specific props
- Post-delete cursor stays at same position index (apply-diff fix)
- MCP delete tool, error messages for locked files
- Removed unused confirmBeforeDelete/deletePermanently setting

Author: vdavid

apps/desktop/coverage-allowlist.json

@@ -183,6 +183,9 @@
         },
         "tooltip/tooltip.ts": {
             "reason": "DOM-dependent singleton tooltip, requires document.body and getBoundingClientRect"
+        },
+        "file-operations/delete/DeleteDialog.svelte": {
+            "reason": "UI modal, logic tested in delete-dialog-utils.test.ts"
         }
     }
 }

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

@@ -8,13 +8,13 @@ immediately to business-logic modules. No significant logic lives here.
 | File | Domain | Notes |
 |------|--------|-------|
 | `mod.rs` | Re-exports | `mtp`, `network`, `volumes` gated behind `#[cfg(target_os = "macos")]` |
-| `file_system.rs` | File listing & writes | Largest file. Streaming + virtual-scroll listing API, write ops, scan preview, conflict resolution, volume copy, native drag, self-drag overlay. Contains `expand_tilde()`. |
+| `file_system.rs` | File listing & writes | Largest file. Streaming + virtual-scroll listing API, write ops (copy, move, delete, trash), scan preview, conflict resolution, volume copy, native drag, self-drag overlay. Contains `expand_tilde()`. |
 | `volumes.rs` | Volume management | `list_volumes`, `get_default_volume_id`, `find_containing_volume`, `get_volume_space` |
 | `mtp.rs` | MTP devices | Full MTP command surface (connect, disconnect, list, download, upload, delete, rename, move, scan) |
 | `network.rs` | SMB/network shares | Discovery, share listing, keychain, mounting. |
 | `font_metrics.rs` | Font metrics cache | `store_font_metrics`, `has_font_metrics` |
 | `icons.rs` | File icons | `get_icons`, `refresh_directory_icons`, cache clear |
-| `rename.rs` | Rename / trash | `move_to_trash` (NSFileManager), `check_rename_permission`, `check_rename_validity`, `rename_file` |
+| `rename.rs` | Rename / trash | `move_to_trash` (delegates to `write_operations::trash::move_to_trash_sync`), `check_rename_permission`, `check_rename_validity`, `rename_file` |
 | `file_viewer.rs` | File viewer | Session lifecycle, line search, word wrap, menu state |
 | `ui.rs` | UI / menu | Context menu, Finder reveal, clipboard, Quick Look, Get Info, view mode |
 | `settings.rs` | Settings | Port availability check, watcher debounce setting, menu accelerator updates |

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

@@ -20,6 +20,7 @@ use crate::file_system::{
     list_directory_start_streaming as ops_list_directory_start_streaming,
     list_directory_start_with_volume as ops_list_directory_start_with_volume, move_files_start as ops_move_files_start,
     resort_listing as ops_resort_listing, scan_for_volume_copy as ops_scan_for_volume_copy,
+    trash_files_start as ops_trash_files_start,
 };
 use std::path::{Path, PathBuf};
 #[cfg(target_os = "macos")]
@@ -325,6 +326,20 @@ pub async fn delete_files(
     ops_delete_files_start(app, sources, config).await
 }
 
+/// Moves files to macOS Trash. Same events as `copy_files` but with `operationType: trash`.
+#[tauri::command]
+pub async fn trash_files(
+    app: tauri::AppHandle,
+    sources: Vec<String>,
+    item_sizes: Option<Vec<u64>>,
+    config: Option<WriteOperationConfig>,
+) -> Result<WriteOperationStartResult, WriteOperationError> {
+    let sources: Vec<PathBuf> = sources.iter().map(|s| PathBuf::from(expand_tilde(s))).collect();
+    let config = config.unwrap_or_default();
+
+    ops_trash_files_start(app, sources, item_sizes, config).await
+}
+
 #[tauri::command]
 pub fn cancel_write_operation(operation_id: String, rollback: bool) {
     ops_cancel_write_operation(&operation_id, rollback);

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

@@ -3,6 +3,7 @@
 use std::path::{Path, PathBuf};
 
 use super::file_system::expand_tilde;
+use crate::file_system::write_operations::trash::move_to_trash_sync;
 
 // ============================================================================
 // Rename operations
@@ -19,36 +20,6 @@ pub async fn move_to_trash(path: String) -> Result<(), String> {
         .map_err(|e| format!("Task failed: {}", e))?
 }
 
-/// Synchronous trash implementation using macOS NSFileManager.trashItem.
-#[cfg(target_os = "macos")]
-fn move_to_trash_sync(path: &Path) -> Result<(), String> {
-    use objc2_foundation::{NSFileManager, NSString, NSURL};
-
-    if !path.exists() {
-        return Err(format!("'{}' doesn't exist", path.display()));
-    }
-
-    let path_str = path.to_string_lossy();
-    let ns_path = NSString::from_str(&path_str);
-    let url = NSURL::fileURLWithPath(&ns_path);
-    let file_manager = NSFileManager::defaultManager();
-
-    // trashItemAtURL:resultingItemURL:error: moves the item to Trash.
-    // We pass None for resultingItemURL since we don't need the trash location.
-    file_manager
-        .trashItemAtURL_resultingItemURL_error(&url, None)
-        .map_err(|e| format!("Failed to move to trash: {}", e))?;
-    Ok(())
-}
-
-#[cfg(not(target_os = "macos"))]
-fn move_to_trash_sync(path: &Path) -> Result<(), String> {
-    Err(format!(
-        "Moving to trash is not supported on this platform for '{}'",
-        path.display()
-    ))
-}
-
 /// Checks if a file/folder can be renamed (parent writable, not immutable, not SIP-protected, not locked).
 #[tauri::command]
 pub async fn check_rename_permission(path: String) -> Result<(), String> {

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

@@ -49,7 +49,7 @@ pub(crate) use watcher::{DirectoryDiff, compute_diff};
 pub use write_operations::{
     OperationStatus, OperationSummary, WriteOperationConfig, WriteOperationError, WriteOperationStartResult,
     cancel_all_write_operations, cancel_write_operation, copy_files_start, delete_files_start, get_operation_status,
-    list_active_operations, move_files_start,
+    list_active_operations, move_files_start, trash_files_start,
 };
 // Re-export volume copy types and functions
 // TODO: Remove this allow once volume_copy is integrated into Tauri commands (Phase 5)

apps/desktop/src-tauri/src/file_system/write_operations/CLAUDE.md

@@ -1,25 +1,26 @@
 # Write operations
 
-Copy, move, and delete with streaming progress, cancellation, conflict resolution, and rollback. macOS only.
+Copy, move, delete, and trash with streaming progress, cancellation, conflict resolution, and rollback. macOS only.
 
 ## Purpose
 
-Implements the three destructive file operations as background tasks that stream Tauri events to the frontend. Every
+Implements the four destructive file operations as background tasks that stream Tauri events to the frontend. Every
 operation is cancellable, reports byte-level progress, and handles edge cases: symlink loops, same-inode overwrites,
 network mounts, cross-filesystem moves, and name/path length limits.
 
 ## Files
 
 | File | Responsibility |
 |------|----------------|
-| `mod.rs` | Public API: `copy_files_start`, `move_files_start`, `delete_files_start`. Validates inputs, creates `WriteOperationState`, spawns `tokio::spawn` + `spawn_blocking`. |
+| `mod.rs` | Public API: `copy_files_start`, `move_files_start`, `delete_files_start`, `trash_files_start`. Validates inputs, creates `WriteOperationState`, spawns `tokio::spawn` + `spawn_blocking`. |
 | `types.rs` | All serializable types: events, config, errors, results. `WriteOperationConfig`, `ConflictResolution`, `WriteOperationError`, `DryRunResult`, scan preview events. |
 | `state.rs` | Two `LazyLock<RwLock<HashMap>>` caches (`WRITE_OPERATION_STATE`, `OPERATION_STATUS_CACHE`). `WriteOperationState`, `CopyTransaction`, `ScanResult`, `FileInfo`. |
 | `helpers.rs` | Validation (`validate_sources`, `validate_destination_writable` via `libc::access`, `validate_disk_space` via `statvfs`). Conflict resolution (condvar wait for Stop mode). `safe_overwrite_file`/`safe_overwrite_dir` (temp+rename). `find_unique_name`. `run_cancellable`. `is_same_filesystem` (device IDs). |
 | `scan.rs` | `scan_sources` (recursive walk, emits progress), `dry_run_scan`, scan preview subsystem (`start_scan_preview`, `cancel_scan_preview`). |
 | `copy.rs` | `copy_files_with_progress`: scan → disk space check → per-file copy via `copy_single_item`. `CopyTransaction` for rollback. |
 | `move_op.rs` | Same-fs: `fs::rename`. Cross-fs: copy to `.cmdr-staging-<uuid>`, atomic rename, delete sources. |
 | `delete.rs` | Scan, delete files first, then directories in reverse/deepest-first order. Not rollbackable. |
+| `trash.rs` | `move_to_trash_sync()` (ObjC `trashItemAtURL` wrapper, reused by `commands/rename.rs`) and `trash_files_with_progress()` (batch trash with per-item progress, cancellation, partial failure). Uses `symlink_metadata()` for existence checks (handles dangling symlinks). |
 | `copy_strategy.rs` | Strategy selection per file: network FS → chunked copy; overwrite → temp+rename; otherwise → macOS `copyfile(3)`. |
 | `macos_copy.rs` | FFI to macOS `copyfile(3)`. Preserves xattrs, ACLs, resource forks, Finder metadata. Supports APFS `clonefile`. |
 | `chunked_copy.rs` | 1 MB chunked read/write for network mounts. Checks cancellation between chunks. Copies xattrs, ACLs, timestamps. |
@@ -82,6 +83,11 @@ actual `copy_files_start` can consume the cache via `preview_id` in `WriteOperat
 - Needs safe overwrite → `safe_overwrite_file`
 - Otherwise → `copy_single_file_native` (macOS `copyfile(3)`, supports `COPYFILE_CLONE` for APFS instant copies)
 
+**Trash has no scan phase.** `trashItemAtURL` is atomic per top-level item (the OS moves the entire tree), so trash
+doesn't need the recursive scan that delete/copy use. Progress tracks top-level items, with optional byte-level progress
+from pre-computed item sizes. Partial failure is supported: if some items fail, others still succeed. The core
+`move_to_trash_sync()` is extracted to `trash.rs` and reused by `commands/rename.rs`.
+
 **Special files skipped.** Sockets, FIFOs, and device files are filtered out during scan.
 
 **`volume_copy` path is incomplete.** The three `volume_*` files are Phase 5 work, but are publicly re-exported from `mod.rs` and at least partially wired up.
@@ -90,7 +96,7 @@ actual `copy_files_start` can consume the cache via `preview_id` in `WriteOperat
 
 | Event | Trigger |
 |-------|---------|
-| `write-progress` | Every ~200ms during copy/move/delete |
+| `write-progress` | Every ~200ms during copy/move/delete/trash |
 | `write-conflict` | Stop mode hit a conflicting destination file |
 | `write-complete` | Operation finished successfully |
 | `write-cancelled` | Operation cancelled (includes `rolled_back` flag) |

apps/desktop/src-tauri/src/file_system/write_operations/mod.rs

@@ -26,6 +26,7 @@ pub(crate) mod macos_copy;
 mod move_op;
 mod scan;
 mod state;
+pub(crate) mod trash;
 mod types;
 mod volume_conflict;
 mod volume_copy;
@@ -48,6 +49,7 @@ use move_op::move_files_with_progress;
 #[cfg(not(test))]
 use state::WriteOperationState;
 use state::{WRITE_OPERATION_STATE, register_operation_status, unregister_operation_status};
+use trash::trash_files_with_progress;
 
 // Re-export public types
 pub use scan::{cancel_scan_preview, start_scan_preview};
@@ -322,6 +324,85 @@ pub async fn delete_files_start(
     })
 }
 
+/// Starts a trash operation in the background.
+///
+/// Moves top-level items to the macOS Trash via `NSFileManager.trashItemAtURL`.
+/// Supports cancellation between items and partial failure (some items may fail
+/// while others succeed).
+///
+/// # Arguments
+/// * `app` - Tauri app handle for event emission
+/// * `sources` - Top-level items to trash
+/// * `item_sizes` - Optional per-item sizes for byte-level progress
+/// * `config` - Operation configuration (only `progress_interval_ms` is used)
+pub async fn trash_files_start(
+    app: tauri::AppHandle,
+    sources: Vec<PathBuf>,
+    item_sizes: Option<Vec<u64>>,
+    config: WriteOperationConfig,
+) -> Result<WriteOperationStartResult, WriteOperationError> {
+    // Validate inputs
+    validate_sources(&sources)?;
+
+    let operation_id = Uuid::new_v4().to_string();
+    let state = Arc::new(WriteOperationState {
+        cancelled: Arc::new(AtomicBool::new(false)),
+        skip_rollback: AtomicBool::new(false),
+        progress_interval: Duration::from_millis(config.progress_interval_ms),
+        pending_resolution: std::sync::RwLock::new(None),
+        conflict_condvar: std::sync::Condvar::new(),
+        conflict_mutex: std::sync::Mutex::new(false),
+    });
+
+    // Store state for cancellation
+    if let Ok(mut cache) = WRITE_OPERATION_STATE.write() {
+        cache.insert(operation_id.clone(), Arc::clone(&state));
+    }
+
+    // Register operation status for query APIs
+    register_operation_status(&operation_id, WriteOperationType::Trash);
+
+    let operation_id_for_spawn = operation_id.clone();
+
+    // Spawn background task
+    tokio::spawn(async move {
+        let operation_id_for_cleanup = operation_id_for_spawn.clone();
+        let app_for_error = app.clone();
+
+        let result = tokio::task::spawn_blocking(move || {
+            trash_files_with_progress(&app, &operation_id_for_spawn, &state, &sources, item_sizes.as_deref())
+        })
+        .await;
+
+        // Clean up state
+        if let Ok(mut cache) = WRITE_OPERATION_STATE.write() {
+            cache.remove(&operation_id_for_cleanup);
+        }
+        unregister_operation_status(&operation_id_for_cleanup);
+
+        // Handle task panic
+        if let Err(e) = result {
+            use tauri::Emitter;
+            let _ = app_for_error.emit(
+                "write-error",
+                WriteErrorEvent {
+                    operation_id: operation_id_for_cleanup,
+                    operation_type: WriteOperationType::Trash,
+                    error: WriteOperationError::IoError {
+                        path: String::new(),
+                        message: format!("Task failed: {}", e),
+                    },
+                },
+            );
+        }
+    });
+
+    Ok(WriteOperationStartResult {
+        operation_id,
+        operation_type: WriteOperationType::Trash,
+    })
+}
+
 #[cfg(test)]
 mod integration_test;
 #[cfg(test)]