Update-all-Button: alle ausstehenden System-Updates in EINEM Job

Neuer POST /api/maintenance/update-all kettet die AUSSTEHENDEN Updates
sequenziell (Engine -> Router -> Hermes -> OS) in einem maintenance-Job.
Bewusst reine Wiederverwendung: jeder Teil ist exakt der Befehl des
Einzel-Updates inkl. dessen Backup/Postcheck/Selbst-Rollback; &&-Kette
stoppt beim ersten Fehler, Banner-Zeilen im Log zeigen den Schritt.
OS zuletzt (breitester Eingriff, braucht als einziges das Box-Passwort;
fehlt es, laufen die sudo-freien Teile trotzdem und OS wird uebersprungen).
Hermes-Befehlskette in _hermes_update_cmd() extrahiert (DRY).

UI (SystemDrawer/Updates): Button 'Alle aktualisieren (N)' neben der
Update-Suche, nur sichtbar wenn etwas aussteht, gesperrt waehrend ein
Wartungs-Job laeuft, mit Bestaetigungs-Dialog der die Kette benennt.

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

backend/services/maintenance.py

@@ -691,12 +691,9 @@ def swap_update_job(sudo_password: str | None = None) -> dict | None:
     return {"ok": True, "job_id": job_id}
 
 
-def hermes_update_job() -> dict:
-    """Hermes-Agent aktualisieren wie die CLI (`hermes update` = git pull + Deps), danach
-    den Gateway neu starten. Davor ein Sicherheits-Backup (unser deploy/backup.sh). Kein sudo
-    (alles im User-Space). Läuft als Hintergrund-Job (kann ~1 Min dauern)."""
-    if busy := _maintenance_busy():
-        return busy
+def _hermes_update_cmd() -> str:
+    """Die komplette Hermes-Update-Befehlskette (Backup → Update → Doctor → UI-Build →
+    Neustarts → Postcheck) — geteilt von hermes_update_job und update_all_job."""
     git = system.find_hermes_agent_git()
     path = (git or {}).get("path") or os.path.expanduser("~/.hermes/hermes-agent")
     py = os.path.join(path, "venv", "bin", "python")
@@ -714,23 +711,81 @@ def hermes_update_job() -> dict:
         f"&& rm -rf {hui_dist} && cp -r /tmp/h-build {hui_dist}; fi"
     )
 
-    cmd = (f"bash {backup} || true; "
-           f"systemctl --user stop hermes-builtin-ui || true; "
-           f"cd {path} && {py} -m hermes_cli.main update --yes "
-           f"&& {py} -m hermes_cli.main doctor "
-           f"&& {build_cmd} "
-           f"&& systemctl --user reset-failed hermes-builtin-ui || true; "
-           f"systemctl --user restart hermes-gateway hermes-builtin-ui "
-           f"&& sleep 6 && bash {postcheck}")
+    return (f"bash {backup} || true; "
+            f"systemctl --user stop hermes-builtin-ui || true; "
+            f"cd {path} && {py} -m hermes_cli.main update --yes "
+            f"&& {py} -m hermes_cli.main doctor "
+            f"&& {build_cmd} "
+            f"&& systemctl --user reset-failed hermes-builtin-ui || true; "
+            f"systemctl --user restart hermes-gateway hermes-builtin-ui "
+            f"&& sleep 6 && bash {postcheck}")
+
+
+def hermes_update_job() -> dict:
+    """Hermes-Agent aktualisieren wie die CLI (`hermes update` = git pull + Deps), danach
+    den Gateway neu starten. Davor ein Sicherheits-Backup (unser deploy/backup.sh). Kein sudo
+    (alles im User-Space). Läuft als Hintergrund-Job (kann ~1 Min dauern)."""
+    if busy := _maintenance_busy():
+        return busy
 
     def on_done():
         _comp_cache.update(ts=0.0, data=[])  # Update-Status neu berechnen lassen
 
-    job_id = jobengine.start_job(["bash", "-c", cmd], "Hermes-Agent-Update",
+    job_id = jobengine.start_job(["bash", "-c", _hermes_update_cmd()], "Hermes-Agent-Update",
                                  group="maintenance", on_done=on_done)
     return {"ok": True, "job_id": job_id}
 
 
+def update_all_job(sudo_password: str | None = None) -> dict:
+    """„Alle aktualisieren": kettet die AUSSTEHENDEN Updates sequenziell in EINEM Job —
+    Engine → Router → Hermes → OS. Bewusst nur Wiederverwendung: jeder Teil ist exakt der
+    Befehl des Einzel-Updates (mit eigenem Backup/Postcheck/Rollback). `&&`-Kette = bei
+    Fehler stoppt der Rest (das Log zeigt, wo). OS zuletzt, weil apt am breitesten eingreift;
+    es braucht als einziges das Box-Passwort — fehlt es, laufen die sudo-freien Teile trotzdem."""
+    if busy := _maintenance_busy():
+        return busy
+    upd = updates()
+    parts: list[tuple[str, str]] = []
+    if upd.get("engine") and ENGINE_UPDATE_CMD:
+        parts.append(("Engine (llama.cpp)", ENGINE_UPDATE_CMD))
+    if upd.get("swap") and SWAP_UPDATE_CMD:
+        parts.append(("Router (llama-swap)", SWAP_UPDATE_CMD))
+    if any(c.get("update") is True for c in upd.get("components") or []):
+        parts.append(("Hermes-Agent", _hermes_update_cmd()))
+    os_pending = (upd.get("os") or 0) > 0
+    if os_pending:
+        if err := check_sudo_needs_password(sudo_password):
+            # Ohne Passwort: OS auslassen statt alles zu blockieren — aber nur, wenn
+            # es überhaupt sudo-freie Teile gibt; sonst ehrlich das Passwort verlangen.
+            if not parts:
+                return err
+            os_pending = False
+        else:
+            parts.append(("OS (apt)", (
+                "sudo apt-get update && "
+                "sudo bash -c 'DEBIAN_FRONTEND=noninteractive apt-get upgrade -y' "
+                f"&& bash {STACK_POSTCHECK}")))
+    if not parts:
+        return {"ok": False, "status": "nothing", "detail": "Keine Updates ausstehend."}
+
+    cmd = " && ".join(
+        f"(echo; echo '════════ [{i + 1}/{len(parts)}] {label} ════════'; {c})"
+        for i, (label, c) in enumerate(parts))
+    if not os_pending:
+        cmd += f" && bash {STACK_POSTCHECK}"  # Abschluss-Check, falls apt ihn nicht schon lieferte
+
+    def on_done():
+        _engine_cache.update(ts=0.0, avail=False)
+        _swap_cache.update(ts=0.0, avail=False)
+        _comp_cache.update(ts=0.0, data=[])
+
+    labels = " → ".join(label for label, _ in parts)
+    job_id = jobengine.start_job(["bash", "-c", cmd], f"Alle aktualisieren ({labels})",
+                                 group="maintenance", on_done=on_done,
+                                 sudo_password=sudo_password)
+    return {"ok": True, "job_id": job_id, "parts": [label for label, _ in parts]}
+
+
 def reboot(sudo_password: str | None = None) -> dict:
     if err := check_sudo_needs_password(sudo_password):
         return err