release: bump version to 0.0.3.1

The chat handler checked sender but never forwarded the text to aria-core.
Only voice messages worked because they went through the audio→STT→send_to_core path.

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

.env.example

@@ -1,20 +1,50 @@
-# ARIA Environment Configuration
+# ════════════════════════════════════════════════
-# Copy to .env and fill in values
+#  ARIA — Umgebungsvariablen
+#  Kopieren nach .env und Werte eintragen
+# ════════════════════════════════════════════════
 
-# Auth token for ARIA Core (generate a long random string)
+# ── ARIA Auth Token ──────────────────────────────
-# openssl rand -hex 32
+# Authentifizierung fuer den OpenClaw Gateway (aria-core).
+# Wird von Diagnostic, Bridge und App genutzt um sich am Gateway anzumelden.
+# Alle Services die mit aria-core kommunizieren brauchen diesen Token.
+# Generieren: openssl rand -hex 32
 ARIA_AUTH_TOKEN=change-me-to-a-long-random-string
 
-# RVS — Rendezvous-Server (Bridge + App verbinden sich hierüber)
+# ── RVS — Rendezvous-Server ─────────────────────
+# Der RVS ist ein WebSocket-Relay im Rechenzentrum.
+# App, Bridge, Diagnostic und XTTS-Bridge verbinden sich hierueber.
+# Alle muessen den gleichen Host, Port und Token nutzen.
+
+# Hostname des RVS-Servers (z.B. rvs.example.de oder mobil.hacker-net.de)
 RVS_HOST=rvs.example.de
+
+# Port auf dem der RVS laeuft (muss mit rvs/docker-compose.yml uebereinstimmen)
 RVS_PORT=443
+
+# TLS (wss://) verwenden? true = verschluesselt, false = unverschluesselt (ws://)
 RVS_TLS=true
+
 # Bei TLS-Fehler automatisch auf ws:// (ohne TLS) fallback?
-# true = Fallback erlaubt, false = nur mit TLS verbinden
+# Nuetzlich wenn kein TLS-Zertifikat vorhanden (z.B. Entwicklung)
 RVS_TLS_FALLBACK=true
+
+# Pairing-Token: Wer den gleichen Token hat, landet im gleichen RVS-Room.
+# Wird von generate-token.sh automatisch generiert und hier eingetragen.
+# Die Android App bekommt den Token per QR-Code beim Pairing.
+# WICHTIG: Muss auf ARIA-VM, Gaming-PC (xtts/.env) und App identisch sein!
+# Generieren: ./generate-token.sh (traegt den Token automatisch ein)
 RVS_TOKEN=
 
-# Gitea (for release.sh — Kennwort wird interaktiv abgefragt)
+# ── Gitea — Release-Verwaltung ───────────────────
+# Wird von release.sh genutzt um APKs auf Gitea zu veroeffentlichen.
+# Kennwort wird beim Release interaktiv abgefragt (nicht in .env!).
 GITEA_URL=https://git.hacker-net.de
 GITEA_REPO=Hacker-Software/ARIA-AGENT
 GITEA_USER=duffyduck
+
+# ── Auto-Update — APK auf RVS-Server kopieren ───
+# SSH-Ziel fuer scp: release.sh kopiert die APK dorthin.
+# Der RVS-Server stellt sie dann per WebSocket an die App bereit.
+# Format: user@host (z.B. root@aria-rvs oder root@rvs.example.de)
+# Leer lassen = Auto-Update ueberspringen, APK manuell auf RVS kopieren.
+RVS_UPDATE_HOST=

README.md

@@ -103,16 +103,31 @@ cd ~/ARIA-AGENT
 cp .env.example .env
 ```
 
-`.env` Datei editieren:
+`.env` Datei editieren (Details siehe `.env.example`):
 ```bash
+# Gateway-Auth: Alle Services die mit aria-core reden brauchen diesen Token
+# Diagnostic, Bridge, App nutzen ihn fuer den WebSocket-Handshake
 ARIA_AUTH_TOKEN=        # openssl rand -hex 32
+
+# RVS-Verbindung: Hostname + Port deines Rendezvous-Servers
 RVS_HOST=               # z.B. rvs.hackersoft.de
 RVS_PORT=443
 RVS_TLS=true
 RVS_TLS_FALLBACK=true
-RVS_TOKEN=              # wird von generate-token.sh automatisch gesetzt
+
+# Pairing-Token: Verbindet App, Bridge, Diagnostic und XTTS im gleichen RVS-Room
+# MUSS auf allen Geraeten identisch sein (ARIA-VM, Gaming-PC, App)
+# Wird von generate-token.sh automatisch generiert und eingetragen
+RVS_TOKEN=              # ./generate-token.sh
+
+# Optional: SSH-Host des RVS-Servers fuer Auto-Update (z.B. root@aria-rvs)
+RVS_UPDATE_HOST=
 ```
 
+**Zwei Tokens, zwei Zwecke:**
+- **ARIA_AUTH_TOKEN**: Authentifizierung am OpenClaw Gateway (aria-core). Wer diesen Token hat, kann ARIA Befehle geben.
+- **RVS_TOKEN**: Pairing-Token fuer den Rendezvous-Server. Alle Geraete mit dem gleichen Token landen im gleichen "Room" und koennen kommunizieren. Die App bekommt diesen Token per QR-Code.
+
 ### 2. Claude CLI einloggen (Proxy-Auth)
 
 Der Proxy-Container nutzt deine Claude Max Subscription. Die Credentials muessen

android/android/app/build.gradle

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

android/android/app/src/main/AndroidManifest.xml

@@ -3,6 +3,7 @@
     <uses-permission android:name="android.permission.INTERNET" />
     <uses-permission android:name="android.permission.CAMERA" />
     <uses-permission android:name="android.permission.RECORD_AUDIO" />
+    <uses-permission android:name="android.permission.REQUEST_INSTALL_PACKAGES" />
 
     <application
       android:name=".MainApplication"
@@ -24,5 +25,15 @@
             <category android:name="android.intent.category.LAUNCHER" />
         </intent-filter>
       </activity>
+
+      <provider
+        android:name="androidx.core.content.FileProvider"
+        android:authorities="${applicationId}.fileprovider"
+        android:exported="false"
+        android:grantUriPermissions="true">
+        <meta-data
+          android:name="android.support.FILE_PROVIDER_PATHS"
+          android:resource="@xml/file_paths" />
+      </provider>
     </application>
 </manifest>

android/android/app/src/main/java/com/ariacockpit/ApkInstallerModule.kt

@@ -0,0 +1,44 @@
+package com.ariacockpit
+
+import android.content.Intent
+import android.net.Uri
+import android.os.Build
+import androidx.core.content.FileProvider
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.Promise
+import java.io.File
+
+class ApkInstallerModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) {
+    override fun getName() = "ApkInstaller"
+
+    @ReactMethod
+    fun install(filePath: String, promise: Promise) {
+        try {
+            val file = File(filePath)
+            if (!file.exists()) {
+                promise.reject("FILE_NOT_FOUND", "APK nicht gefunden: $filePath")
+                return
+            }
+
+            val context = reactApplicationContext
+            val uri: Uri = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+                FileProvider.getUriForFile(context, "${context.packageName}.fileprovider", file)
+            } else {
+                Uri.fromFile(file)
+            }
+
+            val intent = Intent(Intent.ACTION_VIEW).apply {
+                setDataAndType(uri, "application/vnd.android.package-archive")
+                addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+                addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION)
+            }
+
+            context.startActivity(intent)
+            promise.resolve(true)
+        } catch (e: Exception) {
+            promise.reject("INSTALL_ERROR", e.message, e)
+        }
+    }
+}

android/android/app/src/main/java/com/ariacockpit/ApkInstallerPackage.kt

@@ -0,0 +1,16 @@
+package com.ariacockpit
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+class ApkInstallerPackage : ReactPackage {
+    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+        return listOf(ApkInstallerModule(reactContext))
+    }
+
+    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+        return emptyList()
+    }
+}

android/android/app/src/main/java/com/ariacockpit/MainApplication.kt

@@ -18,8 +18,7 @@ class MainApplication : Application(), ReactApplication {
       object : DefaultReactNativeHost(this) {
         override fun getPackages(): List<ReactPackage> =
             PackageList(this).packages.apply {
-              // Packages that cannot be autolinked yet can be added manually here, for example:
+              add(ApkInstallerPackage())
-              // add(MyReactNativePackage())
             }
 
         override fun getJSMainModuleName(): String = "index"

android/android/app/src/main/res/xml/file_paths.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<paths>
+    <cache-path name="cache" path="." />
+</paths>

android/package.json

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

android/src/screens/SettingsScreen.tsx

@@ -748,11 +748,21 @@ const SettingsScreen: React.FC = () => {
       <Text style={styles.sectionTitle}>{'\u00DC'}ber</Text>
       <View style={styles.card}>
         <Text style={styles.aboutTitle}>ARIA Cockpit</Text>
-        <Text style={styles.aboutVersion}>Version 0.0.2.6 </Text>
+        <Text style={styles.aboutVersion}>Version {require('../../package.json').version}</Text>
         <Text style={styles.aboutInfo}>
           Stefans Kommandozentrale f{'\u00FC'}r ARIA.{'\n'}
           Gebaut mit React Native + TypeScript.
         </Text>
+        <TouchableOpacity
+          style={[styles.connectButton, {marginTop: 12}]}
+          onPress={() => {
+            const updateService = require('../services/updater').default;
+            updateService.checkForUpdate();
+            Alert.alert('Update-Check', 'Pruefe auf neue Version...');
+          }}
+        >
+          <Text style={styles.connectButtonText}>Auf Updates pr{'\u00FC'}fen</Text>
+        </TouchableOpacity>
       </View>
 
       {/* Platz am Ende */}

android/src/services/audio.ts

@@ -58,6 +58,8 @@ class AudioService {
   // Audio-Queue fuer sequentielle TTS-Wiedergabe
   private audioQueue: string[] = [];
   private isPlaying: boolean = false;
+  private preloadedSound: Sound | null = null;
+  private preloadedPath: string = '';
 
   // VAD State
   private vadEnabled: boolean = false;
@@ -220,35 +222,62 @@ class AudioService {
     }
 
     this.isPlaying = true;
-    const base64Data = this.audioQueue.shift()!;
 
-    try {
+    // Preloaded Sound verwenden wenn verfuegbar, sonst neu laden
-      const tmpPath = `${RNFS.CachesDirectoryPath}/aria_tts_${Date.now()}.wav`;
+    let sound: Sound;
-      await RNFS.writeFile(tmpPath, base64Data, 'base64');
+    let soundPath: string;
 
-      this.currentSound = new Sound(tmpPath, '', (error) => {
+    if (this.preloadedSound) {
-        if (error) {
+      sound = this.preloadedSound;
-          console.error('[Audio] Fehler beim Laden:', error);
+      soundPath = this.preloadedPath;
-          RNFS.unlink(tmpPath).catch(() => {});
+      this.preloadedSound = null;
-          this._playNext();
+      this.preloadedPath = '';
-          return;
+      // Daten aus Queue entfernen (wurde schon preloaded)
-        }
+      this.audioQueue.shift();
-        this.currentSound?.play((success) => {
+    } else {
-          if (success) {
+      const base64Data = this.audioQueue.shift()!;
-            console.log('[Audio] Wiedergabe abgeschlossen');
+      try {
-          } else {
+        soundPath = `${RNFS.CachesDirectoryPath}/aria_tts_${Date.now()}.wav`;
-            console.warn('[Audio] Wiedergabe fehlgeschlagen');
+        await RNFS.writeFile(soundPath, base64Data, 'base64');
-          }
+        sound = await new Promise<Sound>((resolve, reject) => {
-          this.currentSound?.release();
+          const s = new Sound(soundPath, '', (err) => err ? reject(err) : resolve(s));
-          this.currentSound = null;
-          RNFS.unlink(tmpPath).catch(() => {});
-          // Naechstes Audio abspielen
-          this._playNext();
         });
-      });
+      } catch (err) {
-    } catch (err) {
+        console.error('[Audio] Laden fehlgeschlagen:', err);
-      console.error('[Audio] Wiedergabefehler:', err);
+        this._playNext();
+        return;
+      }
+    }
+
+    this.currentSound = sound;
+
+    // Naechstes Audio schon vorbereiten waehrend dieses abspielt
+    this._preloadNext();
+
+    sound.play((success) => {
+      if (!success) console.warn('[Audio] Wiedergabe fehlgeschlagen');
+      sound.release();
+      this.currentSound = null;
+      RNFS.unlink(soundPath).catch(() => {});
       this._playNext();
+    });
+  }
+
+  /** Naechstes Audio im Hintergrund vorladen (verhindert Stottern) */
+  private async _preloadNext(): Promise<void> {
+    if (this.audioQueue.length === 0 || this.preloadedSound) return;
+
+    const base64Data = this.audioQueue[0]; // Nicht shift — bleibt in Queue
+    try {
+      const tmpPath = `${RNFS.CachesDirectoryPath}/aria_tts_pre_${Date.now()}.wav`;
+      await RNFS.writeFile(tmpPath, base64Data, 'base64');
+      this.preloadedSound = await new Promise<Sound>((resolve, reject) => {
+        const s = new Sound(tmpPath, '', (err) => err ? reject(err) : resolve(s));
+      });
+      this.preloadedPath = tmpPath;
+    } catch {
+      this.preloadedSound = null;
+      this.preloadedPath = '';
     }
   }
 
@@ -261,6 +290,12 @@ class AudioService {
       this.currentSound.release();
       this.currentSound = null;
     }
+    if (this.preloadedSound) {
+      this.preloadedSound.release();
+      this.preloadedSound = null;
+      if (this.preloadedPath) RNFS.unlink(this.preloadedPath).catch(() => {});
+      this.preloadedPath = '';
+    }
   }
 
   // --- Status & Callbacks ---

android/src/services/updater.ts

@@ -7,12 +7,13 @@
  * 3. App zeigt Benachrichtigung → User bestaetigt → Download + Install
  */
 
-import { Alert, Linking, Platform } from 'react-native';
+import { Alert, Linking, Platform, NativeModules } from 'react-native';
 import RNFS from 'react-native-fs';
 import rvs, { RVSMessage } from './rvs';
 
-// Aktuelle App-Version (aus package.json via Build)
+// Version aus package.json (wird beim Build eingebettet)
-const APP_VERSION = '0.0.2.3'; // TODO: aus nativer Build-Config lesen
+const packageJson = require('../../package.json');
+const APP_VERSION = packageJson.version || '0.0.0.0';
 
 type UpdateCallback = (info: UpdateInfo) => void;
 
@@ -116,9 +117,17 @@ class UpdateService {
       const fileSize = await RNFS.stat(destPath);
       console.log(`[Update] APK gespeichert: ${destPath} (${(parseInt(fileSize.size) / 1024 / 1024).toFixed(1)}MB)`);
 
-      // APK installieren (oeffnet Android-Installer)
+      // APK installieren via natives ApkInstaller Module (FileProvider + Intent)
       if (Platform.OS === 'android') {
-        await Linking.openURL(`file://${destPath}`);
+        try {
+          const { ApkInstaller } = NativeModules;
+          await ApkInstaller.install(destPath);
+        } catch (installErr: any) {
+          Alert.alert(
+            'APK heruntergeladen',
+            `Version ${info.version} gespeichert.\n\nBitte manuell installieren:\nDateimanager → ${apkData.fileName} antippen.\n\n(${installErr.message})`,
+          );
+        }
       }
     } catch (err: any) {
       console.error(`[Update] Fehler: ${err.message}`);

bridge/aria_bridge.py

@@ -1045,6 +1045,11 @@ class ARIABridge:
             sender = payload.get("sender", "")
             if sender in ("aria", "stt"):
                 return
+            text = payload.get("text", "")
+            if text:
+                logger.info("[rvs] App-Chat: '%s'", text[:80])
+                await self.send_to_core(text, source="app")
+            return
 
         elif msg_type == "xtts_response":
             # XTTS-Audio vom Gaming-PC empfangen → an App weiterleiten

docker-compose.yml

@@ -18,7 +18,7 @@ services:
       claude-max-api"
     volumes:
       - ~/.claude:/root/.claude                      # Claude CLI Auth (Credentials in /root/.claude/.credentials.json)
-      - ./aria-data/ssh:/root/.ssh:ro               # SSH Keys fuer VM-Zugriff (aria-wohnung)
+      - ./aria-data/ssh:/root/.ssh                    # SSH Keys fuer VM-Zugriff (aria-wohnung, rw fuer ARIA)
       - aria-shared:/shared                          # Shared Volume fuer Datei-Austausch (Uploads von App)
     environment:
       - HOST=0.0.0.0

issue.md

@@ -18,19 +18,36 @@
 - [x] RVS Nachrichten vom Smartphone gehen durch
 - [x] Stimmen-Einstellungen (Ramona/Thorsten, Speed pro Stimme)
 - [x] Highlight-Trigger konfigurierbar in Diagnostic
+- [x] XTTS v2 Integration (Gaming-PC, GPU, Voice Cloning)
+- [x] XTTS Voice Cloning (Audio-Samples hochladen, eigene Stimme)
+- [x] TTS Engine waehlbar (Piper/XTTS) in Diagnostic + App
+- [x] Auto-Update System (APK via RVS WebSocket)
+- [x] Audio-Queue (sequentielle Wiedergabe, kein Ueberlappen)
 
 ## Offen
 
-### TTS / Stimmen
+### Bugs (Prioritaet)
-- [ ] TTS Engine waehlbar: Piper (CPU, schnell) oder Coqui XTTS v2 (GPU, natuerlicher)
+- [ ] Session-Persistenz: Bei Container-Restart wird immer aria-bridge geladen statt die zuletzt gewaehlte Session. Wird nicht persistent gespeichert.
-- [ ] Piper Voices Download ueber Diagnostic (neue Sprachen/Stimmen)
+- [ ] App: Textnachrichten, Bilder und Anhaenge werden von ARIA nicht beantwortet — nur Sprachnachrichten funktionieren.
-- [ ] Coqui XTTS v2 Integration (braucht GPU, bessere deutsche Stimme)
+- [ ] App: Audioausgabe hoert ab und zu einfach auf (mitten im Satz oder zwischen Chunks)
+- [ ] Auto-Update: APK-Installation schlaegt fehl (file:// URI exposed beyond app — braucht FileProvider fuer content:// URI)
+- [ ] Auto-Update: "Auf Updates pruefen" Button in App-Einstellungen
+- [ ] App: Kein Auto-Scroll zur letzten Nachricht beim App-Start (soll direkt springen, nicht animiert scrollen)
+- [ ] App: Bei neuen Nachrichten soll automatisch zur letzten Nachricht gescrollt werden
 
-### App
+### App Features
+- [ ] App: Zu Anhaengen noch Text/Sprache hinzufuegen koennen (z.B. Bild senden + "Was siehst du?")
 - [ ] Wake Word on-device (Porcupine "ARIA" Keyword, Phase 2)
 - [ ] Chat-History zuverlaessiger laden (AsyncStorage Race Condition)
+- [ ] Background Audio Service (TTS auch bei minimierter App)
+
+### TTS / Audio
+- [ ] XTTS Audio-Streaming verbessern (minimales Stottern bei Chunk-Uebergaengen)
+- [ ] Audio-Normalisierung (Lautstaerke zwischen Chunks angleichen)
+- [ ] Piper Voices Download ueber Diagnostic (neue Sprachen/Stimmen)
 
 ### Architektur
 - [ ] Bilder: Claude Vision direkt nutzen (aktuell nur Dateipfad an ARIA)
 - [ ] Auto-Compacting und Memory/Brain Verwaltung (SQLite?)
 - [ ] Diagnostic: System-Info Tab (Container-Status, Disk, RAM, CPU)
+- [ ] RVS Zombie-Connections endgueltig loesen (WebRTC statt WebSocket?)

release.sh

@@ -174,9 +174,11 @@ fi
 RVS_UPDATE_HOST="${RVS_UPDATE_HOST:-}"
 if [ -n "$RVS_UPDATE_HOST" ]; then
     echo -e "${GREEN}[6/6] APK auf RVS-Server kopieren (Auto-Update)...${NC}"
+    # Alte APKs auf dem RVS loeschen, dann neue hochladen
+    ssh "$RVS_UPDATE_HOST" "rm -f ~/ARIA-AGENT/rvs/updates/ARIA-*.apk" 2>/dev/null
     scp "$APK_PATH" "${RVS_UPDATE_HOST}:~/ARIA-AGENT/rvs/updates/${APK_NAME}" 2>/dev/null
     if [ $? -eq 0 ]; then
-        echo -e "  ${GREEN}✓${NC} APK auf RVS-Server kopiert — Apps werden benachrichtigt"
+        echo -e "  ${GREEN}✓${NC} APK auf RVS-Server kopiert (alte Versionen geloescht)"
     else
         echo -e "  ${YELLOW}APK konnte nicht auf RVS kopiert werden (RVS_UPDATE_HOST=$RVS_UPDATE_HOST)${NC}"
         echo -e "  ${YELLOW}Manuell: scp $APK_PATH $RVS_UPDATE_HOST:~/ARIA-AGENT/rvs/updates/${APK_NAME}${NC}"

xtts/bridge.js

@@ -100,44 +100,66 @@ async function handleTTSRequest(payload) {
   // Markdown entfernen
   const cleanText = text.replace(/\*\*([^*]+)\*\*/g, "$1").trim();
 
-  // Text in Saetze aufteilen (sequentiell rendern fuer korrekte Reihenfolge)
+  // Text in Saetze aufteilen, dann zu Chunks von 2-3 Saetzen zusammenfassen
-  const sentences = cleanText.split(/(?<=[.!?])\s+/).map(s => s.trim()).filter(s => s.length > 0);
+  // (mehr Kontext = konsistentere Stimme/Lautstaerke, aber nicht zu lang fuer WebSocket)
-  if (sentences.length === 0) return;
+  const sentences = cleanText.split(/(?<=[.!?])\s+/)
+    .map(s => s.trim())
+    .filter(s => s.length > 0)
+    .map(s => s.replace(/[.]+$/, '')); // Punkt am Ende entfernen
 
-  log(`TTS-Request: "${cleanText.slice(0, 60)}..." (${sentences.length} Saetze, voice: ${voice || "default"}, lang: ${language || "de"})`);
+  const MAX_CHUNK_CHARS = 150; // Max ~150 Zeichen pro Chunk (schnelles Rendering, Preloading reicht)
+  const chunks = [];
+  let currentChunk = '';
+  for (const sentence of sentences) {
+    if (currentChunk && (currentChunk.length + sentence.length + 2) > MAX_CHUNK_CHARS) {
+      chunks.push(currentChunk);
+      currentChunk = sentence;
+    } else {
+      currentChunk = currentChunk ? currentChunk + ', ' + sentence : sentence;
+    }
+  }
+  if (currentChunk) chunks.push(currentChunk);
+  if (chunks.length === 0) return;
+
+  log(`TTS-Request: "${cleanText.slice(0, 60)}..." (${sentences.length} Saetze → ${chunks.length} Chunks, voice: ${voice || "default"}, lang: ${language || "de"})`);
 
   try {
     const voiceSample = voice ? path.join(VOICES_DIR, `${voice}.wav`) : null;
     const hasCustomVoice = voiceSample && fs.existsSync(voiceSample);
 
-    // Jeden Satz sequentiell rendern und sofort senden
+    // Streaming: Chunk rendern → sofort senden → naechster Chunk
-    for (let i = 0; i < sentences.length; i++) {
+    // App spielt mit Preloading-Queue nahtlos ab
-      const sentence = sentences[i];
+    let sentCount = 0;
+
+    for (let i = 0; i < chunks.length; i++) {
+      const chunk = chunks[i];
       try {
-        const audioBuffer = await callXTTSAPI(sentence, language || "de", hasCustomVoice ? voiceSample : null);
+        const audioBuffer = await callXTTSAPI(chunk, language || "de", hasCustomVoice ? voiceSample : null);
 
         if (audioBuffer && audioBuffer.length > 100) {
-          const base64 = audioBuffer.toString("base64");
+          log(`TTS [${i + 1}/${chunks.length}]: ${(audioBuffer.length / 1024).toFixed(0)}KB — "${chunk.slice(0, 50)}"`);
-          log(`TTS [${i + 1}/${sentences.length}]: ${audioBuffer.length} bytes (${(audioBuffer.length / 1024).toFixed(0)}KB) — "${sentence.slice(0, 40)}..."`);
 
           sendToRVS({
             type: "xtts_response",
             payload: {
               requestId: `${requestId || ""}_${i}`,
-              base64,
+              base64: audioBuffer.toString("base64"),
               mimeType: "audio/wav",
               voice: voice || "default",
               engine: "xtts",
+              part: i + 1,
+              totalParts: chunks.length,
             },
             timestamp: Date.now(),
           });
+          sentCount++;
         }
-      } catch (sentenceErr) {
+      } catch (chunkErr) {
-        log(`TTS [${i + 1}/${sentences.length}] Fehler: ${sentenceErr.message} — ueberspringe`);
+        log(`TTS [${i + 1}/${chunks.length}] Fehler: ${chunkErr.message} — ueberspringe`);
       }
     }
 
-    log(`TTS komplett: ${sentences.length} Saetze gerendert`);
+    log(`TTS komplett: ${sentCount}/${chunks.length} Chunks gestreamt`);
   } catch (err) {
     log(`TTS Fehler: ${err.message}`);
     sendToRVS({