fix(android): minSdkVersion 23 -> 24 (Porcupine erfordert Android 7+)

@picovoice/porcupine-react-native deklariert minSdkVersion 24, dadurch
schlug der Manifest-Merger fehl wenn die App weiter auf 23 stand.
Android 7.0 ist eh das pragmatische Minimum (Geraete <7.0 sind <1% Markt).

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

.env.example

@@ -15,7 +15,7 @@ ARIA_AUTH_TOKEN=change-me-to-a-long-random-string
 # App, Bridge, Diagnostic und XTTS-Bridge verbinden sich hierueber.
 # Alle muessen den gleichen Host, Port und Token nutzen.
 
-# Hostname des RVS-Servers (z.B. rvs.example.de oder mobil.hacker-net.de)
+# Hostname des RVS-Servers (z.B. rvs.example.de oder example.com)
 RVS_HOST=rvs.example.de
 
 # Port auf dem der RVS laeuft (muss mit rvs/docker-compose.yml uebereinstimmen)

android/android/app/build.gradle

@@ -79,8 +79,8 @@ android {
         applicationId "com.ariacockpit"
         minSdkVersion rootProject.ext.minSdkVersion
         targetSdkVersion rootProject.ext.targetSdkVersion
-        versionCode 506
-        versionName "0.0.5.6"
+        versionCode 505
+        versionName "0.0.5.5"
         // Fallback fuer Libraries mit Product Flavors
         missingDimensionStrategy 'react-native-camera', 'general'
     }

android/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aria-cockpit",
-  "version": "0.0.5.6",
+  "version": "0.0.5.5",
   "private": true,
   "scripts": {
     "android": "react-native run-android",

android/src/screens/ChatScreen.tsx

@@ -108,9 +108,6 @@ const ChatScreen: React.FC = () => {
   const [searchVisible, setSearchVisible] = useState(false);
   const [pendingAttachments, setPendingAttachments] = useState<{file: any, isPhoto: boolean}[]>([]);
   const [agentActivity, setAgentActivity] = useState<{activity: string, tool: string}>({activity: 'idle', tool: ''});
-  // Service-Status (Gamebox: F5-TTS / Whisper Lade-Status) + Banner-Sichtbarkeit
-  const [serviceStatus, setServiceStatus] = useState<Record<string, {state: string, model?: string, loadSeconds?: number, error?: string}>>({});
-  const [serviceBannerDismissed, setServiceBannerDismissed] = useState(false);
   // Gerätelokale TTS-Config: globaler Toggle (aus Settings) + temporäres Muten (Mund-Button)
   const [ttsDeviceEnabled, setTtsDeviceEnabled] = useState(true);
   const [ttsMuted, setTtsMuted] = useState(false);
@@ -354,24 +351,6 @@ const ChatScreen: React.FC = () => {
           ToastAndroid.show(`Stimme "${v || 'Standard'}" bereit`, ToastAndroid.SHORT);
         }
       }
-
-      // Gamebox-Bridges (f5tts/whisper) melden Lade-Status — Banner oben
-      if (message.type === ('service_status' as any)) {
-        const p = message.payload as any;
-        const svc = (p?.service as string) || '';
-        if (!svc) return;
-        setServiceStatus(prev => ({
-          ...prev,
-          [svc]: {
-            state: (p?.state as string) || 'unknown',
-            model: p?.model as string | undefined,
-            loadSeconds: p?.loadSeconds as number | undefined,
-            error: p?.error as string | undefined,
-          },
-        }));
-        // Bei neuer Loading-Phase Banner wieder aktivieren
-        if (p?.state === 'loading') setServiceBannerDismissed(false);
-      }
     });
 
     const unsubState = rvs.onStateChange((state) => {
@@ -785,49 +764,6 @@ const ChatScreen: React.FC = () => {
         </TouchableOpacity>
       </View>
 
-      {/* Service-Status Banner (Gamebox: F5-TTS / Whisper Lade-Status) */}
-      {(() => {
-        const entries = Object.entries(serviceStatus);
-        if (entries.length === 0 || serviceBannerDismissed) return null;
-        const anyLoading = entries.some(([, v]) => v.state === 'loading');
-        const anyError = entries.some(([, v]) => v.state === 'error');
-        const allReady = !anyLoading && !anyError && entries.every(([, v]) => v.state === 'ready');
-        const bg = anyError ? '#3A1F1F' : anyLoading ? '#3A331F' : '#1F3A2A';
-        const border = anyError ? '#FF3B30' : anyLoading ? '#FFD60A' : '#34C759';
-        const labels: Record<string, string> = { f5tts: 'F5-TTS', whisper: 'Whisper STT' };
-        return (
-          <TouchableOpacity
-            activeOpacity={allReady ? 0.6 : 1.0}
-            onPress={() => { if (allReady) setServiceBannerDismissed(true); }}
-            style={[styles.serviceBanner, { backgroundColor: bg, borderColor: border }]}
-          >
-            {entries.map(([svc, info]) => {
-              let icon = '\u23F3', text = '';
-              if (info.state === 'loading') {
-                text = `${labels[svc] || svc}: laedt${info.model ? ' ' + info.model : ''}...`;
-              } else if (info.state === 'ready') {
-                icon = '\u2705';
-                const sec = info.loadSeconds ? ` (${info.loadSeconds.toFixed(1)}s)` : '';
-                text = `${labels[svc] || svc}: bereit${info.model ? ' ' + info.model : ''}${sec}`;
-              } else if (info.state === 'error') {
-                icon = '\u274C';
-                text = `${labels[svc] || svc}: Fehler ${info.error || ''}`;
-              } else {
-                text = `${labels[svc] || svc}: ${info.state}`;
-              }
-              return (
-                <Text key={svc} style={styles.serviceBannerLine}>
-                  {icon}  {text}
-                </Text>
-              );
-            })}
-            <Text style={styles.serviceBannerHint}>
-              {allReady ? 'Tippen zum Schliessen' : 'Bitte warten...'}
-            </Text>
-          </TouchableOpacity>
-        );
-      })()}
-
       {/* Suchleiste */}
       {searchVisible && (
         <View style={styles.searchBar}>
@@ -1042,25 +978,6 @@ const styles = StyleSheet.create({
     color: '#8888AA',
     fontSize: 12,
   },
-  serviceBanner: {
-    paddingVertical: 8,
-    paddingHorizontal: 12,
-    borderTopWidth: 0,
-    borderBottomWidth: 1,
-    borderLeftWidth: 0,
-    borderRightWidth: 0,
-  },
-  serviceBannerLine: {
-    color: '#FFFFFF',
-    fontSize: 12,
-    lineHeight: 18,
-  },
-  serviceBannerHint: {
-    color: '#AAAACC',
-    fontSize: 10,
-    marginTop: 2,
-    fontStyle: 'italic',
-  },
   messageList: {
     padding: 12,
     paddingBottom: 8,

diagnostic/index.html

@@ -127,15 +127,6 @@
   </style>
 </head>
 <body>
-  <!-- Service-Status Banner unten rechts (Gamebox: F5-TTS / Whisper Lade-Status) -->
-  <div id="service-status-banner" style="display:none;position:fixed;bottom:16px;right:16px;z-index:999;background:#1E1E2E;border:1px solid #2A2A3E;border-radius:8px;padding:10px 14px;font-size:12px;color:#fff;min-width:240px;max-width:360px;box-shadow:0 4px 14px rgba(0,0,0,0.5);">
-    <div style="display:flex;align-items:flex-start;gap:8px;">
-      <span id="service-status-icon" style="font-size:18px;line-height:1;">&#x23F3;</span>
-      <div id="service-status-list" style="flex:1;display:flex;flex-direction:column;gap:6px;"></div>
-      <button id="service-status-close" onclick="document.getElementById('service-status-banner').style.display='none'" style="background:none;border:none;color:#666680;font-size:16px;cursor:pointer;padding:0;line-height:1;display:none;">&times;</button>
-    </div>
-  </div>
-
   <!-- Disk-Space Warnung (dynamisch gesetzt) -->
   <div id="disk-banner" style="display:none;position:sticky;top:0;z-index:500;padding:10px 14px;border-radius:0;margin:-16px -16px 12px -16px;font-size:13px;">
     <div style="display:flex;align-items:center;gap:10px;flex-wrap:wrap;">
@@ -923,11 +914,6 @@
           return;
         }
 
-        if (msg.type === 'service_status') {
-          updateServiceStatus(msg.payload || {});
-          return;
-        }
-
         if (msg.type === 'voice_ready') {
           const v = msg.payload?.voice || '';
           const err = msg.payload?.error;
@@ -1466,68 +1452,6 @@
       'Glob': '\uD83D\uDCC1 Dateien suchen',
       'Agent': '\uD83E\uDD16 Sub-Agent',
     };
-    // ── Service-Status Banner (Gamebox: F5-TTS / Whisper Lade-Status) ──
-    // Aggregiert die Status-Infos der Bridges. Wenn irgendwas am Laden
-    // ist, zeigt das Banner unten rechts. Sobald alles auf 'ready' ist,
-    // bleibt's einen Moment und wird dann vom User weggeklickt (oder
-    // nach 8s automatisch).
-    const _serviceState = {}; // { f5tts: {state, model, ...}, whisper: {...} }
-    let _serviceFadeTimer = null;
-    function updateServiceStatus(p) {
-      const svc = p.service || '?';
-      _serviceState[svc] = p;
-
-      const banner = document.getElementById('service-status-banner');
-      const list = document.getElementById('service-status-list');
-      const icon = document.getElementById('service-status-icon');
-      const closeBtn = document.getElementById('service-status-close');
-
-      // Liste neu aufbauen
-      list.innerHTML = '';
-      let anyLoading = false, anyError = false;
-      const labels = { f5tts: 'F5-TTS', whisper: 'Whisper STT' };
-      for (const [s, info] of Object.entries(_serviceState)) {
-        const row = document.createElement('div');
-        row.style.cssText = 'display:flex;align-items:center;gap:6px;';
-        let dot = '⚫', color = '#666680', text = '';
-        if (info.state === 'loading') {
-          dot = '⏳'; color = '#FFD60A'; anyLoading = true;
-          text = `${labels[s] || s}: laedt${info.model ? ' ' + info.model : ''}...`;
-        } else if (info.state === 'ready') {
-          dot = '✅'; color = '#34C759';
-          const sec = info.loadSeconds ? ` (${info.loadSeconds.toFixed(1)}s)` : '';
-          text = `${labels[s] || s}: bereit${info.model ? ' ' + info.model : ''}${sec}`;
-        } else if (info.state === 'error') {
-          dot = '❌'; color = '#FF3B30'; anyError = true;
-          text = `${labels[s] || s}: Fehler ${info.error || ''}`;
-        } else {
-          text = `${labels[s] || s}: ${info.state}`;
-        }
-        row.innerHTML = `<span style="color:${color}">${dot}</span><span>${text}</span>`;
-        list.appendChild(row);
-      }
-
-      // Icon spiegelt Gesamt-Status
-      if (anyError) icon.innerHTML = '&#x274C;';
-      else if (anyLoading) icon.innerHTML = '&#x23F3;';
-      else icon.innerHTML = '&#x2705;';
-
-      banner.style.display = 'block';
-
-      // Wenn alles ready (kein Loading, kein Error): X-Button anzeigen
-      // + nach 8s automatisch wegfaden
-      if (!anyLoading && !anyError) {
-        closeBtn.style.display = 'block';
-        clearTimeout(_serviceFadeTimer);
-        _serviceFadeTimer = setTimeout(() => {
-          banner.style.display = 'none';
-        }, 8000);
-      } else {
-        closeBtn.style.display = 'none';
-        clearTimeout(_serviceFadeTimer);
-      }
-    }
-
     function updateThinkingIndicator(msg) {
       const indicators = [
         document.getElementById('thinking-indicator'),

diagnostic/server.js

@@ -637,22 +637,6 @@ function connectRVS(forcePlain) {
           log("info", "rvs", `Voice "${v || "default"}" geladen${ms ? ` in ${(ms/1000).toFixed(1)}s` : ""}`);
         }
         broadcast({ type: "voice_ready", payload: msg.payload });
-      } else if (msg.type === "service_status") {
-        // Gamebox-Bridges (f5tts/whisper) melden ihren Lade-Status —
-        // an Browser durchreichen fuer das Banner unten rechts
-        const svc = msg.payload?.service || "?";
-        const state = msg.payload?.state || "?";
-        const model = msg.payload?.model || "";
-        const sec = msg.payload?.loadSeconds;
-        const err = msg.payload?.error;
-        if (err) {
-          log("warn", "rvs", `service_status ${svc}: ${err}`);
-        } else if (state === "ready" && sec) {
-          log("info", "rvs", `service_status ${svc} ready (${model}, ${sec.toFixed(1)}s)`);
-        } else {
-          log("info", "rvs", `service_status ${svc} ${state}${model ? ` (${model})` : ""}`);
-        }
-        broadcast({ type: "service_status", payload: msg.payload });
       } else {
         log("debug", "rvs", `Nachricht: ${JSON.stringify(msg).slice(0, 150)}`);
       }

rvs/server.js

@@ -21,7 +21,6 @@ const ALLOWED_TYPES = new Set([
   "xtts_delete_voice",
   "voice_preload", "voice_ready",
   "stt_request", "stt_response",
-  "service_status",
 ]);
 
 // Token-Raum: token -> { clients: Set<ws> }
@@ -54,10 +53,7 @@ function cleanupRooms() {
 
 // ── WebSocket-Server starten ────────────────────────────────────────
 
-// maxPayload 50MB: TTS-Streaming + Voice-Upload (WAV als base64) +
-// audio_pcm Chunks koennen die ws-Library Default 1MB ueberschreiten.
-// Default-Limit war der Killer fuer die voice_upload Pipeline.
-const wss = new WebSocketServer({ port: PORT, maxPayload: 50 * 1024 * 1024 });
+const wss = new WebSocketServer({ port: PORT });
 
 wss.on("listening", () => {
   log(`RVS läuft auf Port ${PORT} | Max Sessions: ${MAX_SESSIONS}`);

xtts/.env.example

@@ -4,7 +4,7 @@
 # ════════════════════════════════════════════════
 
 # RVS Verbindung (gleiche Daten wie auf der ARIA-VM)
-RVS_HOST=mobil.hacker-net.de
+RVS_HOST=example.com
 RVS_PORT=444
 RVS_TLS=true
 RVS_TLS_FALLBACK=true

xtts/.gitignore

@@ -1,3 +1,7 @@
+# HuggingFace Model-Cache (geteilt zwischen f5tts + whisper bridge,
+# wird via Bind-Mount in die Container reingehaengt)
+hf-cache/
+
 # Voice-Samples (lokal, gehoert nicht ins Repo)
 voices/
 

xtts/docker-compose.yml

@@ -31,11 +31,11 @@ services:
               capabilities: [gpu]
     volumes:
       - ./voices:/voices                         # WAV + TXT Referenz
-                                                 # KEIN HF-Cache-Mount mehr —
-                                                 # Modell wird beim Start neu
-                                                 # gezogen. Diagnostic zeigt
-                                                 # "TTS laedt..." Banner bis
-                                                 # service_status: ready kommt.
+      - ./hf-cache:/root/.cache/huggingface      # HF-Cache als Bind-Mount.
+                                                 # Direkt sichtbar im xtts/hf-cache/,
+                                                 # einfach zu loeschen, kein Docker-
+                                                 # Desktop .vhdx Bloat.
+                                                 # Wird mit whisper-bridge geteilt.
     environment:
       # Bootstrap-only — alle anderen F5-TTS-Settings (Modell, cfg_strength,
       # nfe_step, Custom-Checkpoint) kommen ueber Diagnostic via RVS-config.
@@ -77,6 +77,6 @@ services:
       - WHISPER_DEVICE=${WHISPER_DEVICE:-cuda}
       - WHISPER_COMPUTE_TYPE=${WHISPER_COMPUTE_TYPE:-float16}
       - WHISPER_LANGUAGE=${WHISPER_LANGUAGE:-de}
-    # KEIN HF-Cache-Mount — Whisper-Modell wird beim Start neu gezogen.
-    # Wechsel via Diagnostic triggert ebenso Re-Download.
+    volumes:
+      - ./hf-cache:/root/.cache/huggingface      # gleicher Cache wie f5tts-bridge
     restart: unless-stopped

xtts/f5tts/bridge.py

@@ -110,26 +110,20 @@ class F5Runner:
         self.vocab_file: str = DEFAULT_F5TTS_VOCAB_FILE
         self.cfg_strength: float = DEFAULT_F5TTS_CFG_STRENGTH
         self.nfe_step: int = DEFAULT_F5TTS_NFE_STEP
-        # Last load-time fuer service_status Broadcast
-        self.last_load_seconds: float = 0.0
-        self._load_started_at: float = 0.0
 
     def _load_blocking(self) -> None:
         cls = _get_f5tts_cls()
         logger.info("Lade F5-TTS '%s' (device=%s, ckpt=%s)...",
                     self.model_id, F5TTS_DEVICE, self.ckpt_file or "default")
-        self._load_started_at = time.time()
+        t0 = time.time()
         kwargs = {"model": self.model_id, "device": F5TTS_DEVICE}
         if self.ckpt_file:
             kwargs["ckpt_file"] = self.ckpt_file
         if self.vocab_file:
             kwargs["vocab_file"] = self.vocab_file
         self.model = cls(**kwargs)
-        elapsed = time.time() - self._load_started_at
         logger.info("F5-TTS geladen in %.1fs (cfg_strength=%.1f, nfe=%d)",
-                    elapsed, self.cfg_strength, self.nfe_step)
-        # Wird von outside (run_loop) gelesen um service_status auf 'ready' zu setzen
-        self.last_load_seconds = elapsed
+                    time.time() - t0, self.cfg_strength, self.nfe_step)
 
     async def ensure_loaded(self) -> None:
         async with self._lock:
@@ -586,15 +580,10 @@ async def handle_voice_preload(ws, payload: dict, runner: F5Runner) -> None:
 
 # ── Haupt-Loop ──────────────────────────────────────────────
 
-async def _broadcast_status(ws, state: str, **extra) -> None:
-    """Sendet service_status fuer das F5-TTS Modul.
-    state: 'loading' | 'ready' | 'error'."""
-    payload = {"service": "f5tts", "state": state}
-    payload.update(extra)
-    await _send(ws, "service_status", payload)
-
-
 async def run_loop(runner: F5Runner) -> None:
+    # Preload im Hintergrund starten damit der Startup nicht blockiert
+    asyncio.create_task(runner.ensure_loaded())
+
     use_tls = RVS_TLS
     retry_s = 2
     tls_fallback_tried = False
@@ -612,25 +601,6 @@ async def run_loop(runner: F5Runner) -> None:
                 retry_s = 2
                 tls_fallback_tried = False
 
-                # Status-Broadcast: erst loading, dann ready nach erfolgreichem Load.
-                # Modell wird hier (nicht ausserhalb der Schleife) gestartet damit
-                # der Loading-Status auch wirklich uebertragen werden kann.
-                async def _load_with_status():
-                    if runner.model is not None:
-                        await _broadcast_status(ws, "ready",
-                                                model=runner.model_id,
-                                                loadSeconds=runner.last_load_seconds)
-                        return
-                    await _broadcast_status(ws, "loading", model=runner.model_id)
-                    try:
-                        await runner.ensure_loaded()
-                        await _broadcast_status(ws, "ready",
-                                                model=runner.model_id,
-                                                loadSeconds=runner.last_load_seconds)
-                    except Exception as e:
-                        await _broadcast_status(ws, "error", error=str(e)[:200])
-                asyncio.create_task(_load_with_status())
-
                 # TTS-Worker fuer diese Verbindung starten
                 worker = asyncio.create_task(_tts_worker(ws, runner))
 
@@ -670,26 +640,7 @@ async def run_loop(runner: F5Runner) -> None:
                                     fut.set_result(payload.get("text") or "")
                         elif mtype == "config":
                             # F5-TTS-Settings aktualisieren (Modell, cfg_strength, nfe)
-                            async def _update_with_status(p):
-                                # Schaut ob ein Modell-Wechsel ansteht — falls ja:
-                                # erst loading-Status, dann update, dann ready.
-                                old_model = (runner.model_id, runner.ckpt_file, runner.vocab_file)
-                                new_model_id = (p.get("f5ttsModel") or runner.model_id,
-                                                p.get("f5ttsCkptFile", runner.ckpt_file) or "",
-                                                p.get("f5ttsVocabFile", runner.vocab_file) or "")
-                                will_reload = old_model != new_model_id
-                                if will_reload:
-                                    await _broadcast_status(ws, "loading", model=new_model_id[0])
-                                try:
-                                    await runner.update_config(p)
-                                    if will_reload:
-                                        await _broadcast_status(ws, "ready",
-                                                                model=runner.model_id,
-                                                                loadSeconds=runner.last_load_seconds)
-                                except Exception as e:
-                                    if will_reload:
-                                        await _broadcast_status(ws, "error", error=str(e)[:200])
-                            asyncio.create_task(_update_with_status(payload))
+                            asyncio.create_task(runner.update_config(payload))
                             # Voice-Preload bei Wechsel
                             v = (payload.get("xttsVoice") or "").strip()
                             if v and v != _last_diag_voice:

xtts/whisper/bridge.py

@@ -152,17 +152,8 @@ async def handle_stt_request(ws, payload: dict, runner: WhisperRunner) -> None:
 
     try:
         t_load = time.time()
-        # Falls Modell noch nicht geladen (Race-Condition: stt_request vor config)
-        # → Status-Broadcast loading→ready damit der App-Banner aufpoppt
-        needs_load = runner.model is None or runner.model_size != model
-        if needs_load:
-            await _broadcast_status(ws, "loading", model=model)
         await runner.ensure_loaded(model)
         load_ms = int((time.time() - t_load) * 1000)
-        if needs_load:
-            await _broadcast_status(ws, "ready",
-                                    model=runner.model_size,
-                                    loadSeconds=load_ms / 1000.0)
 
         audio = ffmpeg_to_float32(audio_b64, mime_type)
         if audio.size == 0:
@@ -193,15 +184,13 @@ async def handle_stt_request(ws, payload: dict, runner: WhisperRunner) -> None:
         })
 
 
-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:
+    # 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)
+
     use_tls = RVS_TLS
     retry_s = 2
     tls_fallback_tried = False
@@ -212,24 +201,10 @@ async def run_loop(runner: WhisperRunner) -> None:
         masked = url.replace(RVS_TOKEN, "***") if RVS_TOKEN else url
         try:
             logger.info("Verbinde zu RVS: %s", masked)
-            # max_size 50MB damit grosse stt_request (Voice-Cloning-WAVs als
-            # base64 koennen mehrere MB werden) nicht das Frame-Limit sprengen
-            # und die Verbindung mit 1009 'message too big' killen.
-            async with websockets.connect(url, ping_interval=20, ping_timeout=10, max_size=50 * 1024 * 1024) as ws:
+            async with websockets.connect(url, ping_interval=20, ping_timeout=10) as ws:
                 logger.info("RVS verbunden")
                 retry_s = 2
                 tls_fallback_tried = False
-
-                # KEIN initialer Preload. Der aria-bridge broadcastet kurz nach
-                # RVS-Connect die persistierte Config (whisperModel) — wir laden
-                # erst wenn der drinsteht, sonst wuerde 2x geladen werden
-                # (small als ENV-Default + dann das echte Modell).
-                # Wenn ein stt_request schneller kommt als die Config: ensure_loaded
-                # im Handler greift dann ein und laedt das angeforderte Modell.
-                if runner.model is not None:
-                    # Wir sind reconnectet — Modell schon im RAM, einfach 'ready'
-                    asyncio.create_task(_broadcast_status(ws, "ready", model=runner.model_size))
-
                 async for raw in ws:
                     try:
                         msg = json.loads(raw)
@@ -245,25 +220,10 @@ async def run_loop(runner: WhisperRunner) -> None:
                                     req_id[:8] if req_id != "?" else "?", audio_len // 1365)
                         asyncio.create_task(handle_stt_request(ws, payload, runner))
                     elif mtype == "config":
-                        new_model = payload.get("whisperModel") or WHISPER_MODEL
-                        # Laden wenn (a) noch nix geladen, oder (b) Modell wechselt
-                        needs_load = (runner.model is None) or (new_model != runner.model_size)
-                        if needs_load:
-                            logger.info("Config-Broadcast: Whisper-Modell -> %s%s",
-                                        new_model,
-                                        " (initial)" if runner.model is None else " (Wechsel)")
-                            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))
+                        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))
                     else:
                         # Alle anderen Nachrichten debug-loggen — hilft beim Diagnostizieren,
                         # ob stt_request ueberhaupt durch den RVS kommt