SMB: dedicated friendly copy for STATUS_DELETE_PENDING

- New typed variants `VolumeError::DeletePending` and `WriteOperationError::DeletePending` so the listing and write-error paths can carry the state end-to-end instead of falling through to the generic `IoError`.
- `map_smb_error` dispatches on `err.status() == Some(NtStatus::DELETE_PENDING)` before the kind match (smb2 currently classifies it as `ErrorKind::Other`).
- `kinds::delete_pending` gives users a transient "File is being removed" message that explains an open handle is keeping the file alive, plus a wait/restart suggestion. Replaces the misleading "disk needs attention" copy.
- Tests in `smb.rs`, `volume_copy_tests.rs`, and `friendly_error/mod.rs` pin the mapping, the friendly copy shape, and the no-"error"/"failed" rule for the new variant.

Author: vdavid

apps/desktop/src-tauri/src/file_system/volume/friendly_error/kinds.rs

@@ -206,6 +206,29 @@ pub(super) fn not_supported(raw_detail: String) -> FriendlyError {
     }
 }
 
+/// `STATUS_DELETE_PENDING`: the file has been marked for deletion on the server
+/// but at least one open handle is keeping it alive. The file disappears the
+/// moment the last handle closes, so retry-after-a-moment is the right hint.
+pub(super) fn delete_pending(path_display: &str, raw_detail: String) -> FriendlyError {
+    FriendlyError {
+        category: ErrorCategory::Transient,
+        title: "File is being removed".into(),
+        explanation: format!(
+            "`{}` is on its way out. The server marked it for deletion, but another \
+            open handle is keeping it around until that handle closes.",
+            path_display
+        ),
+        suggestion: "Here's what to try:\n\
+            - Wait a moment and try again — once the last handle closes, the file disappears\n\
+            - Close any other apps that might have this file open\n\
+            - If it sticks around, restart Cmdr to drop any handles it might still hold"
+            .into(),
+        raw_detail,
+        retry_hint: true,
+        action_kind: None,
+    }
+}
+
 pub(super) fn io_serious(path_display: &str, message: &str, raw_detail: String) -> FriendlyError {
     FriendlyError {
         category: ErrorCategory::Serious,

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

@@ -211,6 +211,7 @@ mod tests {
                 true,
             ),
             (VolumeError::Cancelled("x".into()), ErrorCategory::Transient, true),
+            (VolumeError::DeletePending("x".into()), ErrorCategory::Transient, true),
             (
                 VolumeError::IoError {
                     message: "x".into(),
@@ -296,6 +297,7 @@ mod tests {
             VolumeError::NotFound("x".into()),
             VolumeError::PermissionDenied("x".into()),
             VolumeError::ConnectionTimeout("x".into()),
+            VolumeError::DeletePending("x".into()),
             VolumeError::IoError {
                 message: "x".into(),
                 raw_os_error: None,
@@ -357,6 +359,36 @@ mod tests {
         }
     }
 
+    #[test]
+    fn delete_pending_uses_dedicated_copy() {
+        let path = Path::new("/Volumes/share/photo.jpg");
+        let err = VolumeError::DeletePending("Protocol error: STATUS_DELETE_PENDING during Create".into());
+        let friendly = friendly_error_from_volume_error(&err, path);
+
+        assert_eq!(friendly.category, ErrorCategory::Transient);
+        assert!(
+            friendly.retry_hint,
+            "DeletePending is transient — user should see a retry hint"
+        );
+        assert!(
+            friendly.title.contains("being removed"),
+            "DeletePending title should say the file is being removed, got: {:?}",
+            friendly.title,
+        );
+        // The path is interpolated into the explanation so the user knows which file.
+        assert!(
+            friendly.explanation.contains("photo.jpg"),
+            "DeletePending explanation should include the path, got: {:?}",
+            friendly.explanation,
+        );
+        // raw_detail preserves the underlying NTSTATUS for the technical-details disclosure.
+        assert!(
+            friendly.raw_detail.contains("DELETE_PENDING"),
+            "raw_detail should preserve the NTSTATUS code, got: {:?}",
+            friendly.raw_detail,
+        );
+    }
+
     // ── action_kind tests ───────────────────────────────────────────────
 
     #[cfg(target_os = "macos")]

apps/desktop/src-tauri/src/file_system/volume/friendly_error/volume_error.rs

@@ -49,6 +49,7 @@ pub fn friendly_error_from_volume_error(err: &VolumeError, path: &Path) -> Frien
         VolumeError::StorageFull { .. } => kinds::storage_full(raw),
         VolumeError::ConnectionTimeout(_) => kinds::connection_timeout(raw),
         VolumeError::Cancelled(_) => kinds::cancelled(raw),
+        VolumeError::DeletePending(_) => kinds::delete_pending(&path_display, raw),
         VolumeError::IsADirectory(_) => FriendlyError {
             category: ErrorCategory::NeedsAction,
             title: "This is a folder, not a file".into(),

apps/desktop/src-tauri/src/file_system/volume/friendly_error/write_error.rs

@@ -142,6 +142,7 @@ pub fn friendly_from_write_error(err: &crate::file_system::write_operations::Wri
             retry_hint: false,
             action_kind: None,
         },
+        W::DeletePending { path } => kinds::delete_pending(path, raw),
         W::IoError { path, message } => kinds::io_serious(path, message, raw),
     }
 }

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

@@ -166,6 +166,11 @@ pub enum VolumeError {
     Cancelled(String),
     /// The path is a directory, not a file (for example, SMB STATUS_FILE_IS_A_DIRECTORY).
     IsADirectory(String),
+    /// The file is in `STATUS_DELETE_PENDING`: a delete has been requested on the server
+    /// but at least one open handle is keeping the file alive. The file will disappear
+    /// once the last handle closes; any new `Create` (stat, open, write) on the path
+    /// fails with this status in the meantime. SMB-only today.
+    DeletePending(String),
     IoError {
         message: String,
         raw_os_error: Option<i32>,
@@ -194,6 +199,7 @@ impl std::fmt::Display for VolumeError {
             Self::ConnectionTimeout(msg) => write!(f, "Connection timed out: {}", msg),
             Self::Cancelled(msg) => write!(f, "Cancelled: {}", msg),
             Self::IsADirectory(path) => write!(f, "Is a directory: {}", path),
+            Self::DeletePending(path) => write!(f, "Delete pending: {}", path),
             Self::IoError { message, .. } => write!(f, "I/O error: {}", message),
             Self::FriendlyGit(err) => write!(f, "git: {}", err),
         }

apps/desktop/src-tauri/src/file_system/volume/smb.rs

@@ -134,6 +134,15 @@ fn fs_info_to_space_info(info: &smb2::client::tree::FsInfo) -> SpaceInfo {
 /// Converts an `smb2::Error` to `VolumeError`.
 fn map_smb_error(err: smb2::Error) -> VolumeError {
     use smb2::ErrorKind;
+    use smb2::types::status::NtStatus;
+
+    // `STATUS_DELETE_PENDING` currently classifies as `ErrorKind::Other` in
+    // smb2 (no typed variant yet), so we detect it via the raw NTSTATUS before
+    // falling through to the generic kind match.
+    if err.status() == Some(NtStatus::DELETE_PENDING) {
+        return VolumeError::DeletePending(err.to_string());
+    }
+
     match err.kind() {
         ErrorKind::NotFound => VolumeError::NotFound(err.to_string()),
         ErrorKind::AlreadyExists => VolumeError::AlreadyExists(err.to_string()),
@@ -1989,6 +1998,26 @@ mod tests {
         assert!(matches!(ve, VolumeError::NotFound(_)));
     }
 
+    #[test]
+    fn map_smb_error_delete_pending() {
+        // STATUS_DELETE_PENDING surfaces when a delete has been requested but at
+        // least one open handle is keeping the file alive. smb2 currently classifies
+        // it as `ErrorKind::Other`, so `map_smb_error` must dispatch on the raw
+        // NTSTATUS to produce the typed `VolumeError::DeletePending` variant —
+        // otherwise the FE falls back to the generic "disk needs attention" copy
+        // instead of the transient "file is being removed" message.
+        let err = smb2::Error::Protocol {
+            status: smb2::types::status::NtStatus::DELETE_PENDING,
+            command: smb2::types::Command::Create,
+        };
+        let ve = map_smb_error(err);
+        assert!(
+            matches!(ve, VolumeError::DeletePending(_)),
+            "STATUS_DELETE_PENDING should map to VolumeError::DeletePending, got: {:?}",
+            ve,
+        );
+    }
+
     #[test]
     fn map_smb_error_access_denied() {
         let err = smb2::Error::Protocol {

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

@@ -455,6 +455,12 @@ pub enum WriteOperationError {
         path: String,
         message: String,
     },
+    /// The file is in `STATUS_DELETE_PENDING` on the server: a delete was requested
+    /// but at least one open handle is keeping it alive. Transient — clears when the
+    /// last handle closes. SMB-only today.
+    DeletePending {
+        path: String,
+    },
     /// Catch-all for genuinely unexpected IO errors.
     IoError {
         path: String,

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

@@ -1619,6 +1619,9 @@ pub(super) fn map_volume_error(context_path: &str, e: VolumeError) -> WriteOpera
             path,
             message: "Is a directory".to_string(),
         },
+        VolumeError::DeletePending(_) => WriteOperationError::DeletePending {
+            path: context_path.to_string(),
+        },
     }
 }
 

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

@@ -183,6 +183,17 @@ fn test_map_volume_error_not_supported() {
     );
 }
 
+#[test]
+fn test_map_volume_error_delete_pending() {
+    // STATUS_DELETE_PENDING surfaces when a delete was requested but an open
+    // handle is keeping the file alive on the server. It MUST become a typed
+    // `WriteOperationError::DeletePending` so the write-error event carries
+    // the transient "file is being removed" friendly copy — not the generic
+    // IoError fallback.
+    let err = map_volume_error("/ctx", VolumeError::DeletePending("STATUS_DELETE_PENDING".to_string()));
+    assert!(matches!(err, WriteOperationError::DeletePending { path } if path == "/ctx"));
+}
+
 // ========================================
 // LocalPosixVolume integration tests
 // ========================================