feat: HF-Cache raus + service_status Banner in Diagnostic

Stefan akzeptiert die ~5min Modell-Download-Zeit nach jedem Container-
Start, dafuer keine 50GB Cache-Bloat mehr und kein Bind-Mount-Verzeichnis
zu pflegen.

- xtts/docker-compose.yml: hf-cache Bind-Mount entfernt fuer beide
  Bridges. Modelle werden im writable Container-Layer abgelegt und mit
  jedem `docker compose down` automatisch weggeraeumt.
- xtts/.gitignore: hf-cache/ Eintrag raus
- RVS ALLOWED_TYPES: service_status hinzu

Bridges broadcasten Lade-Status:
- f5tts-bridge: bei Connect 'loading' -> ensure_loaded -> 'ready'.
  Auch bei config-getriggertem Modell-Wechsel: erst 'loading' Broadcast,
  dann reload, dann 'ready'.
- whisper-bridge: gleiches Pattern. Modell wird jetzt erst nach
  RVS-Connect geladen damit der loading-Broadcast tatsaechlich rausgeht.

Diagnostic:
- server.js: service_status wird an Browser durchgereicht
- index.html: neues Banner unten rechts (fixed position) zeigt Status
  fuer beide Services. Aggregiert: Icon ist Lupe waehrend Loading,
  Check wenn alles ready, X bei Error.
- Wenn alles ready: X-Button erscheint (manuell schliessen) +
  nach 8s automatisches Fade-Out.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

xtts/whisper/bridge.py

@@ -184,13 +184,15 @@ async def handle_stt_request(ws, payload: dict, runner: WhisperRunner) -> None:
         })
 
 
-async def run_loop(runner: WhisperRunner) -> None:
-    # Modell vorab laden damit erste Anfrage flott ist
-    try:
-        await runner.ensure_loaded(WHISPER_MODEL)
-    except Exception as e:
-        logger.error("Preload fehlgeschlagen: %s — Fortsetzung, wird bei erstem Request nachgeladen", e)
+async def _broadcast_status(ws, state: str, **extra) -> None:
+    """Sendet service_status fuer das Whisper-Modul.
+    state: 'loading' | 'ready' | 'error'."""
+    payload = {"service": "whisper", "state": state}
+    payload.update(extra)
+    await _send(ws, "service_status", payload)
 
+
+async def run_loop(runner: WhisperRunner) -> None:
     use_tls = RVS_TLS
     retry_s = 2
     tls_fallback_tried = False
@@ -205,6 +207,24 @@ async def run_loop(runner: WhisperRunner) -> None:
                 logger.info("RVS verbunden")
                 retry_s = 2
                 tls_fallback_tried = False
+
+                # Modell laden, dabei loading→ready broadcasten
+                async def _load_with_status():
+                    if runner.model is not None:
+                        await _broadcast_status(ws, "ready", model=runner.model_size)
+                        return
+                    await _broadcast_status(ws, "loading", model=WHISPER_MODEL)
+                    try:
+                        t0 = time.time()
+                        await runner.ensure_loaded(WHISPER_MODEL)
+                        elapsed = time.time() - t0
+                        await _broadcast_status(ws, "ready",
+                                                model=runner.model_size,
+                                                loadSeconds=elapsed)
+                    except Exception as e:
+                        await _broadcast_status(ws, "error", error=str(e)[:200])
+                asyncio.create_task(_load_with_status())
+
                 async for raw in ws:
                     try:
                         msg = json.loads(raw)
@@ -222,8 +242,19 @@ async def run_loop(runner: WhisperRunner) -> None:
                     elif mtype == "config":
                         new_model = payload.get("whisperModel")
                         if new_model and new_model != runner.model_size:
-                            logger.info("Config-Broadcast: Whisper-Modell → %s", new_model)
-                            asyncio.create_task(runner.ensure_loaded(new_model))
+                            logger.info("Config-Broadcast: Whisper-Modell -> %s", new_model)
+                            async def _swap_with_status(target):
+                                await _broadcast_status(ws, "loading", model=target)
+                                try:
+                                    t0 = time.time()
+                                    await runner.ensure_loaded(target)
+                                    elapsed = time.time() - t0
+                                    await _broadcast_status(ws, "ready",
+                                                            model=runner.model_size,
+                                                            loadSeconds=elapsed)
+                                except Exception as e:
+                                    await _broadcast_status(ws, "error", error=str(e)[:200])
+                            asyncio.create_task(_swap_with_status(new_model))
                     else:
                         # Alle anderen Nachrichten debug-loggen — hilft beim Diagnostizieren,
                         # ob stt_request ueberhaupt durch den RVS kommt