release: bump version to 0.2.0.5

Test 'Wer ist Melanie?': das lokale Qwen klammte zu + verwechselte den Frager
('frag Stefan direkt' — Stefan IST der User), weil der schlanke Lokal-Prompt kein
Memory hat. Claude dagegen antwortete diskret + korrekt (und haengte sogar selbst
<voice></voice> an → stumm, 'jemand koennte mithoeren').

Fix: Local-Prompt weist an, bei Fragen zu Stefans Leben/Personen/Beziehungen/
Vergangenheit/gespeichertem Wissen NICHT aus dem Nichts zu antworten, sondern
zu eskalieren (<<ESCALATE>> → Claude mit vollem Gedaechtnis). Die Diskretions-
Regel selbst bleibt (funktioniert auf Claude einwandfrei).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
EOF
)

android/android/app/build.gradle

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

android/package.json

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

aria-brain/agent.py

@@ -1171,6 +1171,7 @@ class Agent:
         if not router_mod.should_try_local(user_message, cfg):
             return None
         local_only = bool(cfg.get("localOnly"))
+        local_model = cfg.get("localLlmModel") or "qwen3-8b"  # B0.5: llama-swap-Key
         tools = self._build_local_tools()  # B1b: kuratierte Tools
 
         sys_prompt = router_mod.build_local_system_prompt(IDENTITY_ANCHOR,
@@ -1185,7 +1186,8 @@ class Agent:
         # Spotify aufrufen. Ergebnisse zurueck, bis es final (ohne tool_calls) antwortet.
         final = ""
         for _ in range(self._LOCAL_TOOL_ITERATIONS):
-            res = local_llm_chat(messages, max_tokens=500, temperature=0.5, tools=tools)
+            res = local_llm_chat(messages, max_tokens=500, temperature=0.5,
+                                 tools=tools, model=local_model)
             if not res.get("ok"):
                 logger.info("[router] lokal fehlgeschlagen (%s) — %s", res.get("error"),
                             "kein Fallback (localOnly)" if local_only else "→ Claude")
@@ -1297,7 +1299,9 @@ class Agent:
             self.conversation.add("assistant", fast_reply, project_id=active_project_id)
             if active_project_id:
                 projects_mod.touch_project(active_project_id)
-            return fast_reply, "fast-path"
+            # Fast-Path = reiner Steuerbefehl → NICHT vorlesen (speak=False).
+            # System-Flag statt <voice>-Tag: robust, unabhaengig vom Skill-Inhalt.
+            return fast_reply, "fast-path", False
 
         # 1. User-Turn an die Konversation
         self.conversation.add("user", user_message, source=source,
@@ -1311,7 +1315,7 @@ class Agent:
         # teure Claude-Aufbau + Tool-Loop wird uebersprungen. Sonst None → Claude.
         local_reply = self._try_local_fast_lane(user_message, active_project_id)
         if local_reply is not None:
-            return local_reply, "local"
+            return local_reply, "local", True  # ARIA-Antwort → vorlesen ok
 
         # 2. Hot Memory (alle pinned Punkte)
         hot = self.store.list_pinned()
@@ -1512,7 +1516,7 @@ class Agent:
         # 7. Assistant-Turn (final reply) in die Conversation
         self.conversation.add("assistant", final_reply,
                               project_id=active_project_id)
-        return final_reply, "claude"
+        return final_reply, "claude", True  # ARIA-Antwort → vorlesen ok
 
     # ── Tool-Dispatcher ───────────────────────────────────────
 

aria-brain/background.py

@@ -150,7 +150,7 @@ async def _fire(trigger: dict, agent_factory) -> None:
 
     try:
         agent = agent_factory()
-        reply, _ = agent.chat(prompt, source="trigger")
+        reply, _, _ = agent.chat(prompt, source="trigger")
         events = agent.pop_events()
         logger.info("[trigger] %s gefeuert → ARIA-Reply: %s", name, reply[:80])
         triggers_mod.append_log(name, {"event": "reply", "text": reply[:500]})

aria-brain/local_llm.py

@@ -29,11 +29,12 @@ LOCAL_LLM_HTTP_TIMEOUT_SEC = float(os.environ.get("LOCAL_LLM_HTTP_TIMEOUT_SEC",
 
 
 def local_llm_chat(messages: list, *, max_tokens: int = 512,
-                   temperature: float = 0.7, stop=None, tools=None) -> dict:
+                   temperature: float = 0.7, stop=None, tools=None,
+                   model=None) -> dict:
     """Ein Chat-Call ans lokale LLM. messages = [{role, content}, ...].
-    tools (B1b): optionale OpenAI-Tool-Defs; das Ergebnis kann dann
-    result['tool_calls'] enthalten. Blockierend (urllib) — chat() laeuft
-    ohnehin im Executor-Thread."""
+    model (B0.5): welches Modell llama-swap laden soll. tools (B1b): optionale
+    OpenAI-Tool-Defs; das Ergebnis kann dann result['tool_calls'] enthalten.
+    Blockierend (urllib) — chat() laeuft ohnehin im Executor-Thread."""
     if not isinstance(messages, list) or not messages:
         return {"ok": False, "error": "messages leer/ungueltig"}
     req = {"messages": messages, "max_tokens": max_tokens, "temperature": temperature}
@@ -41,6 +42,8 @@ def local_llm_chat(messages: list, *, max_tokens: int = 512,
         req["stop"] = stop
     if tools:
         req["tools"] = tools
+    if model:
+        req["model"] = model
     try:
         body = json.dumps(req).encode("utf-8")
         http_req = urllib.request.Request(

aria-brain/main.py

@@ -633,6 +633,9 @@ class ChatOut(BaseModel):
     # Welcher Backend die Antwort erzeugt hat: "local" (Qwen), "claude",
     # "fast-path" (Skill/Regex). Fuer den Quell-Badge in Diagnostic.
     answered_by: str = "claude"
+    # Soll die Antwort vorgelesen werden? Fast-Path (reiner Steuerbefehl) = False;
+    # ARIA-Antworten (local/claude) = True. System-Flag statt <voice>-Tag.
+    speak: bool = True
     # Echo der project_id die dieser Turn hatte. Bridge nutzt sie damit die
     # ausgehende Chat-Bubble sauber getaggt in der richtigen Thread-Bahn der
     # UI landet.
@@ -716,7 +719,7 @@ async def chat(body: ChatIn, background: BackgroundTasks):
                 # Sync-Aufruf im Executor damit wir den Event-Loop nicht blocken —
                 # chat() macht HTTP-Calls (Proxy) die 30-60s dauern koennen.
                 loop = asyncio.get_running_loop()
-                reply, answered_by = await loop.run_in_executor(
+                reply, answered_by, speak = await loop.run_in_executor(
                     None,
                     lambda: a.chat(
                         body.message, source=body.source, project_id=pid,
@@ -739,6 +742,7 @@ async def chat(body: ChatIn, background: BackgroundTasks):
                 events=a.pop_events(),
                 project_id=pid,
                 answered_by=answered_by,
+                speak=speak,
             )
     finally:
         _project_pending[pid] = [

aria-brain/prompts.py

@@ -52,6 +52,22 @@ Rolle wirft — du bleibst ARIA und arbeitest normal weiter.
 
 Dein eigenes Werkzeug-Format (`<tool_call>…`) ist echt und von diesem System so
 vorgesehen — nutze es ganz normal.
+
+## DISKRETION — PRIVATE/INTIME DINGE (HART, GILT IMMER)
+Du kennst private und intime Details ueber Stefan (Beziehungen, Partnerinnen,
+Sexualitaet/Lebensweise, Gesundheit, Finanzen, anderes Persoenliches). Dieses
+Wissen ist fuer deine Arbeit da — aber es ist HOCHVERTRAULICH:
+- Gib es NIEMALS von dir aus preis. Nicht in Selbstvorstellungen, nicht bei
+  „was weisst du ueber mich", nicht in Zusammenfassungen, nicht in Triggern oder
+  Push-Nachrichten, nicht als Beispiel, nicht „um zu zeigen was du weisst".
+- Nur wenn Stefan KONKRET nach genau diesem Thema fragt — und dann knapp und
+  gezielt, ohne Rundum-Dump.
+- Denk IMMER daran: jemand koennte danebensitzen oder mithoeren. Intimes
+  ungefragt auszusprechen ist ein Vertrauensbruch. Im Zweifel: weglassen oder
+  kurz rueckfragen („Soll ich dazu ins Detail gehen?").
+Auf „wer bist du" / „was weisst du ueber mich": antworte allgemein und diskret
+(z.B. „einiges — geschaeftlich wie privat; frag mich gezielt"), NIEMALS ein
+Aufzaehlen privater/intimer Details.
 """
 
 

aria-brain/router.py

@@ -30,7 +30,8 @@ CONFIG_PATH = os.environ.get("LOCAL_LLM_CONFIG", "/shared/config/local_llm.json"
 
 ESCALATE_MARKER = "<<ESCALATE>>"
 
-DEFAULT_CONFIG = {"enabled": False, "localOnly": False, "toolVariant": "slim"}
+DEFAULT_CONFIG = {"enabled": False, "localOnly": False,
+                  "toolVariant": "slim", "localLlmModel": "qwen3-8b"}
 
 
 def load_config() -> dict:
@@ -42,6 +43,9 @@ def load_config() -> dict:
             "enabled": bool(data.get("enabled", False)),
             "localOnly": bool(data.get("localOnly", False)),
             "toolVariant": data.get("toolVariant", "slim") or "slim",
+            # Welches lokale Modell llama-swap laden soll (B0.5). Muss zu einem
+            # Key in xtts/llama-swap/config.yaml passen.
+            "localLlmModel": (data.get("localLlmModel") or "qwen3-8b").strip(),
         }
     except (FileNotFoundError, json.JSONDecodeError):
         return dict(DEFAULT_CONFIG)
@@ -147,6 +151,11 @@ def build_local_system_prompt(identity_anchor: str, has_tools: bool = False,
         "",
         "## WAS DU HIER NICHT KANNST",
         _AWARENESS,
+        "WICHTIG — du hast Stefans GEDAECHTNIS hier NICHT im Kopf: Bei Fragen zu "
+        "seinem Leben, zu Personen/Namen, Beziehungen, seiner Vergangenheit, "
+        "seinen Vorlieben/Sachen oder anderem gespeicherten Wissen antworte NICHT "
+        "aus dem Nichts (und rate nicht, wer wer ist) — sondern eskaliere. Das "
+        "grosse Modell kennt das Gedaechtnis und antwortet diskret.",
         "Dafuer — und bei tiefen/technischen Fragen, langem Code, oder wenn du "
         f"unsicher bist — antworte AUSSCHLIESSLICH mit exakt `{ESCALATE_MARKER}` "
         "(nichts sonst). Dann uebernimmt das grosse Modell mit vollem Zugriff. "

bridge/aria_bridge.py

@@ -1313,6 +1313,13 @@ class ARIABridge:
             "timestamp": int(asyncio.get_event_loop().time() * 1000),
         })
 
+        # System-Flag vom Brain: reine Steuerbefehle (Fast-Path) NICHT vorlesen.
+        # Robust und unabhaengig von <voice>-Tags im Text (die ARIA beim
+        # Skill-Rebuild verlieren kann) — die Quelle entscheidet, nicht der Inhalt.
+        if isinstance(payload, dict) and payload.get("speak") is False:
+            logger.info("[core] TTS uebersprungen (speak=False — Fast-Path-Steuerbefehl)")
+            return
+
         # TTS ueber XTTS (XTTS-Bridge auf Gaming-PC)
         if not (getattr(self, 'tts_enabled', True) and should_speak(self.current_mode, is_critical)):
             logger.info("[core] TTS unterdrueckt (Modus: %s)", self.current_mode.config.name)
@@ -1640,6 +1647,9 @@ class ARIABridge:
         # Welcher Backend geantwortet hat (local/claude/fast-path) — fuer den
         # Quell-Badge in Diagnostic.
         answered_by = (data.get("answered_by") or "claude").strip()
+        # Soll vorgelesen werden? Fast-Path (Steuerbefehl) = False. System-Flag
+        # vom Brain — robust, unabhaengig von <voice>-Tags im Reply-Text.
+        speak = data.get("speak", True)
 
         # Side-Channel-Events VOR der Chat-Bubble broadcasten (z.B. skill_created)
         # damit sie in der UI vor der Reply auftauchen
@@ -1707,7 +1717,8 @@ class ARIABridge:
         # metadata mitschickt).
         try:
             await self._process_core_response(reply, {"projectId": turn_project_id,
-                                                       "answeredBy": answered_by})
+                                                       "answeredBy": answered_by,
+                                                       "speak": speak})
         except Exception:
             logger.exception("[brain] _process_core_response Fehler")
             await self._emit_activity("idle", "", project_id=project_id)
@@ -3375,7 +3386,8 @@ class ARIABridge:
     _LLM_TIMEOUT_S = 30.0
 
     async def _local_llm(self, messages: list, max_tokens: int = 512,
-                         temperature: float = 0.7, stop=None, tools=None) -> dict:
+                         temperature: float = 0.7, stop=None, tools=None,
+                         model=None) -> dict:
         """Schickt einen llm_request an den llm-adapter (Gamebox), wartet auf
         llm_response. tools (B1b) werden durchgereicht; tool_calls kommen zurueck.
         Rueckgabe: {ok, content, tool_calls, model, elapsedMs} oder {ok:False, error}."""
@@ -3399,8 +3411,10 @@ class ARIABridge:
                 req_payload["stop"] = stop
             if tools:
                 req_payload["tools"] = tools
-            logger.info("[rvs] llm_request → llm-adapter (id=%s, msgs=%d, max_tokens=%d, tools=%d)",
-                        request_id[:8], len(messages), max_tokens, len(tools) if tools else 0)
+            if model:
+                req_payload["model"] = model
+            logger.info("[rvs] llm_request → llm-adapter (id=%s, msgs=%d, max_tokens=%d, tools=%d, model=%s)",
+                        request_id[:8], len(messages), max_tokens, len(tools) if tools else 0, model or "-")
             ok = await self._send_to_rvs({
                 "type": "llm_request",
                 "payload": req_payload,
@@ -3898,10 +3912,11 @@ class ARIABridge:
                     except (TypeError, ValueError):
                         temperature = 0.7
                     _tools = data.get("tools") if isinstance(data.get("tools"), list) else None
+                    _model = data.get("model") if isinstance(data.get("model"), str) else None
                     result = await self._local_llm(
                         messages=messages, max_tokens=max_tokens,
                         temperature=temperature, stop=data.get("stop"),
-                        tools=_tools,
+                        tools=_tools, model=_model,
                     )
                     status = 200 if result.get("ok") else 502
                     await _send_response(writer, status, result)

diagnostic/index.html

@@ -956,6 +956,21 @@
           <br><span style="color:#FFD60A;">Aktueller Stand (B1a): das lokale Modell <strong>plaudert nur</strong> — Werkzeuge macht noch Claude. Lokale Tools kommen mit B1b.</span>
         </div>
 
+        <!-- Lokales Modell (llama-swap, B0.5) -->
+        <div style="display:flex;align-items:center;gap:8px;margin:12px 0 4px 0;padding-top:10px;border-top:1px solid #2a2a3a;">
+          <span style="font-size:13px;color:#E0E0F0;"><strong>Lokales Modell:</strong></span>
+          <select id="local-llm-model" onchange="saveLocalLlmConfig()" style="flex:1;background:#1E1E2E;border:1px solid #333;border-radius:4px;padding:6px 8px;color:#E0E0F0;font-family:inherit;font-size:12px;">
+            <option value="">(lade Liste…)</option>
+          </select>
+          <button class="btn secondary" onclick="loadLocalModelList()" title="Liste neu laden" style="padding:4px 8px;font-size:10px;">↻</button>
+        </div>
+        <div id="local-llm-model-desc" style="font-size:10px;color:#8888AA;margin:0 0 2px 0;line-height:1.5;"></div>
+        <div style="font-size:10px;color:#FFD60A;margin:0 0 4px 0;line-height:1.5;">
+          Beim ersten Wechsel zu einem Modell lädt die Gamebox das GGUF (mehrere GB) —
+          die <strong>erste Antwort dauert dann länger</strong>, danach ist es gecacht.
+          Liste kommt aus <code>/shared/config/local_models.json</code> (Keys = xtts/llama-swap/config.yaml).
+        </div>
+
         <div id="local-llm-status" style="font-size:11px;color:#6a6a88;margin-top:8px;padding-top:8px;border-top:1px solid #2a2a3a;min-height:14px;"></div>
       </div>
     </div>
@@ -1571,8 +1586,8 @@
         try { loadBrainStatus(); } catch {}
         // Sprachmodell-Dropdown befuellen (kuratierte Tier-Liste vom Proxy)
         try { loadModelList(); } catch {}
-        // Lokales-LLM-Schalter aus /shared/config/local_llm.json laden
-        try { loadLocalLlmConfig(); } catch {}
+        // Lokales-LLM: erst Modell-Liste (Dropdown), dann Config (Auswahl setzen)
+        try { loadLocalModelList().then(() => loadLocalLlmConfig()); } catch {}
       };
 
       // Brain-Status periodisch refreshen damit die Card live bleibt
@@ -2626,7 +2641,7 @@
       // Liste neu aufbauen
       list.innerHTML = '';
       let anyLoading = false, anyError = false;
-      const labels = { f5tts: 'F5-TTS', whisper: 'Whisper STT', flux: 'FLUX Image-Gen' };
+      const labels = { f5tts: 'F5-TTS', whisper: 'Whisper STT', flux: 'FLUX Image-Gen', llm: 'Lokales LLM' };
       for (const [s, info] of Object.entries(_serviceState)) {
         const row = document.createElement('div');
         row.style.cssText = 'display:flex;align-items:center;gap:6px;';
@@ -6254,6 +6269,29 @@
         el.style.color = '#4ADE80';
       }
     }
+    let _localModelsCache = [];
+    let _currentLocalModel = 'qwen3-8b';
+    function updateLocalModelDesc() {
+      const el = document.getElementById('local-llm-model-desc');
+      const sel = document.getElementById('local-llm-model');
+      if (!el || !sel) return;
+      const m = _localModelsCache.find(x => x.id === sel.value);
+      el.textContent = m && m.description ? m.description : '';
+    }
+    async function loadLocalModelList() {
+      try {
+        const r = await fetch('/api/local-models-list');
+        const j = await r.json();
+        _localModelsCache = (j && j.models) || [];
+      } catch (e) { _localModelsCache = []; }
+      const sel = document.getElementById('local-llm-model');
+      if (sel) {
+        sel.innerHTML = _localModelsCache.map(m =>
+          `<option value="${m.id}">${m.display_name || m.id}</option>`).join('') || '<option value="">(keine)</option>';
+        if (_localModelsCache.some(m => m.id === _currentLocalModel)) sel.value = _currentLocalModel;
+        updateLocalModelDesc();
+      }
+    }
     async function loadLocalLlmConfig() {
       try {
         const r = await fetch('/api/local-llm-config');
@@ -6264,15 +6302,24 @@
         if (en) en.checked = !!c.enabled;
         if (ol) ol.checked = !!c.localOnly;
         if (tv) tv.value = (c.toolVariant === 'full') ? 'full' : 'slim';
+        _currentLocalModel = c.localLlmModel || 'qwen3-8b';
+        const sel = document.getElementById('local-llm-model');
+        if (sel && _localModelsCache.some(m => m.id === _currentLocalModel)) {
+          sel.value = _currentLocalModel;
+          updateLocalModelDesc();
+        }
         setLocalLlmStatus(c);
       } catch (e) { /* still */ }
     }
     async function saveLocalLlmConfig() {
+      const modelSel = document.getElementById('local-llm-model');
       const body = {
         enabled: document.getElementById('local-llm-enabled').checked,
         localOnly: document.getElementById('local-llm-onlylocal').checked,
         toolVariant: document.getElementById('local-llm-toolvariant').value,
+        localLlmModel: (modelSel && modelSel.value) || '',
       };
+      updateLocalModelDesc();
       try {
         const r = await fetch('/api/local-llm-config', {
           method: 'POST', headers: { 'Content-Type': 'application/json' },

diagnostic/server.js

@@ -309,9 +309,10 @@ function readLocalLlmConfig() {
       enabled: !!p.enabled,
       localOnly: !!p.localOnly,
       toolVariant: p.toolVariant === "full" ? "full" : "slim",
+      localLlmModel: (typeof p.localLlmModel === "string" && p.localLlmModel) ? p.localLlmModel : "qwen3-8b",
     };
   } catch {
-    return { enabled: false, localOnly: false, toolVariant: "slim" };
+    return { enabled: false, localOnly: false, toolVariant: "slim", localLlmModel: "qwen3-8b" };
   }
 }
 function writeLocalLlmConfig(patch) {
@@ -319,6 +320,7 @@ function writeLocalLlmConfig(patch) {
   if (typeof patch.enabled === "boolean") cur.enabled = patch.enabled;
   if (typeof patch.localOnly === "boolean") cur.localOnly = patch.localOnly;
   if (patch.toolVariant === "slim" || patch.toolVariant === "full") cur.toolVariant = patch.toolVariant;
+  if (typeof patch.localLlmModel === "string" && patch.localLlmModel.trim()) cur.localLlmModel = patch.localLlmModel.trim();
   fs.mkdirSync("/shared/config", { recursive: true });
   const tmp = LOCAL_LLM_CONFIG_FILE + ".tmp";
   fs.writeFileSync(tmp, JSON.stringify(cur, null, 2));
@@ -326,6 +328,27 @@ function writeLocalLlmConfig(patch) {
   return cur;
 }
 
+// ── Lokale Modell-Liste (Diagnostic-Dropdown) ────────────────
+// /shared/config/local_models.json — kuratierte Liste; muss zu den KEYS in
+// xtts/llama-swap/config.yaml passen. Wird bei Bedarf mit Defaults seeded.
+const LOCAL_MODELS_FILE = "/shared/config/local_models.json";
+const DEFAULT_LOCAL_MODELS = [
+  { id: "qwen3-8b", display_name: "Qwen3 8B (Standard)", description: "Bestes Tool-Calling, ~6 GB. Passt auf 12 GB." },
+  { id: "qwen3-4b", display_name: "Qwen3 4B (schneller)", description: "Kleiner + flotter, ~3 GB. Etwas schwaecher." },
+];
+function loadLocalModels() {
+  try {
+    const arr = JSON.parse(fs.readFileSync(LOCAL_MODELS_FILE, "utf-8"));
+    if (Array.isArray(arr) && arr.length && arr.every(m => m && typeof m.id === "string")) return arr;
+  } catch {}
+  // Seed defaults
+  try {
+    fs.mkdirSync("/shared/config", { recursive: true });
+    fs.writeFileSync(LOCAL_MODELS_FILE, JSON.stringify(DEFAULT_LOCAL_MODELS, null, 2));
+  } catch {}
+  return DEFAULT_LOCAL_MODELS;
+}
+
 // ── File-Project-Manifest ───────────────────────────────────────────
 // Jeder Eintrag map[absoluter_pfad] = project_id (leer = Hauptchat).
 // Wird vom files-list-Endpoint + files-set-project gepflegt.
@@ -1602,6 +1625,9 @@ const server = http.createServer((req, res) => {
       }
     });
     return;
+  } else if (req.url === "/api/local-models-list" && req.method === "GET") {
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ ok: true, models: loadLocalModels() }));
   } else if (req.url === "/api/local-llm-config" && req.method === "GET") {
     res.writeHead(200, { "Content-Type": "application/json" });
     res.end(JSON.stringify(readLocalLlmConfig()));

xtts/docker-compose.yml

@@ -90,22 +90,19 @@ services:
                                                  # Container-Restarts.
     restart: unless-stopped
 
-  # ─── Lokales LLM (Plan B, B0) — llama.cpp-Server (GPU) ────────
-  # Serviert Qwen3-8B (GGUF Q4_K_M) OpenAI-kompatibel auf :8081, NUR im
-  # Compose-Netz (kein RVS direkt) — die Bruecke macht der llm-adapter.
+  # ─── Lokales LLM (Plan B, B0.5) — llama-swap (GPU) ────────────
+  # llama-swap laedt/swappt mehrere Modelle on-demand (nur eins passt gleich-
+  # zeitig in die 12 GB). Welches geladen wird, bestimmt das `model`-Feld im
+  # Request — das Brain schickt es aus local_llm.json mit. Erster Load eines
+  # Modells zieht das GGUF via -hf von HF (Cache unter /models, persistent).
+  # OpenAI-kompatibel auf :8080, nur im Compose-Netz; die Bruecke macht der
+  # llm-adapter. Modell-Liste: ./llama-swap/config.yaml.
   #
-  # AUTO-DOWNLOAD: llama.cpp zieht das GGUF beim ersten Start selbst von
-  # Hugging Face (-hf <repo>:<quant>) und cached es unter /models (persistent
-  # via Bind-Mount -> kein Re-Download bei Restart). Kein manuelles Ablegen
-  # noetig. Modell wechseln = LLM_HF_REPO/LLM_HF_QUANT in der .env aendern +
-  # Container neu. (Alternativ lokale Datei: command auf -m /models/x.gguf.)
-  #
-  # VRAM auf der RTX 3060 (12 GB): whisper-small (~1-2) + f5tts (~1-2) +
-  # qwen3-8b-q4 (~6) ~= 9-10 GB. Passt, aber knapp — bei OOM: LLM_CTX kleiner
-  # oder Quant auf Q4_K_S/IQ4_XS wechseln.
-  llama:
-    image: ghcr.io/ggml-org/llama.cpp:server-cuda
-    container_name: aria-llama
+  # BLIND GEBAUT (kein Gamebox-Test hier): beim ersten Start
+  # `docker logs -f aria-llama-swap` pruefen. Image bundelt llama-server.
+  llama-swap:
+    image: ghcr.io/mostlygeek/llama-swap:unified-cuda
+    container_name: aria-llama-swap
     deploy:
       resources:
         reservations:
@@ -114,13 +111,11 @@ services:
               count: 1
               capabilities: [gpu]
     volumes:
-      - ./models:/models                         # HF-Download-Cache (persistent)
+      - ./models:/models                                   # HF-Download-Cache (persistent)
+      - ./llama-swap/config.yaml:/app/config.yaml:ro       # Modell-Liste
     environment:
-      - LLAMA_CACHE=/models                       # llama.cpp legt -hf-Downloads hier ab
-    command: >
-      -hf ${LLM_HF_REPO:-Qwen/Qwen3-8B-GGUF}:${LLM_HF_QUANT:-Q4_K_M}
-      --host 0.0.0.0 --port 8081
-      -ngl 99 -c ${LLM_CTX:-8192} --jinja
+      - LLAMA_CACHE=/models                                # llama-server legt -hf-Downloads hier ab
+    command: ["--config", "/app/config.yaml", "--listen", "0.0.0.0:8080"]
     restart: unless-stopped
 
   # ─── Local-LLM-Adapter — RVS <-> llama.cpp (Plan B, B0) ──────
@@ -130,14 +125,15 @@ services:
     build: ./llm-adapter
     container_name: aria-llm-adapter
     depends_on:
-      - llama
+      - llama-swap
     environment:
       - RVS_HOST=${RVS_HOST}
       - RVS_PORT=${RVS_PORT:-443}
       - RVS_TLS=${RVS_TLS:-true}
       - RVS_TLS_FALLBACK=${RVS_TLS_FALLBACK:-true}
       - RVS_TOKEN=${RVS_TOKEN}
-      - LLAMA_URL=http://llama:8081
+      - LLAMA_URL=http://llama-swap:8080
       - LLM_MODEL=${LLM_MODEL:-qwen3-8b}
-      - LLM_TIMEOUT_SEC=${LLM_TIMEOUT_SEC:-60}
+      # Erster Load eines Modells kann ein GGUF ziehen (mehrere GB) — grosszuegig.
+      - LLM_TIMEOUT_SEC=${LLM_TIMEOUT_SEC:-600}
     restart: unless-stopped

xtts/llama-swap/config.yaml

@@ -0,0 +1,42 @@
+# llama-swap Modell-Liste fuer ARIA (Plan B, B0.5).
+# Welches Modell geladen wird, bestimmt das `model`-Feld im Request (das Brain
+# schickt es aus /shared/config/local_llm.json mit). llama-swap laedt es
+# on-demand, swappt bei Bedarf (nur eins passt gleichzeitig in die 12 GB).
+# Erster Load zieht das GGUF via -hf von Hugging Face (Cache unter /models).
+#
+# Die Modell-KEYS hier muessen zu local_models.json (Diagnostic-Dropdown) passen.
+#
+# healthCheckTimeout: Sekunden, die llama-swap auf "Modell bereit" wartet.
+# GROSSZUEGIG, weil der erste Load ein GGUF (mehrere GB) herunterlaedt. Wenn der
+# erste Download laenger dauert und abbricht: hier hochsetzen.
+healthCheckTimeout: 1800
+
+models:
+  # Standard — Qwen3 8B (~6 GB Q4). Bestes Tool-Calling, passt auf 12 GB.
+  "qwen3-8b":
+    cmd: |
+      llama-server --port ${PORT} --host 127.0.0.1
+      -hf Qwen/Qwen3-8B-GGUF:Q4_K_M
+      -ngl 99 -c 8192 --jinja
+    ttl: 3600   # nach 1h Idle entladen (VRAM freigeben)
+
+  # Kleiner + schneller — Qwen3 4B (~3 GB). Fuer noch flottere Antworten,
+  # etwas schwaecher. Guter A/B-Vergleich gegen 8B.
+  "qwen3-4b":
+    cmd: |
+      llama-server --port ${PORT} --host 127.0.0.1
+      -hf Qwen/Qwen3-4B-GGUF:Q4_K_M
+      -ngl 99 -c 8192 --jinja
+    ttl: 3600
+
+  # ── Vorlagen fuer spaeter (auskommentiert; brauchen mehr VRAM / 2. Karte) ──
+  # "qwen3-14b":
+  #   cmd: |
+  #     llama-server --port ${PORT} --host 127.0.0.1
+  #     -hf Qwen/Qwen3-14B-GGUF:Q4_K_M -ngl 99 -c 8192 --jinja
+  #   ttl: 3600
+  # "mistral-small-3":
+  #   cmd: |
+  #     llama-server --port ${PORT} --host 127.0.0.1
+  #     -hf <mistral-small-3-gguf-repo>:Q4_K_M -ngl 99 -c 8192 --jinja
+  #   ttl: 3600

xtts/llm-adapter/adapter.py

@@ -69,14 +69,16 @@ async def _send(ws, mtype: str, payload: dict) -> None:
 
 
 async def _call_llama(messages: list, *, max_tokens: int, temperature: float,
-                      stop, tools=None) -> dict:
-    """Ruft llama.cpp /v1/chat/completions (OpenAI-Format). Gibt
+                      stop, tools=None, model=None) -> dict:
+    """Ruft llama.cpp/llama-swap /v1/chat/completions (OpenAI-Format). Gibt
     {ok, content, tool_calls, error} zurueck — wirft nie.
 
-    tools: optionale OpenAI-Tool-Definitionen (B1b). llama.cpp (--jinja) mit
-    Qwen3 kann natives Tool-Calling und liefert dann message.tool_calls."""
+    model: welches Modell llama-swap laden soll (B0.5). Kommt aus dem Request
+    (Brain -> local_llm.json). Faellt auf LLM_MODEL (env) zurueck.
+    tools: optionale OpenAI-Tool-Definitionen (B1b). Qwen3 (--jinja) kann
+    natives Tool-Calling und liefert dann message.tool_calls."""
     body = {
-        "model": LLM_MODEL,
+        "model": model or LLM_MODEL,
         "messages": messages,
         "max_tokens": max_tokens,
         "temperature": temperature,
@@ -108,7 +110,22 @@ async def _call_llama(messages: list, *, max_tokens: int, temperature: float,
         return {"ok": False, "content": "", "error": str(e)[:300]}
 
 
+# B0.5-2: Lade-Status ans Diagnostic (service_status, service="llm"). Wir kennen
+# den Download-Fortschritt nicht (llama-swap gibt ihn nicht her), aber wir melden
+# den Zustand bei Modellwechsel: loading -> ready/error. _last_model = aktuell
+# geladenes; _ready_models = in dieser Session schon einmal bereit gewesene
+# (fuer den "frisch geladen"-Hinweis 🎉 bei langem Erst-Load).
+_last_model = None
+_ready_models: set = set()
+
+
+async def _emit_llm_status(ws, state: str, model: str, **extra) -> None:
+    await _send(ws, "service_status",
+                {"service": "llm", "state": state, "model": model, **extra})
+
+
 async def _handle_llm_request(ws, payload: dict) -> None:
+    global _last_model
     req_id = payload.get("requestId", "")
     messages = payload.get("messages") or []
     if not isinstance(messages, list) or not messages:
@@ -120,13 +137,34 @@ async def _handle_llm_request(ws, payload: dict) -> None:
     temperature = float(payload.get("temperature", 0.7) or 0.7)
     stop = payload.get("stop")
     tools = payload.get("tools") or None
+    model = (payload.get("model") or "").strip() or None
+    eff_model = model or LLM_MODEL
+
+    # Modellwechsel (oder erster Request) → llama-swap laedt/swappt: Status melden.
+    switching = eff_model != _last_model
+    if switching:
+        await _emit_llm_status(ws, "loading", eff_model)
+
     t0 = time.time()
     res = await _call_llama(messages, max_tokens=max_tokens,
-                            temperature=temperature, stop=stop, tools=tools)
+                            temperature=temperature, stop=stop, tools=tools,
+                            model=model)
     dt = time.time() - t0
+
+    if switching:
+        if res.get("ok"):
+            fresh = (eff_model not in _ready_models) and dt > 25
+            _ready_models.add(eff_model)
+            _last_model = eff_model
+            await _emit_llm_status(ws, "ready", eff_model,
+                                   loadSeconds=round(dt, 1), freshlyDownloaded=fresh)
+        else:
+            # bei Fehler _last_model NICHT setzen → naechster Versuch meldet erneut loading
+            await _emit_llm_status(ws, "error", eff_model,
+                                   error=(res.get("error") or "")[:120])
     tc = res.get("tool_calls")
-    logger.info("llm_request id=%s -> ok=%s %.2fs content_len=%d tool_calls=%d",
-                (req_id[:8] if req_id else "?"), res.get("ok"), dt,
+    logger.info("llm_request id=%s model=%s -> ok=%s %.2fs content_len=%d tool_calls=%d",
+                (req_id[:8] if req_id else "?"), model or LLM_MODEL, res.get("ok"), dt,
                 len(res.get("content") or ""), len(tc) if tc else 0)
     await _send(ws, "llm_response", {
         "requestId": req_id,
@@ -134,7 +172,7 @@ async def _handle_llm_request(ws, payload: dict) -> None:
         "content": res.get("content", ""),
         "tool_calls": tc,
         "error": res.get("error"),
-        "model": LLM_MODEL,
+        "model": model or LLM_MODEL,
         "elapsedMs": int(dt * 1000),
     })