Bugfix: Per-iter Skip on volume copy now credits byte progress

`ConflictDecision::Skip` carried no payload, so the async driver's per-iter Skip arm bumped `files_done` by 1 but `bytes_done` stayed at 0. Visible as: file counter moved forward while the size bar froze at 0% for the whole operation when conflicts resolved via `apply_to_all` (the mid-operation dialog choice) rather than the pre-flight `preKnownConflicts` bulk-skip.

- `ConflictDecision::Skip { bytes_accounted: u64 }` carries the source's byte size; driver's Skip arm credits both axes.
- `volume_copy`'s resolver looks up `source_hints` and returns the file's size (0 for dirs by convention — recursive total isn't tracked there, that's the separate residual gotcha in CLAUDE.md).
- `volume_move`'s two resolvers pass 0 (move has no pre-flight byte scan; consistent with the move bulk-skip prelude that always credits 0 bytes).
- Driver test `async_driver_progress_accounting_sums_correctly` previously locked in the buggy "conflict-skip has no bytes" expectation; updated to assert the correct 350 = 200 bulk-skip + 50 per-iter-skip + 100 transferred.
- New Playwright spec `MTP-to-local copy with apply-to-all Skip credits byte progress` pins the FE-visible behavior: subscribe to `write-conflict` + `write-complete`, default conflict policy (`stop`), answer the first conflict via `resolve_write_conflict(opId, Skip, applyToAll=true)`, then assert `WriteCompleteEvent.bytes_processed === sum(source file sizes)`.

Author: vdavid

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

@@ -508,9 +508,14 @@ pub(super) struct ConflictDecisionInput<'a> {
 /// Conflict-resolution outcome the resolver hands back to the driver.
 #[derive(Debug)]
 pub(super) enum ConflictDecision {
-    /// Skip this source. Driver bumps counters via skip accounting and
-    /// continues. The `transfer_one` closure is NOT invoked.
-    Skip,
+    /// Skip this source. Driver bumps counters via skip accounting (both
+    /// `files_done += 1` and `bytes_done += bytes_accounted`) and continues.
+    /// The `transfer_one` closure is NOT invoked. `bytes_accounted` is the
+    /// source's byte size from the caller's pre-flight scan (volume copy
+    /// looks it up in `source_hints`; volume move has no scan and passes 0).
+    /// Without it, the size progress bar would stay at 0 % while the file
+    /// counter moved forward on Skip-All operations.
+    Skip { bytes_accounted: u64 },
     /// Proceed with the given (possibly rewritten) destination path. Driver
     /// calls `transfer_one` with `dest_path = Some(this)`.
     Proceed { dest_path: PathBuf },
@@ -671,11 +676,12 @@ where
             .await;
 
             match decision {
-                Ok(ConflictDecision::Skip) => {
+                Ok(ConflictDecision::Skip { bytes_accounted }) => {
                     // Per-iter skip accounting: bump counters and emit
                     // throttled progress so the bar reflects the skip
                     // immediately.
                     files_done += 1;
+                    bytes_done += bytes_accounted;
                     if last_progress_time.elapsed() >= progress_interval {
                         last_progress_time = Instant::now();
                         emit_progress_and_status(

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

@@ -699,7 +699,7 @@ async fn async_driver_does_not_invoke_closure_when_conflict_resolved_as_skip() {
                 assert_eq!(input.source_path, Path::new("/a.txt"));
                 assert_eq!(input.initial_dest_path, Path::new("/dest/a.txt"));
                 assert_eq!(input.dest_size_hint, Some(50));
-                Ok(ConflictDecision::Skip)
+                Ok(ConflictDecision::Skip { bytes_accounted: 0 })
             })
         },
         |ctx: TransferContext<'_>| -> TransferFut<'_> {
@@ -1049,9 +1049,9 @@ async fn async_driver_apply_to_all_resolver_decision_persists_across_sources() {
                 // Closure latches Skip on first call; from then on, returns Skip.
                 let mut guard = latched.lock().unwrap();
                 if guard.is_none() {
-                    *guard = Some(ConflictDecision::Skip);
+                    *guard = Some(ConflictDecision::Skip { bytes_accounted: 0 });
                 }
-                Ok(ConflictDecision::Skip)
+                Ok(ConflictDecision::Skip { bytes_accounted: 0 })
             })
         },
         |ctx: TransferContext<'_>| -> TransferFut<'_> {
@@ -1105,7 +1105,9 @@ async fn async_driver_progress_accounting_sums_correctly() {
             let conflict = p == Path::new("/dest/conflict");
             Box::pin(async move { if conflict { Some(50) } else { None } })
         },
-        |_i: ConflictDecisionInput<'_>| -> ResolveFut<'_> { Box::pin(async { Ok(ConflictDecision::Skip) }) },
+        |_i: ConflictDecisionInput<'_>| -> ResolveFut<'_> {
+            Box::pin(async { Ok(ConflictDecision::Skip { bytes_accounted: 50 }) })
+        },
         |_ctx: TransferContext<'_>| -> TransferFut<'_> {
             Box::pin(async { Ok(TransferOutcome::Transferred { bytes: 100 }) })
         },
@@ -1115,8 +1117,8 @@ async fn async_driver_progress_accounting_sums_correctly() {
     assert!(matches!(outcome.intent, PostLoopIntent::Completed));
     assert_eq!(outcome.files_done, 4, "2 bulk + 1 conflict-skip + 1 transferred");
     assert_eq!(
-        outcome.bytes_done, 300,
-        "200 bulk-skipped + 0 (conflict-skip has no bytes) + 100 transferred"
+        outcome.bytes_done, 350,
+        "200 bulk-skipped + 50 (conflict-skip's `bytes_accounted`) + 100 transferred"
     );
     uninstall_state(&op_id);
     unregister_operation_status(&op_id);
@@ -1143,7 +1145,9 @@ async fn async_driver_status_cache_matches_emitted_progress() {
         &HashSet::new(),
         &copy_config(),
         |_p: &Path| -> FetchFut<'_> { Box::pin(async { Some(50) }) }, // conflict
-        |_i: ConflictDecisionInput<'_>| -> ResolveFut<'_> { Box::pin(async { Ok(ConflictDecision::Skip) }) },
+        |_i: ConflictDecisionInput<'_>| -> ResolveFut<'_> {
+            Box::pin(async { Ok(ConflictDecision::Skip { bytes_accounted: 0 }) })
+        },
         |_ctx: TransferContext<'_>| -> TransferFut<'_> {
             Box::pin(async { panic!("closure should not fire under Skip") })
         },

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

@@ -1011,7 +1011,14 @@ pub(crate) async fn copy_volumes_with_progress(
                                     "copy_volumes_with_progress: skipping {} due to conflict resolution",
                                     source_path_owned.display()
                                 );
-                                ConflictDecision::Skip
+                                // Credit the source's byte size so the size
+                                // progress bar matches the file counter when
+                                // every source is skipped. Dirs report 0 in
+                                // `source_hints` by convention (the recursive
+                                // total isn't tracked there); per-file skips
+                                // credit the real size.
+                                let bytes_accounted = source_hint.map(|h| h.size).unwrap_or(0);
+                                ConflictDecision::Skip { bytes_accounted }
                             }
                             Some(dest_path) => ConflictDecision::Proceed { dest_path },
                         })

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

@@ -354,7 +354,10 @@ pub(super) async fn move_volumes_with_progress(
                                 "move_between_volumes: skipping {} due to conflict resolution",
                                 source_path_owned.display()
                             );
-                            ConflictDecision::Skip
+                            // Move has no pre-flight byte scan, so skip-bytes
+                            // stays at 0 (consistent with the move bulk-skip
+                            // prelude that always credits 0 bytes).
+                            ConflictDecision::Skip { bytes_accounted: 0 }
                         }
                         Some(dest_path) => ConflictDecision::Proceed { dest_path },
                     })
@@ -747,7 +750,9 @@ pub(super) async fn move_within_same_volume_with_progress(
                                 "move_within_same_volume: skipping {} due to conflict resolution",
                                 source_path_owned.display()
                             );
-                            ConflictDecision::Skip
+                            // Move has no pre-flight byte scan, so skip-bytes
+                            // stays at 0.
+                            ConflictDecision::Skip { bytes_accounted: 0 }
                         }
                         Some(dest_path) => ConflictDecision::Proceed { dest_path },
                     })

apps/desktop/test/e2e-playwright/mtp-conflicts.spec.ts

@@ -339,3 +339,125 @@ test.describe('MTP same-volume move conflicts', () => {
     expect(fs.existsSync(path.join(MTP_FIXTURE_ROOT, 'internal', 'Documents', 'report.txt'))).toBe(true)
   })
 })
+
+// ── Cross-volume COPY conflicts (MTP -> local) ─────────────────────────────
+
+test.describe('MTP cross-volume copy conflicts', () => {
+  test('MTP-to-local copy with apply-to-all Skip credits byte progress', async ({ tauriPage }) => {
+    // Regression test for: per-iter Skip in the async transfer driver bumps
+    // `filesDone` but not `bytesDone`. User-visible symptom: the file counter
+    // moves forward while the size counter stays at 0 % on Skip-All copies
+    // where conflicts resolve via `apply_to_all` (the mid-operation conflict
+    // dialog), not via the FE's pre-flight `preKnownConflicts` bulk-skip.
+    //
+    // Setup: MTP `Documents/` has `report.txt` + `notes.txt`. Pre-populate
+    // matching files at local `right/` so both source files conflict at dest.
+    // Trigger MTP -> local copy with the DEFAULT (`stop`) conflict policy so
+    // `preKnownConflicts` stays empty. Intercept the first `write-conflict`
+    // event and resolve it via `resolve_write_conflict(opId, Skip, true)` so
+    // `apply_to_all` latches and subsequent conflicts auto-resolve via the
+    // driver's per-iter Skip arm. Assert the final `write-progress` event has
+    // both axes landed at total.
+    const fixtureRoot = getFixtureRoot()
+    fs.writeFileSync(path.join(fixtureRoot, 'right', 'report.txt'), 'local-report')
+    fs.writeFileSync(path.join(fixtureRoot, 'right', 'notes.txt'), 'local-notes')
+
+    await ensureAppReady(tauriPage)
+    await mcpSelectVolume('left', INTERNAL_STORAGE)
+    const mtpPath = await getMtpVolumePath(INTERNAL_STORAGE)
+    await mcpNavToPath('left', `${mtpPath}/Documents`)
+    await mcpAwaitItem('left', 'report.txt')
+    await mcpAwaitItem('left', 'notes.txt')
+
+    // Subscribe to write-conflict (for the apply-to-all answer) and
+    // write-complete (carries the authoritative `bytes_processed` /
+    // `files_processed`) BEFORE triggering the copy. write-progress is
+    // throttled to 200 ms and 2 fast in-memory Skips don't reliably emit a
+    // post-iter event — write-complete is the source of truth.
+    await tauriPage.evaluate(`(async function() {
+        window.__skipBytesTestConflicts = [];
+        window.__skipBytesTestComplete = null;
+        const conflictHandler = (event) => { window.__skipBytesTestConflicts.push(event.payload); };
+        const completeHandler = (event) => { window.__skipBytesTestComplete = event.payload; };
+        const conflictHandlerId = window.__TAURI_INTERNALS__.transformCallback(conflictHandler);
+        const completeHandlerId = window.__TAURI_INTERNALS__.transformCallback(completeHandler);
+        window.__skipBytesTestConflictId = await window.__TAURI_INTERNALS__.invoke('plugin:event|listen', {
+          event: 'write-conflict',
+          target: { kind: 'Any' },
+          handler: conflictHandlerId,
+        });
+        window.__skipBytesTestCompleteId = await window.__TAURI_INTERNALS__.invoke('plugin:event|listen', {
+          event: 'write-complete',
+          target: { kind: 'Any' },
+          handler: completeHandlerId,
+        });
+      })()`)
+
+    try {
+      // Select both files in the MTP pane.
+      await tauriPage.keyboard.press('Meta+A')
+      await dispatchMenuCommand(tauriPage, 'file.copy')
+
+      await tauriPage.waitForSelector(TRANSFER_DIALOG, 10000)
+      await waitForConflictPolicy(tauriPage)
+      // Leave the dropdown at its default ('stop') so preKnownConflicts stays
+      // empty and conflicts surface per-iter via write-conflict.
+      await clickTransferStart(tauriPage)
+
+      // Wait for the first write-conflict event, then resolve via IPC.
+      await pollUntil(
+        tauriPage,
+        async () => tauriPage.evaluate<boolean>(`(window.__skipBytesTestConflicts ?? []).length > 0`),
+        10000,
+        50,
+      )
+      const firstConflict = await tauriPage.evaluate<{ operationId: string }>(`window.__skipBytesTestConflicts[0]`)
+      expect(firstConflict.operationId).toBeTruthy()
+      await tauriPage.evaluate(`window.__TAURI_INTERNALS__.invoke('resolve_write_conflict', {
+          operationId: '${firstConflict.operationId}',
+          resolution: 'skip',
+          applyToAll: true,
+        })`)
+
+      await waitForDialogsToClose(tauriPage, 30000)
+
+      // Dest content unchanged (both files were skipped).
+      expect(fs.readFileSync(path.join(fixtureRoot, 'right', 'report.txt'), 'utf-8')).toBe('local-report')
+      expect(fs.readFileSync(path.join(fixtureRoot, 'right', 'notes.txt'), 'utf-8')).toBe('local-notes')
+
+      // Source files still on MTP (skip is non-destructive for copy).
+      expect(fs.existsSync(path.join(MTP_FIXTURE_ROOT, 'internal', 'Documents', 'report.txt'))).toBe(true)
+      expect(fs.existsSync(path.join(MTP_FIXTURE_ROOT, 'internal', 'Documents', 'notes.txt'))).toBe(true)
+
+      // write-complete carries the authoritative final tallies. With the bug,
+      // every per-iter Skip bumps `filesProcessed` by 1 but `bytesProcessed`
+      // stays at 0, so the dialog's size bar reads 0 % at the end.
+      const completed = await tauriPage.evaluate<{
+        filesProcessed: number
+        bytesProcessed: number
+      } | null>(`window.__skipBytesTestComplete`)
+      const expectedBytes =
+        fs.statSync(path.join(MTP_FIXTURE_ROOT, 'internal', 'Documents', 'report.txt')).size +
+        fs.statSync(path.join(MTP_FIXTURE_ROOT, 'internal', 'Documents', 'notes.txt')).size
+
+      expect(completed).not.toBeNull()
+      expect(completed!.filesProcessed).toBe(2)
+      expect(completed!.bytesProcessed).toBe(expectedBytes)
+    } finally {
+      await tauriPage.evaluate(`(async function() {
+          const conflictId = window.__skipBytesTestConflictId;
+          const completeId = window.__skipBytesTestCompleteId;
+          if (conflictId !== undefined) {
+            await window.__TAURI_INTERNALS__.invoke('plugin:event|unlisten', { event: 'write-conflict', eventId: conflictId });
+          }
+          if (completeId !== undefined) {
+            await window.__TAURI_INTERNALS__.invoke('plugin:event|unlisten', { event: 'write-complete', eventId: completeId });
+          }
+          delete window.__skipBytesTestConflicts;
+          delete window.__skipBytesTestComplete;
+          delete window.__skipBytesTestConflictId;
+          delete window.__skipBytesTestCompleteId;
+        })()`)
+    }
+  })
+})