@@ -122,6 +122,25 @@ struct MachinesConfigView: View {
               )
               .font(.caption2)
               .foregroundStyle(.secondary)
+
+              // WAZNE: `--bwlimit` jest wpisywany w argumenty demona rclone
+              // TYLKO przy starcie (`startRcloneDaemon`) - nie ma interfejsu
+              // rc/reload, wiec zmiana suwaka NIE dziala na juz dzialajacy
+              // proces. Automatyczny remount przy kazdym tyknieciu suwaka
+              // podczas przeciagania bylby gorszy (wielokrotne, niepotrzebne
+              // przerywanie aktywnego backupu) - zamiast tego jawnie mowimy
+              // uzytkownikowi, kiedy zmiana faktycznie zacznie obowiazywac.
+              if controller.status.mountState == .mounted {
+                HStack(spacing: 4) {
+                  Image(systemName: "info.circle")
+                    .foregroundStyle(.secondary)
+                  Text(
+                    "Zmiana zacznie obowiązywać po następnym odmontowaniu i zamontowaniu (ręcznym lub automatycznej naprawie)."
+                  )
+                }
+                .font(.caption2)
+                .foregroundStyle(.secondary)
+              }
             }
 
             Divider()
 
@@ -41,6 +41,23 @@ public final class CMLock {
       return false
     }
     writePid()
+    // WAZNE: `removeItem` + `createDirectory` powyzej NIE jest atomowe -
+    // dwa procesy przejmujace ta sama osierocona blokade w nakladajacym
+    // sie oknie moga obie odczytac "martwy PID", obie usunac i utworzyc
+    // katalog na nowo, obie zapisac swoj PID - i obie zwrocic `true`.
+    // Odczytujemy wlasnie zapisany plik z powrotem: jesli inny proces
+    // zdazyl go nadpisac swoim PID-em pomiedzy naszym `writePid()` a tym
+    // odczytem, wiemy, ze przegralismy wyscig, i wycofujemy sie zamiast
+    // dzialac w falszywym przekonaniu o wylacznosci. Nie eliminuje to
+    // calkowicie okna (obie strony moga jeszcze przejsciowo "wygrac" tuz
+    // przed ta weryfikacja), ale gwarantuje, ze co najmniej jedna z nich
+    // to wykryje i cofnie.
+    guard
+      let verifyPidString = try? String(contentsOf: pidFile, encoding: .utf8),
+      pid_t(verifyPidString.trimmingCharacters(in: .whitespacesAndNewlines)) == getpid()
+    else {
+      return false
+    }
     acquired = true
     return true
   }
@@ -57,27 +74,54 @@ public final class CMLock {
   /// (dogananie kolejki uploadow, weryfikacja checksumow mogace trwac godziny).
   private static let stuckLockThreshold: TimeInterval = 15 * 60  // 15 minut
 
+  /// Znacznik "od kiedy nieprzerwanie widzimy ten proces w stanie U/D" -
+  /// CELOWO osobny od mtime `lockDir` (czasu PRZEJECIA blokady). Legalna
+  /// dlugotrwala operacja (weryfikacja checksumow trwajaca godziny) moze
+  /// trzymac te sama blokade dlugo PRZED tym, jak w ogole wpadnie w U/D -
+  /// liczenie progu od czasu przejecia blokady (jak robil wczesniejszy kod)
+  /// zabija taki legalny, dlugo dzialajacy proces przy pierwszej probce w
+  /// U/D po uplywie progu, co jest dokladnie tym, przed czym ostrzega
+  /// komentarz w naglowku tego pliku (orphan detection PO PID, NIE po
+  /// wieku). Ten znacznik zapisujemy przy PIERWSZYM zaobserwowanym U/D i
+  /// kasujemy, gdy proces wroci do normalnego stanu - wiec mierzy faktyczny,
+  /// NIEPRZERWANY czas trwania zawieszenia.
+  private var stuckSinceFile: URL { lockDir.appendingPathComponent("stuck-since") }
+
   private func isProcessAlive(_ pid: pid_t) -> Bool {
     guard kill(pid, 0) == 0 else { return false }
 
     // Synchronicznie pobierz stan procesu z `ps`.
-    if let psState = processState(pid: pid) {
-      // Stan 'U' (macOS uninterruptible NFS wait) lub 'D' (Linux disk sleep)
-      // - oba oznaczaja zawieszenie w jadrze, z ktorego SIGKILL nie wybudza.
-      if psState.uppercased().hasPrefix("U") || psState.uppercased().hasPrefix("D") {
-        // Czy blokada czeka juz od ponad progu? mtime lock.d == czas przejecia.
-        if isLockDirOlderThan(seconds: Self.stuckLockThreshold) {
-          CMLogger.log(
-            "[CMLock] OSTRZEZENIE: PID \(pid) trzymajacy blokade '\(lockDir.lastPathComponent)'"
-              + " jest zawieszony w stanie U (NFS hang?) od ponad \(Int(Self.stuckLockThreshold/60)) min."
-              + " Przejmuje blokade. SIGKILL na zawieszony proces (ignorowany przez jadro, ale"
-              + " sprzatnie PID po odmontowaniu)."
-          )
-          kill(pid, SIGKILL)
-          return false
-        }
-      }
+    // Stan 'U' (macOS uninterruptible NFS wait) lub 'D' (Linux disk sleep)
+    // - oba oznaczaja zawieszenie w jadrze, z ktorego SIGKILL nie wybudza.
+    guard let psState = processState(pid: pid),
+      psState.uppercased().hasPrefix("U") || psState.uppercased().hasPrefix("D")
+    else {
+      // Proces dziala normalnie (albo `ps` chwilowo nie odpowiedzialo) -
+      // kasujemy znacznik, gdyby proces przejsciowo wpadl w U/D i wrocil.
+      try? FileManager.default.removeItem(at: stuckSinceFile)
+      return true
     }
+
+    if let stuckSinceString = try? String(contentsOf: stuckSinceFile, encoding: .utf8),
+      let stuckSinceEpoch = TimeInterval(
+        stuckSinceString.trimmingCharacters(in: .whitespacesAndNewlines))
+    {
+      let stuckDuration = Date().timeIntervalSince1970 - stuckSinceEpoch
+      guard stuckDuration > Self.stuckLockThreshold else { return true }
+      CMLogger.log(
+        "[CMLock] OSTRZEZENIE: PID \(pid) trzymajacy blokade '\(lockDir.lastPathComponent)'"
+          + " jest NIEPRZERWANIE zawieszony w stanie U/D (NFS hang?) od ponad"
+          + " \(Int(Self.stuckLockThreshold/60)) min. Przejmuje blokade. SIGKILL na zawieszony"
+          + " proces (ignorowany przez jadro, ale sprzatnie PID po odmontowaniu)."
+      )
+      kill(pid, SIGKILL)
+      try? FileManager.default.removeItem(at: stuckSinceFile)
+      return false
+    }
+    // Pierwsza probka w stanie U/D - zapisujemy poczatek okna i czekamy na
+    // kolejne probki, zanim uznamy proces za utkniety.
+    try? "\(Date().timeIntervalSince1970)".write(
+      to: stuckSinceFile, atomically: true, encoding: .utf8)
     return true
   }
 
@@ -100,17 +144,6 @@ public final class CMLock {
     return String(data: data, encoding: .utf8)?.trimmingCharacters(in: .whitespacesAndNewlines)
   }
 
-  /// Zwraca `true` jesli katalog blokady (lock.d) ma mtime starszy niz `seconds`.
-  /// mtime katalogu == czas przejecia blokady przez mkdir() - nie jest pozniej
-  /// modyfikowany, dobrze sluzy jako znacznik czasu przejecia.
-  private func isLockDirOlderThan(seconds: TimeInterval) -> Bool {
-    guard
-      let attrs = try? FileManager.default.attributesOfItem(atPath: lockDir.path),
-      let mtime = attrs[.modificationDate] as? Date
-    else { return false }
-    return Date().timeIntervalSince(mtime) > seconds
-  }
-
   private func writePid() {
     let pidFile = lockDir.appendingPathComponent("pid")
     try? "\(getpid())".write(to: pidFile, atomically: true, encoding: .utf8)
 
@@ -170,24 +170,36 @@ public enum MountHealth {
   /// sposob ~49GB juz przeslanego backupu w trakcie stall-retry). KAZDY
   /// wywolujacy kod, ktory moze zabic/wymusic odmontowanie rclone dla tego
   /// remote, powinien wywolac to NAJPIERW. `tmutil stopbackup` NIE wymaga sudo.
-  public static func stopTimeMachineIfRunning() async {
+  /// `logPrefix` pozwala wywolujacemu zachowac wlasna konwencje logow (np.
+  /// mount-watchdog prefiksuje kazda linie "[mount-watchdog] ") - bez tego
+  /// te linie wypadaly z atrybucji przy grepowaniu logu per-watchdog.
+  public static func stopTimeMachineIfRunning(logPrefix: String = "") async {
     guard await TimeMachineStatus.isRunning() else { return }
+    // WAZNE: celowo "przed wymuszonym odmontowaniem/zabiciem rclone", NIE
+    // "przed montowaniem" - ta funkcja jest wywolywana zarowno przed mount-
+    // owaniem (MountService), jak i przed czystym odmontowaniem
+    // (UnmountService) - wczesniejsza tresc mowila zawsze o "montowaniu",
+    // co bylo faktycznie mylace podczas odmontowania.
     CMLogger.log(
-      "Time Machine aktywnie kopiuje - zatrzymuje backup przed wymuszona operacja na montowaniu, zeby nie uszkodzic sparsebundle."
+      "\(logPrefix)Time Machine aktywnie kopiuje - zatrzymuje backup przed wymuszonym odmontowaniem/zabiciem rclone, zeby nie uszkodzic sparsebundle."
     )
     _ = try? await ProcessRunner.run("/usr/bin/tmutil", ["stopbackup"], timeout: 20)
     var waited = 0
+    var stopped = false
     while waited < 30 {
-      if !(await TimeMachineStatus.isRunning()) { break }
+      if !(await TimeMachineStatus.isRunning()) {
+        stopped = true
+        break
+      }
       try? await Task.sleep(nanoseconds: 2_000_000_000)
       waited += 2
     }
-    if await TimeMachineStatus.isRunning() {
+    if stopped {
+      CMLogger.log("\(logPrefix)Backup zatrzymany po \(waited)s.")
+    } else {
       CMLogger.log(
-        "OSTRZEZENIE: Time Machine nie zatrzymalo sie po \(waited)s - kontynuuje mimo to, ryzyko uszkodzenia sparsebundle."
+        "\(logPrefix)OSTRZEZENIE: Time Machine nie zatrzymalo sie po \(waited)s - kontynuuje mimo to, ryzyko uszkodzenia sparsebundle."
       )
-    } else {
-      CMLogger.log("Backup zatrzymany po \(waited)s.")
     }
   }
 
 
@@ -77,15 +77,34 @@ public enum MountService {
     // konfiguracyjnych bezposrednio przez NFS).
     let sparsebundlePath = "\(remotePath)/backup.sparsebundle"
     let listResult = try? await ProcessRunner.runRclone(["lsf", sparsebundlePath])
-    // WAZNE: `rclone lsf` zwraca exit 0 z PUSTYM stdout gdy folder istnieje,
-    // ale jest pusty (np. po `rclone delete` ktory zostawia katalog bez plikow).
+    // WAZNE: `try?`/`succeeded != true` NIE ROZROZNIA "sprawdzenie sie nie
+    // udalo" (blad sieci, przejsciowy 429 z Google Drive API, timeout) od
+    // "potwierdzone, ze pusto/nie istnieje". Traktowanie porazki sprawdzenia
+    // jako "nie istnieje" jest niebezpieczne - ponizej kod TWORZY nowy pusty
+    // sparsebundle i `rclone copy` go NA WIERZCH istniejacej sciezki, co przy
+    // prawdziwym, w pelni przeslanym backupie nadpisuje/kasuje jego dane.
+    // Dlatego przerywamy montowanie zamiast zgadywac, gdy samo sprawdzenie
+    // zawiodlo - "nie wiem" nie moze pociagac za soba destrukcyjnej akcji.
+    guard let listResult else {
+      CMLogger.log(
+        "BLAD: nie udalo sie sprawdzic czy sparsebundle istnieje w chmurze (blad polaczenia z rclone) - przerywam, zeby nie ryzykowac nadpisania istniejacego backupu."
+      )
+      return false
+    }
+    guard listResult.succeeded else {
+      CMLogger.log(
+        "BLAD: 'rclone lsf' zakonczylo sie bledem podczas sprawdzania sparsebundle w chmurze - przerywam, zeby nie ryzykowac nadpisania istniejacego backupu. Sprobuje ponownie przy nastepnym cyklu."
+      )
+      return false
+    }
+    // `rclone lsf` zwraca exit 0 z PUSTYM stdout gdy folder istnieje, ale
+    // jest pusty (np. po `rclone delete` ktory zostawia katalog bez plikow).
     // Pusty folder != istniejacy sparsebundle - trzeba sprawdzic czy lsf zwrocil
     // jakikolwiek content (poprawny sparsebundle ZAWSZE ma co najmniej Info.plist).
     // Bez tego warunku MountService pomijal tworzenie nowego sparsebundle i probowal
     // zamontowac pusty folder -> "hdiutil: image not recognized" w nieskonczonosc.
     let sparsebundleExists =
-      listResult?.succeeded == true
-      && !(listResult?.stdout.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty ?? true)
+      !listResult.stdout.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
 
     if !sparsebundleExists {
       guard let limitGB = config.limitGB(forMachineKey: machineKey) else {
@@ -276,14 +295,20 @@ public enum MountService {
     }
   }
 
-  /// Konwertuje Mbps (megabity/s - jednostka, w ktorej dostawcy internetu
-  /// podaja predkosc lacza) na argument `--bwlimit` rclone, ktory oczekuje
-  /// megabajtow/s (dzielimy przez 8). `nil`, gdy limit wylaczony (<=0) - dla
-  /// symetrii z `Optional` zamiast magicznej wartosci w liscie argumentow.
+  /// Konwertuje Mbps (megabity/s dziesietnie - jednostka, w ktorej dostawcy
+  /// internetu podaja predkosc lacza, 1 Mbps = 1_000_000 b/s) na argument
+  /// `--bwlimit` rclone w BAJTACH/s (liczba bez sufiksu). WAZNE: rclone
+  /// interpretuje sufiksy "M"/"k"/"G" binarnie (1024^n), NIE dziesietnie -
+  /// gdyby przekazac np. "12.50M" dla 100 Mbps, rclone odczytalby to jako
+  /// 12.5 MiB/s (~13.1 MB/s), czyli limit ~4.9% wyzszy niz oczekiwany.
+  /// Podanie surowej liczby bajtow/s omija te niejednoznacznosc calkowicie
+  /// i jest przy tym dokladne (mbps * 125_000 to zawsze liczba calkowita).
+  /// `nil`, gdy limit wylaczony (<=0) - dla symetrii z `Optional` zamiast
+  /// magicznej wartosci w liscie argumentow.
   private static func bwLimitArg(mbps: Int) -> String? {
     guard mbps > 0 else { return nil }
-    let megabytesPerSecond = Double(mbps) / 8
-    return String(format: "%.2fM", megabytesPerSecond)
+    let bytesPerSecond = mbps * 125_000
+    return String(bytesPerSecond)
   }
 
   private static func startRcloneDaemon(remotePath: String, localDir: URL, bwLimitMbps: Int)
 
@@ -212,14 +212,25 @@ public enum MountWatchdogService {
     // jest zamontowane, NIE wolno tu z wyprzedzeniem zabijac rclone -
     // moglibysmy trafic w sam srodek juz trwajacego, zdrowego montowania.
     if nfsListed {
+      // WAZNE: wolamy to BEZWARUNKOWO, przed jakimkolwiek demontazem/killem
+      // ponizej - nie tylko przed `hdiutil detach` na sparsebundle. rclone
+      // moze trzymac brudny `--vfs-write-back` cache z wczesniejszego
+      // okresu, gdy sparsebundle BYL zamontowany i Time Machine aktywnie
+      // pisal, nawet jesli TERAZ (w tym przebiegu) `spMount` juz nie jest
+      // zamontowany - `killRcloneForRemote` ponizej i tak przerwie upload
+      // tych zaleglych danych. Wczesniej to wywolanie bylo zagniezdzone
+      // tylko w gałęzi `isMounted(spMount.path)`, wiec `forceUnmount`/
+      // `killRcloneForRemote` dla samego NFS mogly wykonac sie bez ochrony -
+      // dokladnie ten sam typ bledu, ktory ta funkcja ma zapobiegac (patrz
+      // incydent z utrata ~49GB backupu).
+      await MountHealth.stopTimeMachineIfRunning(logPrefix: "[mount-watchdog] ")
       if await MountHealth.isMounted(spMount.path) {
         // WAZNE: jesli Time Machine akurat aktywnie pisze na ten wolumin,
         // `hdiutil detach -force` w trakcie zapisu potrafi uszkodzic
         // metadane sparsebundle - wtedy przy nastepnym mouncie wyglada to
         // jak "zniknal z chmury" i cala historia backupu zaczyna sie od
         // zera. Dajemy Time Machine szanse grzecznie sie zatrzymac, tak
         // jak robi to rowniez `UnmountService` przy recznym odmontowaniu.
-        await MountHealth.stopTimeMachineIfRunning()
         _ = try? await ProcessRunner.run("/usr/bin/hdiutil", ["detach", "-force", spMount.path])
         await MountHealth.forceUnmount(spMount.path, timeoutS: 10)
       }