File ops: Scanning UI no longer flashes back to 0

- Local delete (Shift+F8) and cross-FS local move (F6) now reuse the scan-preview cache via `config.preview_id` instead of re-scanning from 0. The transfer progress dialog goes straight to the active phase with the right totals.
- Removed the scan-phase progress bar in `DeleteDialog` and `ScanPhaseBody`. A full-width bar during scanning visually read as "already deleting/copying". The scan UI is now just tallies, spinner, throughput, current dir.
- In volume scan previews (MTP, SMB), the running file count no longer drops between parent groups or sibling subtrees. `run_oracle_aware_batch_scan` and `scan_subtree_with_oracle` now shift the volume backend's per-call local count by a cumulative baseline before forwarding to the FE.

Author: vdavid

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

@@ -274,6 +274,9 @@ volume-delete handler.
 **Decision**: `delete_files_start` routes to either `delete_files_with_progress` (local, uses `walkdir` + `fs::remove_file`) or `delete_volume_files_with_progress` (non-local, uses `Volume` trait) based on `volume_id`.
 **Why**: MTP volumes can't use `walkdir` or `fs::remove_*`. Rather than refactoring the existing local delete to go through the Volume trait (which would add overhead for local ops), we keep the fast local path and add a parallel volume-aware path. Both emit identical events so the frontend progress dialog works unchanged.
 
+**Decision**: Local delete and cross-FS local move reuse the scan-preview cache via `config.preview_id`.
+**Why**: Both `delete_files_with_progress_inner` and `move_with_staging` used to ignore `preview_id` and always re-run `scan_sources`. The FE had just paid the cost of a full scan in `DeleteDialog` / `TransferDialog` (which emits cumulative `scan-preview-progress` events), so the second BE-side scan starting from `filesDone=0` made the count visibly reset in `TransferProgressDialog` ("scan again from 0, climb to N, then phase flips to Deleting/Copying and the bar jumps to total"). Now both functions check `config.preview_id` first: on cache hit the `ScanResult` is consumed directly (same shape copy.rs uses), skipping the redundant scan and going straight to the active phase. On miss (e.g. empty `files` list from a volume preview cache, or no preview at all) the original `scan_sources` path stays — so MCP triggers, programmatic deletes, and forensic dialog flows still work. Delete also gets an initial `phase: Deleting` `WriteProgressEvent` emit after the cache hit so the FE switches to the active-phase UI with the right denominator; move already had this for Copying. Same template as `delete_volume_files_with_progress_inner`'s cache reuse, just for the local-FS paths.
+
 **Decision**: Volume delete reuses the scan preview and is oracle-aware on the no-preview path.
 **Why**: Before this, `delete_volume_files_with_progress_inner` ignored `config.preview_id` entirely and ran `scan_volume_recursive` again. On MTP that meant a second 17 s parent listing for a 135-photo `/DCIM/Camera` delete after the user had just paid that cost in the pre-flight dialog — and the second scan emitted no per-top-level-file progress, so the UI looked frozen. The fix has three parts. (1) `delete_volume_files_with_progress_inner` calls `take_cached_scan_result(preview_id)` at the top; on hit, top-level files are recorded from `CopyScanResult::total_bytes` with no `is_directory` probe and no `list_directory` round-trip, and top-level dirs recurse via the oracle-aware `scan_volume_recursive` (passing `is_dir_hint = Some(true)` so the recursion never re-probes). (2) The walker's internal `volume.list_directory(path, ...)` is now preceded by `try_get_watched_listing(volume_id, path)`; on hit, the cached entries replace the volume call entirely at every recursion level. (3) On the no-preview path (MCP triggers, programmatic deletes), the top-level `volume.is_directory(source)` probe stays only when the parent oracle misses — when a pane has the source's parent open and watcher-fresh, the type comes from the cached `FileEntry` and the probe is skipped. The cache-hit path also emits a throttled scan-progress event per `progress_interval` while building the entry list, so the FE dialog shows movement during the fast path instead of waiting for the delete phase to start. Pinned by `delete_volume_reuse_tests.rs`. Data-safety contract: stale-by-one cached entries can either silently skip a now-gone file (acceptable: the user already moved it elsewhere) or attempt to delete a missing one (the volume's `delete` errors cleanly). Neither direction can delete the wrong file because we feed `volume.delete(&entry.path)` exact paths the cache observed; a cached entry that races with a concurrent rename ends up addressing the old path the next call won't find.
 
@@ -309,6 +312,9 @@ and `statfs.f_fstypename` for APFS. See `copy_strategy.rs` for the implementatio
 **Gotcha**: On macOS, never use `statvfs` alone for disk space checks; use `NSURLVolumeAvailableCapacityForImportantUsageKey`
 **Why**: `statvfs` reports only physically free blocks. On APFS, purgeable space (iCloud caches, APFS snapshots) can account for tens of GB that macOS will reclaim on demand. Using `statvfs` causes the "insufficient space" error to reject copies that would actually succeed, and shows a different available-space number than the status bar (which uses the NSURL API). `validate_disk_space` in `helpers.rs` calls `crate::volumes::get_volume_space()` on macOS and falls back to `statvfs` on Linux.
 
+**Gotcha**: Volume-side `on_progress` callbacks report counts LOCAL to the current scan operation, not cumulative.
+**Why**: `Volume::scan_for_copy_batch_with_progress` and `scan_subtree_with_oracle` both invoke `on_progress(count)` with a count local to the current `list_directory` call / subtree (starts at 1 each time). Forwarding that unchanged through `run_volume_scan_preview`'s closure made the FE's running tally drop visibly between parent groups, between sibling top-level dirs in a cache-hit branch, and between recursion frames inside `scan_subtree_with_oracle`. `run_oracle_aware_batch_scan` now wraps `on_progress` with a `baseline = aggregate.file_count` shift before each scan call (cold-cache batch + cache-hit subtree), and `scan_subtree_with_oracle` does the same at its own recursion site (`baseline = totals.file_count`). The visible FE count stays cumulative across the entire scan. Direct `on_progress(aggregate.file_count)` emit sites in `run_oracle_aware_batch_scan` (cache-hit per-file paths, fallthrough `scan_for_copy` after a name miss) stay unwrapped — they're already cumulative. Future scan call sites that delegate to a volume backend or to `scan_subtree_with_oracle` need the same baseline wrap.
+
 **Gotcha**: Hardlink dedup doesn't straddle the oracle/walk boundary.
 **Why**: `walk_dir_recursive` dedupes hardlinks by inode for `total_bytes` (so a hardlink-heavy tree like cargo's `target/` reports correct bytes-to-free). `FileEntry` doesn't carry inode, so when the oracle supplies one half of a hardlink pair from the cached listing and a real walk supplies the other half, the dedup misses and bytes get over-counted. Direction is safe: over-counting → pessimistic ETA + conservative disk-space reject, never the other way. The walker's existing `walker_dedupes_hardlinks_by_inode` test still pins the same-side dedup. If true cross-boundary dedup ever becomes worth it, add `inode: Option<u64>` to `FileEntry`; not in this milestone.
 

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

@@ -39,16 +39,47 @@ pub(super) fn delete_files_with_progress_inner(
     sources: &[PathBuf],
     config: &WriteOperationConfig,
 ) -> Result<(), WriteOperationError> {
-    // Phase 1: Scan to get file count (delete uses default sorting)
-    let scan_result = scan_sources(
-        sources,
-        state,
-        events,
-        operation_id,
-        WriteOperationType::Delete,
-        config.sort_column,
-        config.sort_order,
-    )?;
+    // Phase 1: Scan (or reuse cached preview results)
+    let scan_result = if let Some(preview_id) = &config.preview_id {
+        // Volume scans cache aggregate stats with an empty `files` list; the
+        // per-file delete loop needs the file list, so treat an empty-files
+        // cache hit the same as a miss and fall through to a fresh local scan.
+        if let Some(cached) = take_cached_scan_result(preview_id).filter(|c| !c.files.is_empty()) {
+            log::debug!(
+                "delete_files_with_progress: reusing cached scan for operation_id={}, preview_id={}, files={}, bytes={}",
+                operation_id,
+                preview_id,
+                cached.file_count,
+                cached.total_bytes
+            );
+            cached
+        } else {
+            log::warn!(
+                "preview_id={} cache miss despite frontend coordination, starting fresh scan for operation_id={}",
+                preview_id,
+                operation_id
+            );
+            scan_sources(
+                sources,
+                state,
+                events,
+                operation_id,
+                WriteOperationType::Delete,
+                config.sort_column,
+                config.sort_order,
+            )?
+        }
+    } else {
+        scan_sources(
+            sources,
+            state,
+            events,
+            operation_id,
+            WriteOperationType::Delete,
+            config.sort_column,
+            config.sort_order,
+        )?
+    };
 
     // Handle dry-run mode (delete has no conflicts)
     if config.dry_run {
@@ -69,6 +100,33 @@ pub(super) fn delete_files_with_progress_inner(
     let mut bytes_done = 0u64;
     let mut last_progress_time = Instant::now();
 
+    // Emit initial Deleting-phase event with totals. Important when reusing a
+    // cached preview: no scanning events were emitted by the BE, so the FE
+    // still has scan-phase tallies on screen. This event flips the FE to the
+    // active-phase UI with the correct denominator on file/byte progress.
+    state.emit_progress_via_sink(
+        events,
+        WriteProgressEvent::new(
+            operation_id.to_string(),
+            WriteOperationType::Delete,
+            WriteOperationPhase::Deleting,
+            None,
+            0,
+            scan_result.file_count,
+            0,
+            scan_result.total_bytes,
+        ),
+    );
+    update_operation_status(
+        operation_id,
+        WriteOperationPhase::Deleting,
+        None,
+        0,
+        scan_result.file_count,
+        0,
+        scan_result.total_bytes,
+    );
+
     let mut tracker = SourceItemTracker::new(&scan_result.files);
 
     // Delete files

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

@@ -8,7 +8,7 @@ use std::time::Instant;
 
 use super::copy::copy_single_item;
 use super::helpers::{is_same_filesystem, remove_dir_all_in_background, resolve_conflict, spawn_async_sync};
-use super::scan::{SourceItemTracker, handle_dry_run, scan_sources};
+use super::scan::{SourceItemTracker, handle_dry_run, scan_sources, take_cached_scan_result};
 use super::state::{CopyTransaction, OperationIntent, WriteOperationState, load_intent, update_operation_status};
 use super::types::{
     ConflictResolution, IoResultExt, OperationEventSink, TauriEventSink, WriteCancelledEvent, WriteCompleteEvent,
@@ -321,16 +321,47 @@ fn move_with_staging(
     destination: &Path,
     config: &WriteOperationConfig,
 ) -> Result<(), WriteOperationError> {
-    // Phase 1: Scan (move uses default sorting - order doesn't matter much for move)
-    let scan_result = scan_sources(
-        sources,
-        state,
-        events,
-        operation_id,
-        WriteOperationType::Move,
-        config.sort_column,
-        config.sort_order,
-    )?;
+    // Phase 1: Scan (or reuse cached preview results)
+    let scan_result = if let Some(preview_id) = &config.preview_id {
+        // Volume scans cache aggregate stats with an empty `files` list; the
+        // per-file move loop needs the file list, so treat an empty-files
+        // cache hit the same as a miss and fall through to a fresh local scan.
+        if let Some(cached) = take_cached_scan_result(preview_id).filter(|c| !c.files.is_empty()) {
+            log::debug!(
+                "move_with_staging: reusing cached scan for operation_id={}, preview_id={}, files={}, bytes={}",
+                operation_id,
+                preview_id,
+                cached.file_count,
+                cached.total_bytes
+            );
+            cached
+        } else {
+            log::warn!(
+                "preview_id={} cache miss despite frontend coordination, starting fresh scan for operation_id={}",
+                preview_id,
+                operation_id
+            );
+            scan_sources(
+                sources,
+                state,
+                events,
+                operation_id,
+                WriteOperationType::Move,
+                config.sort_column,
+                config.sort_order,
+            )?
+        }
+    } else {
+        scan_sources(
+            sources,
+            state,
+            events,
+            operation_id,
+            WriteOperationType::Move,
+            config.sort_column,
+            config.sort_order,
+        )?
+    };
 
     // Create staging directory
     let staging_dir = destination.join(format!(".cmdr-staging-{}", operation_id));

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

@@ -272,15 +272,35 @@ pub(super) async fn scan_subtree_with_oracle(
         }
         let child_path = PathBuf::from(&entry.path);
         if entry.is_directory && !entry.is_symlink {
-            // Recurse — oracle re-applies inside this call.
-            let child_totals = Box::pin(scan_subtree_with_oracle(
-                volume,
-                volume_id,
-                &child_path,
-                is_cancelled,
-                on_progress,
-            ))
-            .await?;
+            // Recurse — oracle re-applies inside this call. The recursive
+            // emit reports counts local to the child subtree (starting at 1),
+            // so wrap `on_progress` with a baseline of the current
+            // `totals.file_count`; without this the FE display visibly drops
+            // back to 1 every time the walker descends into a new sibling dir.
+            let baseline = totals.file_count;
+            let child_totals = match on_progress {
+                Some(cb) => {
+                    let shifted = move |n: usize| cb(baseline + n);
+                    Box::pin(scan_subtree_with_oracle(
+                        volume,
+                        volume_id,
+                        &child_path,
+                        is_cancelled,
+                        Some(&shifted),
+                    ))
+                    .await?
+                }
+                None => {
+                    Box::pin(scan_subtree_with_oracle(
+                        volume,
+                        volume_id,
+                        &child_path,
+                        is_cancelled,
+                        None,
+                    ))
+                    .await?
+                }
+            };
             totals.file_count += child_totals.file_count;
             // The directory itself plus all its descendant dirs.
             totals.dir_count += 1 + child_totals.dir_count;

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

@@ -447,8 +447,14 @@ pub(super) async fn run_oracle_aware_batch_scan(
                 };
 
                 if entry.is_directory && !entry.is_symlink {
+                    // `scan_subtree_with_oracle` emits a count local to this
+                    // subtree (starting at 1). Shift by `aggregate.file_count`
+                    // so the FE display stays cumulative across multiple
+                    // top-level dirs in this call.
+                    let baseline = aggregate.file_count;
+                    let shifted = |n: usize| on_progress(baseline + n);
                     let subtree: SubtreeTotals =
-                        scan_subtree_with_oracle(volume, volume_id, source, is_cancelled, Some(on_progress)).await?;
+                        scan_subtree_with_oracle(volume, volume_id, source, is_cancelled, Some(&shifted)).await?;
                     aggregate.file_count += subtree.file_count;
                     // `scan_for_copy_batch`'s aggregate.dir_count counts descendants
                     // only, not the top-level path itself. Match that convention
@@ -484,8 +490,17 @@ pub(super) async fn run_oracle_aware_batch_scan(
             // Cold cache for this parent. Delegate to the volume's own batch
             // scan: it preserves the MTP parent-grouping and SMB pipelined-stat
             // optimizations for cold paths.
+            //
+            // The volume's callback reports a count LOCAL to its current
+            // `list_directory` call (starts at 1). Shift by `aggregate.file_count`
+            // before forwarding so the FE display stays cumulative as we walk
+            // multiple parent groups — without this, every new group's first
+            // entry drops the visible count back to 1, then climbs to the
+            // group's local total before the next group restarts.
+            let baseline = aggregate.file_count;
+            let shifted = |n: usize| on_progress(baseline + n);
             let group_result = volume
-                .scan_for_copy_batch_with_progress(paths_in_group, Some(on_progress))
+                .scan_for_copy_batch_with_progress(paths_in_group, Some(&shifted))
                 .await?;
             aggregate.file_count += group_result.aggregate.file_count;
             aggregate.dir_count += group_result.aggregate.dir_count;

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

@@ -43,10 +43,11 @@ F8/Shift+F8 (trash/delete). Transfer and delete operations share `TransferProgre
    - Dynamic stage indicator: "Scanning" → "Copying" (+ "Cleaning up" for cross-FS move)
    - **Scanning-phase UI** (both `waitingForScan` and `phase === 'scanning'` paths): rendered via the
      `ScanPhaseBody.svelte` child component. Shows source path, running tallies (`bytesFound / filesFound / dirsFound`),
-     FE-computed throughput from `ScanThroughput` (`scan-throughput.ts`), and, when the backend supplies
-     `expectedFilesTotal` / `expectedBytesTotal` from the drive index, a `ProgressBar` capped at 100% with "X% of
-     estimated" text. Current directory (`event.currentDir`) renders above the filename so the user sees where in the
-     tree the walker is. Title is reframed per operation: "Verifying before copy…", "Counting items to delete…", etc.
+     FE-computed throughput from `ScanThroughput` (`scan-throughput.ts`), and a spinner. Current directory
+     (`event.currentDir`) renders above the filename so the user sees where in the tree the walker is. Title is reframed
+     per operation: "Verifying before copy…", "Counting items to delete…", etc. The backend still emits
+     `expectedFilesTotal` / `expectedBytesTotal` on scan events but the FE ignores them — the bar this used to drive was
+     visually indistinguishable from the destructive-phase bar and read as "already deleting".
    - Conflict resolution inline (if using `Stop` mode instead of dry-run). The per-file dialog has a 2-column grid: left
      column is the single-file action (`Skip` / `Rename` / `Overwrite`), right column is the apply-to-all variant
      (`Skip all` / `Rename all` / `Overwrite all`). A 4th row holds the two conditional bulk actions —