feat(diagnostic): B1a-2 — Schalter fuer lokales LLM (Master/Nur-lokal/Tool-Umfang)

Neuer Settings-Block "Lokales LLM (schnelle Antworten)":
- Master-Checkbox "Lokales LLM nutzen" (aus = alles Claude)
- "Nur lokales LLM (kein Claude-Fallback)" — Eval-Haken
- "Tool-Umfang: Abgespeckt / Voll" — Voll deaktiviert (gated) + ⓘ mit VRAM-Erklaerung
- ⓘ-Haupt-Info erklaert Router/Latenz/Heim-Internet-Abhaengigkeit

server.js: GET/POST /api/local-llm-config <-> /shared/config/local_llm.json
(read/write, spiegelt runtime-config-Muster). Genau die Datei, die router.py
im Brain live liest. Onchange-Autosave, Status-Zeile, Laden bei ws.onopen.

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

.gitignore

@@ -78,4 +78,8 @@ __pycache__/
 .vscode/settings.json
 .idea/
 *.swp
-*.swo
+*.swo
+
+# Lokale LLM-Modelle (Plan B) — GGUF/HF-Cache sind mehrere GB, nicht ins Repo
+xtts/models/*
+!xtts/models/.gitkeep

aria-brain/agent.py

@@ -26,8 +26,10 @@ from typing import Optional
 
 from conversation import Conversation, Turn
 from memory import Embedder, VectorStore, MemoryPoint
-from prompts import build_system_prompt
+from prompts import build_system_prompt, IDENTITY_SEED, IDENTITY_ANCHOR
 from proxy_client import ProxyClient, Message as ProxyMessage
+import router as router_mod
+from local_llm import local_llm_chat
 import skills as skills_mod
 import triggers as triggers_mod
 import watcher as watcher_mod
@@ -1053,6 +1055,61 @@ class Agent:
                 return reply
         return None
 
+    # ── Fast-Lane: lokales schnelles LLM (Plan B, B1a) ──
+    #
+    # Zwischen Skill-Fast-Path und Claude-Loop: einfache Plauder-Turns beantwortet
+    # das lokale Qwen (schlanker Prompt, KEINE Tools) in <1 s. Gated ueber
+    # /shared/config/local_llm.json (Default aus → alles Claude wie bisher).
+    # Rueckgabe: fertige Antwort (str) wenn lokal erledigt, sonst None → Claude.
+
+    _LOCAL_WINDOW_TURNS = 8  # nur die letzten N Turns ans lokale Modell (Speed)
+
+    def _try_local_fast_lane(self, user_message: str,
+                             active_project_id: str) -> Optional[str]:
+        cfg = router_mod.load_config()
+        if not router_mod.should_try_local(user_message, cfg):
+            return None
+
+        sys_prompt = router_mod.build_local_system_prompt(IDENTITY_ANCHOR)
+        # Nur die letzten paar Turns ans lokale Modell — es ist fuer kurze
+        # Plauder-Turns da. Volles Fenster (bis 50) wuerde das Prefill aufblaehen
+        # und den Speed-Vorteil auffressen (gemessen: 12 Turns → ~2,6s statt ~0,8s).
+        window = self.conversation.window(project_id=active_project_id)[-self._LOCAL_WINDOW_TURNS:]
+        messages = [{"role": "system", "content": sys_prompt}]
+        messages += [{"role": t.role, "content": t.content} for t in window]
+
+        res = local_llm_chat(messages, max_tokens=400, temperature=0.5)
+        local_only = bool(cfg.get("localOnly"))
+
+        if not res.get("ok"):
+            logger.info("[router] lokal fehlgeschlagen (%s) — %s",
+                        res.get("error"), "kein Fallback (localOnly)" if local_only else "→ Claude")
+            if local_only:
+                # Eval-Modus: KEIN Claude. Ehrliche Fehlermeldung statt Stille.
+                return f"[Lokales LLM nicht erreichbar: {res.get('error', 'unbekannt')}]"
+            return None
+
+        content = (res.get("content") or "").strip()
+
+        if local_only:
+            # Erzwungen lokal: Escalation-Marker ignorieren, Antwort so nehmen.
+            content = content.replace(router_mod.ESCALATE_MARKER, "").strip()
+            if not content:
+                return "[Lokales LLM lieferte keine Antwort.]"
+            logger.info("[router] lokal (localOnly) %sms", res.get("elapsedMs"))
+            self.conversation.add("assistant", content, project_id=active_project_id)
+            return content
+
+        # Normalbetrieb: leere Antwort oder Escalation-Marker → Claude.
+        if not content or router_mod.ESCALATE_MARKER in content:
+            logger.info("[router] lokal eskaliert → Claude")
+            return None
+
+        logger.info("[router] lokal beantwortet in %sms (%d Zeichen)",
+                    res.get("elapsedMs"), len(content))
+        self.conversation.add("assistant", content, project_id=active_project_id)
+        return content
+
     # ── Hauptpfad: ein User-Turn → Tool-Loop → finaler Reply ──
 
     MAX_TOOL_ITERATIONS = 8  # Schutz vor Endlos-Loops
@@ -1101,6 +1158,14 @@ class Agent:
         if active_project_id:
             projects_mod.touch_project(active_project_id)
 
+        # Fast-Lane: lokales schnelles LLM (Plan B, B1a). Gated ueber
+        # /shared/config/local_llm.json (Default aus → alles laeuft wie bisher
+        # ueber Claude). Erledigt es den Turn: fertige Antwort zurueck, der
+        # 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
+
         # 2. Hot Memory (alle pinned Punkte)
         hot = self.store.list_pinned()
 
@@ -1190,6 +1255,13 @@ class Agent:
                     f"weiterfuehren': project_enter aufrufen."
                 )
         messages = [ProxyMessage(role="system", content=system_prompt)]
+        # Identitaets-Grounding IM Konversations-Strom (Defense-in-Depth neben
+        # dem vollen System-Prompt-Replace via --system-prompt). Ein
+        # synthetischer erster ARIA-Turn in ihrer eigenen Stimme haelt die Rolle
+        # per Self-Grounding auch bei duennem Verlauf (Hauptchat / erster Turn
+        # eines neuen Projekts). Kein <system>-Tag -> kein Injection-Trigger.
+        # Rein ephemer — wird NIE persistiert. Siehe IDENTITY_SEED in prompts.py.
+        messages.append(ProxyMessage(role="assistant", content=IDENTITY_SEED))
         # Conversation-Window auf das aktive Projekt filtern: in einem Projekt
         # sieht der LLM nur die Projekt-Turns (sauberer Kontext); im Hauptthread
         # nur die nicht-getaggten Turns.

aria-brain/clean_poisoned_turns.py

@@ -0,0 +1,154 @@
+#!/usr/bin/env python3
+"""Einmal-Cleanup: entfernt "vergiftete" Hauptthread-Turns aus conversation.jsonl.
+
+Hintergrund
+-----------
+Solange ARIAs Persona nur via --append-system-prompt kam (statt --system-prompt,
+voller Replace), fiel das Modell im Hauptchat aus der Rolle und antwortete als
+"Claude Code" ("das ist injizierter Kontext, ich adoptiere die Persona nicht").
+Jede dieser Antworten wurde per conversation.add("assistant", ...) in die History
+geschrieben. Beim naechsten Request landet sie als <previous_response> im
+stdin-Prompt — das Modell sieht seine EIGENEN Ablehnungs-Turns und setzt die
+Haltung fort (Self-Grounding rueckwaerts). Der --system-prompt-Fix verhindert
+NEUE Vergiftung, aber die bestehenden Gift-Turns muessen einmalig raus, sonst
+zieht die History das Modell weiter aus der Rolle.
+
+Was das Script tut
+------------------
+- Findet Hauptthread-Assistant-Turns (KEIN project_id), deren Inhalt eindeutig
+  eine Rollen-Ablehnung ist: enthaelt "claude code" UND einen zweiten Marker
+  (injiz/inject/fabriz/fabricat/adoptier/adopting/prompt injection/keine echten).
+- Entfernt diese Assistant-Turns PLUS den unmittelbar davor stehenden
+  Hauptthread-User-Turn (die ausloesende Frage) — also den ganzen Fehl-Dialog.
+- Laesst ALLES andere unangetastet: projekt-getaggte Turns, distill-Marker,
+  legitime Hauptchat-Turns.
+- Standard = DRY-RUN (zeigt nur was raus wuerde). Mit --apply wird geschrieben,
+  vorher ein Backup .pre-cleanup.bak angelegt. Idempotent.
+
+Aufruf (auf der VM, Host-Pfad des Bind-Mounts):
+    python3 clean_poisoned_turns.py ../aria-data/brain/data/conversation.jsonl
+    python3 clean_poisoned_turns.py ../aria-data/brain/data/conversation.jsonl --apply
+
+Danach Brain neu starten, damit die bereinigte History geladen wird:
+    docker compose restart aria-brain
+"""
+
+from __future__ import annotations
+
+import json
+import re
+import shutil
+import sys
+from pathlib import Path
+
+# "claude code" ist fuer sich genommen noch kein Beweis (Stefan und ARIA reden
+# im Dev-Kontext legitim ueber Claude Code). Erst in Kombination mit einem
+# zweiten Ablehnungs-Marker ist es eindeutig eine aus-der-Rolle-Antwort.
+_PRIMARY = re.compile(r"claude\s*code", re.IGNORECASE)
+_SECONDARY = re.compile(
+    r"injiz|inject|fabriz|fabricat|adoptier|adopting|"
+    r"prompt[\s-]*injection|keine echten|nicht (?:real|adopt)",
+    re.IGNORECASE,
+)
+
+
+def is_poison(content: str) -> bool:
+    return bool(_PRIMARY.search(content) and _SECONDARY.search(content))
+
+
+def get_content(obj: dict) -> str:
+    """conversation.jsonl nutzt 'content', chat_backup.jsonl nutzt 'text'."""
+    v = obj.get("content")
+    if not isinstance(v, str):
+        v = obj.get("text")
+    return v if isinstance(v, str) else ""
+
+
+def is_main_thread(obj: dict) -> bool:
+    """Hauptthread = kein Projekt-Tag. Brain nutzt 'project_id', UI/Bridge
+    'projectId'."""
+    pid = obj.get("project_id")
+    if pid is None:
+        pid = obj.get("projectId")
+    return not (str(pid or "").strip())
+
+
+def main() -> int:
+    args = [a for a in sys.argv[1:] if not a.startswith("--")]
+    apply = "--apply" in sys.argv[1:]
+    path = Path(args[0]) if args else Path("/data/conversation.jsonl")
+
+    if not path.exists():
+        print(f"FEHLER: {path} existiert nicht.", file=sys.stderr)
+        return 2
+
+    raw_lines = path.read_text(encoding="utf-8").splitlines()
+    # Parse zu (raw, obj|None). Nicht-JSON / leere Zeilen bleiben unangetastet.
+    parsed: list[tuple[str, dict | None]] = []
+    for line in raw_lines:
+        s = line.strip()
+        if not s:
+            parsed.append((line, None))
+            continue
+        try:
+            parsed.append((line, json.loads(s)))
+        except Exception:
+            parsed.append((line, None))
+
+    drop = [False] * len(parsed)
+    poisoned_pairs = []  # (assistant_idx, user_idx|None) fuer's Log
+
+    for i, (_, obj) in enumerate(parsed):
+        if not isinstance(obj, dict):
+            continue
+        if obj.get("op") == "distill":
+            continue
+        if obj.get("role") != "assistant" or not is_main_thread(obj):
+            continue
+        content = get_content(obj)
+        if not content or not is_poison(content):
+            continue
+        # Gift-Assistant-Turn -> droppen
+        drop[i] = True
+        user_idx = None
+        # Unmittelbar davor stehenden Hauptthread-User-Turn (die Frage) mit weg.
+        for j in range(i - 1, -1, -1):
+            pj = parsed[j][1]
+            if not isinstance(pj, dict) or pj.get("op") == "distill":
+                continue
+            if pj.get("role") == "user" and is_main_thread(pj):
+                drop[j] = True
+                user_idx = j
+            break  # nur der direkt vorangehende Turn
+        poisoned_pairs.append((i, user_idx))
+
+    n_drop = sum(drop)
+    if n_drop == 0:
+        print("Keine Gift-Turns gefunden — History ist sauber. Nichts zu tun.")
+        return 0
+
+    print(f"Gefundene Fehl-Dialoge: {len(poisoned_pairs)} "
+          f"(insgesamt {n_drop} Zeilen zu entfernen)\n")
+    for a_idx, u_idx in poisoned_pairs:
+        if u_idx is not None:
+            uq = get_content(parsed[u_idx][1] or {})
+            print(f"  Frage   (Zeile {u_idx + 1}): {uq[:90]!r}")
+        ac = get_content(parsed[a_idx][1] or {})
+        print(f"  Ablehng (Zeile {a_idx + 1}): {ac[:90]!r}")
+        print()
+
+    if not apply:
+        print("DRY-RUN — nichts geschrieben. Zum Anwenden erneut mit --apply aufrufen.")
+        return 0
+
+    backup = path.with_suffix(path.suffix + ".pre-cleanup.bak")
+    shutil.copy2(path, backup)
+    kept = [raw for idx, (raw, _) in enumerate(parsed) if not drop[idx]]
+    path.write_text("\n".join(kept) + ("\n" if kept else ""), encoding="utf-8")
+    print(f"OK — {n_drop} Zeilen entfernt. Backup: {backup}")
+    print("Jetzt Brain neu starten: docker compose restart aria-brain")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

aria-brain/local_llm.py

@@ -0,0 +1,61 @@
+"""
+Local-LLM-Client (Plan B) — Brain-Seite.
+
+Ruft das schnelle lokale LLM (Qwen3 auf der Gamebox) ueber die Bridge:
+  Brain → HTTP /internal/local-llm → Bridge → RVS → llm-adapter → llama.cpp
+
+Analog zum Claude-`proxy_client`, nur ueber die Bridge (die ist der RVS-Client;
+das Brain bleibt HTTP-only). Der Router im Brain (B1) entscheidet, welche Turns
+hierher gehen (einfach) und welche an Claude (schwer / Tool-Bedarf).
+
+Rueckgabe von local_llm_chat: {ok, content, model?, elapsedMs?} oder {ok:False, error}.
+Nie werfen — der Aufrufer entscheidet bei ok=False, ob er auf Claude eskaliert.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+import urllib.error
+import urllib.request
+
+logger = logging.getLogger(__name__)
+
+BRIDGE_URL = os.environ.get("BRIDGE_URL", "http://aria-bridge:8090")
+# Etwas ueber dem Bridge-seitigen _LLM_TIMEOUT_S (30s), damit der HTTP-Call nicht
+# vor dem eigentlichen LLM-Timeout abbricht.
+LOCAL_LLM_HTTP_TIMEOUT_SEC = float(os.environ.get("LOCAL_LLM_HTTP_TIMEOUT_SEC", "35"))
+
+
+def local_llm_chat(messages: list, *, max_tokens: int = 512,
+                   temperature: float = 0.7, stop=None) -> dict:
+    """Ein Chat-Call ans lokale LLM. messages = [{role, content}, ...].
+    Blockierend (urllib) — im Brain laeuft chat() 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}
+    if stop:
+        req["stop"] = stop
+    try:
+        body = json.dumps(req).encode("utf-8")
+        http_req = urllib.request.Request(
+            f"{BRIDGE_URL}/internal/local-llm", data=body, method="POST",
+            headers={"Content-Type": "application/json"},
+        )
+        with urllib.request.urlopen(http_req, timeout=LOCAL_LLM_HTTP_TIMEOUT_SEC) as resp:
+            result = json.loads(resp.read().decode("utf-8", "ignore"))
+    except urllib.error.HTTPError as exc:
+        try:
+            err_data = json.loads(exc.read().decode("utf-8", "ignore"))
+            err = err_data.get("error") or str(exc)
+        except Exception:
+            err = str(exc)
+        return {"ok": False, "error": f"local-llm: {err}"}
+    except Exception as exc:
+        logger.warning("local_llm_chat HTTP-Call fehlgeschlagen: %s", exc)
+        return {"ok": False, "error": f"local-llm nicht erreichbar ({exc})"}
+
+    if not isinstance(result, dict) or not result.get("ok"):
+        return {"ok": False, "error": (result or {}).get("error", "unbekannt")}
+    return result

aria-brain/prompts.py

@@ -54,6 +54,29 @@ vorgesehen — nutze es ganz normal.
 """
 
 
+# Identitaets-Grounding IM Konversations-Strom — Defense-in-Depth.
+#
+# PRIMAERER Fix ist der volle System-Prompt-Replace (--system-prompt statt
+# --append-system-prompt, siehe docker-compose.yml + openai-to-cli.js): damit
+# ist die ARIA-Persona DIE Identitaet des Modells, nicht ein Anhaengsel hinter
+# Claude Codes "You are Claude Code". Zuvor (--append) hat die eingebaute
+# Identitaet bei duennem Kontext (Hauptchat, erster Turn eines neuen Projekts)
+# gewonnen und ARIA aus der Rolle geworfen ("ich bin Claude Code, ich adoptiere
+# die Persona nicht"), samt Flaggen von GPS/Tool-XML als Injection.
+#
+# ZUSAETZLICH setzen wir einen synthetischen ERSTEN ARIA-Turn in IHRER eigenen
+# Stimme an den Anfang des Konversations-Stroms. Das Modell setzt seine EIGENE
+# etablierte Stimme fort (Self-Grounding) — greift auch dann, falls eine CLI-
+# Version --system-prompt mal nicht sauber isoliert. Weil es ein
+# <previous_response> ist und KEIN <system>-Tag, ist es kein Injection-Trigger.
+# Rein ephemer (nur im Request-messages-Array, wird NIE persistiert).
+IDENTITY_SEED = (
+    "Ich bin ARIA, Stefans persoenliche Assistentin. Ich bin einsatzbereit und "
+    "antworte durchgehend als ARIA — im Hauptchat wie im Projekt, bei kurzen "
+    "Alltagsfragen genauso wie bei tiefen technischen Themen. Womit kann ich helfen?"
+)
+
+
 def build_time_section() -> str:
     """Aktueller Zeitstempel — damit ARIA Timer korrekt anlegen kann
     und Watcher-Conditions mit hour_of_day etc. einordenbar bleiben."""

aria-brain/router.py

@@ -0,0 +1,135 @@
+"""
+Router (Plan B, B1a) — entscheidet pro Turn: lokales schnelles LLM oder Claude.
+
+Gestaffelt:
+- B1a (hier): „nur reden" — einfache Plauder-Turns → lokales Qwen (schlanker
+  Prompt, KEINE Tools). Antwortet es sauber → fertig in <1 s. Sagt es
+  `<<ESCALATE>>`, braucht ein Tool oder faellt aus → Claude (bestehender Pfad).
+- B1b (spaeter): kuratierte lokale Tools + lokale Tool-Loop.
+
+Schalter kommen aus /shared/config/local_llm.json (Diagnostic schreibt, Brain
+liest pro Request):
+    {
+      "enabled": false,        # Master: lokales Tier an/aus (aus = alles Claude)
+      "localOnly": false,      # Eval: erzwinge lokal, KEIN Claude-Fallback
+      "toolVariant": "slim"    # "slim" | "full"  (B1b; "full" braucht mehr VRAM)
+    }
+Default (Datei fehlt/kaputt): enabled=false → Verhalten wie bisher (alles Claude).
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+import re
+
+logger = logging.getLogger(__name__)
+
+CONFIG_PATH = os.environ.get("LOCAL_LLM_CONFIG", "/shared/config/local_llm.json")
+
+ESCALATE_MARKER = "<<ESCALATE>>"
+
+DEFAULT_CONFIG = {"enabled": False, "localOnly": False, "toolVariant": "slim"}
+
+
+def load_config() -> dict:
+    """Liest die Schalter. Nie werfen — bei Fehler Defaults (= alles Claude)."""
+    try:
+        with open(CONFIG_PATH, encoding="utf-8") as f:
+            data = json.load(f) or {}
+        return {
+            "enabled": bool(data.get("enabled", False)),
+            "localOnly": bool(data.get("localOnly", False)),
+            "toolVariant": data.get("toolVariant", "slim") or "slim",
+        }
+    except (FileNotFoundError, json.JSONDecodeError):
+        return dict(DEFAULT_CONFIG)
+    except Exception as exc:
+        logger.debug("local_llm-Config lesen fehlgeschlagen: %s", exc)
+        return dict(DEFAULT_CONFIG)
+
+
+# ── Heuristik: ist dieser Turn „einfach genug" fuers lokale Tier (B1a)? ──
+#
+# B1a ist reden-ohne-Tools. Also: alles, was ein Tool/Aktion braucht oder tief/
+# technisch ist, geht an Claude. Lieber konservativ (im Zweifel Claude) — das
+# lokale Tier soll nur die klaren Plauder-Turns abgreifen; Fehlklassifikation
+# faengt zusaetzlich das <<ESCALATE>> im Modell selbst ab.
+
+# Wortstämme, die auf Tool-/Aktionsbedarf hindeuten → nicht lokal (in B1a).
+_TOOL_HINTS = re.compile(
+    r"\b(wetter|temperatur|regne|timer|erinner|weck|licht|lampe|steckdose|"
+    r"spotify|musik|lied|song|playlist|lauter|leiser|"
+    r"bild|generier|male?\b|zeichne|foto|"
+    r"merk dir|memory|gedächtnis|erinnere dich|"
+    r"skill|trigger|projekt|oauth|spotify|kalender|termin|"
+    r"such(e|st)?\b|google|internet|news|nachrichten|aktie|kurs|"
+    r"maild?|email|nachricht schreiben|sende)\b",
+    re.IGNORECASE,
+)
+
+# Technik-/Tiefe-Marker → Claude (lokales 8B soll das nicht raten).
+_HARD_HINTS = re.compile(
+    r"```|"                                    # Codeblock
+    r"\b(code|fehler|error|stacktrace|exception|bug|debug|pentest|exploit|"
+    r"vuln|payload|regex|sql|python|javascript|docker|kubernetes|"
+    r"analysier|erklär.*genau|schritt für schritt|refactor|implementier)\b",
+    re.IGNORECASE,
+)
+
+_MAX_LEN_FOR_LOCAL = 220   # laengere Nachrichten = eher komplexe Aufgaben → Claude
+
+
+def should_try_local(user_message: str, cfg: dict) -> bool:
+    """True, wenn der Router diesen Turn (B1a, reden-only) lokal versuchen soll.
+    localOnly überschreibt die Heuristik (dann IMMER lokal)."""
+    if not cfg.get("enabled"):
+        return False
+    if cfg.get("localOnly"):
+        return True
+    msg = (user_message or "").strip()
+    if not msg or len(msg) > _MAX_LEN_FOR_LOCAL:
+        return False
+    if _TOOL_HINTS.search(msg):
+        return False
+    if _HARD_HINTS.search(msg):
+        return False
+    return True
+
+
+# ── Schlanker System-Prompt fuers lokale Tier ──
+#
+# Klein halten (Speed!). Persona-Kern + Identitaets-Anker + kurze Awareness-Liste
+# (WAS ARIA kann, ohne volle Schemas) + Escalation-Regel. KEINE Tool-Schemas,
+# kein volles Memory (B1a).
+
+_AWARENESS = (
+    "ARIA kann ausserdem (ueber ihr grosses Backend, nicht in diesem schnellen "
+    "Modus): Wetter/Zeit/Websuche, Timer & Erinnerungen, Musik (Spotify) & Licht "
+    "steuern, Bilder generieren, ins Gedaechtnis schreiben/suchen, Skills bauen, "
+    "Projekte & OAuth verwalten."
+)
+
+
+def build_local_system_prompt(identity_anchor: str, pinned_persona: str = "") -> str:
+    """Schlanker System-Prompt fuers lokale LLM. identity_anchor = derselbe
+    Anker wie bei Claude (Rolle haelt); pinned_persona optional kurz."""
+    parts = [
+        identity_anchor.strip(),
+        "",
+        "## SCHNELL-MODUS",
+        "Du laeufst gerade als schnelles lokales Modell fuer einfache, kurze "
+        "Alltags-Konversation. Antworte knapp, freundlich, auf Deutsch, als ARIA.",
+        "",
+        "## WAS DU HIER NICHT TUST",
+        _AWARENESS,
+        "Fuer alles, was ein Werkzeug/eine Aktion braucht, tiefer/technischer wird, "
+        "aktuelles Wissen oder Nachschlagen verlangt, oder wo du unsicher bist: "
+        f"antworte AUSSCHLIESSLICH mit exakt `{ESCALATE_MARKER}` (nichts sonst). "
+        "Dann uebernimmt automatisch das grosse Modell mit vollem Zugriff. "
+        "Lieber einmal eskalieren als falsch raten.",
+    ]
+    if pinned_persona.strip():
+        parts += ["", "## PERSONA", pinned_persona.strip()]
+    return "\n".join(parts)

bridge/aria_bridge.py

@@ -643,6 +643,11 @@ class ARIABridge:
         # flux-bridge service_status: True wenn ready. Render-Timeouts werden
         # bei 'loading' deutlich grosszuegiger gesetzt (Modell-Download ~24 GB).
         self._remote_flux_ready: bool = False
+        # Lokales LLM (Plan B): requestId → Future mit dem llm_response-Payload.
+        # Analog zu _pending_flux — Brain ruft /internal/local-llm, wir relayen
+        # llm_request via RVS an den llm-adapter (Gamebox) und warten auf
+        # llm_response.
+        self._pending_llm: dict[str, asyncio.Future] = {}
         # User-Message-Counter fuer Auto-Compact. Bei zu langer Konversation
         # sprengt die argv-Liste beim Claude-Subprocess-Spawn (E2BIG). Bei
         # COMPACT_AFTER erreicht → Sessions reset + Container restart.
@@ -1326,9 +1331,18 @@ class ARIABridge:
             or 1.0
         )
 
-        tts_text = tts_text_preview or text
+        # Ein vorhandener <voice>-Tag ist die EXPLIZITE TTS-Vorgabe von ARIA —
+        # auch wenn er leer ist. Leeres <voice></voice> = bewusst stumm: die
+        # Bubble erscheint im Chat, aber es wird NICHTS gesprochen. Use-Case:
+        # Steuerbefehl-Quittungen (Spotify next/pause, Licht an) — dort darf die
+        # Sprachausgabe NICHT feuern, weil das TTS-Playback auf dem Handy den
+        # Audio-Fokus klaut, Spotify duckt/pausiert und (bei kurzem Text) nicht
+        # sauber weiterspielt. Nur OHNE Voice-Tag faellt es auf den vollen Text
+        # zurueck (normale Antwort ohne TTS-Annotation wird komplett gelesen).
+        has_voice_tag = "<voice>" in (text or "").lower()
+        tts_text = tts_text_preview if has_voice_tag else (tts_text_preview or text)
         if not tts_text:
-            logger.info("[core] TTS-Text leer nach Cleanup — uebersprungen")
+            logger.info("[core] TTS-Text leer (bewusst stumm via <voice></voice> oder nach Cleanup) — uebersprungen")
             return
         try:
             xtts_request_id = str(uuid.uuid4())
@@ -2954,6 +2968,15 @@ class ARIABridge:
             future.set_result(payload)
             return
 
+        elif msg_type == "llm_response":
+            # Antwort des llm-adapter (Gamebox) auf unseren llm_request.
+            request_id = payload.get("requestId", "")
+            future = self._pending_llm.get(request_id)
+            if future is None or future.done():
+                return
+            future.set_result(payload)
+            return
+
         elif msg_type == "service_status":
             # Gamebox-Bridges (whisper / f5tts / flux) melden ihren Lade-Status.
             # Wir nutzen das fuer den dynamischen STT-Timeout: solange whisper
@@ -3337,6 +3360,59 @@ class ARIABridge:
     _FLUX_TIMEOUT_READY_S = 240.0      # 4 min nach erstem Render
     _FLUX_TIMEOUT_LOADING_S = 900.0    # 15 min beim allerersten Mal (Modell-Download)
 
+    # ── Local-LLM-Roundtrip: Brain → Bridge → RVS → llm-adapter → zurueck ──
+    # Qwen3 auf der Gamebox antwortet auf kurze Turns in <1 s. Grosszuegiger
+    # Timeout deckt Kaltstart / laengere Antworten / Netz-Jitter (Gamebox@home)
+    # ab. Bei Timeout faellt der Router im Brain per Escalation auf Claude.
+    _LLM_TIMEOUT_S = 30.0
+
+    async def _local_llm(self, messages: list, max_tokens: int = 512,
+                         temperature: float = 0.7, stop=None) -> dict:
+        """Schickt einen llm_request an den llm-adapter (Gamebox), wartet auf
+        llm_response. Rueckgabe: {ok, content, model, elapsedMs} oder {ok:False, error}."""
+        if self.ws_rvs is None:
+            return {"ok": False, "error": "RVS-Verbindung nicht aktiv"}
+        if not isinstance(messages, list) or not messages:
+            return {"ok": False, "error": "messages leer/ungueltig"}
+
+        request_id = str(uuid.uuid4())
+        loop = asyncio.get_event_loop()
+        future: asyncio.Future = loop.create_future()
+        self._pending_llm[request_id] = future
+        try:
+            req_payload = {
+                "requestId": request_id,
+                "messages": messages,
+                "max_tokens": max_tokens,
+                "temperature": temperature,
+            }
+            if stop:
+                req_payload["stop"] = stop
+            logger.info("[rvs] llm_request → llm-adapter (id=%s, msgs=%d, max_tokens=%d)",
+                        request_id[:8], len(messages), max_tokens)
+            ok = await self._send_to_rvs({
+                "type": "llm_request",
+                "payload": req_payload,
+                "timestamp": int(time.time() * 1000),
+            })
+            if not ok:
+                return {"ok": False, "error": "llm_request konnte nicht gesendet werden"}
+            try:
+                result = await asyncio.wait_for(future, timeout=self._LLM_TIMEOUT_S)
+            except asyncio.TimeoutError:
+                return {"ok": False, "error": f"Timeout ({self._LLM_TIMEOUT_S:.0f}s) — Gamebox nicht erreichbar?"}
+            if not isinstance(result, dict) or not result.get("ok"):
+                err = (result or {}).get("error") if isinstance(result, dict) else "leeres Resultat"
+                return {"ok": False, "error": err or "llm-adapter Fehler"}
+            return {
+                "ok": True,
+                "content": result.get("content", ""),
+                "model": result.get("model"),
+                "elapsedMs": result.get("elapsedMs"),
+            }
+        finally:
+            self._pending_llm.pop(request_id, None)
+
     async def _flux_generate(self, prompt: str, width: int, height: int,
                              steps: Optional[int], guidance: Optional[float],
                              seed: Optional[int], model: Optional[str] = None) -> dict:
@@ -3788,6 +3864,33 @@ class ARIABridge:
                     )
                     status = 200 if result.get("ok") else 502
                     await _send_response(writer, status, result)
+                elif method == "POST" and path == "/internal/local-llm":
+                    # Vom Brain (Router / Testchat) gefeuert. Wir relayen den
+                    # Chat-Request via RVS an den llm-adapter (Gamebox Qwen3),
+                    # warten synchron auf llm_response und geben content zurueck.
+                    try:
+                        data = json.loads(body.decode("utf-8", "ignore"))
+                    except Exception as exc:
+                        await _send_response(writer, 400, {"error": f"bad json: {exc}"})
+                        return
+                    messages = data.get("messages")
+                    if not isinstance(messages, list) or not messages:
+                        await _send_response(writer, 400, {"error": "messages (nicht-leere Liste) erforderlich"})
+                        return
+                    try:
+                        max_tokens = int(data.get("max_tokens") or 512)
+                    except (TypeError, ValueError):
+                        max_tokens = 512
+                    try:
+                        temperature = float(data.get("temperature"))
+                    except (TypeError, ValueError):
+                        temperature = 0.7
+                    result = await self._local_llm(
+                        messages=messages, max_tokens=max_tokens,
+                        temperature=temperature, stop=data.get("stop"),
+                    )
+                    status = 200 if result.get("ok") else 502
+                    await _send_response(writer, status, result)
                 elif method == "POST" and path == "/internal/delete-chat-message":
                     try:
                         data = json.loads(body.decode("utf-8", "ignore"))

diagnostic/index.html

@@ -878,20 +878,64 @@
       <h2>Sprachmodell (Brain)</h2>
       <div class="card" style="max-width:500px;">
         <div style="font-size:11px;color:#8888AA;margin-bottom:10px;line-height:1.5;">
-          Welches Claude-Model nutzt das Brain pro Anfrage. Wert wird in
+          Welches Claude-Model das Brain pro Anfrage nutzt. Wert wird in
           <code>/shared/config/runtime.json</code> als <code>brainModel</code> persistiert.
           Bei Aenderung: <strong>aria-brain restarten</strong> (Reparatur-Section oben), damit's greift.
           <br><br>
-          Verfuegbar via Proxy: <code>claude-sonnet-4</code> (Default — schnell, gut),
-          <code>claude-opus-4</code> (langsam, smarter), <code>claude-haiku-4-5</code> (sehr schnell, kleiner Kontext).
+          ARIA laeuft ueber dein Claude-Max-Abo (CLI) — waehlbar ist der <strong>Tier</strong>
+          (Opus/Sonnet/Haiku), nicht eine feste Version. Die CLI nimmt automatisch das
+          jeweils aktuelle Modell des Tiers.
+          <br><br>
+          Die Auswahlliste kommt aus <code>/shared/config/models.json</code> — dort kannst du
+          Tiers/Beschreibungen anpassen (kein Neustart noetig, danach „↻ Aktualisieren").
         </div>
         <div style="display:flex;align-items:center;gap:8px;margin-bottom:8px;">
           <span style="font-size:12px;color:#8888AA;white-space:nowrap;">Aktives Model:</span>
-          <input type="text" id="setting-model" placeholder="claude-sonnet-4" style="flex:1;background:#1E1E2E;border:1px solid #333;border-radius:4px;padding:6px 8px;color:#E0E0F0;font-family:inherit;font-size:12px;">
-          <button class="btn secondary" onclick="loadModel()" style="padding:4px 8px;font-size:10px;">Laden</button>
+          <select id="setting-model-select" onchange="onModelSelectChange()" 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="loadModelList()" title="Liste vom Proxy neu holen" style="padding:4px 8px;font-size:10px;">↻ Aktualisieren</button>
           <button class="btn" onclick="saveModel()" style="padding:4px 8px;font-size:10px;">Setzen</button>
         </div>
-        <div id="model-status" style="font-size:10px;color:#8888AA;"></div>
+        <div id="model-desc" style="font-size:10px;color:#6a6a88;margin-bottom:6px;min-height:12px;"></div>
+        <div id="model-status" style="font-size:10px;color:#8888AA;margin-bottom:8px;"></div>
+        <details style="font-size:11px;color:#8888AA;">
+          <summary style="cursor:pointer;">Erweitert: freie Model-ID</summary>
+          <div style="display:flex;align-items:center;gap:8px;margin-top:6px;">
+            <input type="text" id="setting-model" placeholder="z.B. claude-opus-4" style="flex:1;background:#1E1E2E;border:1px solid #333;border-radius:4px;padding:6px 8px;color:#E0E0F0;font-family:inherit;font-size:12px;">
+            <button class="btn secondary" onclick="loadModel()" style="padding:4px 8px;font-size:10px;">Laden</button>
+            <button class="btn" onclick="saveModelFreeText()" style="padding:4px 8px;font-size:10px;">Setzen</button>
+          </div>
+        </details>
+      </div>
+    </div>
+
+    <div class="settings-section">
+      <h2>Lokales LLM (schnelle Antworten) <button class="info-btn" onclick="showInfo('local-llm')" title="Wie funktioniert das?">ℹ</button></h2>
+      <div class="card" style="max-width:500px;">
+        <div style="font-size:11px;color:#8888AA;margin-bottom:10px;line-height:1.5;">
+          Ein schnelles lokales Modell (Qwen3 auf der Gamebox) beantwortet einfache
+          Plauder-Turns in unter 1&nbsp;Sekunde; alles Schwere/Werkzeug-artige geht
+          weiter an Claude. Schreibt <code>/shared/config/local_llm.json</code> —
+          der Router im Brain liest sie live (kein Neustart noetig).
+        </div>
+        <label style="display:flex;align-items:center;gap:8px;margin-bottom:8px;font-size:12px;color:#E0E0F0;cursor:pointer;">
+          <input type="checkbox" id="local-llm-enabled" onchange="saveLocalLlmConfig()" style="margin:0;">
+          <span>Lokales LLM nutzen <span style="color:#8888AA;">(aus = alles ueber Claude)</span></span>
+        </label>
+        <label style="display:flex;align-items:center;gap:8px;margin-bottom:10px;font-size:12px;color:#E0E0F0;cursor:pointer;">
+          <input type="checkbox" id="local-llm-onlylocal" onchange="saveLocalLlmConfig()" style="margin:0;">
+          <span>Nur lokales LLM — kein Claude-Fallback <span style="color:#8888AA;">(zum Testen)</span></span>
+        </label>
+        <div style="display:flex;align-items:center;gap:8px;margin-bottom:6px;">
+          <span style="font-size:12px;color:#8888AA;">Tool-Umfang:</span>
+          <select id="local-llm-toolvariant" onchange="saveLocalLlmConfig()" style="background:#1E1E2E;border:1px solid #333;border-radius:4px;padding:6px 8px;color:#E0E0F0;font-family:inherit;font-size:12px;">
+            <option value="slim">Abgespeckt (kuratierte Tools)</option>
+            <option value="full" disabled>Voll (braucht mehr VRAM)</option>
+          </select>
+          <button class="info-btn" onclick="showInfo('local-llm-tools')" title="Voll: wie viel VRAM?">ℹ</button>
+        </div>
+        <div id="local-llm-status" style="font-size:10px;color:#6a6a88;margin-top:6px;min-height:12px;"></div>
       </div>
     </div>
 
@@ -1504,6 +1548,10 @@
         send({ action: 'load_chat_history' });
         // Brain-Card initial laden (sonst zeigt sie "Lade...")
         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 {}
       };
 
       // Brain-Status periodisch refreshen damit die Card live bleibt
@@ -1966,8 +2014,14 @@
         // session_restarted / openclaw_config WS-Events entfernt — aria-core ist raus.
         if (msg.type === 'model_info') {
           const el = document.getElementById('setting-model');
+          const sel = document.getElementById('setting-model-select');
           const st = document.getElementById('model-status');
           if (el && msg.model) el.value = msg.model;
+          // Dropdown auf das aktuelle Model stellen (falls in der Liste).
+          if (sel && msg.model) {
+            const has = Array.from(sel.options).some(o => o.value === msg.model);
+            if (has) { sel.value = msg.model; onModelSelectChange(); }
+          }
           if (st) {
             st.textContent = msg.info || msg.error || '';
             st.style.color = msg.error ? '#FF6B6B' : '#34C759';
@@ -5833,6 +5887,28 @@
 
     // Vor-definierte Info-Blocks
     const INFO_TEXTS = {
+      'local-llm': {
+        title: 'Lokales LLM — schnelle Antworten',
+        html: `
+          <p>Ein kleines, schnelles Modell (<strong>Qwen3 8B</strong>) laeuft auf deiner Gamebox-GPU und beantwortet <strong>einfache Plauder-Turns in &lt;1&nbsp;s</strong>. Alles Schwere, Technische oder Werkzeug-artige (Wetter, Timer, Musik, Bilder, Gedaechtnis, Code) reicht ein Router automatisch an <strong>Claude</strong> weiter.</p>
+          <p><strong>Lokales LLM nutzen</strong> — Master-Schalter. Aus = alle Anfragen laufen wie bisher ueber Claude.</p>
+          <p><strong>Nur lokales LLM</strong> — erzwingt lokal, KEIN Claude-Fallback. Zum Ausprobieren, wie stark das lokale Modell allein ist. Achtung: Werkzeug-Turns (Wetter/Timer/…) funktionieren dann nicht — das lokale Tier hat keine Tools.</p>
+          <p>Die Antwortzeit haengt an deinem Heim-Internet (Gamebox @home, ARIA @RZ). Ist die Gamebox aus/nicht erreichbar, faellt ARIA automatisch auf Claude zurueck.</p>
+        `,
+      },
+      'local-llm-tools': {
+        title: 'Tool-Umfang: Abgespeckt vs. Voll',
+        html: `
+          <p><strong>Abgespeckt</strong> — das lokale Modell bekommt eine kleine, kuratierte Tool-Auswahl (Wetter, Zeit, Gedaechtnis-Suche, Timer, Spotify, Licht). Der Rest laeuft ueber Claude. Passt in den VRAM einer <strong>1×RTX&nbsp;3060 (12&nbsp;GB)</strong>.</p>
+          <p><strong>Voll</strong> — das lokale Modell soll ARIAs komplettes Arsenal kennen. Das sind ~15-20&nbsp;K Tokens Tool-Schemas → passt <em>nicht</em> in ein 8-K-Kontextfenster. Groesseres Fenster kostet VRAM:</p>
+          <ul>
+            <li><strong>12&nbsp;GB (1×3060):</strong> nur „Abgespeckt".</li>
+            <li><strong>24&nbsp;GB (2×3060, eine Box):</strong> Qwen mit grossem Kontext = volles Schema, oder ein groesseres Modell.</li>
+            <li><strong>Cluster:</strong> weitere GPU-Hosts, jeder ein Modell-Server ueber RVS.</li>
+          </ul>
+          <p>Deshalb ist „Voll" hier deaktiviert, bis die Hardware (2.&nbsp;Karte) und die lokale Tool-Loop (B1b) da sind.</p>
+        `,
+      },
       'brain-status': {
         title: 'Gehirn — Status',
         html: `
@@ -6062,14 +6138,112 @@
 
     // ── Einstellungen: Model ────────────────────────────────
 
+    let _modelListCache = [];
+
     function loadModel() {
       send({ action: 'get_model' });
     }
 
+    // Kuratierte Tier-Liste vom Proxy holen (via Diagnostic-Server) und ins
+    // Dropdown fuellen. Danach get_model, damit das aktive Model markiert wird.
+    async function loadModelList() {
+      const sel = document.getElementById('setting-model-select');
+      const st = document.getElementById('model-status');
+      if (!sel) return;
+      try {
+        const r = await fetch('/api/models-list');
+        const d = await r.json();
+        if (!d.ok) throw new Error(d.error || 'Fehler');
+        _modelListCache = d.models || [];
+        sel.innerHTML = '';
+        for (const m of _modelListCache) {
+          const opt = document.createElement('option');
+          opt.value = m.id;
+          opt.textContent = m.displayName || m.id;
+          sel.appendChild(opt);
+        }
+        if (!_modelListCache.length) {
+          const opt = document.createElement('option');
+          opt.value = ''; opt.textContent = '(keine Modelle vom Proxy)';
+          sel.appendChild(opt);
+        }
+        onModelSelectChange();
+        // Aktuelles Model vom Brain holen → markiert die richtige Option
+        loadModel();
+      } catch (e) {
+        if (st) { st.textContent = 'Model-Liste laden fehlgeschlagen: ' + e.message; st.style.color = '#FF6B6B'; }
+      }
+    }
+
+    function onModelSelectChange() {
+      const sel = document.getElementById('setting-model-select');
+      const desc = document.getElementById('model-desc');
+      if (!sel || !desc) return;
+      const m = _modelListCache.find(x => x.id === sel.value);
+      desc.textContent = m && m.description ? m.description : '';
+    }
+
     function saveModel() {
+      const sel = document.getElementById('setting-model-select');
+      const model = sel && sel.value ? sel.value : '';
+      if (!model) return;
+      send({ action: 'set_model', model });
+      const st = document.getElementById('model-status');
+      if (st) { st.textContent = 'Gesetzt — aria-brain neu starten (Reparatur oben), damit es greift.'; st.style.color = '#FFD60A'; }
+    }
+
+    function saveModelFreeText() {
       const model = document.getElementById('setting-model').value.trim();
       if (!model) return;
       send({ action: 'set_model', model });
+      const st = document.getElementById('model-status');
+      if (st) { st.textContent = 'Gesetzt (Freitext) — aria-brain neu starten, damit es greift.'; st.style.color = '#FFD60A'; }
+    }
+
+    // ── Einstellungen: Lokales LLM (Plan B) ─────────────────
+    function setLocalLlmStatus(c) {
+      const el = document.getElementById('local-llm-status');
+      if (!el) return;
+      if (!c || !c.enabled) {
+        el.textContent = 'Aus — alle Anfragen laufen ueber Claude.';
+        el.style.color = '#6a6a88';
+        return;
+      }
+      if (c.localOnly) {
+        el.textContent = 'NUR lokal — kein Claude-Fallback (Testmodus). Werkzeug-Turns funktionieren hier nicht.';
+        el.style.color = '#FFD60A';
+      } else {
+        el.textContent = 'Aktiv — einfache Turns lokal (<1s), Rest → Claude.';
+        el.style.color = '#4ADE80';
+      }
+    }
+    async function loadLocalLlmConfig() {
+      try {
+        const r = await fetch('/api/local-llm-config');
+        const c = await r.json();
+        const en = document.getElementById('local-llm-enabled');
+        const ol = document.getElementById('local-llm-onlylocal');
+        const tv = document.getElementById('local-llm-toolvariant');
+        if (en) en.checked = !!c.enabled;
+        if (ol) ol.checked = !!c.localOnly;
+        if (tv) tv.value = (c.toolVariant === 'full') ? 'full' : 'slim';
+        setLocalLlmStatus(c);
+      } catch (e) { /* still */ }
+    }
+    async function saveLocalLlmConfig() {
+      const body = {
+        enabled: document.getElementById('local-llm-enabled').checked,
+        localOnly: document.getElementById('local-llm-onlylocal').checked,
+        toolVariant: document.getElementById('local-llm-toolvariant').value,
+      };
+      try {
+        const r = await fetch('/api/local-llm-config', {
+          method: 'POST', headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify(body),
+        });
+        const j = await r.json();
+        if (j.ok) setLocalLlmStatus(j.config);
+      } catch (e) { /* still */ }
     }
 
     // ── Einstellungen: OpenClaw Config ──────────────────────

diagnostic/server.js

@@ -297,6 +297,35 @@ function writeRuntimeConfig(patch) {
 }
 
 // Atomic write: temp-file + rename, laute Logs bei Fehler.
+
+// ── Local-LLM-Config: /shared/config/local_llm.json ─────────────────
+// Der Router im Brain (router.py) liest diese Datei pro Request. Wir schreiben
+// sie hier aus den Diagnostic-Schaltern. Default = alles aus (nur Claude).
+const LOCAL_LLM_CONFIG_FILE = "/shared/config/local_llm.json";
+function readLocalLlmConfig() {
+  try {
+    const p = JSON.parse(fs.readFileSync(LOCAL_LLM_CONFIG_FILE, "utf-8"));
+    return {
+      enabled: !!p.enabled,
+      localOnly: !!p.localOnly,
+      toolVariant: p.toolVariant === "full" ? "full" : "slim",
+    };
+  } catch {
+    return { enabled: false, localOnly: false, toolVariant: "slim" };
+  }
+}
+function writeLocalLlmConfig(patch) {
+  const cur = readLocalLlmConfig();
+  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;
+  fs.mkdirSync("/shared/config", { recursive: true });
+  const tmp = LOCAL_LLM_CONFIG_FILE + ".tmp";
+  fs.writeFileSync(tmp, JSON.stringify(cur, null, 2));
+  fs.renameSync(tmp, LOCAL_LLM_CONFIG_FILE);
+  return cur;
+}
+
 // ── File-Project-Manifest ───────────────────────────────────────────
 // Jeder Eintrag map[absoluter_pfad] = project_id (leer = Hauptchat).
 // Wird vom files-list-Endpoint + files-set-project gepflegt.
@@ -1573,6 +1602,24 @@ const server = http.createServer((req, res) => {
       }
     });
     return;
+  } else if (req.url === "/api/local-llm-config" && req.method === "GET") {
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify(readLocalLlmConfig()));
+  } else if (req.url === "/api/local-llm-config" && req.method === "POST") {
+    let body = "";
+    req.on("data", chunk => { body += chunk; if (body.length > 8192) req.destroy(); });
+    req.on("end", () => {
+      try {
+        const cfg = writeLocalLlmConfig(JSON.parse(body));
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ ok: true, config: cfg }));
+        log("info", "server", `Local-LLM-Config: enabled=${cfg.enabled} localOnly=${cfg.localOnly} tools=${cfg.toolVariant}`);
+      } catch (err) {
+        res.writeHead(400, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ ok: false, error: err.message }));
+      }
+    });
+    return;
   } else if (req.url === "/api/onboarding") {
     // RVS-Credentials fuer QR-Code App-Onboarding
     res.writeHead(200, { "Content-Type": "application/json" });
@@ -1625,6 +1672,28 @@ const server = http.createServer((req, res) => {
       res.end(JSON.stringify({ ok: false, error: err.message }));
     }
     return;
+  } else if (req.url === "/api/models-list" && req.method === "GET") {
+    // Kuratierte Model-Liste vom Proxy (/v1/models) — Tier-Auswahl fuers
+    // Sprachmodell-Dropdown. ARIA laeuft ueber das Max-Abo/CLI, waehlbar ist
+    // der Tier (opus/sonnet/haiku), keine feste Version.
+    (async () => {
+      try {
+        const r = await fetch(`${PROXY_URL}/v1/models`);
+        const d = await r.json();
+        const models = (d.data || []).map(m => ({
+          id: m.id,
+          tier: m.tier || m.id,
+          displayName: m.display_name || m.id,
+          description: m.description || "",
+        }));
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ ok: true, models }));
+      } catch (err) {
+        res.writeHead(502, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ ok: false, error: String(err && err.message || err) }));
+      }
+    })();
+    return;
   } else if (req.url === "/api/files-list" && req.method === "GET") {
     // Liste alle Dateien in /shared/uploads/ — die kommen entweder vom User
     // (Upload aus App/Diagnostic) oder von ARIA (aria_<name>.<ext> Pattern).

docker-compose.yml

@@ -12,7 +12,7 @@ services:
       DIST=$$(find /usr/local/lib -path '*/claude-max-api-proxy/dist' -type d | head -1) &&
       sed -i 's/startServer({ port })/startServer({ port, host: process.env.HOST || \"127.0.0.1\" })/' $$DIST/server/standalone.js &&
       sed -i 's/\"--no-session-persistence\",/\"--no-session-persistence\",\"--dangerously-skip-permissions\",/' $$DIST/subprocess/manager.js &&
-      sed -i 's/\"--dangerously-skip-permissions\",/\"--dangerously-skip-permissions\",\"--append-system-prompt\",options.systemPrompt,/' $$DIST/subprocess/manager.js &&
+      sed -i 's/\"--dangerously-skip-permissions\",/\"--dangerously-skip-permissions\",\"--system-prompt\",options.systemPrompt,/' $$DIST/subprocess/manager.js &&
       sed -i 's/const DEFAULT_TIMEOUT = 300000;/const DEFAULT_TIMEOUT = 86400000;/' $$DIST/subprocess/manager.js &&
       sed -i '/prompt, \\/\\/ Pass prompt as argument/d' $$DIST/subprocess/manager.js &&
       sed -i 's|this\\.process\\.stdin?\\.end();|this.process.stdin?.end(prompt);|' $$DIST/subprocess/manager.js &&

docs/plan-local-llm-router.md

@@ -0,0 +1,263 @@
+# Plan B — Lokaler LLM-Router (Gamebox) neben Claude
+
+**Ziel:** „Gemini-Feeling" für den Alltag, ohne die Claude-Max-Subscription
+aufzugeben. Ein schnelles lokales LLM beantwortet die einfachen ~80 % der Turns
+in <1 s; nur die schweren 20 % (Tiefe, Code, Tools, Pentest, langer Kontext)
+gehen an Claude. Claude bleibt das Tiefen-Hirn.
+
+## Warum das der einzige realistische Weg zu „live" ist
+
+Gemessen (10.07.2026): CLI-Round-trip über den Claude-Max-Proxy hat einen
+**harten Boden von ~3,5 s** (Subprozess-Start pro Turn). Streaming-API würde das
+brechen, kostet aber API-Geld → verliert die Max-Subscription. Ein lokales
+LLM für die einfachen Turns umgeht den 3,5-s-Boden komplett und ist **gratis**
+(läuft auf vorhandener Gamebox-GPU). Echtes Speech-to-Speech-Duplex (Gemini
+Live nativ) ist mit einem Text-Modell als Hirn prinzipiell nicht drin.
+
+## Modell & Serving (entschieden)
+
+- **Modell:** Qwen3 8B, GGUF **Q4_K_M** (~6 GB). Bestes Tool-Calling der 7/8B-
+  Klasse, solides Deutsch, Apache-2.0. Alt.: Mistral Small 3 7B (schneller,
+  weniger Tool-Calling).
+- **Serving:** **llama.cpp `llama-server`** im Docker-Container auf der Gamebox
+  (kein Ollama nötig — nativer OpenAI-kompatibler `/v1/chat/completions`).
+- **VRAM-Budget:** 12-GB-Karte, Whisper-small (~1–2 GB) + F5-TTS (~1–2 GB) →
+  ~8–9 GB frei → passt. (FLUX ist auf 12 GB eh raus.)
+
+## Anbindung: über den RVS, wie TTS/STT (kein IP-Pflegen)
+
+Die Gamebox ist ein anderer Host als das Brain. Statt direktem HTTP (IP/Port/
+Firewall) läuft das LLM **über den RVS-Token-Room**, exakt wie Whisper/F5-TTS:
+
+- llama.cpp hört nur auf localhost der Gamebox.
+- Ein **dünner RVS-Adapter** daneben (Vorbild: whisper-/xtts-Bridge) verbindet
+  sich mit dem RVS-Token, lauscht auf `llm_request`, ruft lokal llama-server,
+  schickt `llm_response` (korreliert per requestId) zurück.
+- `rvs/server.js` `ALLOWED_TYPES` um `llm_request`, `llm_response` und (Phase 2)
+  `llm_partial` erweitern.
+- Das Brain bekommt einen zweiten „Proxy" — nur über RVS statt direktem HTTP.
+
+## Router-Logik im Brain
+
+Reihenfolge pro Turn (früh raus = schnell):
+
+- **Tier 0 — Fast-Path (existiert):** reine Steuerbefehle (Spotify, Licht) →
+  Skill direkt, **kein LLM**. <1 s.
+- **Tier 1 — Lokal (Qwen3):** einfache Konversation, kurze Fakten, Smalltalk,
+  Bestätigungen. Ziel <1 s.
+- **Tier 2 — Claude:** tief/technisch, Code, Tool-Use nötig, Pentest-Projekt,
+  langer/komplexer Kontext.
+
+**Routing-Signal (heuristisch zuerst, deterministisch & schnell):**
+Nachrichtenlänge, Schlüsselwörter, ob ein Tool nötig scheint, Projekt-Kontext
+(Pentest-Projekt → immer Claude), Konversationstiefe.
+
+**Escalation statt perfekter Vorab-Klassifikation:** Das lokale Modell bekommt
+die Anweisung, bei Unsicherheit oder Tool-Bedarf **NICHT zu raten**, sondern zu
+eskalieren (z.B. Antwort `<<ESCALATE>>`). Das Brain routet den Turn dann an
+Claude. So sind Fehlklassifikationen billig — lieber einmal lokal→Claude als
+eine falsche lokale Antwort.
+
+**Modus „Nur lokales LLM" (Diagnostic-Checkbox, Eval-Schalter):** Ein Flag
+`localLlmOnly` (in Diagnostic setzbar, vom Brain beim Routen gelesen). Ist es an:
+JEDER Turn geht ans lokale LLM, `<<ESCALATE>>` / „zu schwer" werden ignoriert
+(kein Claude-Fallback) — damit Stefan die echte Staerke/Schwaeche des lokalen
+Modells sieht, ohne dass Claude die schweren Turns rettet. Haken aus = normale
+Heuristik + Escalation. Ehrlicher Hinweis: im Nur-lokal-Modus funktionieren
+werkzeug-abhaengige Turns (Wetter, Timer, Memory, Bild) nicht — das lokale Tier
+hat keine Tools; das ist ein Gespraechs-Eval-Modus, kein Voll-ARIA. Fast-Path
+(Spotify etc.) laeuft davon unberuehrt weiter.
+
+## Persona auf BEIDEN Modellen
+
+Das lokale Modell braucht ARIAs Identität, sonst bricht es aus der Rolle
+(gelernt aus dem `--system-prompt`-Debakel). Aber **schlanker**:
+- IDENTITY_SEED + Kern-Persona: ja.
+- Volles Memory / ALLE Skill-Schemas: **nein** — nur eine **kuratierte, kleine
+  Tool-Auswahl** (siehe unten). Haelt den lokalen Prompt klein → schnell.
+- Persona kommt lokal auch als echter System-Prompt (llama.cpp `system`-Rolle).
+
+## Tool-Calling lokal (kuratierte Auswahl)
+
+Das lokale LLM DARF Werkzeuge nutzen (Qwen3 = natives OpenAI-Tool-Calling, von
+llama.cpp `--jinja` unterstuetzt). Ablauf wie bei Claude: Brain schickt
+messages + tools → Qwen antwortet mit `tool_calls` → Brain fuehrt via
+`_dispatch_tool` aus → Ergebnis zurueck → finale Antwort. Tool-Loop im Brain,
+Ziel = lokales LLM statt Claude-Proxy.
+
+**Awareness ≠ Authority.** Das lokale Modell soll WISSEN, was ARIA alles kann
+(damit es gezielt eskaliert statt zu halluzinieren), aber nicht alles ausfuehren.
+
+**Harte Grenze = Kontext/VRAM, nicht Misstrauen.** Das volle Tool-Schema sind
+~15-20 K Tokens. Qwens Kontext steht auf 8 K (`LLM_CTX=8192`) — es passt nicht
+rein. Hochdrehen auf 32 K kostet mehrere GB KV-Cache extra → OOM auf der
+geteilten 12-GB-3060 (Whisper + F5-TTS liegen mit drauf). Claude im RZ hat
+200 K-1 M Kontext und ist zuverlaessig → kann sich das ganze Arsenal leisten;
+das lokale 8B auf Heim-Hardware nicht. Andere Hardware-Klasse, anderes Budget.
+
+**Design (gibt „im Bilde" ohne VRAM zu sprengen):**
+- **Ausfuehrbar lokal:** kleiner, risikoarmer Start-Satz — Wetter, Uhrzeit,
+  `memory_search` (lesen), `trigger_timer`, Spotify-Steuerung, Licht/Smart-Home.
+- **Awareness-Liste (billig, ~paar hundert Tokens im System-Prompt):** kurze
+  Aufzaehlung des Rests — „ARIA kann ausserdem: Skills bauen, OAuth, Projekte,
+  Bilder, ins Gedaechtnis schreiben — dafuer `<<ESCALATE>>`." Kein volles Schema.
+- **Bleibt bei Claude (Authority):** `skill_create/update/delete`, `oauth_*`,
+  `project_*`, `flux_generate`, `memory_save`.
+
+Escalation-Netz bleibt: braucht ein Turn ein Tool, das lokal nicht ausfuehrbar
+ist → `<<ESCALATE>>` → Claude mit vollem Arsenal. Der „Nur lokales LLM"-Haken
+dient dazu, spaeter datengetrieben zu messen, ob der ausfuehrbare Satz erweitert
+werden kann.
+
+Implementierung (B1): Adapter reicht `tools` an llama.cpp + gibt `tool_calls`
+zurueck; Bridge schleust beides durch (llm_request/llm_response); Brain-Tool-Loop
+mit Ziel lokal.
+
+## Phasen
+
+- **B0 — Infra:** llama.cpp-Container + RVS-Adapter auf der Gamebox,
+  `ALLOWED_TYPES`, `local_llm_chat()` im Brain. Isoliert testen („sag hallo").
+- **B1 — Router + lokale Tools:** Heuristik Tier-1/2 + Escalation, schlanke
+  Persona lokal, **kuratierte Tool-Auswahl lokal** (Adapter/Bridge/Brain-Tool-
+  Loop, siehe oben) + „Nur lokales LLM"-Checkbox. Einfache Turns → lokal.
+  Messen: Trefferquote, Tool-Zuverlaessigkeit & Latenz.
+- **B2 — Streaming/Voice:** `llm_partial` → TTS beginnt beim ersten Satz →
+  der „live"-Sprung. **Hier den Gong-/Ohr-Re-Arm-Bug mit-fixen** (Barge-In,
+  sauberes Re-Listen).
+- **B3 (optional):** lokalen Tool-Satz erweitern, sobald Qwen sich als
+  zuverlaessig erweist (z.B. `memory_save`).
+
+## Offene Entscheidungen (für Stefan)
+
+1. **Modell:** Qwen3 8B (Tool-Calling) — oder doch Mistral Small 3 7B (Speed)?
+2. **Routing v1:** rein heuristisch + Escalation (entschieden).
+3. **Tools lokal:** kuratierte kleine Auswahl (entschieden — Start-Satz oben;
+   Stefan bestaetigt/justiert die konkrete Liste vor dem B1-Bau).
+
+## Folge-Baustein: Modell-Auswahl in ARIA Diagnostic (B0.5)
+
+Ziel: In Diagnostic ein Modell auswählen; ist es nicht da, lädt der Container
+es on-demand und aktiviert es. Spiegelt zwei bestehende Muster: den
+`whisperModel`-Hotswap (RVS-Config-Broadcast → Bridge hot-swapped) und die
+kuratierte Claude-Tier-Liste aus `models.json`.
+
+**Kernproblem:** `llama.cpp`-Server serviert **ein** Modell pro Prozess —
+„anderes aktivieren" = neu laden/swappen.
+
+**Lösung: `llama-swap`** (Proxy vor llama.cpp): kennt eine Liste von Modellen,
+lädt bei Anfrage das gewünschte on-demand (Download via `-hf` beim ersten Mal),
+swappt bei VRAM-Knappheit das alte raus. OpenAI-kompatibel — der llm-adapter
+zeigt statt auf `llama:8081` auf `llama-swap`.
+
+**Bausteine:**
+- `llama-swap`-Service in `xtts/docker-compose.yml` (ersetzt/ergänzt `llama`),
+  Config mit den verfügbaren Modellen (Name → `-hf`-Command).
+- Kuratierte Liste `local_models.json` (analog `models.json`) — Diagnostic-UI
+  liest sie, zeigt Dropdown „Lokales Modell".
+- Diagnostic → RVS-Config-Broadcast `localLlmModel` → llm-adapter setzt das
+  `model`-Feld seiner llama-swap-Requests → swap/Download passiert automatisch.
+- Status zurück an Diagnostic (lädt / bereit / VRAM-OOM), analog whisper-Status.
+
+**Konkret gewünschte UI (Stefan):**
+- Modell-Status sichtbar: **lädt (mit Fortschrittsbalken) → heruntergeladen →
+  aktiviert**. Ist ein Modell schon im Cache: **nicht neu laden, nur
+  aktivieren** (llama.cpp/llama-swap macht das nativ ueber den Cache).
+- **Testchat-Zeile** in Diagnostic: kurze Nachricht direkt ans lokale LLM
+  schicken, Antwort + Latenz anzeigen. Nutzt denselben RVS-Pfad
+  (`llm_request`/`llm_response`) wie der Self-Test — kein neuer Kanal noetig.
+
+Bis dahin: **ein** Modell via `-hf` Auto-Download (B0, erledigt). Erst end-to-end
+grün, dann dieser Komfort-Layer.
+
+## Skalierung: VRAM, Multi-GPU, „Cluster"
+
+**Wichtige Klarstellung:** Roher VRAM/GPU ist NICHT ueber RVS teilbar. RVS ist ein
+Nachrichten-Relay; GPUs werden lokal per CUDA/PCIe angesprochen. Ueber RVS teilt
+man **Inferenz-Faehigkeit** (transkribiere/vervollstaendige), nicht VRAM. Es gibt
+daher keinen „GPU-Broker-Container", der Karten uebers Netz verleiht.
+
+Skalierungspfade (echt):
+- **Mehr Karten in EINER Box → VRAM-Pool.** llama.cpp/vLLM splitten ein Modell
+  ueber mehrere GPUs (`--tensor-split`). 2×3060 = 24 GB → groesseres Modell ODER
+  Qwen8B mit grossem Kontext → **volles Tool-Schema passt rein**. Das ist der
+  Weg zum „vollen Arsenal lokal".
+- **Ein Modell ueber mehrere HOSTS splitten** (llama.cpp `--rpc`): moeglich, aber
+  langsam (Layer-Grenzen ueber's Netz) — nur schnelles LAN, fuer „schnell"
+  ungeeignet. Nicht empfohlen.
+- **Mehrere eigenstaendige Modell-Server, je einer pro GPU/Host, Router waehlt:**
+  einfach, = unser RVS-Muster. Zweiter GPU-Host = noch ein llm-adapter, meldet
+  sich am RVS an, Router load-balanced. Das ist der sinnvolle „Cluster".
+- **Innerhalb eines Hosts:** ein geteilter Inferenz-Server (`llama-swap`/vLLM)
+  statt VRAM-Duplikat pro Container — kommt mit B0.5.
+
+**Diagnostic ⓘ (Feature):** Checkbox „volleres Arsenal" + Info-Icon mit
+VRAM-Bedarf: 12 GB (1×3060) = kuratierte Tools; 24 GB (2×3060, eine Box) = Qwen
+mit grossem Kontext/volles Schema oder groesseres Modell; Cluster = weitere
+GPU-Hosts als Modell-Server ueber RVS. (B0.5/B1-UI.)
+
+### „Waechter" / Orchestrator (Ausbaustufe, gestaffelt)
+
+Idee: ein Dienst, der auf den am RVS angemeldeten Hosts Container startet/stoppt.
+Zerfaellt in zwei Teile:
+- **Billig & bald nuetzlich — Registrierung + Heartbeat:** jeder GPU-Host meldet
+  dem RVS „lebe, GPUs, VRAM frei, laufende Dienste" (kleine Erweiterung der
+  Adapter; whisper broadcastet schon Status). Nutzen: Diagnostic zeigt die
+  Flotte (Live-Daten fuers ⓘ), Router weiss ob lokal erreichbar (sonst Claude).
+- **Teuer & aufschiebbar — Steuerung (Container start/stop):** Agent pro Host
+  (Docker-Socket) + Controller mit Placement-Policy + Reconciliation +
+  Broadcast-Kollisions-Vermeidung (nicht 2× dieselbe Faehigkeit). = Mini-Nomad.
+
+**Empfehlung:** Fuer 2 Gameboxen NICHT bauen — statische Platzierung reicht
+(Gamebox1=LLM, Gamebox2=Voice). Dynamisches Laden/Entladen zum VRAM-Freimachen
+deckt `llama-swap` innerhalb eines Hosts (B0.5). Waechst die Flotte: erst den
+billigen Heartbeat-Teil; fuer echte Orchestrierung Docker Swarm / Nomad nehmen
+statt selbst einen Scheduler zu bauen.
+
+### ENTSCHIEDEN: manuelle Platzierung + read-only GPU-Dashboard (kein Auto)
+
+Statt Auto-Controller (Semi-Auto verworfen — Host wechselt selten, Komplexitaet
+lohnt nicht):
+- **Pin = Docker Compose Profiles.** Services kriegen `profiles: [...]`, jeder
+  Host setzt `COMPOSE_PROFILES=<seins>` in der `.env`; `docker compose up`
+  startet nur die eigenen. „In Config gepinnt", nativ, kein Code.
+- **Verschiebe-Regel:** `up` auf neuem Host + `docker compose rm -sf <svc>` auf
+  altem (sonst holt `restart: unless-stopped` den Dienst beim Reboot zurueck →
+  Broadcast-Kollision; Profile gelten nur beim `up`, nicht beim Daemon-Restart).
+- **GPU-Dashboard in Diagnostic (read-only):** jeder GPU-Host sendet periodisch
+  einen Heartbeat via RVS (Host, GPU-Util, VRAM frei/belegt, laufende
+  GPU-Container). Diagnostic zeigt pro Host VRAM-Balken + Dienste + „Host X hat
+  N GB frei". Kein Start/Stop, nur Sicht + Hinweis wohin verschiebbar.
+- **Zukunft (Gamebox3, 4×3060 = 48 GB):** neuer Host, eigenes Profil, `up` →
+  erscheint im Dashboard; grosses lokales LLM oder FLUX-Vollausbau dorthin.
+  Ohne Orchestrator.
+
+### Verschieben-Button (Semi-Auto) — reboot-sicher via Platzierungs-Config
+
+Wenn ein „Verschieben"-Button in Diagnostic gewuenscht ist (Dropdown Ziel-Host +
+Button = hier stoppen, dort starten), braucht das remote Container-Steuerung →
+**kleiner Agent pro GPU-Host** (Docker-Zugriff, hoert RVS-Befehle). Das ist der
+zuvor „teure" Teil, aber in der DUMMEN Variante:
+
+- **Eine Platzierungs-Config ist Single Source of Truth:**
+  `/shared/config/gpu_placement.json` = `{service: host}`.
+- **Dummer Reconcile-Agent pro Host:** bei Start UND Config-Aenderung — starte
+  die mir zugewiesenen Dienste, stoppe die anderen. Keine Policy, kein
+  VRAM-Placement. Mensch = Scheduler (Button), Agent = befolgt nur Config.
+- **Button aendert nur die Config** → Agenten reconcilen (alt stoppt, neu
+  startet). **Reboot liest Config** → kein Divergieren, keine Kollision.
+- **Reboot-Falle vermieden:** NIE Laufzeit-Move ohne Config-Update (sonst holt
+  `restart: unless-stopped` den Dienst beim Reboot zurueck). Config = Wahrheit.
+
+Deploy-Story: Code liegt via git auf allen Hosts (`pull`+`build`), aber `up -d`
+startet nichts GPU-maessig von selbst — die Platzierungs-Config (bzw.
+`COMPOSE_PROFILES`) entscheidet, was wo laeuft. Neuer Host = zuweisen, Agent
+startet.
+
+**Reihenfolge:** NACH B0/B1. Fallback ohne Button: reine `COMPOSE_PROFILES` pro
+Host + Verschieben von Hand (null neue Infra).
+
+## Nicht-Ziele
+
+- Kein echter Gemini-Live-Duplex-Klon (Text-Modell als Hirn).
+- FLUX bleibt optional/später (dickere GPU). Bild-Generierung separat als
+  pluggbarer Provider (ChatGPT/DALL·E-Alternative) — eigenes Feature, nicht Teil B.

proxy-patches/openai-to-cli.js

@@ -153,9 +153,12 @@ export function messagesToPrompt(messages, tools) {
 /**
  * Extrahiert NUR den System-Anteil (System-Messages + Tool-Use-Block) als
  * rohen Text — OHNE <system>-Tags. Fuer den ECHTEN System-Prompt-Kanal der
- * Claude-CLI (--append-system-prompt), damit die ARIA-Persona nicht als
- * <system>-getaggter User-Content ankommt (den das Modell als Injection wertet),
- * sondern als genuine System-Instruktion.
+ * Claude-CLI (--system-prompt, VOLLER Replace — nicht --append). Damit ist
+ * die ARIA-Persona DIE Identitaet des Modells und nicht ein Anhaengsel hinter
+ * Claude Codes eigener "You are Claude Code"-Identitaet (die bei duennem
+ * Kontext sonst gewinnt und die Persona als Injection abwehrt). Der Output
+ * muss deshalb SELBSTTRAGEND sein — er ersetzt Claude Codes System-Prompt
+ * komplett inkl. dynamischer Sektionen (cwd, git, platform).
  * Reihenfolge: erst der Tool-Use-Block (Format-Anweisung), dann die
  * System-Messages in Original-Reihenfolge.
  */
@@ -217,12 +220,15 @@ export function conversationToPrompt(messages) {
 
 export function openaiToCli(request) {
     // Persona/System + Tool-Block gehen ueber den ECHTEN System-Prompt-Kanal
-    // (--append-system-prompt, siehe manager.js buildArgs-Patch). Der Prompt
-    // enthaelt nur noch den Gespraechsverlauf — so kann das Modell die
-    // ARIA-Vorgaben nicht mehr als <system>-getaggten User-Content und damit als
-    // Prompt-Injection fehldeuten.
+    // (--system-prompt = VOLLER Replace, siehe manager.js buildArgs-Patch in
+    // docker-compose.yml). Der Prompt enthaelt nur noch den Gespraechsverlauf.
+    // Voller Replace statt --append, weil Anhaengen Claude Codes eingebaute
+    // "You are Claude Code"-Identitaet stehen laesst — die bei duennem Kontext
+    // (Hauptchat) gewinnt und die ARIA-Persona als Injection abwehrt.
     // systemPrompt ist immer ein String (extractSystemPrompt liefert "" statt
-    // undefined) → --append-system-prompt "" ist harmlos, kein spawn-Crash.
+    // undefined). ACHTUNG: bei --system-prompt darf er NIE leer sein, sonst
+    // laeuft das Modell ganz ohne System-Prompt — der Brain schickt aber immer
+    // eine System-Message + Tool-Block, also ist er real nie leer.
     return {
         prompt: conversationToPrompt(request.messages),
         systemPrompt: extractSystemPrompt(request.messages, request.tools),

proxy-patches/routes.js

@@ -19,6 +19,7 @@
  */
 import { v4 as uuidv4 } from "uuid";
 import http from "http";
+import fs from "fs";
 import { ClaudeSubprocess } from "../subprocess/manager.js";
 import { openaiToCli } from "../adapter/openai-to-cli.js";
 import { cliResultToOpenai, createDoneChunk, } from "../adapter/cli-to-openai.js";
@@ -362,8 +363,8 @@ async function handleStreamingResponse(req, res, subprocess, cliInput, requestId
             model: cliInput.model,
             sessionId: cliInput.sessionId,
             // ARIA: echter System-Prompt-Kanal — manager.js reicht das (sobald
-            // gepatcht) als --append-system-prompt an die CLI. Aktuell ignoriert
-            // ein ungepatchter manager diese Extra-Option gefahrlos.
+            // gepatcht) als --system-prompt (VOLLER Replace) an die CLI. Aktuell
+            // ignoriert ein ungepatchter manager diese Extra-Option gefahrlos.
             systemPrompt: cliInput.systemPrompt,
         }).catch((err) => {
             console.error("[Streaming] Subprocess start error:", err);
@@ -452,29 +453,64 @@ async function handleNonStreamingResponse(res, subprocess, cliInput, requestId)
  *
  * Returns available models
  */
+// Kuratierte Tier-Liste. ARIA laeuft ueber das Claude-Max-Abo via CLI —
+// waehlbar ist der TIER (opus/sonnet/haiku), nicht eine feste Modellversion;
+// die CLI loest den Alias aufs aktuelle Modell des Tiers auf. Die id-Strings
+// muessen von openai-to-cli.js extractModel() erkannt werden (MODEL_MAP).
+//
+// Quelle: /shared/config/models.json — damit neue Tier-Namen oder angepasste
+// Beschreibungen eine reine DATEI-Aenderung sind (kein Code-Edit, kein Neubau,
+// kein Neustart: handleModels liest pro Request neu; einfach die Datei
+// bearbeiten und im Diagnostic „Aktualisieren" druecken). Fehlt/kaputt die
+// Datei, greifen die eingebauten Defaults; die Datei wird dann einmalig mit
+// diesen Defaults angelegt, damit es was zu editieren gibt.
+const MODELS_FILE = process.env.ARIA_MODELS_FILE || "/shared/config/models.json";
+const DEFAULT_MODELS = [
+    { id: "claude-sonnet-4", tier: "sonnet", display_name: "Sonnet (aktuell: Sonnet 5)",
+      description: "Schnell & gut — Standard fuer den Alltag." },
+    { id: "claude-opus-4", tier: "opus", display_name: "Opus (aktuell: Opus 4.8)",
+      description: "Langsamer, aber am schlausten — fuer schwere/lange Aufgaben." },
+    { id: "claude-haiku-4", tier: "haiku", display_name: "Haiku (aktuell: Haiku 4.5)",
+      description: "Sehr schnell & guenstig, kleinerer Kontext — fuer einfache Tasks." },
+];
+
+function _loadModels() {
+    try {
+        const raw = fs.readFileSync(MODELS_FILE, "utf-8");
+        const arr = JSON.parse(raw);
+        if (Array.isArray(arr) && arr.length && arr.every(m => m && typeof m.id === "string")) {
+            return arr;
+        }
+        console.error("[aria-models] models.json ungueltig — nutze Defaults");
+    } catch (_) {
+        // Datei fehlt (oder unlesbar) → Defaults + einmalig seeden zum Editieren
+        try {
+            fs.mkdirSync("/shared/config", { recursive: true });
+            if (!fs.existsSync(MODELS_FILE)) {
+                fs.writeFileSync(MODELS_FILE, JSON.stringify(DEFAULT_MODELS, null, 2));
+                console.error("[aria-models] models.json mit Defaults angelegt:", MODELS_FILE);
+            }
+        } catch (e) {
+            console.error("[aria-models] Seeden fehlgeschlagen:", e && e.message);
+        }
+    }
+    return DEFAULT_MODELS;
+}
+
 export function handleModels(_req, res) {
+    const created = Math.floor(Date.now() / 1000);
+    const models = _loadModels();
     res.json({
         object: "list",
-        data: [
-            {
-                id: "claude-opus-4",
-                object: "model",
-                owned_by: "anthropic",
-                created: Math.floor(Date.now() / 1000),
-            },
-            {
-                id: "claude-sonnet-4",
-                object: "model",
-                owned_by: "anthropic",
-                created: Math.floor(Date.now() / 1000),
-            },
-            {
-                id: "claude-haiku-4",
-                object: "model",
-                owned_by: "anthropic",
-                created: Math.floor(Date.now() / 1000),
-            },
-        ],
+        data: models.map(m => ({
+            id: m.id,
+            object: "model",
+            owned_by: "anthropic",
+            created,
+            tier: m.tier || m.id,
+            display_name: m.display_name || m.id,
+            description: m.description || "",
+        })),
     });
 }
 /**

rvs/server.js

@@ -62,6 +62,10 @@ const ALLOWED_TYPES = new Set([
   "flux_request", "flux_response",
   "agent_stream",
   "oauth_callback",
+  // Lokales LLM (Plan B) — Router im Brain schickt einfache Turns an das
+  // Qwen3 auf der Gamebox (via Bridge → RVS → llm-adapter → llama.cpp).
+  // llm_partial ist fuer B2 (Token-Streaming) reserviert, noch ungenutzt.
+  "llm_request", "llm_response", "llm_partial",
 ]);
 
 // Token-Raum: token -> { clients: Set<ws> }

xtts/docker-compose.yml

@@ -89,3 +89,55 @@ services:
                                                  # Stimm-Embedding) persistent zwischen
                                                  # 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.
+  #
+  # 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
+    deploy:
+      resources:
+        reservations:
+          devices:
+            - driver: nvidia
+              count: 1
+              capabilities: [gpu]
+    volumes:
+      - ./models:/models                         # HF-Download-Cache (persistent)
+    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
+    restart: unless-stopped
+
+  # ─── Local-LLM-Adapter — RVS <-> llama.cpp (Plan B, B0) ──────
+  # Verbindet sich per Token an den RVS (wie f5tts/whisper), nimmt
+  # llm_request entgegen, ruft llama.cpp lokal, antwortet llm_response.
+  llm-adapter:
+    build: ./llm-adapter
+    container_name: aria-llm-adapter
+    depends_on:
+      - llama
+    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
+      - LLM_MODEL=${LLM_MODEL:-qwen3-8b}
+      - LLM_TIMEOUT_SEC=${LLM_TIMEOUT_SEC:-60}
+    restart: unless-stopped

xtts/llm-adapter/Dockerfile

@@ -0,0 +1,8 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+COPY adapter.py .
+
+CMD ["python", "-u", "adapter.py"]

xtts/llm-adapter/README.md

@@ -0,0 +1,66 @@
+# Local-LLM-Adapter (Gamebox) — Plan B, Phase B0
+
+Bringt ein lokales, schnelles LLM (Qwen3 8B) auf die Gamebox und haengt es
+per RVS an ARIA — fuer die einfachen ~80 % der Turns (<1 s), waehrend Claude
+das Tiefen-Hirn bleibt. Siehe `docs/plan-local-llm-router.md` im Repo-Root.
+
+## Zwei Container (in `xtts/docker-compose.yml`)
+
+- **`llama`** — `llama.cpp`-Server (CUDA), serviert das GGUF OpenAI-kompatibel
+  auf `:8081`, nur im Compose-Netz.
+- **`llm-adapter`** — verbindet sich per Token an den RVS (wie f5tts/whisper),
+  nimmt `llm_request` entgegen, ruft `llama` lokal, antwortet `llm_response`.
+
+## Modell — Auto-Download (nichts manuell ablegen)
+
+`llama.cpp` zieht das GGUF beim **ersten Start selbst von Hugging Face** und
+cached es unter `xtts/models/` (Bind-Mount → kein Re-Download bei Restart).
+Default: **Qwen3 8B, Q4_K_M** aus dem offiziellen Repo `Qwen/Qwen3-8B-GGUF`.
+
+Modell/Quant wechseln = in der `.env` der Gamebox setzen (kein Code):
+
+```
+LLM_HF_REPO=Qwen/Qwen3-8B-GGUF     # HF-Repo
+LLM_HF_QUANT=Q4_K_M                # Quant-Tag (Q4_K_M, Q5_K_M, Q8_0, …)
+LLM_CTX=8192                       # Kontextfenster (kleiner = weniger VRAM)
+```
+
+Mistral statt Qwen testen (A/B): `LLM_HF_REPO` auf ein Mistral-Small-3-GGUF-Repo
+umstellen + Container neu — Ein-Zeilen-Wechsel, kein Code.
+
+> Der erste Start lädt mehrere GB — Log zeigt den Download-Fortschritt.
+> Danach liegt das GGUF im Cache und der Start ist sofort.
+
+**Modell-Auswahl in ARIA Diagnostic** (on-demand laden/aktivieren mehrerer
+Modelle) ist ein geplanter Folge-Baustein via `llama-swap` — siehe
+`docs/plan-local-llm-router.md`.
+
+## Start (auf der Gamebox)
+
+```bash
+cd xtts
+docker compose up -d --build llama llm-adapter
+docker logs -f aria-llm-adapter     # "RVS verbunden — llm-adapter online"
+```
+
+## Standalone-Test (ohne ARIA), direkt gegen llama.cpp
+
+```bash
+curl http://localhost:8081/v1/chat/completions -H "Content-Type: application/json" -d '{
+  "messages":[{"role":"system","content":"Du bist ARIA."},
+              {"role":"user","content":"sag kurz hallo"}],
+  "max_tokens":64
+}'
+```
+
+## VRAM-Hinweis (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` reduzieren, `-ngl` senken (weniger Layer auf GPU),
+oder kleineres Quant (Q4_K_S / IQ4_XS).
+
+## Nachrichten-Kontrakt (RVS)
+
+- `llm_request`  → `{ requestId, messages:[{role,content}], max_tokens?, temperature?, stop? }`
+- `llm_response` ← `{ requestId, ok, content, error?, model, elapsedMs }`
+- `llm_partial`  — reserviert fuer B2 (Token-Streaming), noch ungenutzt.

xtts/llm-adapter/adapter.py

@@ -0,0 +1,176 @@
+"""
+ARIA Local-LLM-Adapter (Gamebox) — Plan B, Phase B0.
+
+Bruecke zwischen RVS und dem lokalen llama.cpp-Server. Spiegelt das Muster der
+whisper-bridge: verbindet sich per WebSocket mit dem RVS (Token-Room, TLS mit
+ws-Fallback, Reconnect-Backoff), lauscht auf `llm_request` und ruft den lokalen
+llama.cpp-`/v1/chat/completions`-Endpoint (OpenAI-kompatibel), antwortet mit
+`llm_response` (korreliert per requestId).
+
+Topologie: Gamebox steht zuhause, ARIA im RZ — die Kommunikation laeuft ueber
+den RVS (wie TTS/STT), keine IPs zu pflegen. Nur URL + Token.
+
+Env:
+  RVS_HOST, RVS_PORT, RVS_TLS, RVS_TLS_FALLBACK, RVS_TOKEN  (wie f5tts/whisper)
+  LLAMA_URL         Default http://llama:8081  (llama.cpp im selben Compose-Netz)
+  LLM_MODEL         optionaler Modell-Name fuer llama (llama.cpp ignoriert ihn
+                    meist, dient nur der Transparenz im Log)
+  LLM_TIMEOUT_SEC   Default 60
+
+Bewusst NICHT-streamend in B0 (volle llm_response). Token-Streaming (llm_partial)
+kommt in B2 zusammen mit TTS-on-first-sentence.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+import os
+import time
+
+import httpx
+import websockets
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
+)
+logger = logging.getLogger("llm-adapter")
+
+RVS_HOST = os.getenv("RVS_HOST", "").strip()
+RVS_PORT = os.getenv("RVS_PORT", "443").strip()
+RVS_TLS = os.getenv("RVS_TLS", "true").lower() == "true"
+RVS_TLS_FALLBACK = os.getenv("RVS_TLS_FALLBACK", "true").lower() == "true"
+RVS_TOKEN = os.getenv("RVS_TOKEN", "").strip()
+
+LLAMA_URL = os.getenv("LLAMA_URL", "http://llama:8081").rstrip("/")
+LLM_MODEL = os.getenv("LLM_MODEL", "qwen3-8b")
+LLM_TIMEOUT_SEC = float(os.getenv("LLM_TIMEOUT_SEC", "60"))
+# Qwen3 hat Thinking-Mode default AN — dann verbraet es Tokens in einem
+# <think>-Block und liefert (bei kleinem max_tokens) leeren/abgeschnittenen
+# content, ausserdem 3x langsamer. ARIAs schnelles Tier will KEIN Grübeln
+# (grübeln = harter Turn = Claude). Wir schalten Thinking daher per
+# chat_template_kwargs ab (Qwen3-Template versteht enable_thinking=false;
+# andere Templates ignorieren das kwarg). Bei einem Modell, das darauf
+# empfindlich reagiert: LLM_DISABLE_THINKING=false setzen.
+LLM_DISABLE_THINKING = os.getenv("LLM_DISABLE_THINKING", "true").lower() == "true"
+
+
+async def _send(ws, mtype: str, payload: dict) -> None:
+    try:
+        await ws.send(json.dumps({
+            "type": mtype,
+            "payload": payload,
+            "timestamp": int(time.time() * 1000),
+        }))
+    except Exception as e:
+        logger.warning("Send fehlgeschlagen (%s): %s", mtype, e)
+
+
+async def _call_llama(messages: list, *, max_tokens: int, temperature: float,
+                      stop) -> dict:
+    """Ruft llama.cpp /v1/chat/completions (OpenAI-Format). Gibt
+    {ok, content, error} zurueck — wirft nie."""
+    body = {
+        "model": LLM_MODEL,
+        "messages": messages,
+        "max_tokens": max_tokens,
+        "temperature": temperature,
+        "stream": False,
+    }
+    if stop:
+        body["stop"] = stop
+    if LLM_DISABLE_THINKING:
+        # llama.cpp (--jinja) reicht chat_template_kwargs an die Chat-Vorlage
+        # weiter. Qwen3 unterdrueckt damit den <think>-Block.
+        body["chat_template_kwargs"] = {"enable_thinking": False}
+    try:
+        async with httpx.AsyncClient(timeout=LLM_TIMEOUT_SEC) as client:
+            r = await client.post(f"{LLAMA_URL}/v1/chat/completions", json=body)
+            r.raise_for_status()
+            data = r.json()
+        content = (data.get("choices") or [{}])[0].get("message", {}).get("content", "")
+        return {"ok": True, "content": content or "", "usage": data.get("usage")}
+    except Exception as e:
+        logger.warning("llama.cpp-Call fehlgeschlagen: %s", e)
+        return {"ok": False, "content": "", "error": str(e)[:300]}
+
+
+async def _handle_llm_request(ws, payload: dict) -> None:
+    req_id = payload.get("requestId", "")
+    messages = payload.get("messages") or []
+    if not isinstance(messages, list) or not messages:
+        await _send(ws, "llm_response", {
+            "requestId": req_id, "ok": False, "error": "leere/ungueltige messages",
+        })
+        return
+    max_tokens = int(payload.get("max_tokens", 512) or 512)
+    temperature = float(payload.get("temperature", 0.7) or 0.7)
+    stop = payload.get("stop")
+    t0 = time.time()
+    res = await _call_llama(messages, max_tokens=max_tokens,
+                            temperature=temperature, stop=stop)
+    dt = time.time() - t0
+    logger.info("llm_request id=%s -> ok=%s %.2fs content_len=%d",
+                (req_id[:8] if req_id else "?"), res.get("ok"), dt,
+                len(res.get("content") or ""))
+    await _send(ws, "llm_response", {
+        "requestId": req_id,
+        "ok": res.get("ok", False),
+        "content": res.get("content", ""),
+        "error": res.get("error"),
+        "model": LLM_MODEL,
+        "elapsedMs": int(dt * 1000),
+    })
+
+
+async def _run() -> None:
+    if not RVS_HOST:
+        logger.error("RVS_HOST nicht gesetzt — Abbruch")
+        return
+    if not RVS_TOKEN:
+        logger.error("RVS_TOKEN nicht gesetzt — Abbruch")
+        return
+
+    use_tls = RVS_TLS
+    retry_s = 2
+    tls_fallback_tried = False
+
+    while True:
+        scheme = "wss" if use_tls else "ws"
+        url = f"{scheme}://{RVS_HOST}:{RVS_PORT}/ws?token={RVS_TOKEN}"
+        masked = url.replace(RVS_TOKEN, "***") if RVS_TOKEN else url
+        try:
+            logger.info("Verbinde zu RVS: %s (llama=%s)", masked, LLAMA_URL)
+            async with websockets.connect(
+                url, ping_interval=20, ping_timeout=10, max_size=16 * 1024 * 1024
+            ) as ws:
+                logger.info("RVS verbunden — llm-adapter online")
+                retry_s = 2
+                tls_fallback_tried = False
+                async for raw in ws:
+                    try:
+                        msg = json.loads(raw)
+                    except Exception:
+                        continue
+                    if msg.get("type") != "llm_request":
+                        continue
+                    payload = msg.get("payload", {}) or {}
+                    # Jede Anfrage nebenlaeufig — llama.cpp serialisiert intern,
+                    # aber wir blockieren so nicht den Empfang weiterer Messages.
+                    asyncio.create_task(_handle_llm_request(ws, payload))
+        except Exception as e:
+            logger.warning("RVS-Verbindung verloren/fehlgeschlagen: %s", e)
+            if use_tls and RVS_TLS_FALLBACK and not tls_fallback_tried:
+                tls_fallback_tried = True
+                use_tls = False
+                logger.info("TLS fehlgeschlagen — Fallback auf ws://")
+                continue
+            await asyncio.sleep(min(retry_s, 30))
+            retry_s = min(retry_s * 2, 30)
+            use_tls = RVS_TLS
+
+
+if __name__ == "__main__":
+    asyncio.run(_run())

xtts/llm-adapter/requirements.txt

@@ -0,0 +1,2 @@
+websockets>=12.0
+httpx>=0.27.0