SMB/MTP: Listing updates after mutations and external changes

Unified change notification system for all volume types. Fixes "listing doesn't update after create/delete/rename" on SMB and MTP shares.

- Add `notify_directory_changed` unified entry point with `DirectoryChange` enum (Added/Removed/Modified/Renamed/FullRefresh) for incremental listing cache patches
- Add `notify_mutation` on `Volume` trait — called after each successful mutation, triggers instant listing update via the volume's own protocol (smb2/MTP), not `std::fs`
- Add smb2 background watcher (dedicated connection, `CHANGE_NOTIFY` long-poll) for external changes with 200ms debounce and 50-event threshold
- Fix `handle_directory_change` to use `Volume::list_directory` instead of raw `std::fs::read_dir` — works for all volume types now
- Move sequence counter from `WatchedDirectory` to `CachedListing` so `directory-diff` events emit for non-FSEvents volumes
- Add `volume_id` field to `SmbVolume` and `MtpVolume` for notification routing
- Add `find_listings_for_path_on_volume` with volume_id filtering
- Fix rename having no listing notification on any volume type (pre-existing bug)
- Run watcher event processing via `spawn_blocking` to avoid `block_on`-from-async panics
- `SmbVolume::supports_local_fs_access` returns `false` (skips legacy `std::fs` synthetic diff path)

Author: vdavid

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

@@ -16,7 +16,7 @@ immediately to business-logic modules. No significant logic lives here.
 | `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` (delegates to `write_operations::trash::move_to_trash_sync`), `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`. `rename_file` calls `notify_mutation` after success to update the listing cache (both local and volume-aware paths). |
 | `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, `set_menu_context` (enables/disables file-scoped menu items based on window focus) |
 | `settings.rs` | Settings | Port availability check, watcher debounce setting, menu accelerator updates |

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

@@ -873,7 +873,7 @@ fn should_emit_synthetic_diff(volume_id: Option<&str>) -> bool {
 fn emit_synthetic_entry_diff(app: &tauri::AppHandle, entry_path: &Path, parent_path: &Path) {
     use crate::file_system::listing::reading::get_single_entry;
     use crate::file_system::listing::{find_listings_for_path, insert_entry_sorted};
-    use crate::file_system::watcher::{DiffChange, DirectoryDiff, WATCHER_MANAGER};
+    use crate::file_system::watcher::{DiffChange, DirectoryDiff};
     use tauri::Emitter;
 
     // 1. Construct a FileEntry for the new entry
@@ -901,18 +901,9 @@ fn emit_synthetic_entry_diff(app: &tauri::AppHandle, entry_path: &Path, parent_p
             continue; // Already exists or listing gone
         };
 
-        // Increment sequence in WATCHER_MANAGER (after LISTING_CACHE lock is released)
-        let sequence = {
-            let mut manager = match WATCHER_MANAGER.write() {
-                Ok(m) => m,
-                Err(_) => continue,
-            };
-            let watch = match manager.watches.get_mut(&listing_id) {
-                Some(w) => w,
-                None => continue,
-            };
-            watch.sequence += 1;
-            watch.sequence
+        // Increment sequence on CachedListing (after LISTING_CACHE write lock is released)
+        let Some(sequence) = crate::file_system::listing::increment_sequence(&listing_id) else {
+            continue;
         };
 
         let diff = DirectoryDiff {

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

@@ -106,7 +106,9 @@ pub async fn rename_file(from: String, to: String, force: bool, volume_id: Optio
     let volume_id_str = volume_id.unwrap_or_else(|| "root".to_string());
 
     if volume_id_str != "root" {
-        // Volume-aware rename (MTP and other non-local volumes)
+        // Volume-aware rename (MTP, SMB, and other non-local volumes).
+        // The volume's `rename` method calls `notify_mutation` internally,
+        // so the listing cache is updated automatically.
         let volume = crate::file_system::get_volume_manager()
             .get(&volume_id_str)
             .ok_or_else(|| IpcError::from_err(format!("Volume '{}' not found", volume_id_str)))?;
@@ -131,6 +133,9 @@ pub async fn rename_file(from: String, to: String, force: bool, volume_id: Optio
         let from_path = PathBuf::from(&from_expanded);
         let to_path = PathBuf::from(&to_expanded);
 
+        let from_for_notify = from_path.clone();
+        let to_for_notify = to_path.clone();
+
         tokio::time::timeout(
             Duration::from_secs(5),
             tokio::task::spawn_blocking(move || {
@@ -143,7 +148,51 @@ pub async fn rename_file(from: String, to: String, force: bool, volume_id: Optio
         .await
         .map_err(|_| IpcError::timeout())?
         .map_err(|e| IpcError::from_err(format!("Task failed: {}", e)))?
-        .map_err(IpcError::from_err)
+        .map_err(IpcError::from_err)?;
+
+        // Notify listing cache about the rename (fixes pre-existing bug where
+        // rename had no listing notification on any volume type).
+        notify_rename_in_listing(&volume_id_str, &from_for_notify, &to_for_notify);
+
+        Ok(())
+    }
+}
+
+/// Notifies the listing cache about a rename via the volume's `notify_mutation`.
+fn notify_rename_in_listing(volume_id: &str, from: &Path, to: &Path) {
+    use crate::file_system::volume::MutationEvent;
+
+    let volume = match crate::file_system::get_volume_manager().get(volume_id) {
+        Some(v) => v,
+        None => return,
+    };
+
+    if let (Some(from_parent), Some(from_name), Some(to_name)) = (from.parent(), from.file_name(), to.file_name()) {
+        if from.parent() == to.parent() {
+            // Same-directory rename
+            volume.notify_mutation(
+                volume_id,
+                from_parent,
+                MutationEvent::Renamed {
+                    from: from_name.to_string_lossy().to_string(),
+                    to: to_name.to_string_lossy().to_string(),
+                },
+            );
+        } else {
+            // Cross-directory move
+            volume.notify_mutation(
+                volume_id,
+                from_parent,
+                MutationEvent::Deleted(from_name.to_string_lossy().to_string()),
+            );
+            if let Some(to_parent) = to.parent() {
+                volume.notify_mutation(
+                    volume_id,
+                    to_parent,
+                    MutationEvent::Created(to_name.to_string_lossy().to_string()),
+                );
+            }
+        }
     }
 }
 

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

@@ -46,7 +46,7 @@ Frontend                          Backend
 
 **LISTING_CACHE**: Global `RwLock<HashMap<String, CachedListing>>`
 **Key**: `listing_id` (UUID per navigation)
-**Value**: `CachedListing { volume_id, path, entries, sort_by, sort_order, directory_sort_mode }`
+**Value**: `CachedListing { volume_id, path, entries, sort_by, sort_order, directory_sort_mode, sequence }`
 
 **Lifecycle**:
 1. `list_directory_start_streaming()` receives listing ID from frontend, spawns task
@@ -84,6 +84,9 @@ Frontend                          Backend
 **Decision**: Font metrics in Rust binary cache, not frontend canvas measurement
 **Why**: Measuring 50k filenames in JS is slow. Rust precomputes metrics for system fonts, stores in `.bin` cache. `calculate_max_width()` is a hash lookup.
 
+**Decision**: Sequence counter lives on `CachedListing`, not on `WatchedDirectory`
+**Why**: SMB and MTP volumes don't use FSEvents (`supports_watching() == false`), so they never get a `WatchedDirectory` entry. With the sequence on the watcher, `increment_sequence` returned `None` and `directory-diff` events were never emitted for those volumes. Moving the `AtomicU64` to `CachedListing` makes it work for all volume types. The FSEvents watcher path also uses this same counter now.
+
 **Decision**: File watcher starts AFTER listing complete
 **Why**: Watcher diffs rely on cached entries. Starting before cache is populated would miss initial state.
 
@@ -105,12 +108,26 @@ Frontend                          Backend
 
 Used by the watcher's incremental path and synthetic mkdir to patch listings without full re-reads:
 - `find_listings_for_path(path)` — returns all listing IDs whose directory matches the given path (multiple panes/tabs may show the same directory)
+- `find_listings_for_path_on_volume(volume_id, path)` — same, but also filters by volume ID. Prevents false matches when two volumes serve overlapping paths.
 - `insert_entry_sorted(listing_id, entry)` — inserts an entry in sorted position, returns the insertion index
 - `remove_entry_by_path(listing_id, path)` — removes an entry by its file path, returns the removed index and entry
 - `update_entry_sorted(listing_id, entry)` — updates an existing entry (remove + re-insert if sort position changed), returns `ModifyResult`
 - `has_entry(listing_id, path)` — checks if a path exists in the cached listing (used to classify watcher events as add vs modify)
 - `get_listing_path(listing_id)` — returns the directory path for a listing (used to filter watcher events to direct children)
 
+### Change notification API (caching.rs)
+
+`notify_directory_changed(volume_id, parent_path, change)` — unified entry point for notifying the listing system that a directory changed on a volume. Accepts a `DirectoryChange` enum:
+- `Added(FileEntry)` — single entry added, patches cache via `insert_entry_sorted`
+- `Removed(String)` — single entry removed by name, patches cache via `remove_entry_by_path`
+- `Modified(FileEntry)` — single entry modified, patches cache via `update_entry_sorted`
+- `Renamed { old_name, new_entry }` — same-dir rename, remove old + insert new
+- `FullRefresh` — re-reads directory via Volume trait, computes diff against cache
+
+All variants enrich entries with index data and emit `directory-diff` events. Natural deduplication: `insert_entry_sorted` returns `None` for duplicates, `remove_entry_by_path` returns `None` if already removed.
+
+**Callers**: `Volume::notify_mutation()` (called after each successful create/delete/rename on all volume types) and the `rename_file` command (for local filesystem renames). The old `emit_synthetic_entry_diff` remains as a legacy fallback for `create_file`/`create_directory` on volumes where `supports_local_fs_access()` returns `true`.
+
 **Gotcha**: Background task runs to completion even if cancelled on frontend
 **Why**: `loadGeneration` discards stale results, but Rust keeps iterating. Mitigation: `AtomicBool` checked per-entry stops early.