fix(mounts): Wache, die die Freigabe nach einem Rebuild von selbst zurueckholt

Dreimal in Folge reproduziert, jetzt bei JEDEM Deploy: Nach `docker compose up -d
--build` ist die CIFS-Freigabe tot. `mount` meldet Rueckgabewert 0, /proc/mounts
zeigt genau eine korrekt aussehende Schicht, die Erreichbarkeits-Probe antwortet
direkt nach dem Mount sogar - und Sekunden spaeter laeuft jeder Zugriff in die
Zeitgrenze. Derselbe Ablauf ein bis zwei Minuten spaeter stellt sie zuverlaessig
her (POST /storage-mounts/rippy/repair, mehrfach belegt).

Die Ursache liegt am NAS und ist nicht gefunden. Aber die Wirkung ist teuer: Nach
jedem Update war jeder Rip auf die NAS kaputt, ohne dass irgendwo etwas davon zu
sehen war - und der Commander haette es jedes Mal von Hand richten muessen.
Wenn die Heilung bekannt und billig ist, gehoert sie automatisiert, auch ohne die
Ursache zu kennen.

Die Wache sieht jede Minute nach und verbindet stumme Freigaben neu. Zwei Dinge
sind dabei wichtiger als die Heilung selbst:

1. NIE waehrend ein Job laeuft. Neu verbinden heisst `umount -l`; mitten in einem
   Rip oder Encode waere das ein Datenverlust. Die Wache steht still, solange
   irgendein Job nicht durch ist - auch bei einem wartenden, der jeden Moment
   anlaufen kann (db.hat_arbeit).
2. Gemeldet wird nur der UEBERGANG. Ist das NAS ausgeschaltet, waere ein Log je
   Minute ein Wasserfall.

Der Zustand steht in /health/vorraete, damit man sehen kann, dass die Wache lebt
- dieselbe Lehre wie heute Nachmittag beim stillen except.

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

docker/api/main.py

@@ -73,6 +73,9 @@ async def startup_event():
     # schlafendes NAS lässt os.path.isdir bis zum CIFS-Timeout hängen (hier
     # 10 s gemessen) — und /jobs wird alle 4 Sekunden abgefragt.
     asyncio.create_task(_rohdaten_schleife())
+    # Freigaben bewachen: Nach einem Rebuild ist die CIFS-Freigabe reproduzierbar
+    # tot, und der zweite Anlauf hilft (Begründung bei _mount_schleife).
+    asyncio.create_task(_mount_schleife())
 
 
 # Auto-Pre-Scan-Ergebnisse je Laufwerk: das Dashboard zeigt damit sofort,
@@ -330,6 +333,10 @@ async def health_vorraete():
                               else round(jetzt - _ROHDATEN["stand"], 1),
             "intervall": ROHDATEN_INTERVALL_SEKUNDEN,
         },
+        "mounts": {
+            "stand": _MOUNT_STAND,
+            "intervall": MOUNT_WACHE_INTERVALL_SEKUNDEN,
+        },
     }
 
 
@@ -365,6 +372,71 @@ _ROHDATEN = {"treffer": {}, "stand": None}
 ROHDATEN_INTERVALL_SEKUNDEN = 30
 
 
+# --- Mount-Wache ------------------------------------------------------------
+#
+# ⚠️ Warum es die braucht (26.07.2026, DREIMAL in Folge reproduziert): Nach
+# `docker compose up -d --build` ist die CIFS-Freigabe tot. `mount` meldet
+# Rückgabewert 0, /proc/mounts zeigt genau eine korrekt aussehende Schicht, die
+# Erreichbarkeits-Probe antwortet direkt nach dem Mount sogar — und Sekunden
+# später läuft jeder Zugriff in die Zeitgrenze. Derselbe Ablauf ein zweites Mal,
+# ein bis zwei Minuten später, stellt sie zuverlässig her.
+#
+# Die Ursache liegt am NAS und ist nicht gefunden. Aber die Wirkung ist teuer:
+# Nach JEDEM Update war jeder Rip auf die NAS kaputt, ohne dass irgendwo etwas
+# davon zu sehen war. Wenn die Heilung bekannt und billig ist, gehört sie
+# automatisiert — auch ohne die Ursache zu kennen. Genau das tut diese Schleife.
+MOUNT_WACHE_INTERVALL_SEKUNDEN = 60
+_MOUNT_STAND = {}
+
+
+async def _mount_schleife():
+    """Sieht nach, ob die Freigaben antworten, und verbindet sie sonst neu."""
+    while True:
+        # Erst warten: Der Start hat gerade selbst gemountet (alle_remounten),
+        # und die zweite Chance soll die sein, die laut Messung funktioniert.
+        await asyncio.sleep(MOUNT_WACHE_INTERVALL_SEKUNDEN)
+        try:
+            await asyncio.to_thread(_mounts_nachsehen)
+        except Exception as e:  # darf nie sterben
+            print(f"Mount-Wache fehlgeschlagen: {type(e).__name__}: {e}")
+
+
+def _mounts_nachsehen() -> None:
+    """Unerreichbare Freigaben neu verbinden — NIE während ein Job läuft.
+
+    Neu verbinden heißt `umount -l`; mitten in einem Rip oder Encode wäre das
+    ein Datenverlust. Deshalb steht die Wache still, solange irgendein Job nicht
+    durch ist — auch bei einem wartenden, der jeden Moment anlaufen kann.
+    """
+    eintraege = db.list_mounts()
+    if not eintraege or db.hat_arbeit():
+        return
+    for eintrag in eintraege:
+        name = eintrag["name"]
+        erreichbar = mount_verwaltung.ist_erreichbar(name)
+        vorher = _MOUNT_STAND.get(name)
+        _MOUNT_STAND[name] = erreichbar
+        if erreichbar:
+            if vorher is False:
+                db.add_log("success", "mounts", f"{name}: antwortet wieder")
+            continue
+        # Nur beim ÜBERGANG meckern, nicht jede Minute: Ist das NAS
+        # ausgeschaltet, wäre das sonst ein Log-Wasserfall.
+        if vorher is not False:
+            db.add_log("warning", "mounts",
+                       f"{name}: antwortet nicht — wird neu verbunden")
+        try:
+            mount_verwaltung.reparieren(
+                name, eintrag["typ"], eintrag["quelle"],
+                eintrag.get("optionen") or "", eintrag.get("username") or "",
+                eintrag.get("passwort") or "",
+            )
+            _MOUNT_STAND[name] = True
+            db.add_log("success", "mounts", f"{name}: neu verbunden")
+        except Exception as e:
+            db.add_log("warning", "mounts", f"{name}: Neuverbinden fehlgeschlagen — {e}")
+
+
 async def _rohdaten_schleife():
     """Hält den Rohdaten-Vorrat frisch. Darf nie sterben.