Bugfix: Bulk-skip credit no longer pollutes throughput estimator

After e7f657d made bulk-skip correctly credit `bytes_done`, the ETA estimator started treating the instant counter jump as throughput: the bulk-skip delta over ε time pinned `bytes_per_second` at GB/s level on the first sample, and EWMA took 10+ samples (many seconds) to decay it. User-visible symptom: speeds opened with bogus values (1.91 GB/s instead of ~15 MB/s, 63 files/s instead of ~1 file/s, ~20 s ETA instead of ~20 min) before settling.

- `EtaEstimator::reseed_baseline(now, bytes, files)` re-anchors `last_t/last_bytes/last_files` and resets `samples` to 0 without changing the phase. The bulk-skip jump becomes the new starting point, not a delta.
- Both driver preludes (`drive_transfer_serial_sync`, `drive_transfer_serial_async`) and the inline concurrent path in `copy_volumes_with_progress` call `reseed_baseline` right before emitting the bulk-skip event.
- New unit test `bulk_skip_baseline_jump_does_not_pollute_rate` pins the property: after a `(0, 0)` → `(22 GB, 250 files)` jump over 1 ms followed by a real `15 MB / 1 file` in 1 s emit, `bytes_per_second < 50 MB/s` and `files_per_second < 5`. Pre-fix this test fails with GB/s-level rates.

Author: vdavid

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

@@ -93,6 +93,33 @@ impl EtaEstimator {
         Self::default()
     }
 
+    /// Re-anchor the estimator's baseline to the given counters without
+    /// computing a rate from the jump. Use this when the caller wants to
+    /// advance the absolute counters by a chunk that is NOT throughput
+    /// (e.g. the bulk-skip prelude credits N files / B bytes instantly to
+    /// reflect "Skip-All for pre-known conflicts" — those files were never
+    /// actually copied, so feeding the delta into the EWMA pins the first
+    /// sample at GB/s and pollutes the rate display for many seconds).
+    ///
+    /// No-op if no phase is active (the next `update` will seed normally).
+    /// Does NOT change the phase; the next `update` keeps the current phase
+    /// unless it actually transitions.
+    pub fn reseed_baseline(&mut self, now: Instant, bytes_done: u64, files_done: usize) {
+        if let Some(state) = self.state.as_mut() {
+            state.last_t = now;
+            state.last_bytes = bytes_done;
+            state.last_files = files_done;
+            // Reset samples to 0 so the next `update` takes the fast-path
+            // first-sample seed (initialize EWMA from the instantaneous rate
+            // rather than smoothing from zero, per the existing first-sample
+            // rationale). The samples gate also keeps `eta_seconds = None`
+            // until two real samples land.
+            state.samples = 0;
+            state.bytes_rate = 0.0;
+            state.files_rate = 0.0;
+        }
+    }
+
     /// Update the estimator with the latest counters and return the current stats.
     ///
     /// `now` is injected (not read from `Instant::now()` internally) so tests can
@@ -291,6 +318,57 @@ mod tests {
         assert_eq!(stats, EtaStats::ZERO);
     }
 
+    #[test]
+    fn bulk_skip_baseline_jump_does_not_pollute_rate() {
+        // Models the volume-copy Skip-All path. Caller emits `(0, 0)` at the
+        // Copying-phase boundary (the estimator reseeds and returns ZERO);
+        // the driver's bulk-skip prelude then jumps the counters to
+        // `(bulk_skip_files, bulk_skip_bytes)` instantly. Without an explicit
+        // baseline reseed, the bulk-skip delta over ε time becomes the
+        // first-sample rate (~22 GB/s, ~250 files/s in this fixture), and
+        // EWMA takes many seconds to decay it. The fix: call
+        // `reseed_baseline` before the bulk-skip emit so the jump becomes
+        // the new starting point, not throughput. The next real per-file
+        // emit's delta is then just the actually-copied portion.
+        let start = Instant::now();
+        let mut est = EtaEstimator::new();
+
+        // t=0: initial Copying emit (phase transition Scanning -> Copying).
+        let initial = est.update(at(start, 0), WriteOperationPhase::Copying, 0, 35_000_000_000, 0, 1051);
+        assert_eq!(initial, EtaStats::ZERO);
+
+        // t=1 ms: driver bulk-skip prelude credits 22 GB / 250 files
+        // instantly. Caller calls `reseed_baseline` immediately before the
+        // emit so the estimator absorbs the jump as its new starting point.
+        est.reseed_baseline(at(start, 1), 22_000_000_000, 250);
+
+        // t=1001 ms: first real per-file emit. Actually-copied delta vs.
+        // the new baseline = 15 MB / 1 file over 1 s.
+        let stats = est.update(
+            at(start, 1001),
+            WriteOperationPhase::Copying,
+            22_015_000_000,
+            35_000_000_000,
+            251,
+            1051,
+        );
+
+        // Pre-fix: bytes_per_second is in the GB/s range and files_per_second
+        // is in the hundreds (a 250-file / 22-GB jump over ε time pinned the
+        // EWMA's first sample, then partially decayed). Assert single-digit
+        // multiples of the true rate, not orders of magnitude off.
+        assert!(
+            stats.bytes_per_second < 50_000_000,
+            "bytes_per_second = {} (expected ~15 MB/s, bulk-skip should not feed the rate)",
+            stats.bytes_per_second,
+        );
+        assert!(
+            stats.files_per_second < 5.0,
+            "files_per_second = {} (expected ~1 file/s, bulk-skip should not feed the rate)",
+            stats.files_per_second,
+        );
+    }
+
     #[test]
     fn warmup_suppresses_eta_until_min_elapsed() {
         // Two samples 200 ms apart, below MIN_ELAPSED_FOR_ETA.

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

@@ -385,6 +385,14 @@ where
             bulk_skip_files,
             bulk_skip_bytes
         );
+        // Re-anchor the rate estimator BEFORE emitting. The bulk-skip jump
+        // is past work credited instantly, not throughput; without this
+        // reseed the first real per-file emit's delta is computed against
+        // `(0, 0)` and pins `bytes_per_second` at GB/s level. See
+        // `eta::EtaEstimator::reseed_baseline` for the full rationale.
+        if let Ok(mut est) = state.estimator.lock() {
+            est.reseed_baseline(Instant::now(), bytes_done, files_done);
+        }
         emit_progress_and_status(
             events,
             state,
@@ -610,6 +618,11 @@ where
             bulk_skip_files,
             bulk_skip_bytes
         );
+        // Re-anchor the rate estimator: bulk-skip credit is past work, not
+        // throughput. See `drive_transfer_serial_sync` for the rationale.
+        if let Ok(mut est) = state.estimator.lock() {
+            est.reseed_baseline(Instant::now(), bytes_done, files_done);
+        }
         emit_progress_and_status(
             events,
             state,

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

@@ -612,6 +612,13 @@ pub(crate) async fn copy_volumes_with_progress(
             bulk_skip_files,
             bulk_skip_bytes
         );
+        // Re-anchor the rate estimator: bulk-skip credit is past work, not
+        // throughput. Without this the first per-task progress callback's
+        // delta against `(0, 0)` pins `bytes_per_second` at GB/s level.
+        // Same pattern as the driver's serial preludes.
+        if let Ok(mut est) = state.estimator.lock() {
+            est.reseed_baseline(Instant::now(), new_bytes, new_files);
+        }
         state.emit_progress_via_sink(
             &*events,
             WriteProgressEvent::new(