chore(release): 0.1.1

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

.dockerignore

@@ -0,0 +1,8 @@
+.venv
+.git
+data
+**/__pycache__
+.pytest_cache
+.mypy_cache
+.ruff_cache
+tests

CHANGELOG.md

@@ -8,6 +8,39 @@ Die Version steht an genau einer Stelle: `src/netmover/__init__.py`.
 
 ## [Unreleased]
 
+## [0.1.1] – 2026-10-10
+
+Korrekturen aus dem ersten Praxistest auf einer Debian-13-VM mit echten
+SMB-, NFS- und SFTP-Servern.
+
+### Behoben
+- **systemd-Unit:** `ProtectSystem`, `PrivateTmp` und `ProtectControlGroups`
+  gaben dem Dienst einen eigenen Mount-Namespace. Die Mounts waren für das System
+  und andere Programme unsichtbar und verschwanden bei jedem Neustart des Dienstes
+  (`MountFlags=shared` half nicht). Jetzt nur noch Härtungen ohne Namespace.
+- **Stabilitätsprüfung:** CIFS lieferte per `stat()` sekundenlang eine veraltete
+  Größe einer noch wachsenden Datei. Gemessen wird jetzt per `open()` + `fstat()`,
+  das erzwingt frische Attribute. Gesperrte Dateien gelten als „in Benutzung“.
+  (Die zweite Sicherung, die Byte-Zählung beim Kopieren, hatte den Fall bereits
+  abgefangen; es kam keine unvollständige Datei an.)
+- **Ausfall länger als die Wiederherstellung (z. B. NAS-Neustart, Stromausfall):**
+  Von NetMover selbst ausgehängte Anbindungen mit „automatisch einhängen“ werden
+  jetzt jede Minute erneut eingehängt, auch wenn das Einhängen schon beim
+  Dienststart scheiterte. Entwarnung per Webhook. Von außen ausgehängte Anbindungen
+  bleiben weiterhin unangetastet.
+- Bei einer Zeitüberschreitung von `mount` wird die ganze Prozessgruppe beendet, damit
+  `mount.nfs` nicht später doch noch einhängt.
+- Hinweistexte zu `mount`-Fehlern werden nicht mehr mitgeschwärzt.
+- `install.sh` ohne `debconf`-Warnungen, wenn kein Terminal angeschlossen ist.
+
+### Dokumentation
+- Fehlersuche: verzögert sichtbare Dateien auf CIFS → `nohandlecache`.
+- README erklärt, warum die Unit keine Namespace-Härtung nutzt.
+
+## [0.1.0] – 2026-10-10
+
+Erste Version.
+
 ### Hinzugefügt
 - Projektgerüst (Python ≥ 3.12, FastAPI-Stack, src-Layout, ruff, mypy strict, pytest).
 - Datenmodell mit SQLAlchemy 2.x: `credentials`, `mounts`, `rules`, `runs`,
@@ -67,6 +100,13 @@ Die Version steht an genau einer Stelle: `src/netmover/__init__.py`.
   auch für Anbindungen, deren Wiederherstellung scheitert.
 - Dienststart: Migration → Schlüssel → Anbindungen wiederherstellen → Scheduler;
   beim Beenden werden Mounts nicht ausgehängt.
+- Endname lokal per `renameat2(RENAME_NOREPLACE)`: echtes `rename` (Watcher sehen
+  `IN_MOVED_TO`), trotzdem nie überschreibend; Rückfall auf `link` + `unlink`.
+- Deployment: systemd-Unit (`ProtectSystem=full`, `MountFlags=shared`),
+  Installationsskript für Debian 13, `Dockerfile` und `compose.yml` mit
+  `rshared`-Propagation.
+- README mit Installation, Synology→Paperless-Beispiel (SMB-Quelle, SFTP-Ziel),
+  Docker, Reverse Proxy, Konfiguration, Fehlersuche und Sicherheitshinweisen.
 - Weboberfläche (FastAPI, Jinja2, HTMX ohne Build-Schritt, handyfähig, Hell/Dunkel):
   Status, Anbindungen, Regeln, Protokoll, Einstellungen.
 - Ersteinrichtung mit Pflicht-Passwort (≥ 10 Zeichen) und einmaligem
@@ -87,3 +127,7 @@ Die Version steht an genau einer Stelle: `src/netmover/__init__.py`.
   Session stand (Session erkennt nur Neuzuweisungen als Änderung).
 - Löschen von Zugangsdaten, die noch von einem Mount benutzt werden, trennt den
   Mount nicht mehr stillschweigend ab, sondern wird von der Datenbank abgelehnt.
+
+[Unreleased]: https://git.wilde-server.de/florian.wilde/netmover/compare/v0.1.1...HEAD
+[0.1.1]: https://git.wilde-server.de/florian.wilde/netmover/compare/v0.1.0...v0.1.1
+[0.1.0]: https://git.wilde-server.de/florian.wilde/netmover/releases/tag/v0.1.0

DEVLOG.md

@@ -12,10 +12,87 @@ Zeiten in Ortszeit (Europe/Berlin).
 | 2026-10-10 | 18:53 | 19:07 | 0:14  | 3       | Mover-Logik                            |
 | 2026-10-10 | 19:10 | 19:17 | 0:07  | 4       | Scheduler, Protokoll, Benachrichtigung |
 | 2026-10-10 | 19:18 | 19:34 | 0:16  | 5       | Weboberfläche und Anmeldung            |
-| **Summe**  |       |       | **0:56** |      |                                        |
+| 2026-10-10 | 19:40 | 19:50 | 0:10  | 6       | Deployment, README, Release 0.1.0      |
+| 2026-10-10 | 21:36 | 22:05 | 0:29  | –       | Praxistest auf VM, Release 0.1.1       |
+| **Summe**  |       |       | **1:35** |      |                                        |
 
 ---
 
+## 2026-10-10 · 21:36–22:05 · Praxistest auf der Debian-13-VM, Release 0.1.1
+
+**Umgebung**
+- KVM-VM `srv-rz-netmover` (10.0.10.223), Debian 13, Python 3.13, 2 GB RAM.
+- Installation per `deploy/install.sh` aus einem `git archive` (VM ohne Gitea-Zugang).
+- Vorübergehende Testserver auf der VM: Samba (nur `lo`), NFS-Exporte für
+  `127.0.0.1` (mit/ohne Root-Squash), SFTP-Benutzer `paperless` mit Schlüssel
+  `restrict,command="/usr/lib/openssh/sftp-server"`.
+- Auf Wunsch `NETMOVER_HOST=0.0.0.0`, damit die Oberfläche im LAN erreichbar ist.
+
+**Bestanden**
+- Ersteinrichtung mit Code aus dem Log, Cookie-Flags.
+- CIFS (Passwort mit Komma/Ausrufezeichen, Credentials-Datei danach weg), NFS 4,
+  NFS 3, Root-Squash-Erkennung mit Synology-Hinweis, SFTP mit TOFU (Fingerabdruck
+  = `ssh-keygen -lf`), echtes OpenSSH liefert `statvfs`.
+- Probelauf, Kollision `scan001-1.pdf`, `.txt`/`.part` ignoriert, keine `.part`-Reste,
+  Eigentümer `paperless` im SFTP-Ziel.
+- Langsam wachsende Datei (20 × 50 KB/s): erst nach Ende verschoben, Prüfsumme gleich.
+- Kopiermodus rekursiv mit Eigentümer/Modus; zweiter Lauf „2 bereits übertragen“.
+- Samba gestoppt: Lebenszeichen 15 s → gestört → 3 Versuche → Fehler, `/healthz` 503,
+  nichts angefasst. NFS-Server gestoppt (hängender `hard`-Mount): Oberfläche und
+  andere Regel liefen weiter, Rückkehr automatisch.
+- Mounts überstehen Stopp/Start des Dienstes (gleiche Mount-IDs).
+- Neustart der VM: NFS sofort, SMB per Neuversuch nach ~1 min, Regel läuft weiter.
+
+**Gefunden und behoben (v0.1.1)**
+1. **systemd-Unit mit eigenem Mount-Namespace** (ProtectSystem/PrivateTmp/…):
+   Mounts nur im Dienst sichtbar, `shared,slave`. Härtung ohne Namespace.
+2. **CIFS-Attribut-Cache**: `stat()` meldete 3 s lang eine veraltete Größe einer
+   wachsenden Datei; die Byte-Zählung beim Kopieren fing das ab. Jetzt
+   `open()` + `fstat()` für beide Messungen.
+3. **Nach drei gescheiterten Versuchen endgültig aufgegeben** – zu kurz für einen
+   NAS-Neustart, und beim Booten vor dem NAS kam die Freigabe nie zurück.
+   Jetzt minütlicher Neuversuch (nur für von NetMover selbst ausgehängte
+   Anbindungen mit `auto_mount`) plus Scheduler-Job.
+4. `mount`-Zeitlimit beendete nur `mount`, nicht `mount.nfs` → später doch
+   eingehängt. Jetzt ganze Prozessgruppe.
+5. Hinweistext wurde mitgeschwärzt; `debconf`-Warnungen in `install.sh`.
+
+**Nicht nachstellbar**
+- Einmalig 46 s Verzögerung direkt nach dem Booten (CIFS-Verzeichnis-Cache bei
+  lokal statt per SMB angelegter Datei). Messungen danach 9–11 s, mit und ohne
+  `nohandlecache`. Als Hinweis in die Fehlersuche aufgenommen.
+
+## 2026-10-10 · 19:40–19:50 · Schritt 6: Deployment, README, Release 0.1.0
+
+**Erledigt**
+- `deploy/netmover.service`, `deploy/netmover.env`, `deploy/install.sh`,
+  `Dockerfile` (python:3.12-slim-trixie, mehrstufig), `compose.yml`, `.dockerignore`.
+- README vollständig; `LICENSE` (MIT, wie seit Schritt 1 in `pyproject.toml`).
+- Version 0.1.0, Changelog-Abschnitt, Tag `v0.1.0`.
+
+**Geprüft**
+- Wheel enthält Templates, statische Dateien und Migrationen.
+- Docker-Image gebaut; Container startet, `/healthz` = 200, `mount.cifs` 7.4 und
+  `mount.nfs` vorhanden. **Propagation getestet:** tmpfs im Container unter
+  `/mnt/netmover` eingehängt → mit `rshared` auf dem Host sichtbar, ohne nicht.
+- `systemd-analyze verify` der Unit ohne Beanstandung. Ein echter Start der Unit
+  als root (insb. `MountFlags=shared` mit `ProtectSystem`) war hier nicht möglich →
+  beim ersten Einsatz mit `findmnt -R /mnt/netmover` prüfen.
+
+**Entscheidungen**
+- Paperless-ngx-Consumer geprüft: nutzt `watchfiles` (`Change.added`) plus
+  5-Minuten-Rescan – erkennt also auch per `link()` erzeugte Dateien. Für Watcher,
+  die nur `IN_MOVED_TO`/`IN_CLOSE_WRITE` kennen, trotzdem auf
+  `renameat2(RENAME_NOREPLACE)` umgestellt (entspricht der Vorgabe `os.replace`,
+  ohne die Garantie „nie überschreiben“ aufzugeben).
+- Härtung der Unit bewusst zurückhaltend (keine `CapabilityBoundingSet`, kein
+  `ProtectKernelModules`): ungetestete Einschränkungen könnten Mounten brechen
+  (z. B. NFS mit privilegiertem Quellport, Modul-Autoload für cifs).
+- SFTP-Schlüssel im README per `restrict,command="…/sftp-server"` auf SFTP beschränkt.
+
+**Offen für später**
+- Erster Praxistest auf der Ziel-VM mit echtem Synology-NAS und Paperless-LXC.
+
 ## 2026-10-10 · 19:18–19:34 · Schritt 5: Weboberfläche und Anmeldung
 
 **Erledigt**

Dockerfile

@@ -0,0 +1,29 @@
+# NetMover im Container (Alternative zum systemd-Dienst, siehe README).
+# Braucht zur Laufzeit CAP_SYS_ADMIN und ein Mount-Verzeichnis mit
+# Propagation „rshared“ – sonst sieht der Host die Mounts nicht.
+
+FROM python:3.12-slim-trixie AS build
+WORKDIR /src
+COPY pyproject.toml README.md ./
+COPY src ./src
+RUN pip wheel --no-cache-dir --wheel-dir /wheels .
+
+FROM python:3.12-slim-trixie
+RUN apt-get update \
+ && apt-get install -y --no-install-recommends cifs-utils nfs-common \
+ && rm -rf /var/lib/apt/lists/*
+COPY --from=build /wheels /wheels
+RUN pip install --no-cache-dir /wheels/*.whl && rm -rf /wheels
+
+ENV NETMOVER_HOST=0.0.0.0 \
+    NETMOVER_PORT=8080 \
+    NETMOVER_DATA_DIR=/var/lib/netmover \
+    NETMOVER_RUN_DIR=/run/netmover \
+    NETMOVER_MOUNT_BASE=/mnt/netmover \
+    PYTHONUNBUFFERED=1
+
+VOLUME ["/var/lib/netmover"]
+EXPOSE 8080
+HEALTHCHECK --interval=30s --timeout=5s --start-period=20s \
+  CMD python -c "import urllib.request,sys; sys.exit(0 if urllib.request.urlopen('http://127.0.0.1:8080/healthz', timeout=4).status == 200 else 1)"
+CMD ["netmover", "serve"]

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Florian Wilde
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1,9 +1,371 @@
 # NetMover
 
-Selbst gehosteter Dienst mit Web-Oberfläche, der SMB/CIFS- und NFS-Freigaben
+Selbst gehosteter Dienst mit Weboberfläche, der **SMB/CIFS- und NFS-Freigaben
-verwaltet und Dateien zeitgesteuert zwischen ihnen verschiebt.
+verwaltet** und **Dateien zeitgesteuert verschiebt** – „alle N Sekunden Ordner 1
+prüfen, passende Dateien nach Ordner 2 bringen“. Quelle und Ziel sind
+unabhängig voneinander per SMB, NFS, lokal oder (nur als Ziel) per SFTP angebunden.
 
-> Status: in Entwicklung (Schritt 5 von 6). Vollständige Doku folgt mit Schritt 6.
+Typischer Einsatz: Ein Synology-NAS nimmt Scans entgegen, NetMover schiebt sie alle
+30 Sekunden in den Eingangsordner von Paperless-ngx.
+
+- [Wie NetMover Datenverlust verhindert](#wie-netmover-datenverlust-verhindert)
+- [Installation](#installation) · [Erster Start](#erster-start)
+- [Beispiel: Synology → Paperless](#beispiel-synology--paperless)
+- [Docker](#alternative-docker) · [Reverse Proxy](#reverse-proxy-mit-tls)
+- [Konfiguration](#konfiguration) · [Fehlersuche](#fehlersuche) · [Sicherheit](#sicherheit)
+- [Entwicklung](#entwicklung)
+
+## Wie NetMover Datenverlust verhindert
+
+Quelle und Ziel liegen fast immer auf verschiedenen Dateisystemen. „Verschieben“
+heißt deshalb immer **kopieren, prüfen, dann erst die Quelle löschen**:
+
+| Gefahr | Was NetMover tut |
+|---|---|
+| Halb geschriebene Scans | Datei wird nur angefasst, wenn Größe **und** Änderungszeit über das Stabilitätsfenster (Standard 5 s) gleich bleiben. `.part`, `.tmp`, `.crdownload`, `.filepart`, `.!ut` und versteckte Dateien werden ignoriert. |
+| Freigabe nicht eingehängt | Vor jedem Lauf prüft NetMover über `/proc/self/mountinfo`, ob Quelle und Ziel wirklich eingehängt sind – nie daran, ob Dateien da sind. Sonst: Lauf abbrechen, nichts anfassen. |
+| Wachsende Datei im Zielordner | Geschrieben wird in `.netmover-<uuid>.part`, dann `fsync`, Größenprüfung, erneute Prüfung der Quelle und atomares Umbenennen ohne Überschreiben. Erst danach wird die Quelle gelöscht. |
+| `scan001.pdf` existiert schon | `scan001-1.pdf`, `scan001-2.pdf`, … – jedes Mal neu gegen das Dateisystem geprüft. Überschreiben nur, wenn ausdrücklich eingestellt. |
+| Kopiermodus kopiert endlos | Übertragene Dateiversionen (Pfad, Größe, mtime) werden gemerkt. |
+| Hängender NFS-Mount, „Stale file handle“ | Jeder Lauf arbeitet in einem eigenen Worker mit Zeitlimit; gestörte Mounts werden per `umount -l` neu eingehängt (max. 3 Versuche). |
+| Ziel voll | Vor jeder Kopie: freier Platz ≥ Dateigröße + 5 %. |
+| Stiller Ausfall | Statusseite und `/healthz` werden rot, wenn eine Regel länger als das Dreifache ihres Intervalls keinen erfolgreichen Lauf hatte. |
+
+## Installation
+
+### Wo installieren?
+
+| Variante | Empfehlung |
+|---|---|
+| **VM mit Debian 13** | ✅ Empfohlen. Einhängen funktioniert ohne Sonderkonfiguration. |
+| Proxmox-Host direkt | Funktioniert, aber zusätzliche Software auf dem Hypervisor ist meist unerwünscht. |
+| **Privilegierter** LXC | Möglich: `pct set <id> -features mount=cifs;nfs`. |
+| Unprivilegierter LXC | ❌ Der Kernel erlaubt dort kein CIFS/NFS-Mount. |
+| Docker | Möglich, siehe [Alternative: Docker](#alternative-docker). |
+
+### systemd-Dienst (empfohlen)
+
+```bash
+apt install -y git
+git clone https://git.wilde-server.de/florian.wilde/netmover.git
+cd netmover
+sudo ./deploy/install.sh
+```
+
+Das Skript installiert `python3-venv`, `cifs-utils` und `nfs-common` und richtet
+NetMover in `/opt/netmover/venv` ein. Danach installiert es
+[`deploy/netmover.service`](deploy/netmover.service) und startet den Dienst.
+Ein Update ist derselbe Aufruf nach einem `git pull`.
+
+Was wo liegt:
+
+| Pfad | Inhalt |
+|---|---|
+| `/var/lib/netmover/netmover.db` | Datenbank (SQLite) |
+| `/var/lib/netmover/secret.key` | Schlüssel für die Zugangsdaten (0600) – **mitsichern!** |
+| `/etc/netmover/netmover.env` | Einstellungen (Port, Logs, …) |
+| `/mnt/netmover/<name>` | Mountpoints – nur NetMover legt hier etwas an |
+| `/run/netmover` | kurzlebige Credentials-Dateien für `mount.cifs` |
+
+**Warum als root?** Ein- und Aushängen braucht `CAP_SYS_ADMIN`. Außerdem soll
+NetMover Dateien auf beliebigen Freigaben lesen, löschen und mit den richtigen
+Eigentümern anlegen können.
+
+**Warum so wenig systemd-Härtung?** Optionen wie `ProtectSystem=`, `PrivateTmp=`
+oder `ProtectHome=` geben dem Dienst einen eigenen Mount-Namespace. Die Mounts
+landeten dann *nur dort*: Das System und Paperless sähen sie nicht, und jeder
+Neustart des Dienstes würde sie verwerfen. `MountFlags=shared` hilft dagegen nicht.
+Auf der Test-VM nachgewiesen. Die Unit nutzt deshalb nur Härtungen ohne eigenen
+Namespace (`NoNewPrivileges`, `RestrictSUIDSGID`, `LockPersonality`,
+`RestrictRealtime`); Datenbank und Schlüssel sind nur für root lesbar. Prüfen:
+
+```bash
+findmnt -l | grep /mnt/netmover    # die eingehängten Freigaben müssen hier stehen
+```
+
+**Beim Beenden bleiben die Mounts eingehängt**, weil andere Programme sie benutzen
+könnten. Beim Start werden alle Anbindungen mit „automatisch einhängen“
+wiederhergestellt. Erst danach startet der Scheduler.
+
+## Erster Start
+
+NetMover lauscht standardmäßig nur auf `127.0.0.1:8080`. Vom Arbeitsplatz aus
+erreichst du die Oberfläche per SSH-Tunnel:
+
+```bash
+ssh -L 8080:127.0.0.1:8080 root@netmover-vm
+# dann im Browser: http://localhost:8080
+```
+
+Beim ersten Aufruf musst du ein Administratorpasswort setzen (mindestens 10 Zeichen).
+Dafür brauchst du den **Einrichtungscode** aus dem Log. Damit kann nicht irgendwer
+im Netz, der die Seite zuerst öffnet, das Passwort setzen:
+
+```bash
+journalctl -u netmover | grep setup.required
+# … event=setup.required code=4f2a-91c0-7d3e …
+```
+
+Passwort vergessen? `sudo /opt/netmover/venv/bin/netmover reset-password`, dann
+`systemctl restart netmover` und die Einrichtung neu durchlaufen.
+
+## Beispiel: Synology → Paperless
+
+Ziel: Scans landen auf dem NAS in `scans`. NetMover schiebt PDFs alle 30 Sekunden
+in den Consume-Ordner von Paperless, das in einem LXC per SSH erreichbar ist.
+
+### 1. Synology vorbereiten
+
+1. **Systemsteuerung → Benutzer** → Benutzer `netmover` anlegen, Lese-/Schreibrecht
+   auf den gemeinsamen Ordner `scans`.
+2. **Systemsteuerung → Dateidienste → SMB**: aktiviert. Unter *Erweitert* als
+   minimales Protokoll SMB2 oder höher.
+
+### 2. Anbindung „Synology Scans“ anlegen
+
+*Anbindungen → Neue Anbindung*:
+
+| Feld | Wert |
+|---|---|
+| Name | `Synology Scans` |
+| Typ | SMB/CIFS |
+| Server | `192.168.1.10` (IP des NAS) |
+| Freigabe | `scans` |
+| Benutzername / Passwort | `netmover` / … |
+| Zusatzoptionen | `vers=3.0` |
+| Beim Start automatisch einhängen | ✓ |
+
+Klicke auf **Testen**. Alle drei Schritte (Einhängen, Lesen, Schreiben) sollten ✓
+zeigen, und die Rolle sollte „Quelle mit Löschen“ lauten. Danach speichern und
+**Einhängen**.
+
+### 3. Paperless-LXC vorbereiten (SFTP-Ziel)
+
+Lege in NetMover die *Anbindung → Neue Anbindung* an:
+
+| Feld | Wert |
+|---|---|
+| Name | `Paperless` |
+| Typ | SFTP (nur Ziel) |
+| Server / SSH-Port | IP des LXC / `22` |
+| Freigabe / Pfad | `/opt/paperless_data/consume` |
+| Anmeldeart | SSH-Schlüssel (NetMover erzeugt ihn) |
+| Benutzername | `paperless` (der Benutzer, unter dem Paperless läuft) |
+
+Nach dem Speichern zeigt NetMover den **öffentlichen Schlüssel**. Trage ihn im LXC
+ein, und zwar so, dass der Schlüssel **nur SFTP** darf:
+
+```bash
+# im Paperless-LXC als root
+install -d -m 700 -o paperless -g paperless ~paperless/.ssh
+echo 'restrict,command="/usr/lib/openssh/sftp-server" ssh-ed25519 AAAA… netmover@paperless' \
+  >> ~paperless/.ssh/authorized_keys
+chown paperless:paperless ~paperless/.ssh/authorized_keys
+chmod 600 ~paperless/.ssh/authorized_keys
+```
+
+Dann in NetMover bei der Anbindung **Testen**. Prüfe den angezeigten Fingerabdruck
+des Hostschlüssels. Ermitteln kannst du ihn im LXC mit
+`ssh-keygen -lf /etc/ssh/ssh_host_ed25519_key.pub`. NetMover hält ihn beim ersten
+Test fest und verweigert später jede Verbindung, wenn er sich ändert.
+
+> Weil die Dateien als Benutzer `paperless` ankommen, darf Paperless sie nach dem
+> Einlesen auch löschen. Paperless-ngx (aktuelle Versionen mit `watchfiles`)
+> bemerkt neue Dateien sofort. Ältere Versionen, die nur auf
+> `IN_CLOSE_WRITE`/`IN_MOVED_TO` lauschen, siehe [Fehlersuche](#fehlersuche).
+
+### 4. Regel anlegen
+
+*Regeln → Neue Regel*:
+
+| Feld | Wert |
+|---|---|
+| Name | `Scans → Paperless` |
+| Intervall | `30` |
+| Quelle | `Synology Scans`, Unterordner leer |
+| Filter | Glob `*.pdf` |
+| Ziel | Anbindung `Paperless`, Zielordner leer |
+| Aktion | verschieben |
+| Wenn Datei existiert | umbenennen |
+| Stabilitätsfenster | `5` |
+| Quarantäneordner | `_quarantaene` (optional) |
+
+Klicke auf **Probelauf**. Die Tabelle zeigt, welche Datei wohin ginge, ohne etwas
+zu verändern. Danach aktivieren und auf der Statusseite verfolgen.
+
+**Getrennt nach Unterordnern?** Scannt z. B. jede Person in einen eigenen
+Unterordner (`scans/max`, `scans/erika`), legst du pro Unterordner eine Regel mit
+eigenem Quell-Unterordner und eigenem Ziel an.
+
+**Paperless lokal statt per SSH?** Läuft Paperless auf demselben Host, wähle als Ziel
+„Lokaler Pfad“ (z. B. `/opt/paperless_data/consume`). Der Ordner muss existieren und
+darf nicht unter `/mnt/netmover` liegen. Mit „Eigentümer setzen“ (z. B. `1000:1000`)
+gehören die Dateien danach dem Paperless-Benutzer.
+
+### NFS statt SMB
+
+Am NAS: *Dateidienste → NFS* aktivieren. Dann unter *Gemeinsamer Ordner →
+Bearbeiten → NFS-Berechtigungen* eine Regel mit der IP des NetMover-Hosts anlegen.
+In NetMover Typ „NFS 4“, Freigabe `/volume1/scans`.
+
+**Root-Squash:** NetMover läuft als root. Synology bildet root standardmäßig auf
+`nobody` ab, dann scheitert das Schreiben oder `chown`. Der **Testen**-Knopf erkennt
+das und sagt es dir. Abhilfe in der NFS-Regel: *Squash → „Keine Zuordnung“* (No
+mapping) oder „Alle Benutzer zu admin zuordnen“.
+
+## Alternative: Docker
+
+```bash
+mkdir -p /mnt/netmover
+docker compose up -d --build
+docker compose logs | grep setup.required
+```
+
+[`compose.yml`](compose.yml) gibt dem Container die nötigen Rechte:
+`cap_add: [SYS_ADMIN, DAC_READ_SEARCH]` und `security_opt: [apparmor:unconfined]`.
+
+> **Wichtig:** `/mnt/netmover` muss als `bind` mit **`propagation: rshared`**
+> eingebunden sein. Ohne das bleiben die Mounts im Container gefangen: NetMover
+> selbst sieht sie, aber weder der Host noch andere Container (z. B. Paperless).
+> Getestet: Mit `rshared` erscheint ein im Container eingehängtes Dateisystem
+> sofort unter `/mnt/netmover` auf dem Host, ohne `rshared` nicht.
+
+Lokale Ziele musst du zusätzlich als Volume einbinden. Für NFSv3 im Container die
+Option `nolock` setzen oder besser NFSv4 nehmen; NFSv3-Locking braucht
+`rpc.statd`, und den gibt es im Container nicht.
+
+**Unterschied zum systemd-Dienst:** Der Dienst direkt auf dem Host braucht keine
+Propagation-Tricks, keine AppArmor-Ausnahme und keine zusätzlichen Volumes. Docker
+kapselt die Software, hat aber trotz Container `CAP_SYS_ADMIN` und ist damit kaum
+weniger mächtig als root auf dem Host.
+
+## Reverse Proxy mit TLS
+
+NetMover gehört **nicht ins Internet**. Es hat root-Rechte, hängt beliebige
+Freigaben ein und speichert Zugangsdaten zu deinem NAS. Ein Fehler oder ein
+schwaches Passwort wäre ein direkter Weg in dein Netz. Für den Zugriff im LAN gehört
+ein Reverse Proxy mit TLS davor; für unterwegs nimm VPN (z. B. WireGuard).
+
+Beispiel Caddy auf demselben Host:
+
+```caddyfile
+netmover.lan {
+    tls internal
+    reverse_proxy 127.0.0.1:8080
+}
+```
+
+Beispiel nginx:
+
+```nginx
+server {
+    listen 443 ssl;
+    server_name netmover.lan;
+    ssl_certificate     /etc/ssl/netmover.crt;
+    ssl_certificate_key /etc/ssl/netmover.key;
+    location / {
+        proxy_pass http://127.0.0.1:8080;
+        proxy_set_header Host $host;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+        proxy_read_timeout 300s;   # Mount-Tests können dauern
+    }
+}
+```
+
+Dann in `/etc/netmover/netmover.env`:
+
+```bash
+NETMOVER_COOKIE_SECURE=true          # Session-Cookie nur noch per HTTPS
+NETMOVER_FORWARDED_ALLOW_IPS=127.0.0.1
+```
+
+## Konfiguration
+
+Umgebungsvariablen (in `/etc/netmover/netmover.env`); alles Übrige stellst du in
+der Oberfläche unter *Einstellungen* ein:
+
+| Variable | Standard | Bedeutung |
+|---|---|---|
+| `NETMOVER_HOST` | `127.0.0.1` | Adresse, auf der NetMover lauscht |
+| `NETMOVER_PORT` | `8080` | Port |
+| `NETMOVER_DATA_DIR` | `/var/lib/netmover` | Datenbank und Schlüssel |
+| `NETMOVER_MOUNT_BASE` | `/mnt/netmover` | Basisverzeichnis der Mountpoints |
+| `NETMOVER_RUN_DIR` | `/run/netmover` | kurzlebige Credentials-Dateien |
+| `NETMOVER_COOKIE_SECURE` | `false` | Cookie nur per HTTPS (hinter TLS-Proxy: `true`) |
+| `NETMOVER_FORWARDED_ALLOW_IPS` | `127.0.0.1` | Proxy-IPs, deren `X-Forwarded-*` gilt |
+| `NETMOVER_SESSION_HOURS` | `12` | Gültigkeit der Anmeldung |
+| `NETMOVER_LOG_LEVEL` | `INFO` | `DEBUG`, `INFO`, `WARNING`, `ERROR` |
+| `NETMOVER_LOG_FORMAT` | `logfmt` | `logfmt` oder `json` (ein Ereignis pro Zeile) |
+
+In der Oberfläche unter *Einstellungen* stellst du ein:
+- Aufbewahrung der Protokolle (Standard 30 Tage).
+- Webhook-Benachrichtigung: „bei jedem Fehler“ oder „nach N Fehlern in Folge“,
+  jeweils mit Entwarnung.
+- Export und Import der Konfiguration, **ohne** Zugangsdaten und Webhook-URL.
+
+Webhook-Vorlagen (Platzhalter `$event $title $message $rule $time $host`):
+
+| Dienst | URL | Content-Type | Vorlage |
+|---|---|---|---|
+| ntfy | `https://ntfy.sh/<topic>` | `text/plain` | `$title: $message` |
+| Gotify | `https://gotify.lan/message?token=…` | `application/json` | `{"title": "$title", "message": "$message", "priority": 5}` |
+| eigener Empfänger | beliebig | `application/json` | Standardvorlage |
+
+`GET /healthz` liefert `200` oder `503` mit der Liste der Probleme (ohne Anmeldung),
+z. B. für Uptime Kuma.
+
+## Fehlersuche
+
+```bash
+journalctl -u netmover -f                    # Log live
+journalctl -u netmover | grep level=error
+findmnt -R /mnt/netmover                     # was ist wirklich eingehängt?
+```
+
+| Meldung / Symptom | Ursache und Abhilfe |
+|---|---|
+| `mount error(13): Permission denied` (CIFS) | Benutzer oder Passwort falsch, oder keine Rechte auf die Freigabe. |
+| `mount error(2): No such file or directory` | Freigabename falsch geschrieben (Groß/klein!). |
+| `mount error(112): Host is down` | NAS nicht erreichbar, oder SMB1 erwartet: `vers=3.0` bzw. `vers=2.1` probieren. |
+| `… helper program` / `unknown filesystem type` | `apt install cifs-utils nfs-common` |
+| `Operation not permitted` / `only root can do that` | Kein `CAP_SYS_ADMIN`: unprivilegierter LXC oder Docker ohne `cap_add`. |
+| `access denied by server` (NFS) | NFS-Regel am NAS fehlt für die IP dieses Hosts (oder falsches Subnetz in der Regel). |
+| Test: „Root-Squash“ | Siehe [NFS statt SMB](#nfs-statt-smb); `chown` wird bis dahin übersprungen. |
+| „… ist nicht leer“ beim Einhängen | Im Mountpoint liegen Dateien, die geschrieben wurden, als nichts eingehängt war. Inhalt prüfen und sichern, Verzeichnis leeren, erneut einhängen. |
+| „nicht eingehängt – Lauf abgebrochen“ | Die Freigabe ist weg (z. B. von Hand ausgehängt). Auf der Anbindungsseite **Einhängen**. NetMover hängt verschwundene Mounts absichtlich nicht selbst neu ein. |
+| „gestört (ESTALE …)“, danach wieder OK | NAS-Neustart; NetMover hat neu eingehängt. Bleibt der Fehler: Netzwerk/NAS prüfen. |
+| „weiterhin nicht verfügbar – neuer Versuch in 60 s“ | Das NAS ist (noch) weg, z. B. während eines DSM-Updates. Bei Anbindungen mit „automatisch einhängen“ versucht NetMover es jede Minute erneut und meldet per Webhook, wenn es wieder klappt. |
+| „Keine Reaktion seit 120 s“ | Ein Dateizugriff hängt (meist NFS mit `hard`). Die Regel bleibt blockiert („läuft seit …“), bis der Zugriff zurückkehrt; die Anbindung wird vor dem nächsten Lauf geprüft. |
+| „Hostschlüssel … hat sich geändert“ (SFTP) | Wurde der Zielserver neu aufgesetzt? Dann bei der Anbindung „Hostschlüssel zurücksetzen“ und neu testen. Sonst **nicht** verbinden. |
+| SFTP: „Anmeldung abgelehnt“ | Öffentlicher Schlüssel fehlt in `authorized_keys`, oder Rechte von `~/.ssh` stimmen nicht (700/600, Eigentümer). |
+| Paperless bemerkt neue Dateien nicht | Ältere Paperless-Versionen: `PAPERLESS_CONSUMER_POLLING=10` setzen. |
+| Neue Dateien erscheinen erst nach bis zu 30 s | Der CIFS-Client speichert Verzeichnislisten zwischen. Gelangen Dateien nicht per SMB aufs NAS (z. B. per FTP vom Scanner), erfährt er nichts davon. Abhilfe: Zusatzoption `nohandlecache`. |
+| Regel gelb „länger als 3 × Intervall“ | Seit dem Dreifachen des Intervalls kein erfolgreicher Lauf; Protokoll der Regel ansehen. |
+| Einrichtungscode verloren | `systemctl restart netmover` erzeugt einen neuen. |
+
+## Sicherheit
+
+- **Nicht ins Internet stellen** (siehe [Reverse Proxy](#reverse-proxy-mit-tls)).
+- Zugangsdaten liegen nur verschlüsselt in der Datenbank (Fernet, Schlüssel
+  `secret.key`, 0600). Die Oberfläche zeigt sie nie an; in der Prozessliste stehen
+  sie ebenfalls nie, weil `mount.cifs` eine kurzlebige Credentials-Datei bekommt.
+  Ausgaben von `mount` werden geschwärzt, bevor sie protokolliert werden.
+- **Sichere `secret.key` zusammen mit der Datenbank.** Ohne den Schlüssel sind die
+  gespeicherten Passwörter verloren.
+- Anmeldung:
+  - Ein Administratorkonto mit Argon2-Passworthash.
+  - Sperre nach 5 Fehlversuchen.
+  - Session-Cookie `HttpOnly`, `SameSite=Lax`.
+  - CSRF-Token bei jedem POST.
+  - Strikte Content-Security-Policy ohne Inline-Skripte.
+- Eingaben, die in `mount` landen, werden streng geprüft. Zusatzoptionen
+  sind nur aus einer Allowlist erlaubt, `credentials`, `username`, `password` und
+  `pass` sind gesperrt, `mount` wird nie über eine Shell aufgerufen.
+- Mountpoints entstehen ausschließlich unter `/mnt/netmover`; NetMover ändert
+  `/etc/fstab` nie.
+- SFTP-Ziele: Schlüssel per `restrict,command="/usr/lib/openssh/sftp-server"` auf
+  SFTP beschränken; der Hostschlüssel wird festgehalten.
 
 ## Entwicklung
 
@@ -12,10 +374,26 @@ python3 -m venv .venv            # oder: --without-pip + get-pip.py
 .venv/bin/pip install -e '.[dev]'
 .venv/bin/pytest
 .venv/bin/ruff check . && .venv/bin/ruff format --check . && .venv/bin/mypy
-NETMOVER_DATA_DIR=$PWD/data .venv/bin/netmover migrate
+
+# Oberfläche ohne root und ohne NAS ausprobieren (simulierte Mounts):
+NETMOVER_DATA_DIR=/tmp/nm NETMOVER_RUN_DIR=/tmp/nm/run NETMOVER_MOUNT_BASE=/tmp/nm/mnt \
+NETMOVER_MOUNT_BACKEND=fake .venv/bin/netmover serve
+# Freigaben simulieren: mkdir -p /tmp/nm/fake/remote/<server>/<freigabe>
 ```
 
-Neue Migration nach Modelländerung:
+Aufbau:
+
+| Modul | Aufgabe |
+|---|---|
+| `mounting/` | `MountBackend` (Linux/Fake), Mount-Verwaltung, Test, Wiederherstellung, SFTP |
+| `mover/` | Scan, Stabilität, atomares Schreiben, Kollisionen, Buchführung, Regellauf |
+| `runs.py`, `scheduler.py`, `health.py`, `notify.py` | Protokoll, Zeitsteuerung, Gesundheit, Webhook |
+| `admin.py`, `transfer.py`, `web/` | Formulare, Export/Import, Oberfläche |
+
+Die gesamte Mover-Logik ist mit dem `FakeMountBackend` ohne root testbar. SFTP
+wird gegen einen echten SFTP-Server im Testprozess getestet.
+
+Neue Migration nach einer Modelländerung:
 
 ```bash
 NETMOVER_DATA_DIR=$PWD/data .venv/bin/alembic revision --autogenerate -m "…"
@@ -23,11 +401,19 @@ NETMOVER_DATA_DIR=$PWD/data .venv/bin/alembic revision --autogenerate -m "…"
 
 Veröffentlichte Migrationen (ab v0.1.0) werden nie mehr geändert, nur ergänzt.
 
-## Arbeitsweise
+### Arbeitsweise
 
 - Commits nach [Conventional Commits](https://www.conventionalcommits.org/de/)
   (`feat:`, `fix:`, `docs:`, `test:`, `chore:` …).
-- Jede nutzerrelevante Änderung bekommt einen Eintrag unter `[Unreleased]` in
+- Jede nutzerrelevante Änderung kommt unter `[Unreleased]` in
-  [CHANGELOG.md](CHANGELOG.md). Beim Release wird der Abschnitt versioniert,
+  [CHANGELOG.md](CHANGELOG.md). Bei einem Release:
-  die Version in `src/netmover/__init__.py` angehoben und ein Tag `vX.Y.Z` gesetzt.
+  1. Den Abschnitt `[Unreleased]` mit Versionsnummer versehen.
-- Arbeitszeit und Entscheidungen: [DEVLOG.md](DEVLOG.md).
+  2. Die Version in `src/netmover/__init__.py` anheben.
+  3. Einen Tag `vX.Y.Z` setzen.
+- Arbeitszeit und Entscheidungen stehen in [DEVLOG.md](DEVLOG.md).
+- htmx 2.0.4 liegt unter `src/netmover/web/static/htmx.min.js`
+  (SHA-256 `e209dda5c8235479f3166defc7750e1dbcd5a5c1808b7792fc2e6733768fb447`).
+
+## Lizenz
+
+MIT

compose.yml

@@ -0,0 +1,37 @@
+# NetMover per Docker Compose. Vorher auf dem Host:
+#   mkdir -p /mnt/netmover
+# Die Weboberfläche ist nur auf dem Host selbst erreichbar (127.0.0.1:8080).
+services:
+  netmover:
+    build: .
+    image: netmover:0.1.1
+    container_name: netmover
+    restart: unless-stopped
+    cap_add:
+      - SYS_ADMIN        # mount/umount
+      - DAC_READ_SEARCH  # mount.cifs liest die Credentials-Datei
+    security_opt:
+      - apparmor:unconfined  # Dockers AppArmor-Profil verbietet mount
+    ports:
+      - "127.0.0.1:8080:8080"
+    environment:
+      NETMOVER_LOG_LEVEL: INFO
+      # Hinter einem Reverse Proxy mit HTTPS:
+      # NETMOVER_COOKIE_SECURE: "true"
+      # NETMOVER_FORWARDED_ALLOW_IPS: "172.16.0.0/12"
+    volumes:
+      - netmover-data:/var/lib/netmover
+      # WICHTIG: rshared – sonst bleiben die Mounts im Container gefangen und
+      # weder der Host noch andere Container sehen sie.
+      - type: bind
+        source: /mnt/netmover
+        target: /mnt/netmover
+        bind:
+          propagation: rshared
+      # Lokale Ziele (z. B. Paperless-Consume-Ordner) zusätzlich einbinden:
+      # - /opt/paperless/consume:/opt/paperless/consume
+    tmpfs:
+      - /run/netmover:mode=0700
+
+volumes:
+  netmover-data:

deploy/install.sh

@@ -0,0 +1,47 @@
+#!/bin/sh
+# NetMover auf Debian 13 installieren bzw. aktualisieren (als root ausführen).
+#
+#   ./deploy/install.sh                 # aus diesem Verzeichnis installieren
+#   ./deploy/install.sh 'git+https://git.wilde-server.de/florian.wilde/netmover.git@v0.1.0'
+set -eu
+
+SOURCE="${1:-$(cd "$(dirname "$0")/.." && pwd)}"
+PREFIX=/opt/netmover
+
+if [ "$(id -u)" -ne 0 ]; then
+    echo "Bitte als root ausführen." >&2
+    exit 1
+fi
+
+echo "==> Pakete"
+export DEBIAN_FRONTEND=noninteractive
+apt-get update -qq
+apt-get install -y -qq python3 python3-venv cifs-utils nfs-common >/dev/null
+
+echo "==> Virtuelle Umgebung in $PREFIX/venv"
+install -d -m 0755 "$PREFIX"
+[ -x "$PREFIX/venv/bin/python" ] || python3 -m venv "$PREFIX/venv"
+"$PREFIX/venv/bin/pip" install -q --upgrade pip
+"$PREFIX/venv/bin/pip" install -q --upgrade "$SOURCE"
+
+echo "==> Konfiguration"
+install -d -m 0755 /etc/netmover
+if [ ! -f /etc/netmover/netmover.env ]; then
+    install -m 0640 "$(dirname "$0")/netmover.env" /etc/netmover/netmover.env
+fi
+install -d -m 0755 /mnt/netmover
+
+echo "==> systemd"
+install -m 0644 "$(dirname "$0")/netmover.service" /etc/systemd/system/netmover.service
+systemctl daemon-reload
+systemctl enable netmover >/dev/null 2>&1
+systemctl restart netmover
+
+sleep 2
+systemctl --no-pager --lines=0 status netmover || true
+echo
+if journalctl -u netmover -n 200 --no-pager | grep -q "setup.required"; then
+    echo "Ersteinrichtung: Einrichtungscode aus dem Log:"
+    journalctl -u netmover -n 200 --no-pager | grep "setup.required" | tail -1
+fi
+echo "Fertig. Weboberfläche: http://127.0.0.1:8080 (README: SSH-Tunnel / Reverse Proxy)"

deploy/netmover.env

@@ -0,0 +1,17 @@
+# Umgebungsvariablen für NetMover (/etc/netmover/netmover.env).
+# Nach Änderungen: systemctl restart netmover
+
+# Nur lokal erreichbar – für Zugriff aus dem LAN einen Reverse Proxy mit TLS
+# davorsetzen (README, „Reverse Proxy“) oder per SSH-Tunnel arbeiten.
+NETMOVER_HOST=127.0.0.1
+NETMOVER_PORT=8080
+
+# Hinter einem Reverse Proxy mit HTTPS:
+# NETMOVER_COOKIE_SECURE=true
+# NETMOVER_FORWARDED_ALLOW_IPS=127.0.0.1
+
+# NETMOVER_MOUNT_BASE=/mnt/netmover
+# NETMOVER_SESSION_HOURS=12
+NETMOVER_LOG_LEVEL=INFO
+# logfmt (gut lesbar im Journal) oder json
+NETMOVER_LOG_FORMAT=logfmt

deploy/netmover.service

@@ -0,0 +1,44 @@
+# NetMover als systemd-Dienst direkt auf dem Host (empfohlen).
+# Installation: siehe README, Abschnitt „Installation“.
+[Unit]
+Description=NetMover – NFS/SMB-Mounts und zeitgesteuertes Verschieben
+Documentation=https://git.wilde-server.de/florian.wilde/netmover
+Wants=network-online.target
+After=network-online.target remote-fs-pre.target
+
+[Service]
+Type=exec
+# root ist nötig: mount/umount brauchen CAP_SYS_ADMIN, und Dateien auf beliebigen
+# Freigaben sollen mit den richtigen Eigentümern geschrieben werden (siehe README).
+User=root
+EnvironmentFile=-/etc/netmover/netmover.env
+ExecStart=/opt/netmover/venv/bin/netmover serve
+Restart=on-failure
+RestartSec=5
+# Beim Stoppen werden Mounts bewusst NICHT ausgehängt.
+KillMode=mixed
+TimeoutStopSec=20
+
+# /var/lib/netmover (Datenbank, Schlüssel) und /run/netmover (kurzlebige
+# Credentials-Dateien für mount.cifs) – beide nur für root lesbar.
+StateDirectory=netmover
+StateDirectoryMode=0700
+RuntimeDirectory=netmover
+RuntimeDirectoryMode=0700
+
+# Härtung, soweit mit Mounten vereinbar.
+# WICHTIG: Keine Optionen, die einen eigenen Mount-Namespace erzeugen
+# (ProtectSystem=, ProtectHome=, PrivateTmp=, ProtectControlGroups=,
+# ReadOnlyPaths=, BindPaths= …). Sonst landen die Mounts im Namespace des
+# Dienstes: das System und andere Programme (Paperless!) sähen sie nicht, und
+# jeder Neustart des Dienstes würde sie verwerfen. MountFlags=shared hilft dagegen
+# nicht – systemd setzt den Namespace als „slave“ auf, Mounts fließen nur hinein.
+# Auf dem Testsystem nachgewiesen; prüfen mit: findmnt -l | grep /mnt/netmover
+NoNewPrivileges=yes
+LockPersonality=yes
+RestrictRealtime=yes
+RestrictSUIDSGID=yes
+UMask=0022
+
+[Install]
+WantedBy=multi-user.target

src/netmover/__init__.py

@@ -1,3 +1,3 @@
 """NetMover – NFS/SMB-Mounts verwalten und Dateien zeitgesteuert verschieben."""
 
-__version__ = "0.1.0.dev0"
+__version__ = "0.1.1"

src/netmover/app_state.py

@@ -58,7 +58,9 @@ class NetMover:
         )
         self.runner = RuleRunner(self.session_factory, self.mounts)
         self.runs = RunService(self.session_factory, self.runner, self.notifier)
-        self.scheduler = RuleScheduler(self.session_factory, self.runs)
+        self.scheduler = RuleScheduler(
+            self.session_factory, self.runs, retry_mounts=self.mounts.retry_pending
+        )
         self.started_at: datetime = utcnow()
         self.restore_results: list[RestoreResult] = []
 

src/netmover/mounting/linux.py

@@ -8,7 +8,9 @@ Optionszeile – die stünde sonst in der Prozessliste.
 
 from __future__ import annotations
 
+import contextlib
 import os
+import signal
 import subprocess
 import uuid
 from collections.abc import Callable, Sequence
@@ -24,6 +26,28 @@ log = get_logger(__name__)
 
 Runner = Callable[..., "subprocess.CompletedProcess[str]"]
 
+
+def run_process_group(argv: list[str], **kwargs: Any) -> subprocess.CompletedProcess[str]:
+    """Wie ``subprocess.run``, aber in eigener Prozessgruppe: Bei Zeitüberschreitung
+    wird die ganze Gruppe beendet. ``mount`` startet Hilfsprogramme wie
+    ``mount.nfs``; würde nur ``mount`` beendet, liefe ``mount.nfs`` weiter und
+    hängte womöglich Minuten später doch noch ein (auf der Test-VM beobachtet)."""
+    timeout = kwargs.pop("timeout", None)
+    kwargs.pop("check", None)
+    capture = kwargs.pop("capture_output", False)
+    if capture:
+        kwargs["stdout"] = kwargs["stderr"] = subprocess.PIPE
+    with subprocess.Popen(argv, start_new_session=True, **kwargs) as proc:
+        try:
+            out, err = proc.communicate(timeout=timeout)
+        except subprocess.TimeoutExpired:
+            with contextlib.suppress(ProcessLookupError):
+                os.killpg(proc.pid, signal.SIGKILL)
+            proc.communicate()
+            raise
+    return subprocess.CompletedProcess(argv, proc.returncode, out, err)
+
+
 _ENV = {"LC_ALL": "C", "PATH": "/usr/sbin:/usr/bin:/sbin:/bin"}
 
 
@@ -60,7 +84,7 @@ class LinuxMountBackend(MountBackend):
         self,
         run_dir: Path,
         mountinfo_path: Path = MOUNTINFO,
-        runner: Runner = subprocess.run,
+        runner: Runner = run_process_group,
     ) -> None:
         self.run_dir = run_dir
         self.mountinfo_path = mountinfo_path

src/netmover/mounting/manager.py

@@ -15,7 +15,9 @@ Fallstricke:
 
 from __future__ import annotations
 
+import contextlib
 import errno
+import math
 import os
 import threading
 import time
@@ -104,6 +106,13 @@ class RestoreResult:
     message: str
 
 
+def _redact_output(message: str, secrets: Sequence[str]) -> str:
+    """Schwärzt nur die Ausgabe von ``mount``, nicht den angehängten Hinweistext
+    (sonst würde z. B. das Passwort „falsch“ auch im Hinweis geschwärzt)."""
+    output, sep, hint = message.partition("\n→ ")
+    return redact(output, secrets) + sep + hint
+
+
 def build_spec(cfg: MountConfig, mountpoint: Path, cred: CredentialData | None) -> MountSpec:
     """Baut den ``mount``-Aufruf. Validiert erneut (Verteidigung in der Tiefe) –
     auch Daten aus der Datenbank laufen hier noch einmal durch die Prüfung."""
@@ -166,6 +175,8 @@ class MountManager:
         sleep: Callable[[float], None] = time.sleep,
         euid: Callable[[], int] = os.geteuid,
         notifier: Notifier | None = None,
+        retry_interval: float = 60,
+        clock: Callable[[], float] = time.monotonic,
     ) -> None:
         self.session_factory = session_factory
         self.backend = backend
@@ -177,6 +188,12 @@ class MountManager:
         self._sleep = sleep
         self._euid = euid
         self._notifier = notifier
+        self.retry_interval = retry_interval
+        self._clock = clock
+        # Mounts, die NetMover nach gescheiterter Wiederherstellung selbst ausgehängt
+        # hat: nächster erlaubter Versuch (monotone Zeit). Nur diese werden
+        # automatisch neu eingehängt – von außen ausgehängte nie (Fallstrick 2).
+        self._retry_at: dict[int, float] = {}
         self._locks: dict[int, threading.RLock] = {}
         self._locks_guard = threading.Lock()
 
@@ -267,6 +284,7 @@ class MountManager:
 
     def mount(self, mount_id: int) -> None:
         with self._lock(mount_id):
+            self._retry_at.pop(mount_id, None)
             m, cred = self._load(mount_id)
             if not m.type.is_kernel_mount:
                 raise MountError("SFTP-Anbindungen werden nicht eingehängt, nur getestet")
@@ -292,6 +310,7 @@ class MountManager:
 
     def unmount(self, mount_id: int) -> None:
         with self._lock(mount_id):
+            self._retry_at.pop(mount_id, None)
             m, _ = self._load(mount_id)
             if not m.type.is_kernel_mount:
                 self._set_state(mount_id, MountState.UNMOUNTED)
@@ -325,6 +344,8 @@ class MountManager:
                 self.mount(mount_id)
                 results.append(RestoreResult(name, True, "eingehängt"))
             except (MountError, ValidationError, LookupError) as exc:
+                # z. B. Stromausfall: die VM bootet schneller als das NAS
+                self._retry_at[mount_id] = self._clock() + self.retry_interval
                 results.append(RestoreResult(name, False, str(exc)))
                 self._notify("mount.restore_failed", name, str(exc))
         for r in results:
@@ -391,7 +412,7 @@ class MountManager:
                 self.backend.mount(build_spec(cfg, temp, cred), timeout=self.mount_timeout)
             except (MountError, ValidationError) as exc:
                 self._remove_mountpoint(temp)
-                report.step("mount", False, redact(str(exc), secrets))
+                report.step("mount", False, _redact_output(str(exc), secrets))
                 report.step("read", None)
                 report.step("write", None)
                 return report
@@ -501,6 +522,9 @@ class MountManager:
                 return None
             mp = self.mountpoint_for(m.slug)
             if not self.backend.is_mounted(mp):
+                if mount_id in self._retry_at:
+                    self._retry_mount(mount_id, m, cred, mp)
+                    return mp
                 msg = f"„{m.name}“ ist nicht eingehängt – Lauf abgebrochen, nichts angefasst."
                 self._set_state(mount_id, MountState.ERROR, msg)
                 raise MountUnavailable(msg)
@@ -568,10 +592,74 @@ class MountManager:
             f"„{m.name}“ gestört ({reason}); Neu-Einhängen nach "
             f"{len(self.recover_backoff)} Versuchen gescheitert: {last}"
         )
+        if m.auto_mount:
+            self._retry_at[mount_id] = self._clock() + self.retry_interval
+            msg += f"\n→ Neuer Versuch automatisch alle {self.retry_interval:g} s."
         self._set_state(mount_id, MountState.ERROR, msg)
         self._notify("mount.error", m.name, msg)
         raise MountUnavailable(msg)
 
+    def retry_pending(self) -> list[str]:
+        """Fällige Neuversuche ausführen (Scheduler-Job, jede Minute) – auch für
+        Anbindungen, die gerade keine Regel benutzt. Liefert die zurückgeholten Namen."""
+        recovered: list[str] = []
+        for mount_id in list(self._retry_at):
+            if self._retry_at.get(mount_id, float("inf")) > self._clock():
+                continue
+            with self._lock(mount_id):
+                if mount_id not in self._retry_at:
+                    continue
+                try:
+                    m, cred = self._load(mount_id)
+                except LookupError:
+                    self._retry_at.pop(mount_id, None)
+                    continue
+                if not (m.enabled and m.auto_mount and m.type.is_kernel_mount):
+                    self._retry_at.pop(mount_id, None)
+                    continue
+                mp = self.mountpoint_for(m.slug)
+                if self.backend.is_mounted(mp):
+                    self._retry_at.pop(mount_id, None)
+                    continue
+                try:
+                    self._retry_mount(mount_id, m, cred, mp)
+                    recovered.append(m.name)
+                except MountUnavailable:
+                    pass
+        return recovered
+
+    def _retry_mount(self, mount_id: int, m: Mount, cred: CredentialData | None, mp: Path) -> None:
+        """Ein Versuch, einen von NetMover selbst ausgehängten Mount zurückzuholen –
+        höchstens einmal pro ``retry_interval``, damit kein Lauf alle 10 s hängt."""
+        wait = self._retry_at[mount_id] - self._clock()
+        if wait > 0:
+            raise MountUnavailable(
+                f"„{m.name}“ nicht verfügbar – nächster Versuch, neu einzuhängen, "
+                f"in {math.ceil(wait)} s. Lauf abgebrochen, nichts angefasst."
+            )
+        try:
+            self._prepare_mountpoint(mp)
+            self.backend.mount(
+                build_spec(MountConfig.from_model(m), mp, cred), timeout=self.mount_timeout
+            )
+            self._probe(m.name, mp)
+        except (MountError, OSError, OperationTimeout, ValidationError) as exc:
+            if self.backend.is_mounted(mp):
+                with contextlib.suppress(MountError):
+                    self.backend.unmount(mp, lazy=True, timeout=self.mount_timeout)
+            self._retry_at[mount_id] = self._clock() + self.retry_interval
+            msg = (
+                f"„{m.name}“ weiterhin nicht verfügbar: {exc}\n"
+                f"→ Neuer Versuch in {self.retry_interval:g} s."
+            )
+            self._set_state(mount_id, MountState.ERROR, msg)
+            event(log, "mount.retry_failed", level=30, mount=m.name, error=str(exc))
+            raise MountUnavailable(msg) from None
+        del self._retry_at[mount_id]
+        self._set_state(mount_id, MountState.MOUNTED, mounted=True)
+        event(log, "mount.recovered", mount=m.name, attempt="retry")
+        self._notify("mount.recovered", m.name, f"„{m.name}“ ist wieder eingehängt.")
+
     def usage(self, mount_id: int, timeout: float | None = None) -> tuple[int, int] | None:
         """(gesamt, frei) in Bytes – nur bei eingehängten Kernel-Mounts."""
         m, _ = self._load(mount_id)

src/netmover/mover/destinations.py

@@ -7,7 +7,8 @@ verlieren. Ablauf für jede Datei:
    Größe prüfen,
 2. Metadaten setzen (mtime, Modus, Eigentümer – Fehler sind nur Hinweise),
 3. prüfen, dass sich die Quelle seit der Stabilitätsmessung nicht verändert hat,
-4. atomar auf den Endnamen umbenennen – ohne zu überschreiben (``link`` bzw.
+4. atomar auf den Endnamen umbenennen – ohne zu überschreiben
+   (``renameat2(RENAME_NOREPLACE)``, sonst ``link`` + ``unlink`` bzw.
    SFTP-``rename``), außer „überschreiben“ ist ausdrücklich eingestellt,
 5. erst danach löscht der Aufrufer die Quelle.
 
@@ -33,6 +34,7 @@ from typing import Literal
 
 from netmover.models import CollisionPolicy
 from netmover.mounting.sftp import SftpSession
+from netmover.mover.fsops import rename_noreplace
 from netmover.mover.naming import collision_candidates
 from netmover.timeouts import CancelToken
 
@@ -283,6 +285,9 @@ class LocalDestination(Destination):
 
     def _link_noreplace(self, tmp: str, final: str) -> None:
         src, dst = self._p(tmp), self._p(final)
+        # Bevorzugt ein echtes rename ohne Überschreiben (Watcher sehen IN_MOVED_TO).
+        if rename_noreplace(src, dst):
+            return
         try:
             os.link(src, dst)
         except FileExistsError:
@@ -340,6 +345,9 @@ class LocalDestination(Destination):
                         raise CollisionSkip
                     continue
                 try:
+                    if rename_noreplace(src, self._p(cand)):
+                        final = cand
+                        break
                     os.link(src, self._p(cand))
                 except FileExistsError:
                     if policy is CollisionPolicy.SKIP:

src/netmover/mover/engine.py

@@ -13,6 +13,7 @@ Reihenfolge pro Lauf:
 
 from __future__ import annotations
 
+import dataclasses
 import errno
 import os
 import stat
@@ -39,7 +40,7 @@ from netmover.mover.destinations import (
 )
 from netmover.mover.ledger import FailureInfo, Ledger
 from netmover.mover.naming import collision_candidates
-from netmover.mover.scan import Candidate, FileState, Matcher, current_state, scan
+from netmover.mover.scan import BUSY, Candidate, FileState, Matcher, current_state, scan
 from netmover.timeouts import Cancelled, CancelToken
 
 log = get_logger(__name__)
@@ -222,26 +223,32 @@ class Engine:
             else:
                 pending.append(c)
 
-        # Stabilität (Fallstrick 1): zweite Messung nach dem Stabilitätsfenster.
+        # Stabilität (Fallstrick 1): zwei frische Messungen (öffnen + fstat, nicht
+        # der Verzeichnis-Cache) im Abstand des Stabilitätsfensters.
+        first: dict[str, FileState | None] = {c.relpath: current_state(c.path) for c in pending}
         if pending and rule.stability_seconds > 0:
             self._sleep(rule.stability_seconds)
             token.check()
         stable: list[Candidate] = []
         for c in pending:
-            st = current_state(c.path)
+            before, st = first[c.relpath], current_state(c.path)
-            if st is None:
+            if before is None or st is None:
                 continue  # inzwischen verschwunden – nichts zu tun
-            if st != c.state:
+            if st != before or st == BUSY:
                 result.add(
                     ItemResult(
                         c.relpath,
                         ItemStatus.SKIPPED,
-                        size=st.size,
+                        size=max(st.size, 0),
-                        message="wird noch geschrieben (Größe/Zeit geändert)",
+                        message="wird noch geschrieben (Größe/Zeit geändert)"
+                        if st != BUSY
+                        else "Datei ist gerade in Benutzung",
                     )
                 )
                 continue
-            stable.append(c)
+            # ab hier gilt der frisch gemessene Zustand (für Prüfung vor dem Umbenennen
+            # und für die Kopier-Buchführung)
+            stable.append(dataclasses.replace(c, state=st))
 
         failures = self.ledger.failures(rule.id)
         for c in stable:

src/netmover/mover/fsops.py

@@ -0,0 +1,53 @@
+"""Atomares Umbenennen ohne Überschreiben.
+
+``renameat2(..., RENAME_NOREPLACE)`` ist ein echtes ``rename`` (Watcher sehen
+``IN_MOVED_TO`` wie bei ``os.replace``), scheitert aber mit ``EEXIST``, statt
+eine vorhandene Datei zu ersetzen. ext4, xfs, btrfs und tmpfs können das; NFS
+und CIFS meist nicht – dann liefert :func:`rename_noreplace` ``False`` und der
+Aufrufer weicht auf ``link()`` + ``unlink()`` aus.
+"""
+
+from __future__ import annotations
+
+import ctypes
+import ctypes.util
+import errno
+import os
+from collections.abc import Callable
+from functools import cache
+
+AT_FDCWD = -100
+RENAME_NOREPLACE = 1
+_UNSUPPORTED = frozenset({errno.EINVAL, errno.ENOSYS, errno.ENOTSUP, errno.EOPNOTSUPP, errno.EPERM})
+
+
+@cache
+def _renameat2() -> Callable[..., int] | None:
+    name = ctypes.util.find_library("c")
+    if name is None:
+        return None
+    libc = ctypes.CDLL(name, use_errno=True)
+    fn = getattr(libc, "renameat2", None)
+    if fn is None:
+        return None
+    fn.argtypes = [ctypes.c_int, ctypes.c_char_p, ctypes.c_int, ctypes.c_char_p, ctypes.c_uint]
+    fn.restype = ctypes.c_int
+    renameat2: Callable[..., int] = fn
+    return renameat2
+
+
+def rename_noreplace(src: str | os.PathLike[str], dst: str | os.PathLike[str]) -> bool:
+    """True = umbenannt. False = vom Dateisystem nicht unterstützt (nichts passiert).
+    ``FileExistsError``, wenn ``dst`` existiert; andere Fehler als ``OSError``."""
+    fn = _renameat2()
+    if fn is None:
+        return False
+    res = fn(AT_FDCWD, os.fsencode(src), AT_FDCWD, os.fsencode(dst), RENAME_NOREPLACE)
+    if res == 0:
+        return True
+    err = ctypes.get_errno()
+    if err == errno.EEXIST:
+        raise FileExistsError(err, os.strerror(err), os.fsdecode(dst))
+    if err in _UNSUPPORTED:
+        return False
+    raise OSError(err, os.strerror(err), os.fsdecode(src))

src/netmover/mover/scan.py

@@ -10,6 +10,7 @@
 
 from __future__ import annotations
 
+import errno
 import fnmatch
 import os
 import re
@@ -100,11 +101,31 @@ def scan(
     yield from walk(root, "")
 
 
+# Datei ist geöffnet, aber gerade nicht lesbar (z. B. exklusiv vom Schreiber
+# gesperrt): gilt als „noch nicht fertig“ – gleicht nie einem echten Zustand.
+BUSY = FileState(-1, -1)
+
+
 def current_state(path: Path) -> FileState | None:
+    """Aktuelle Größe und mtime – **frisch vom Server**.
+
+    ``stat()`` beantworten CIFS- und NFS-Clients aus ihrem Attribut-Cache; im
+    Praxistest lieferte CIFS so sekundenlang eine veraltete Größe, während die
+    Datei noch wuchs. Erst ``open()`` erzwingt frische Attribute (NFS:
+    Close-to-open-Konsistenz, SMB: Antwort auf CREATE). Darum öffnen + ``fstat``.
+    """
     try:
-        st = os.stat(path, follow_symlinks=False)
+        fd = os.open(path, os.O_RDONLY | os.O_NOFOLLOW | os.O_NONBLOCK)
     except FileNotFoundError:
         return None
+    except OSError as exc:
+        if exc.errno in (errno.ELOOP, errno.ENOTDIR):
+            return None  # Symlink oder kein Pfad mehr
+        return BUSY
+    try:
+        st = os.fstat(fd)
+    finally:
+        os.close(fd)
     if not stat.S_ISREG(st.st_mode):
         return None
     return FileState(st.st_size, st.st_mtime_ns)

src/netmover/notify.py

@@ -125,4 +125,9 @@ class Notifier:
 
     def mount_event(self, kind: str, mount: str, message: str) -> None:
         """Passt zur ``Notifier``-Signatur des :class:`MountManager`."""
-        self.send(Notification(kind, f"NetMover: Anbindung „{mount}“ gestört", message))
+        title = (
+            f"NetMover: Anbindung „{mount}“ wieder verfügbar"
+            if kind == "mount.recovered"
+            else f"NetMover: Anbindung „{mount}“ gestört"
+        )
+        self.send(Notification(kind, title, message))

src/netmover/scheduler.py

@@ -13,6 +13,7 @@ from __future__ import annotations
 
 import asyncio
 import random
+from collections.abc import Callable
 from concurrent.futures import ThreadPoolExecutor
 from datetime import UTC, datetime, timedelta
 
@@ -31,6 +32,7 @@ log = get_logger(__name__)
 MAX_START_OFFSET = 10.0
 HEARTBEAT_SECONDS = 30
 CLEANUP_SECONDS = 3600
+RETRY_SECONDS = 60
 
 
 def _job_id(rule_id: int) -> str:
@@ -43,11 +45,13 @@ class RuleScheduler:
         session_factory: sessionmaker[Session],
         service: RunService,
         *,
+        retry_mounts: Callable[[], object] | None = None,
         rng: random.Random | None = None,
         workers: int = 8,
     ) -> None:
         self.session_factory = session_factory
         self.service = service
+        self._retry_mounts = retry_mounts
         self._rng = rng or random.Random()  # noqa: S311 – nur Startversatz
         self._executor = ThreadPoolExecutor(max_workers=workers, thread_name_prefix="nm-run")
         self.scheduler = AsyncIOScheduler(
@@ -70,6 +74,10 @@ class RuleScheduler:
             IntervalTrigger(seconds=CLEANUP_SECONDS, start_date=utcnow() + timedelta(minutes=1)),
             id="cleanup",
         )
+        if self._retry_mounts is not None:
+            self.scheduler.add_job(
+                self._retry, IntervalTrigger(seconds=RETRY_SECONDS), id="mount-retry"
+            )
         self.sync()
         event(log, "scheduler.started", rules=len(self._intervals))
 
@@ -141,6 +149,11 @@ class RuleScheduler:
             self._executor, self.service.execute, rule_id, RunTrigger.MANUAL, dry_run
         )
 
+    async def _retry(self) -> None:
+        if self._retry_mounts is not None:
+            loop = asyncio.get_running_loop()
+            await loop.run_in_executor(self._executor, self._retry_mounts)
+
     async def _cleanup(self) -> None:
         loop = asyncio.get_running_loop()
         await loop.run_in_executor(self._executor, cleanup, self.session_factory)

tests/test_engine.py

@@ -240,6 +240,9 @@ def test_source_not_deletable_keeps_target_and_prevents_duplicate(
 ) -> None:
     if path == "copy":
         monkeypatch.setattr(LocalDestination, "move_same_device", lambda *a, **k: None)
+    else:
+        # Dateisystem ohne renameat2 → link + unlink, unlink scheitert
+        monkeypatch.setattr("netmover.mover.destinations.rename_noreplace", lambda *a: False)
     write(src / "scan.pdf")
     real_unlink = os.unlink
 
@@ -637,22 +640,24 @@ def test_local_destination_must_exist(
 def test_fsync_before_final_rename(
     engine: Engine, rule_id: int, src: Path, dst: Path, monkeypatch: pytest.MonkeyPatch
 ) -> None:
+    from netmover.mover import fsops
+
     events: list[str] = []
-    real_fsync, real_link = os.fsync, os.link
+    real_fsync, real_rename = os.fsync, fsops.rename_noreplace
 
     def fsync(fd: int) -> None:
         events.append("fsync")
         real_fsync(fd)
 
-    def link(a: object, b: object, *args: object, **kw: object) -> None:
+    def rename(a: object, b: object) -> bool:
-        events.append(f"link:{Path(str(b)).name}")
+        events.append(f"rename:{Path(str(b)).name}")
-        real_link(a, b)  # type: ignore[arg-type]
+        return real_rename(a, b)  # type: ignore[arg-type]
 
     monkeypatch.setattr("netmover.mover.destinations.os.fsync", fsync)
-    monkeypatch.setattr("netmover.mover.destinations.os.link", link)
+    monkeypatch.setattr("netmover.mover.destinations.rename_noreplace", rename)
     write(src / "a.pdf")
     run(engine, snap(rule_id), src, dst)
-    assert events.index("fsync") < events.index("link:a.pdf")
+    assert events.index("fsync") < events.index("rename:a.pdf")
 
 
 @pytest.mark.usefixtures("cross_device")
@@ -678,3 +683,99 @@ def test_name_taken_between_check_and_link_is_never_overwritten(
     assert result.items[0].dst == str(dst / "scan-1.pdf")
     assert (dst / "scan.pdf").read_text() == "fremd"
     assert (dst / "scan-1.pdf").read_text() == "neu"
+
+
+# -- renameat2(RENAME_NOREPLACE) ----------------------------------------------------------
+
+
+def test_rename_noreplace(tmp_path: Path) -> None:
+    from netmover.mover.fsops import rename_noreplace
+
+    a, b = write(tmp_path / "a", "neu"), write(tmp_path / "b", "alt")
+    ino = a.stat().st_ino
+    if not rename_noreplace(a, tmp_path / "c"):
+        pytest.skip("Dateisystem des Testrechners kann kein renameat2")
+    assert (tmp_path / "c").stat().st_ino == ino and not a.exists()  # echtes rename
+    with pytest.raises(FileExistsError):
+        rename_noreplace(tmp_path / "c", b)
+    assert b.read_text() == "alt" and (tmp_path / "c").exists()
+
+
+@pytest.mark.usefixtures("cross_device")
+@pytest.mark.parametrize("supported", [True, False])
+def test_final_step_is_a_real_rename_when_possible(
+    engine: Engine,
+    rule_id: int,
+    src: Path,
+    dst: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    supported: bool,
+) -> None:
+    """Watcher wie Paperless sehen ein rename (IN_MOVED_TO); ohne Unterstützung
+    bleibt es beim link-Rückfallweg – überschrieben wird in keinem Fall."""
+    links: list[object] = []
+    real_link = os.link
+
+    def spy_link(a: object, b: object, *args: object, **kw: object) -> None:
+        links.append(b)
+        real_link(a, b)  # type: ignore[arg-type]
+
+    monkeypatch.setattr("netmover.mover.destinations.os.link", spy_link)
+    if not supported:
+        monkeypatch.setattr("netmover.mover.destinations.rename_noreplace", lambda *a: False)
+    write(dst / "a.pdf", "alt")
+    write(src / "a.pdf", "neu")
+    result = run(engine, snap(rule_id), src, dst)
+    assert result.items[0].dst == str(dst / "a-1.pdf")
+    assert (dst / "a.pdf").read_text() == "alt" and (dst / "a-1.pdf").read_text() == "neu"
+    assert bool(links) is not supported
+    assert [p.name for p in dst.iterdir() if p.name.endswith(".part")] == []
+
+
+# -- Praxisbefund: veralteter Attribut-Cache (CIFS/NFS) -------------------------------------
+
+
+def test_stability_uses_fresh_attributes_not_stat_cache(
+    engine: Engine,
+    rule_id: int,
+    src: Path,
+    dst: Path,
+    hooks: list[Callable[[], None]],
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """Auf dem Testhost lieferte CIFS per stat() sekundenlang eine veraltete Größe,
+    während die Datei wuchs. Simuliert: os.stat liefert für die Datei immer den
+    alten Stand (Cache), nur öffnen + fstat sieht die Wahrheit."""
+    growing = write(src / "langsam.pdf", "a" * 10)
+    stale = os.stat(growing)
+    real_stat = os.stat
+
+    def cached_stat(path: object, *a: object, **kw: object) -> os.stat_result:
+        if str(path) == str(growing):
+            return stale
+        return real_stat(path, *a, **kw)  # type: ignore[arg-type]
+
+    monkeypatch.setattr(os, "stat", cached_stat)
+    hooks.append(lambda: growing.write_text("a" * 20))
+    result = run(engine, snap(rule_id), src, dst)
+    assert statuses(result) == {"langsam.pdf": ItemStatus.SKIPPED}
+    assert "wird noch geschrieben" in (result.items[0].message or "")
+    assert growing.exists() and not (dst / "langsam.pdf").exists()
+
+
+def test_locked_file_counts_as_in_use(
+    engine: Engine, rule_id: int, src: Path, dst: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    f = write(src / "gesperrt.pdf")
+    real_open = os.open
+
+    def locked(path: object, flags: int, *a: object, **kw: object) -> int:
+        if str(path) == str(f):
+            raise PermissionError(errno.EACCES, "Permission denied", str(path))
+        return real_open(path, flags, *a, **kw)  # type: ignore[arg-type]
+
+    monkeypatch.setattr("netmover.mover.scan.os.open", locked)
+    result = run(engine, snap(rule_id), src, dst)
+    assert statuses(result) == {"gesperrt.pdf": ItemStatus.SKIPPED}
+    assert result.items[0].message == "Datei ist gerade in Benutzung"
+    assert f.exists()

tests/test_linux_backend.py

@@ -115,3 +115,38 @@ def test_is_mounted_reads_mountinfo(tmp_path: Path) -> None:
 )
 def test_explain(fstype: str, msg: str, expect: str) -> None:
     assert expect in explain_mount_error(fstype, msg)
+
+
+def _alive(pid: int) -> bool:
+    try:
+        with open(f"/proc/{pid}/stat") as fh:
+            return fh.read().split(")")[-1].split()[0] != "Z"
+    except FileNotFoundError:
+        return False
+
+
+def test_timeout_kills_whole_process_group(tmp_path: Path) -> None:
+    """mount startet Helfer (mount.nfs) – die dürfen nach dem Zeitlimit nicht weiterlaufen."""
+    from netmover.mounting.linux import run_process_group
+
+    pidfile = tmp_path / "helper.pid"
+    script = f"sleep 30 & echo $! > {pidfile}; wait"
+    with pytest.raises(subprocess.TimeoutExpired):
+        run_process_group(["sh", "-c", script], capture_output=True, text=True, timeout=0.5)
+    helper = int(pidfile.read_text())
+    for _ in range(20):
+        if not _alive(helper):
+            break
+        import time
+
+        time.sleep(0.05)
+    assert not _alive(helper)
+
+
+def test_process_group_runner_returns_output() -> None:
+    from netmover.mounting.linux import run_process_group
+
+    r = run_process_group(
+        ["sh", "-c", "echo out; echo err >&2; exit 3"], capture_output=True, text=True, timeout=5
+    )
+    assert (r.returncode, r.stdout, r.stderr) == (3, "out\n", "err\n")

tests/test_manager.py

@@ -367,3 +367,159 @@ def test_usage(
     manager.mount(mid)
     usage = manager.usage(mid)
     assert usage is not None and usage[0] >= usage[1] > 0
+
+
+# -- Praxisbefund: NAS-Neustart dauert länger als die Wiederherstellung ----------------------
+
+
+class Clock:
+    def __init__(self) -> None:
+        self.now = 1000.0
+
+    def __call__(self) -> float:
+        return self.now
+
+
+@pytest.fixture
+def clock() -> Clock:
+    return Clock()
+
+
+@pytest.fixture
+def retry_manager(
+    session_factory: sessionmaker[Session],
+    fake_backend: FakeMountBackend,
+    secretbox: object,
+    mount_base: Path,
+    notifications: list[tuple[str, str, str]],
+    clock: Clock,
+) -> MountManager:
+    return MountManager(
+        session_factory,
+        fake_backend,
+        secretbox,
+        mount_base,  # type: ignore[arg-type]
+        probe_timeout=0.5,
+        recover_backoff=(0, 0, 0),
+        sleep=lambda _: None,
+        notifier=lambda *a: notifications.append(a),
+        retry_interval=60,
+        clock=clock,
+    )
+
+
+def test_failed_recovery_retries_every_interval_until_nas_is_back(
+    retry_manager: MountManager,
+    fake_backend: FakeMountBackend,
+    make_mount: MountFactory,
+    session_factory: sessionmaker[Session],
+    notifications: list[tuple[str, str, str]],
+    clock: Clock,
+) -> None:
+    fake_backend.export("nas", "scans")
+    mid = make_mount()
+    retry_manager.mount(mid)
+    mp = retry_manager.mountpoint_for("scans")
+    fake_backend.inject_fault(mp, errno.ESTALE)
+    fake_backend.fail_next_mount(times=3)  # NAS startet neu
+    with pytest.raises(MountUnavailable, match="alle 60 s"):
+        retry_manager.check_alive(mid)
+    assert not fake_backend.is_mounted(mp)
+
+    mounts_before = sum(1 for c in fake_backend.calls if c.action == "mount")
+    clock.now += 30  # zu früh: kein Versuch, Lauf abgebrochen
+    with pytest.raises(MountUnavailable, match="in 30 s"):
+        retry_manager.check_alive(mid)
+    assert sum(1 for c in fake_backend.calls if c.action == "mount") == mounts_before
+
+    clock.now += 30  # NAS noch nicht zurück
+    fake_backend.fail_next_mount()
+    with pytest.raises(MountUnavailable, match="weiterhin nicht verfügbar"):
+        retry_manager.check_alive(mid)
+
+    clock.now += 60  # NAS wieder da
+    assert retry_manager.check_alive(mid) == mp
+    assert fake_backend.is_mounted(mp)
+    assert _state(session_factory, mid).state is MountState.MOUNTED
+    assert notifications[-1][0] == "mount.recovered"
+
+
+def test_no_retry_without_auto_mount(
+    retry_manager: MountManager,
+    fake_backend: FakeMountBackend,
+    make_mount: MountFactory,
+    clock: Clock,
+) -> None:
+    fake_backend.export("nas", "scans")
+    mid = make_mount(auto_mount=False)
+    retry_manager.mount(mid)
+    fake_backend.inject_fault(retry_manager.mountpoint_for("scans"), errno.ESTALE)
+    fake_backend.fail_next_mount(times=3)
+    with pytest.raises(MountUnavailable):
+        retry_manager.check_alive(mid)
+    clock.now += 600
+    with pytest.raises(MountUnavailable, match="nicht eingehängt"):
+        retry_manager.check_alive(mid)
+
+
+def test_externally_unmounted_is_still_never_remounted(
+    retry_manager: MountManager,
+    fake_backend: FakeMountBackend,
+    make_mount: MountFactory,
+    clock: Clock,
+) -> None:
+    fake_backend.export("nas", "scans")
+    mid = make_mount()
+    retry_manager.mount(mid)
+    fake_backend.vanish(retry_manager.mountpoint_for("scans"))
+    clock.now += 600
+    with pytest.raises(MountUnavailable, match="nicht eingehängt"):
+        retry_manager.check_alive(mid)
+    assert [c.action for c in fake_backend.calls] == ["mount"]
+
+
+def test_hint_text_is_not_redacted() -> None:
+    from netmover.mounting.manager import _redact_output
+
+    msg = "mount error(13): Permission denied falsch\n→ Benutzername/Passwort falsch oder …"
+    out = _redact_output(msg, ["falsch"])
+    assert out.startswith("mount error(13): Permission denied ••••••")
+    assert out.endswith("→ Benutzername/Passwort falsch oder …")
+
+
+def test_restore_failure_at_boot_is_retried_by_background_job(
+    retry_manager: MountManager,
+    fake_backend: FakeMountBackend,
+    make_mount: MountFactory,
+    session_factory: sessionmaker[Session],
+    notifications: list[tuple[str, str, str]],
+    clock: Clock,
+) -> None:
+    """Stromausfall: die VM bootet schneller als das NAS."""
+    fake_backend.export("nas", "scans")
+    mid = make_mount()  # keine Regel benutzt die Anbindung
+    fake_backend.fail_next_mount()
+    assert [r.ok for r in retry_manager.restore_all()] == [False]
+    assert retry_manager.retry_pending() == []  # noch nicht fällig
+    clock.now += 60
+    assert retry_manager.retry_pending() == ["scans"]
+    assert fake_backend.is_mounted(retry_manager.mountpoint_for("scans"))
+    assert _state(session_factory, mid).state is MountState.MOUNTED
+    assert notifications[-1][0] == "mount.recovered"
+    clock.now += 60
+    assert retry_manager.retry_pending() == []  # erledigt
+
+
+def test_manual_unmount_stops_retrying(
+    retry_manager: MountManager,
+    fake_backend: FakeMountBackend,
+    make_mount: MountFactory,
+    clock: Clock,
+) -> None:
+    mid = make_mount()  # nicht exportiert → Wiederherstellung scheitert
+    retry_manager.restore_all()
+    retry_manager.unmount(mid)
+    fake_backend.export("nas", "scans")
+    clock.now += 120
+    assert retry_manager.retry_pending() == []
+    assert not fake_backend.mounted