release: bump version to 0.0.4.1

fix: QR-Code overflowed Container — auf SVG umgestellt mit width/height 100%
Der QR wurde mit createImgTag() als fester Pixel-IMG gerendert und ueberlappte den Warnhinweis + Button rechts daneben. Fix: - createSvgTag mit cellSize=4 + scalable=true - SVG skaliert auf width:100%/height:100% der 220x220 Box - Container: flex-shrink:0 (damit Flex ihn nicht weiter schrumpft) - overflow:hidden als Sicherheit Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
2026-04-19 21:00:49 +02:00 · 2026-04-19 16:28:41 +02:00 · 2026-04-19 16:27:56 +02:00 · 2026-04-19 16:18:37 +02:00 · 2026-04-19 16:16:25 +02:00 · 2026-04-19 16:10:54 +02:00
17 changed files with 1339 additions and 136 deletions
@@ -306,7 +306,8 @@ aria-core → Antwort → Gateway → Diagnostic → RVS → App
 ### Features

 - **STT**: faster-whisper (lokal, offline, 16kHz mono)
- **TTS**: Piper (Ramona + Thorsten, offline)
+- **TTS**: Piper (Ramona + Thorsten, offline) oder XTTS v2 (remote, GPU, Voice Cloning)
+- **Markdown-Bereinigung**: Entfernt **fett**, *kursiv*, `code`, Links, Listen etc. vor TTS (natuerliche Sprache)
 - **Wake-Word**: openwakeword (lokales Mikrofon auf der VM)
 - **App-Audio**: Base64 Audio von App → FFmpeg → Whisper STT → Text an aria-core
 - **Modi**: Normal, Nicht stoeren, Fluestern, Hangar, Gaming
@@ -340,10 +341,10 @@ Erreichbar unter `http://<VM-IP>:3001`. Teilt das Netzwerk mit aria-core.
 - **Chat-Test**: Nachrichten direkt an ARIA senden (Gateway oder via RVS), Vollbild-Modus
 - **"ARIA denkt..." Indikator**: Zeigt live was ARIA gerade tut (Denken, Tool, Schreiben)
 - **Abbrechen-Button**: Stoppt laufende Anfragen + doctor --fix
- **Session-Verwaltung**: Sessions auflisten, wechseln, erstellen, loeschen
+- **Session-Verwaltung**: Sessions auflisten, wechseln, erstellen, loeschen, als Markdown exportieren (⬇ Button)
 - **Chat-History**: Wird beim Laden und Session-Wechsel angezeigt (read-only aus JSONL)
 - **TTS-Diagnose Tab**: Stimmen testen, Status pruefen, Fehler anzeigen
- **Einstellungen**: TTS-Engine (Piper/XTTS), Stimmen, Speed, Highlight-Trigger, Betriebsmodi
+- **Einstellungen**: TTS-Engine (Piper/XTTS), Stimmen, Speed, Highlight-Trigger, Betriebsmodi, Whisper-Modell (tiny…large-v3, Hot-Reload)
 - **XTTS Voice Cloning**: Audio-Samples hochladen, eigene Stimme erstellen
 - **Claude Login**: Browser-Terminal zum Einloggen in den Proxy
 - **Core Terminal**: Shell in aria-core (openclaw CLI)
@@ -367,15 +368,19 @@ API-Endpoint fuer andere Services: `GET http://localhost:3001/api/session`

 - Text-Chat mit ARIA
 - **Sprachaufnahme**: Push-to-Talk (halten) oder Tap-to-Talk (tippen, Auto-Stop bei Stille)
+- **Gespraechsmodus** (Ohr-Button): Nach jeder ARIA-Antwort startet automatisch die Aufnahme — wie ein natuerliches Gespraech hin und her, ohne Buttons druecken
 - **VAD (Voice Activity Detection)**: Erkennt 1.8s Stille und stoppt automatisch
- **STT (Speech-to-Text)**: Audio wird in der Bridge per Whisper transkribiert, transkribierter Text erscheint im Chat
- **TTS-Wiedergabe**: ARIA antwortet per Lautsprecher (Piper oder XTTS v2)
+- **Speech Gate**: Aufnahme wird verworfen wenn keine Sprache erkannt (kein Rauschen an Whisper)
+- **STT (Speech-to-Text)**: Audio wird als 16kHz mono aufgenommen und in der Bridge per Whisper transkribiert, transkribierter Text erscheint im Chat
+- **"ARIA denkt..." Indicator**: Zeigt live den Status vom Core (Denken, Tool, Schreiben) + Abbrechen-Button
+- **TTS-Wiedergabe**: ARIA antwortet per Lautsprecher (Piper oder XTTS v2), Audio-Queue mit Preloading
 - **Play-Button**: Jede ARIA-Nachricht kann nochmal vorgelesen werden
 - **Chat-Suche**: Lupe in der Statusleiste filtert Nachrichten live
- **Datei- und Bild-Upload**: Bilder inline im Chat (Vollbild-Tap), Dateien mit Icon + Name + Groesse
+- **Mehrere Anhaenge**: Bilder + Dateien sammeln, Text hinzufuegen, dann zusammen senden
+- **Paste-Support**: Bilder aus Zwischenablage einfuegen (Diagnostic)
 - **Anhaenge**: Bridge speichert in Shared Volume, ARIA kann darauf zugreifen, Re-Download ueber RVS
 - **Einstellungen**: TTS Engine, Stimmen, Speed pro Stimme, Speicherort, Auto-Download, GPS
- **Auto-Update**: Prueft beim Start auf neue Version, Download + Installation ueber RVS
+- **Auto-Update**: Prueft beim Start + per Button auf neue Version, Download + Installation ueber RVS (FileProvider)
 - GPS-Position (optional)
 - QR-Code Scanner fuer Token-Pairing

@@ -421,6 +426,17 @@ GITEA_USER=stefan
 RVS_UPDATE_HOST=root@aria-rvs    # Optional: fuer Auto-Update
 ```

+### Docker-Cleanup
+
+Das Bridge-Image zieht grosse ML-Deps (faster-whisper, ctranslate2, onnxruntime,
+openwakeword, piper-tts) — bei jedem Rebuild waechst der Docker-Build-Cache. Wenn
+die VM voll laeuft:
+
+```bash
+./cleanup.sh           # sicher: Build-Cache + ungenutzte Images
+./cleanup.sh --full    # aggressiv: zusaetzlich ungenutzte Volumes (mit Rueckfrage)
+```
+
 ### Auto-Update

 Die App prueft beim Start ob eine neuere Version auf dem RVS liegt.
@@ -709,6 +725,17 @@ docker exec aria-core ssh aria-wohnung hostname
 - [x] Auto-Update System (APK via RVS)
 - [x] Chat-Suche, Play-Button, Abbrechen-Button
 - [x] XTTS v2 Integration (GPU, Voice Cloning, remote ueber RVS)
+- [x] Gespraechsmodus (Ohr-Button, automatische Aufnahme nach ARIA-Antwort)
+- [x] Mehrere Anhaenge + Text vor dem Senden + Paste-Support
+- [x] Markdown-Bereinigung fuer TTS
+- [x] Auto-Update mit FileProvider + Update-Check Button
+- [x] Inverted FlatList (zuverlaessiges Scroll-to-Bottom)
+- [x] Speech Gate (VAD verwirft Aufnahme ohne erkannte Sprache)
+- [x] Session-Persistenz ueber Container-Restarts (sessionFromFile + atomic write)
+- [x] Session-Export als Markdown-Datei (Download-Button pro Session)
+- [x] "ARIA denkt..."-Indicator + Abbrechen-Button in App (via Bridge → RVS)
+- [x] Whisper-Modell waehlbar in Diagnostic (tiny…large-v3, Hot-Reload)
+- [x] App-Aufnahme explizit 16kHz mono (optimal fuer Whisper, kein Resample)

 ### Phase 2 — ARIA wird produktiv

@@ -79,8 +79,8 @@ android {
        applicationId "com.ariacockpit"
        minSdkVersion rootProject.ext.minSdkVersion
        targetSdkVersion rootProject.ext.targetSdkVersion
-        versionCode 304
-        versionName "0.0.3.4"
+        versionCode 401
+        versionName "0.0.4.1"
        // Fallback fuer Libraries mit Product Flavors
        missingDimensionStrategy 'react-native-camera', 'general'
    }
@@ -0,0 +1,93 @@
+package com.ariacockpit
+
+import android.content.Context
+import android.media.AudioAttributes
+import android.media.AudioFocusRequest
+import android.media.AudioManager
+import android.os.Build
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+
+/**
+ * Steuert Audio-Focus fuer Ducking/Muten anderer Apps.
+ *
+ * - requestDuck()      → andere Apps werden leiser (ARIA spricht TTS)
+ * - requestExclusive() → andere Apps werden pausiert (Mikrofon-Aufnahme)
+ * - release()          → Focus abgeben, andere Apps duerfen wieder
+ */
+class AudioFocusModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) {
+    override fun getName() = "AudioFocus"
+
+    private var currentRequest: AudioFocusRequest? = null
+
+    private fun audioManager(): AudioManager? =
+        reactApplicationContext.getSystemService(Context.AUDIO_SERVICE) as? AudioManager
+
+    private fun requestFocus(durationHint: Int, usage: Int, promise: Promise) {
+        val am = audioManager()
+        if (am == null) {
+            promise.reject("NO_AUDIO_MANAGER", "AudioManager nicht verfuegbar")
+            return
+        }
+
+        release()
+
+        val result: Int = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            val attrs = AudioAttributes.Builder()
+                .setUsage(usage)
+                .setContentType(AudioAttributes.CONTENT_TYPE_SPEECH)
+                .build()
+            val req = AudioFocusRequest.Builder(durationHint)
+                .setAudioAttributes(attrs)
+                .setOnAudioFocusChangeListener { /* kein Callback noetig */ }
+                .build()
+            currentRequest = req
+            am.requestAudioFocus(req)
+        } else {
+            @Suppress("DEPRECATION")
+            am.requestAudioFocus(null, AudioManager.STREAM_MUSIC, durationHint)
+        }
+
+        promise.resolve(result == AudioManager.AUDIOFOCUS_REQUEST_GRANTED)
+    }
+
+    /** Andere Apps werden leiser (TTS spricht). */
+    @ReactMethod
+    fun requestDuck(promise: Promise) {
+        requestFocus(
+            AudioManager.AUDIOFOCUS_GAIN_TRANSIENT_MAY_DUCK,
+            AudioAttributes.USAGE_ASSISTANT,
+            promise,
+        )
+    }
+
+    /** Andere Apps werden pausiert (Mikrofon-Aufnahme / Gespraech). */
+    @ReactMethod
+    fun requestExclusive(promise: Promise) {
+        requestFocus(
+            AudioManager.AUDIOFOCUS_GAIN_TRANSIENT_EXCLUSIVE,
+            AudioAttributes.USAGE_VOICE_COMMUNICATION,
+            promise,
+        )
+    }
+
+    /** Focus abgeben — andere Apps duerfen wieder volle Lautstaerke. */
+    @ReactMethod
+    fun release(promise: Promise) {
+        release()
+        promise.resolve(true)
+    }
+
+    private fun release() {
+        val am = audioManager() ?: return
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            currentRequest?.let { am.abandonAudioFocusRequest(it) }
+        } else {
+            @Suppress("DEPRECATION")
+            am.abandonAudioFocus(null)
+        }
+        currentRequest = null
+    }
+}
@@ -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 AudioFocusPackage : ReactPackage {
+    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+        return listOf(AudioFocusModule(reactContext))
+    }
+
+    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+        return emptyList()
+    }
+}
@@ -19,6 +19,7 @@ class MainApplication : Application(), ReactApplication {
        override fun getPackages(): List<ReactPackage> =
            PackageList(this).packages.apply {
              add(ApkInstallerPackage())
+              add(AudioFocusPackage())
            }

        override fun getJSMainModuleName(): String = "index"
@@ -1,6 +1,6 @@
 {
  "name": "aria-cockpit",
-  "version": "0.0.3.4",
+  "version": "0.0.4.1",
  "private": true,
  "scripts": {
    "android": "react-native run-android",
@@ -5,7 +5,7 @@
 * Datei- und Kamera-Upload.
 */

-import React, { useState, useEffect, useRef, useCallback } from 'react';
+import React, { useState, useEffect, useRef, useCallback, useMemo } from 'react';
 import {
  View,
  Text,
@@ -48,12 +48,22 @@ interface ChatMessage {
  text: string;
  timestamp: number;
  attachments?: Attachment[];
+  /** Bridge-Message-ID zur Zuordnung von TTS-Audio */
+  messageId?: string;
+  /** Lokaler Pfad zur gecachten TTS-Audio-Datei (file://...) */
+  audioPath?: string;
 }

 // --- Konstanten ---

 const CHAT_STORAGE_KEY = 'aria_chat_messages';
 const MAX_STORED_MESSAGES = 500;
+const MAX_MEMORY_MESSAGES = 500;
+
+// Hilfe: Messages-Array auf Max kappen (aelteste raus) — verhindert OOM
+// im Gespraechsmodus bei sehr vielen Nachrichten.
+const capMessages = (msgs: ChatMessage[]): ChatMessage[] =>
+  msgs.length > MAX_MEMORY_MESSAGES ? msgs.slice(-MAX_MEMORY_MESSAGES) : msgs;
 const DEFAULT_ATTACHMENT_DIR = `${RNFS.DocumentDirectoryPath}/chat_attachments`;
 const STORAGE_PATH_KEY = 'aria_attachment_storage_path';

@@ -96,6 +106,7 @@ const ChatScreen: React.FC = () => {
  const [searchQuery, setSearchQuery] = useState('');
  const [searchVisible, setSearchVisible] = useState(false);
  const [pendingAttachments, setPendingAttachments] = useState<{file: any, isPhoto: boolean}[]>([]);
+  const [agentActivity, setAgentActivity] = useState<{activity: string, tool: string}>({activity: 'idle', tool: ''});

  const flatListRef = useRef<FlatList>(null);
  const messageIdCounter = useRef(0);
@@ -217,12 +228,12 @@ const ChatScreen: React.FC = () => {
        if (sender === 'diagnostic') {
          const diagText = (message.payload.text as string) || '';
          if (diagText) {
-            setMessages(prev => [...prev, {
+            setMessages(prev => capMessages([...prev, {
              id: nextId(),
              sender: 'user',
              text: diagText,
              timestamp: message.timestamp,
-            }]);
+            }]));
          }
          return;
        }
@@ -241,14 +252,33 @@ const ChatScreen: React.FC = () => {
            text,
            timestamp: ts,
            attachments: message.payload.attachments as Attachment[] | undefined,
+            messageId: (message.payload.messageId as string) || undefined,
          };
-          return [...prev, ariaMsg];
+          return capMessages([...prev, ariaMsg]);
        });
      }

      // TTS-Audio abspielen wenn vorhanden
      if (message.type === 'audio' && message.payload.base64) {
-        audioService.playAudio(message.payload.base64 as string);
+        const b64 = message.payload.base64 as string;
+        const refId = (message.payload.messageId as string) || '';
+        audioService.playAudio(b64);
+        // Wenn messageId mitgeliefert wurde: Audio in Cache speichern + Pfad in Message eintragen
+        if (refId) {
+          audioService.cacheAudio(b64, refId).then(audioPath => {
+            if (!audioPath) return;
+            setMessages(prev => prev.map(m =>
+              m.messageId === refId ? { ...m, audioPath } : m
+            ));
+          }).catch(() => {});
+        }
+      }
+
+      // Thinking-Indicator Status von der Bridge
+      if (message.type === 'agent_activity') {
+        const activity = (message.payload.activity as string) || 'idle';
+        const tool = (message.payload.tool as string) || '';
+        setAgentActivity({ activity, tool });
      }
    });

@@ -310,7 +340,7 @@ const ChatScreen: React.FC = () => {
          timestamp: Date.now(),
          attachments: [{ type: 'audio', name: 'Sprachaufnahme' }],
        };
-        setMessages(prev => [...prev, userMsg]);
+        setMessages(prev => capMessages([...prev, userMsg]));
        rvs.send('audio', {
          base64: result.base64,
          durationMs: result.durationMs,
@@ -369,33 +399,8 @@ const ChatScreen: React.FC = () => {
    return () => { if (saveTimer.current) clearTimeout(saveTimer.current); };
  }, [messages]);

-  // Auto-Scroll: immer zur letzten Nachricht springen
-  const shouldAutoScroll = useRef(true);
-  const lastMessageCount = useRef(0);
-
-  // Bei neuen Nachrichten oder App-Start: nach unten springen
-  useEffect(() => {
-    if (messages.length > 0 && shouldAutoScroll.current) {
-      const isInitial = lastMessageCount.current === 0;
-      // Mehrfach versuchen (FlatList braucht Zeit zum Rendern)
-      const delays = isInitial ? [100, 300, 600, 1000] : [100, 300];
-      for (const delay of delays) {
-        setTimeout(() => {
-          flatListRef.current?.scrollToEnd({ animated: !isInitial });
-        }, delay);
-      }
-    }
-    lastMessageCount.current = messages.length;
-  }, [messages]);
-
-  const handleScrollBeginDrag = useCallback(() => {
-    shouldAutoScroll.current = false;
-  }, []);
-  const handleScrollEndDrag = useCallback((e: any) => {
-    const { contentOffset, contentSize, layoutMeasurement } = e.nativeEvent;
-    const isAtBottom = contentOffset.y + layoutMeasurement.height >= contentSize.height - 50;
-    shouldAutoScroll.current = isAtBottom;
-  }, []);
+  // Inverted FlatList: neueste Nachrichten unten, kein manuelles Scrollen noetig
+  const invertedMessages = useMemo(() => [...messages].reverse(), [messages]);

  // GPS-Position holen (optional)
  const getCurrentLocation = useCallback((): Promise<{ lat: number; lon: number } | null> => {
@@ -440,7 +445,7 @@ const ChatScreen: React.FC = () => {
      text,
      timestamp: Date.now(),
    };
-    setMessages(prev => [...prev, userMsg]);
+    setMessages(prev => capMessages([...prev, userMsg]));

    // An RVS senden
    rvs.send('chat', {
@@ -449,6 +454,12 @@ const ChatScreen: React.FC = () => {
    });
  }, [inputText, getCurrentLocation, pendingAttachments, sendPendingAttachments]);

+  // Anfrage abbrechen — sofort lokalen Indicator weg, Bridge triggert doctor --fix
+  const cancelRequest = useCallback(() => {
+    setAgentActivity({ activity: 'idle', tool: '' });
+    rvs.send('cancel_request' as any, {});
+  }, []);
+
  // Sprachaufnahme abgeschlossen
  const handleVoiceRecording = useCallback(async (result: RecordingResult) => {
    const location = await getCurrentLocation();
@@ -459,7 +470,7 @@ const ChatScreen: React.FC = () => {
      text: '🎙 Spracheingabe wird verarbeitet...',
      timestamp: Date.now(),
    };
-    setMessages(prev => [...prev, userMsg]);
+    setMessages(prev => capMessages([...prev, userMsg]));

    rvs.send('audio', {
      base64: result.base64,
@@ -513,7 +524,7 @@ const ChatScreen: React.FC = () => {
      timestamp: Date.now(),
      attachments,
    };
-    setMessages(prev => [...prev, userMsg]);
+    setMessages(prev => capMessages([...prev, userMsg]));

    // Alle Dateien an RVS senden + auf Disk speichern
    for (const { file, isPhoto } of pendingAttachments) {
@@ -625,16 +636,19 @@ const ChatScreen: React.FC = () => {
            {item.text}
          </Text>
        )}
-        {/* Play-Button fuer ARIA-Nachrichten */}
+        {/* Play-Button fuer ARIA-Nachrichten — Cache bevorzugt, sonst Regenerierung */}
        {!isUser && item.text.length > 0 && (
          <TouchableOpacity
            style={styles.playButton}
            onPress={() => {
-              // TTS-Request an Bridge senden
-              rvs.send('tts_request' as any, { text: item.text, voice: '' });
+              if (item.audioPath) {
+                audioService.playFromPath(item.audioPath);
+              } else {
+                rvs.send('tts_request' as any, { text: item.text, voice: '' });
+              }
            }}
          >
-            <Text style={styles.playButtonText}>{'\uD83D\uDD0A'}</Text>
+            <Text style={styles.playButtonText}>{item.audioPath ? '\uD83D\uDD0A' : '\uD83D\uDD0A'}</Text>
          </TouchableOpacity>
        )}
        <Text style={styles.timestamp}>{time}</Text>
@@ -684,13 +698,12 @@ const ChatScreen: React.FC = () => {
      {/* Nachrichtenliste */}
      <FlatList
        ref={flatListRef}
-        data={searchQuery ? messages.filter(m => m.text.toLowerCase().includes(searchQuery.toLowerCase())) : messages}
+        inverted
+        data={searchQuery ? messages.filter(m => m.text.toLowerCase().includes(searchQuery.toLowerCase())).reverse() : invertedMessages}
        keyExtractor={item => item.id}
        renderItem={renderMessage}
        contentContainerStyle={styles.messageList}
        showsVerticalScrollIndicator={false}
-        onScrollBeginDrag={handleScrollBeginDrag}
-        onScrollEndDrag={handleScrollEndDrag}
        ListEmptyComponent={
          <View style={styles.emptyContainer}>
            <Text style={styles.emptyIcon}>{'\uD83E\uDD16'}</Text>
@@ -700,6 +713,22 @@ const ChatScreen: React.FC = () => {
        }
      />

+      {/* Thinking-Indicator */}
+      {agentActivity.activity !== 'idle' && (
+        <View style={styles.thinkingBar}>
+          <Text style={styles.thinkingText}>
+            {agentActivity.activity === 'tool' && agentActivity.tool
+              ? `\uD83D\uDD27 ${agentActivity.tool}`
+              : agentActivity.activity === 'assistant'
+              ? '\u270D\uFE0F ARIA schreibt...'
+              : '\uD83D\uDCAD ARIA denkt...'}
+          </Text>
+          <TouchableOpacity style={styles.thinkingCancel} onPress={cancelRequest}>
+            <Text style={styles.thinkingCancelText}>Abbrechen</Text>
+          </TouchableOpacity>
+        </View>
+      )}
+
      {/* Pending Anhaenge Vorschau */}
      {pendingAttachments.length > 0 && (
        <View style={styles.pendingBar}>
@@ -996,6 +1025,33 @@ const styles = StyleSheet.create({
  wakeWordIcon: {
    fontSize: 16,
  },
+  thinkingBar: {
+    flexDirection: 'row',
+    alignItems: 'center',
+    justifyContent: 'space-between',
+    backgroundColor: '#1E1E2E',
+    paddingHorizontal: 12,
+    paddingVertical: 6,
+    borderTopWidth: 1,
+    borderTopColor: '#2A2A3E',
+  },
+  thinkingText: {
+    color: '#FFD60A',
+    fontSize: 12,
+    flex: 1,
+  },
+  thinkingCancel: {
+    paddingHorizontal: 10,
+    paddingVertical: 4,
+    borderWidth: 1,
+    borderColor: '#FF3B30',
+    borderRadius: 4,
+  },
+  thinkingCancelText: {
+    color: '#FF3B30',
+    fontSize: 11,
+    fontWeight: 'bold',
+  },
  pendingBar: {
    flexDirection: 'row',
    alignItems: 'center',
@@ -6,7 +6,7 @@
 * Nutzt react-native-audio-recorder-player fuer Aufnahme.
 */

-import { Platform, PermissionsAndroid } from 'react-native';
+import { Platform, PermissionsAndroid, NativeModules } from 'react-native';
 import Sound from 'react-native-sound';
 import RNFS from 'react-native-fs';
 import AudioRecorderPlayer, {
@@ -16,6 +16,15 @@ import AudioRecorderPlayer, {
  OutputFormatAndroidType,
 } from 'react-native-audio-recorder-player';

+// Native Module fuer Audio-Focus (Ducking/Muten anderer Apps)
+const { AudioFocus } = NativeModules as {
+  AudioFocus?: {
+    requestDuck: () => Promise<boolean>;
+    requestExclusive: () => Promise<boolean>;
+    release: () => Promise<boolean>;
+  };
+};
+
 // --- Typen ---

 export interface RecordingResult {
@@ -42,6 +51,11 @@ const AUDIO_ENCODING = 'audio/wav';
 // VAD (Voice Activity Detection) — Stille-Erkennung
 const VAD_SILENCE_THRESHOLD_DB = -45;  // dB unter dem als "Stille" gilt
 const VAD_SILENCE_DURATION_MS = 1800;  // ms Stille bevor Auto-Stop
+const VAD_SPEECH_THRESHOLD_DB = -28;   // dB ueber dem als "Sprache" gilt (Sprach-Gate) — hoeher = weniger Umgebungsgeraeusche
+const VAD_SPEECH_MIN_MS = 500;         // ms Sprache bevor Aufnahme zaehlt — laenger = keine Huestler/Klopfer mehr
+
+// Max-Dauer einer Aufnahme in Gespraechsmodus (Notbremse gegen Runaway-Loops)
+const MAX_RECORDING_MS = 30000;

 // --- Audio-Service ---

@@ -61,10 +75,15 @@ class AudioService {
  private preloadedSound: Sound | null = null;
  private preloadedPath: string = '';

+  // Sprach-Gate: Aufnahme erst senden wenn tatsaechlich gesprochen wurde
+  private speechDetected: boolean = false;
+  private speechStartTime: number = 0;
+
  // VAD State
  private vadEnabled: boolean = false;
  private lastSpeechTime: number = 0;
  private vadTimer: ReturnType<typeof setInterval> | null = null;
+  private maxDurationTimer: ReturnType<typeof setTimeout> | null = null;

  constructor() {
    this.recorder = new AudioRecorderPlayer();
@@ -114,6 +133,10 @@ class AudioService {
      // Laufende Wiedergabe stoppen (damit ARIA sich nicht selbst hoert)
      this.stopPlayback();

+      // Aufraeumen: Alte aria_recording_ und aria_tts_ Files loeschen
+      // (Schutz gegen Cache-Ueberlauf im Gespraechsmodus bei vielen Zyklen)
+      this._cleanupStaleCacheFiles().catch(() => {});
+
      this.recordingPath = `${RNFS.CachesDirectoryPath}/aria_recording_${Date.now()}.mp4`;

      // Aufnahme mit Metering starten
@@ -121,6 +144,8 @@ class AudioService {
        AudioEncoderAndroid: AudioEncoderAndroidType.AAC,
        AudioSourceAndroid: AudioSourceAndroidType.MIC,
        OutputFormatAndroid: OutputFormatAndroidType.MPEG_4,
+        AudioSamplingRateAndroid: 16000,
+        AudioChannelsAndroid: 1,
      }, true); // meteringEnabled = true

      // Metering-Callback
@@ -128,7 +153,21 @@ class AudioService {
        const db = e.currentMetering ?? -160;
        this.meterListeners.forEach(cb => cb(db));

-        // VAD: Stille erkennen
+        // Sprach-Gate: Erkennen ob tatsaechlich gesprochen wird
+        if (db > VAD_SPEECH_THRESHOLD_DB) {
+          if (!this.speechDetected && this.speechStartTime === 0) {
+            this.speechStartTime = Date.now();
+          }
+          if (this.speechStartTime > 0 && Date.now() - this.speechStartTime >= VAD_SPEECH_MIN_MS) {
+            this.speechDetected = true;
+          }
+        } else {
+          if (!this.speechDetected) {
+            this.speechStartTime = 0; // Reset wenn noch nicht als Sprache erkannt
+          }
+        }
+
+        // VAD: Stille erkennen (nur wenn Sprache erkannt wurde)
        if (this.vadEnabled) {
          if (db > VAD_SILENCE_THRESHOLD_DB) {
            this.lastSpeechTime = Date.now();
@@ -138,8 +177,13 @@ class AudioService {

      this.recordingStartTime = Date.now();
      this.lastSpeechTime = Date.now();
+      this.speechDetected = false;
+      this.speechStartTime = 0;
      this.setState('recording');

+      // Andere Apps waehrend der Aufnahme pausieren (Musik, Videos etc.)
+      AudioFocus?.requestExclusive().catch(() => {});
+
      // VAD aktivieren
      this.vadEnabled = autoStop;
      if (autoStop) {
@@ -150,6 +194,11 @@ class AudioService {
            this.silenceListeners.forEach(cb => cb());
          }
        }, 200);
+        // Notbremse: Nach MAX_RECORDING_MS zwangsweise stoppen
+        this.maxDurationTimer = setTimeout(() => {
+          console.warn(`[Audio] Max-Dauer ${MAX_RECORDING_MS}ms erreicht — Zwangs-Stop`);
+          this.silenceListeners.forEach(cb => cb());
+        }, MAX_RECORDING_MS);
      }

      console.log('[Audio] Aufnahme gestartet (autoStop: %s)', autoStop);
@@ -174,12 +223,28 @@ class AudioService {
      clearInterval(this.vadTimer);
      this.vadTimer = null;
    }
+    if (this.maxDurationTimer) {
+      clearTimeout(this.maxDurationTimer);
+      this.maxDurationTimer = null;
+    }

    try {
      await this.recorder.stopRecorder();
      this.recorder.removeRecordBackListener();

+      // Audio-Focus freigeben — andere Apps duerfen wieder
+      AudioFocus?.release().catch(() => {});
+
      const durationMs = Date.now() - this.recordingStartTime;
+      const hadSpeech = this.speechDetected;
+
+      // Sprach-Gate: Wenn keine Sprache erkannt → Aufnahme verwerfen
+      if (!hadSpeech) {
+        RNFS.unlink(this.recordingPath).catch(() => {});
+        this.setState('idle');
+        console.log('[Audio] Aufnahme verworfen — keine Sprache erkannt (nur Umgebungsgeraeusche)');
+        return null;
+      }

      // Audio-Datei als Base64 lesen
      const base64Data = await RNFS.readFile(this.recordingPath, 'base64');
@@ -188,7 +253,7 @@ class AudioService {
      RNFS.unlink(this.recordingPath).catch(() => {});

      this.setState('idle');
-      console.log(`[Audio] Aufnahme beendet (${durationMs}ms, ${Math.round(base64Data.length / 1024)}KB)`);
+      console.log(`[Audio] Aufnahme beendet (${durationMs}ms, ${Math.round(base64Data.length / 1024)}KB, Sprache erkannt)`);

      return {
        base64: base64Data,
@@ -214,6 +279,46 @@ class AudioService {
    }
  }

+  /** Base64-Audio persistent speichern. Gibt file:// Pfad zurueck (oder leer bei Fehler). */
+  async cacheAudio(base64Data: string, messageId: string): Promise<string> {
+    if (!base64Data || !messageId) return '';
+    try {
+      const dir = `${RNFS.DocumentDirectoryPath}/tts_cache`;
+      await RNFS.mkdir(dir).catch(() => {});
+      const path = `${dir}/${messageId}.wav`;
+      // Wenn Datei schon existiert (z.B. XTTS Chunks) → anhaengen statt ueberschreiben
+      const exists = await RNFS.exists(path);
+      if (exists) {
+        // Bestehende + neue Base64 laden, zusammenkleben (fuer jetzt: ueberschreiben)
+        // XTTS sendet mehrere Chunks — bei mehrfacher Ueberschreibung bleibt nur der letzte
+        // Fuer eine echte Konkatenation muesste WAV-Header gemerged werden
+        await RNFS.writeFile(path, base64Data, 'base64');
+      } else {
+        await RNFS.writeFile(path, base64Data, 'base64');
+      }
+      return `file://${path}`;
+    } catch (err) {
+      console.warn('[Audio] cacheAudio fehlgeschlagen:', err);
+      return '';
+    }
+  }
+
+  /** Audio aus lokaler Datei (file:// Pfad) in die Queue und abspielen. */
+  async playFromPath(filePath: string): Promise<void> {
+    if (!filePath) return;
+    try {
+      const cleanPath = filePath.replace(/^file:\/\//, '');
+      if (!(await RNFS.exists(cleanPath))) {
+        console.warn('[Audio] Cache-Datei existiert nicht mehr:', cleanPath);
+        return;
+      }
+      const b64 = await RNFS.readFile(cleanPath, 'base64');
+      this.playAudio(b64);
+    } catch (err) {
+      console.warn('[Audio] playFromPath fehlgeschlagen:', err);
+    }
+  }
+
  // Callback wenn alle Audio-Teile abgespielt sind
  private playbackFinishedListeners: (() => void)[] = [];

@@ -228,11 +333,17 @@ class AudioService {
  private async _playNext(): Promise<void> {
    if (this.audioQueue.length === 0) {
      this.isPlaying = false;
+      // Audio-Focus abgeben → andere Apps volle Lautstaerke
+      AudioFocus?.release().catch(() => {});
      // Alle Audio-Teile abgespielt → Listener benachrichtigen
      this.playbackFinishedListeners.forEach(cb => cb());
      return;
    }

+    // Beim ersten Playback-Start: andere Apps ducken
+    if (!this.isPlaying) {
+      AudioFocus?.requestDuck().catch(() => {});
+    }
    this.isPlaying = true;

    // Preloaded Sound verwenden wenn verfuegbar, sonst neu laden
@@ -308,6 +419,8 @@ class AudioService {
      if (this.preloadedPath) RNFS.unlink(this.preloadedPath).catch(() => {});
      this.preloadedPath = '';
    }
+    // Audio-Focus freigeben
+    AudioFocus?.release().catch(() => {});
  }

  // --- Status & Callbacks ---
@@ -346,6 +459,46 @@ class AudioService {
      this.stateListeners.forEach(cb => cb(state));
    }
  }
+
+  /** Alte Aufnahme- und TTS-Files aus dem Cache loeschen (>30s alt). */
+  private async _cleanupStaleCacheFiles(): Promise<void> {
+    try {
+      const files = await RNFS.readDir(RNFS.CachesDirectoryPath);
+      const now = Date.now();
+      for (const f of files) {
+        if (!f.isFile()) continue;
+        if (!f.name.startsWith('aria_recording_') && !f.name.startsWith('aria_tts_')) continue;
+        const age = now - (f.mtime ? f.mtime.getTime() : 0);
+        if (age > 30000) {
+          await RNFS.unlink(f.path).catch(() => {});
+        }
+      }
+    } catch {
+      // silent — cleanup ist best-effort
+    }
+  }
+
+  /** Alte TTS-Cache-Dateien loeschen die nicht mehr referenziert sind (>30 Tage). */
+  async cleanupOldTTSCache(keepMessageIds: Set<string>, maxAgeDays = 30): Promise<void> {
+    try {
+      const dir = `${RNFS.DocumentDirectoryPath}/tts_cache`;
+      if (!(await RNFS.exists(dir))) return;
+      const files = await RNFS.readDir(dir);
+      const maxAgeMs = maxAgeDays * 24 * 60 * 60 * 1000;
+      const now = Date.now();
+      for (const f of files) {
+        if (!f.isFile() || !f.name.endsWith('.wav')) continue;
+        const messageId = f.name.replace(/\.wav$/, '');
+        const age = now - (f.mtime ? f.mtime.getTime() : 0);
+        // Loeschen wenn: nicht mehr referenziert UND aelter als X Tage
+        if (!keepMessageIds.has(messageId) && age > maxAgeMs) {
+          await RNFS.unlink(f.path).catch(() => {});
+        }
+      }
+    } catch {
+      // silent
+    }
+  }
 }

 // Singleton
@@ -21,8 +21,14 @@ class WakeWordService {
  /** Gespraechsmodus starten */
  async start(): Promise<boolean> {
    if (this.state === 'listening') return true;
-    console.log('[WakeWord] Gespraechsmodus aktiviert — Aufnahme startet nach ARIA-Antwort');
+    console.log('[WakeWord] Gespraechsmodus aktiviert — starte sofort Aufnahme');
    this.setState('listening');
+    // Sofort erste Aufnahme starten
+    setTimeout(() => {
+      if (this.state === 'listening') {
+        this.wakeCallbacks.forEach(cb => cb());
+      }
+    }, 500);
    return true;
  }

@@ -9,3 +9,10 @@ PIPER_THORSTEN=/voices/de_DE-thorsten-high.onnx

 # Wake-Word
 WAKE_WORD=aria
+
+# Whisper STT — wird zur Laufzeit in der Diagnostic (Sektion "Whisper") umgeschaltet
+# und in /shared/config/voice_config.json gespeichert. Der Wert hier ist nur der
+# Initial-Default beim ersten Start.
+# Optionen: tiny | base | small | medium | large-v3
+WHISPER_MODEL=medium
+WHISPER_LANGUAGE=de
@@ -63,7 +63,7 @@ RVS_TLS = os.getenv("RVS_TLS", "true")       # true = wss://, false = ws://
 RVS_TLS_FALLBACK = os.getenv("RVS_TLS_FALLBACK", "true")  # Bei TLS-Fehler ws:// versuchen
 RVS_TOKEN = os.getenv("RVS_TOKEN", "")       # Pairing-Token (gleich wie in der App)
 DIAGNOSTIC_URL = os.getenv("DIAGNOSTIC_URL", "http://127.0.0.1:3001")  # Diagnostic API
-WHISPER_MODEL = os.getenv("WHISPER_MODEL", "small")
+WHISPER_MODEL = os.getenv("WHISPER_MODEL", "medium")
 WHISPER_LANGUAGE = os.getenv("WHISPER_LANGUAGE", "de")

 # Audio-Parameter
@@ -105,7 +105,14 @@ EPIC_TRIGGERS = load_epic_triggers()


 def load_config() -> dict[str, str]:
-    """Laedt Konfiguration aus /config/aria.env."""
+    """Laedt Konfiguration.
+
+    Reihenfolge (hoechste Prioritaet zuletzt):
+    1. /config/aria.env (bind-mount)
+    2. /shared/config/runtime.json (zentral gepflegt ueber Diagnostic UI)
+
+    Werte aus runtime.json ueberschreiben die env-Datei.
+    """
    config: dict[str, str] = {}
    if CONFIG_PATH.exists():
        for line in CONFIG_PATH.read_text().splitlines():
@@ -118,12 +125,115 @@ def load_config() -> dict[str, str]:
        logger.info("Konfiguration geladen aus %s", CONFIG_PATH)
    else:
        logger.warning("Keine Konfiguration gefunden: %s", CONFIG_PATH)
+
+    # Runtime-Overrides aus zentralem Shared-Volume (Diagnostic UI)
+    runtime_path = Path("/shared/config/runtime.json")
+    if runtime_path.exists():
+        try:
+            runtime = json.loads(runtime_path.read_text())
+            overrides = {k: str(v) for k, v in runtime.items() if v not in (None, "")}
+            if overrides:
+                config.update(overrides)
+                logger.info("Runtime-Overrides geladen: %s", sorted(overrides.keys()))
+        except Exception as e:
+            logger.warning("runtime.json konnte nicht gelesen werden: %s", e)
    return config


 # ── Voice Engine ─────────────────────────────────────────────


+import re as _re_tts
+
+_UNIT_WORDS = [
+    (r'\bTB\b', 'Terabyte'),
+    (r'\bGB\b', 'Gigabyte'),
+    (r'\bMB\b', 'Megabyte'),
+    (r'\bKB\b', 'Kilobyte'),
+    (r'\bkB\b', 'Kilobyte'),
+    (r'\bms\b', 'Millisekunden'),
+    (r'\bkm/h\b', 'Kilometer pro Stunde'),
+    (r'\bkm\b', 'Kilometer'),
+    (r'\bm/s\b', 'Meter pro Sekunde'),
+    (r'\bkg\b', 'Kilogramm'),
+    (r'\b°C\b', 'Grad Celsius'),
+    (r'°C', ' Grad Celsius'),
+    (r'\bMbps\b', 'Megabit pro Sekunde'),
+    (r'\bGbps\b', 'Gigabit pro Sekunde'),
+    (r'\bMhz\b|\bMHz\b', 'Megahertz'),
+    (r'\bGhz\b|\bGHz\b', 'Gigahertz'),
+    (r'%', ' Prozent'),
+    (r'\bCPU\b', 'C P U'),
+    (r'\bGPU\b', 'G P U'),
+    (r'\bRAM\b', 'R A M'),
+    (r'\bSSD\b', 'S S D'),
+    (r'\bHDD\b', 'H D D'),
+    (r'\bURL\b', 'U R L'),
+    (r'\bAPI\b', 'A P I'),
+    (r'\bRVS\b', 'R V S'),
+    (r'\bSSH\b', 'S S H'),
+    (r'\bVM\b', 'V M'),
+    (r'\bUI\b', 'U I'),
+    (r'\bTTS\b', 'T T S'),
+    (r'\bSTT\b', 'S T T'),
+    (r'\bTLS\b', 'T L S'),
+]
+
+
+def clean_text_for_tts(text: str) -> str:
+    """Bereitet Chat-Text fuer Sprachausgabe auf.
+
+    - `<voice>...</voice>` Tag: wenn vorhanden, NUR dieser Inhalt wird gelesen
+    - Code-Bloecke (```...``` und `...`) werden komplett entfernt
+    - Markdown (Fett, Kursiv, Links, Headings, Listen, Zitate) wird abgeraeumt
+    - Einheiten und gaengige Abkuerzungen werden ausgeschrieben (22GB → 22 Gigabyte)
+    - URLs werden durch "ein Link" ersetzt
+    - Mehrfach-Leerzeichen/Umbrueche normalisiert
+    """
+    if not text:
+        return ""
+
+    # <voice>...</voice> wenn vorhanden → nur das nehmen
+    voice_match = _re_tts.search(r'<voice>([\s\S]*?)</voice>', text, _re_tts.IGNORECASE)
+    if voice_match:
+        text = voice_match.group(1)
+
+    t = text
+
+    # Code-Bloecke komplett raus (Zeilenumbruch statt Platzhalter — sonst bricht Satzlogik)
+    t = _re_tts.sub(r'```[\s\S]*?```', '. ', t)
+    t = _re_tts.sub(r'`[^`]+`', '', t)
+
+    # Markdown
+    t = _re_tts.sub(r'\*\*([^*]+)\*\*', r'\1', t)
+    t = _re_tts.sub(r'\*([^*]+)\*', r'\1', t)
+    t = _re_tts.sub(r'__([^_]+)__', r'\1', t)
+    t = _re_tts.sub(r'\[([^\]]+)\]\((https?://[^)]+)\)', r'\1, ein Link', t)
+    t = _re_tts.sub(r'\[([^\]]+)\]\([^)]+\)', r'\1', t)
+    t = _re_tts.sub(r'https?://\S+', 'ein Link', t)
+    t = _re_tts.sub(r'^#{1,6}\s*', '', t, flags=_re_tts.MULTILINE)
+    t = _re_tts.sub(r'^>\s*', '', t, flags=_re_tts.MULTILINE)
+    t = _re_tts.sub(r'^[\-\*]\s+', '', t, flags=_re_tts.MULTILINE)
+
+    # Zahlen + Einheit: "22GB" → "22 Gigabyte" (Leerzeichen einfuegen)
+    t = _re_tts.sub(r'(\d+)([A-Za-z]{1,4})\b', r'\1 \2', t)
+
+    # Einheiten/Abkuerzungen ausschreiben
+    for pat, repl in _UNIT_WORDS:
+        t = _re_tts.sub(pat, repl, t)
+
+    # Anfuehrungszeichen
+    t = _re_tts.sub(r'["""„`]', '', t)
+
+    # Absaetze/Zeilenumbrueche normalisieren
+    t = _re_tts.sub(r'\n{2,}', '. ', t)
+    t = _re_tts.sub(r'\n', ', ', t)
+    t = _re_tts.sub(r'\s{2,}', ' ', t)
+    t = _re_tts.sub(r'\s*\.\s*\.\s*', '. ', t)
+
+    return t.strip()
+
+
 class VoiceEngine:
    """Verwaltet Piper TTS mit zwei Stimmen: Ramona und Thorsten."""

@@ -201,21 +311,9 @@ class VoiceEngine:
            return None

        try:
-            # Markdown + Sonderzeichen entfernen fuer natuerliche Sprache
+            # Zentraler TTS-Cleanup (Markdown, Code, Einheiten, URLs)
            import re
-            clean = text.strip()
-            clean = re.sub(r'\*\*([^*]+)\*\*', r'\1', clean)  # **fett**
-            clean = re.sub(r'\*([^*]+)\*', r'\1', clean)      # *kursiv*
-            clean = re.sub(r'`[^`]+`', '', clean)              # `code`
-            clean = re.sub(r'```[\s\S]*?```', '', clean)       # Code-Bloecke
-            clean = re.sub(r'\[([^\]]+)\]\([^)]+\)', r'\1', clean)  # [text](url)
-            clean = re.sub(r'#{1,6}\s*', '', clean)            # ### Ueberschriften
-            clean = re.sub(r'>\s*', '', clean)                 # > Zitate
-            clean = re.sub(r'[-*]\s+', '', clean)              # Listen
-            clean = re.sub(r'\n{2,}', '. ', clean)             # Absaetze
-            clean = re.sub(r'\n', ', ', clean)                 # Zeilenumbrueche
-            clean = re.sub(r'\s{2,}', ' ', clean)              # Mehrfach-Leerzeichen
-            clean = re.sub(r'["""„]', '', clean)               # Anfuehrungszeichen
+            clean = clean_text_for_tts(text)
            sentences = re.split(r'(?<=[.!?])\s+', clean)
            sentences = [s.strip() for s in sentences if s.strip()]

@@ -330,6 +428,25 @@ class STTEngine:
        self.model = WhisperModel(self.model_size, device="cpu", compute_type="int8")
        logger.info("Whisper-Modell geladen")

+    def reload(self, model_size: str) -> bool:
+        """Laedt ein anderes Whisper-Modell (bei Config-Aenderung)."""
+        if model_size == self.model_size and self.model is not None:
+            return False
+        allowed = {"tiny", "base", "small", "medium", "large-v3"}
+        if model_size not in allowed:
+            logger.warning("Ungueltiges Whisper-Modell: %s (erlaubt: %s)", model_size, allowed)
+            return False
+        logger.info("Lade Whisper-Modell neu: %s -> %s", self.model_size, model_size)
+        self.model_size = model_size
+        self.model = None
+        try:
+            self.model = WhisperModel(model_size, device="cpu", compute_type="int8")
+            logger.info("Whisper-Modell '%s' geladen", model_size)
+            return True
+        except Exception:
+            logger.exception("Whisper-Modell '%s' konnte nicht geladen werden", model_size)
+            return False
+
    def transcribe(self, audio_data: np.ndarray) -> str:
        """Transkribiert Audio-Daten zu Text.

@@ -502,6 +619,7 @@ class ARIABridge:
        # Komponenten
        self.voice_engine = VoiceEngine(VOICES_DIR)
        self.tts_enabled = True
+        vc: dict = {}
        # Gespeicherte Voice-Config laden
        try:
            vc_path = "/shared/config/voice_config.json"
@@ -520,8 +638,10 @@ class ARIABridge:
                logger.info("Voice-Config geladen: %s", vc)
        except Exception as e:
            logger.warning("Voice-Config laden fehlgeschlagen: %s", e)
+        # Whisper-Modell: Config hat Vorrang, dann env/Default (medium)
+        whisper_model = vc.get("whisperModel") or self.config.get("WHISPER_MODEL", WHISPER_MODEL)
        self.stt_engine = STTEngine(
-            model_size=self.config.get("WHISPER_MODEL", WHISPER_MODEL),
+            model_size=whisper_model,
            language=self.config.get("WHISPER_LANGUAGE", WHISPER_LANGUAGE),
        )
        self.wake_word = WakeWordDetector()
@@ -530,6 +650,12 @@ class ARIABridge:
        self.ws_core: Optional[websockets.WebSocketClientProtocol] = None
        self.ws_rvs: Optional[websockets.WebSocketClientProtocol] = None

+        # Letzter gesendeter agent_activity-State (zum Entduplizieren)
+        self._last_activity_state: Optional[tuple] = None
+        # Zeitstempel des letzten chat:final — waehrend 3s danach werden
+        # trailing Agent-Events unterdrueckt (Core raeumt manchmal nach).
+        self._last_chat_final_at: float = 0.0
+
    def initialize(self) -> None:
        """Initialisiert alle Komponenten.

@@ -734,8 +860,18 @@ class ARIABridge:
        if event_name == "agent":
            data = payload.get("data", {})
            delta = data.get("delta", "")
-            if delta and payload.get("stream") == "assistant":
+            stream = payload.get("stream", "")
+            if delta and stream == "assistant":
                logger.debug("[core] Delta: '%s'", delta[:40])
+            # Activity-Signal zur App (entdupliziert)
+            tool_name = data.get("name") or data.get("tool") or payload.get("tool") or ""
+            if stream == "tool_use" or data.get("type") == "tool_use":
+                activity = "tool"
+            elif stream == "assistant":
+                activity = "assistant"
+            else:
+                activity = "thinking"
+            await self._emit_activity(activity, tool_name)
            return

        # ── chat Events: Snapshots mit state=delta|final|error ──
@@ -744,6 +880,8 @@ class ARIABridge:

            if state == "final":
                text = self._extract_chat_text(payload)
+                self._last_chat_final_at = asyncio.get_event_loop().time()
+                await self._emit_activity("idle", "")
                if not text:
                    logger.warning("[core] chat final ohne Text: %s", json.dumps(payload)[:200])
                    return
@@ -754,6 +892,8 @@ class ARIABridge:
            if state == "error":
                error = payload.get("error", "Unbekannt")
                logger.error("[core] Chat-Fehler: %s", error)
+                self._last_chat_final_at = asyncio.get_event_loop().time()
+                await self._emit_activity("idle", "")
                await self._send_to_rvs({
                    "type": "chat",
                    "payload": {
@@ -825,6 +965,14 @@ class ARIABridge:
        - Leitet Antwort an die App weiter (via RVS)
        - Sprachausgabe ueber TTS (wenn Modus erlaubt)
        """
+        # NO_REPLY Token: ARIA signalisiert explizit "nicht antworten"
+        # → komplett verwerfen (keine Chat-Nachricht, kein TTS)
+        # Toleranz fuer Variationen: "NO_REPLY", "no_reply", mit Punkt/Anfuehrungszeichen
+        stripped = text.strip().strip('."\'`*').upper()
+        if stripped == "NO_REPLY" or stripped.startswith("NO_REPLY"):
+            logger.info("[core] NO_REPLY empfangen — Antwort still verworfen")
+            return
+
        metadata = payload.get("metadata", {})
        is_critical = metadata.get("critical", False)
        requested_voice = metadata.get("voice")
@@ -847,6 +995,9 @@ class ARIABridge:
        # Stimme auswaehlen
        voice_name = requested_voice or self.voice_engine.select_voice(text)

+        # Eindeutige Message-ID fuer Audio-Cache-Zuordnung
+        message_id = str(uuid.uuid4())
+
        # Antwort an die App weiterleiten (als Chat-Nachricht)
        await self._send_to_rvs({
            "type": "chat",
@@ -854,6 +1005,7 @@ class ARIABridge:
                "text": text,
                "sender": "aria",
                "voice": voice_name,
+                "messageId": message_id,
            },
            "timestamp": int(asyncio.get_event_loop().time() * 1000),
        })
@@ -863,20 +1015,24 @@ class ARIABridge:
            tts_engine = getattr(self, 'tts_engine_type', 'piper')

            if tts_engine == "xtts":
-                # XTTS: Ganzen Text senden, XTTS-Bridge teilt satzweise auf
+                # XTTS: aufbereiteter Text (Code-Bloecke raus, Einheiten ausgeschrieben)
                xtts_voice = getattr(self, 'xtts_voice', '')
+                tts_text = clean_text_for_tts(text)
+                if not tts_text:
+                    logger.info("[core] TTS-Text leer nach Cleanup — XTTS uebersprungen")
+                    return
                try:
                    await self._send_to_rvs({
                        "type": "xtts_request",
                        "payload": {
-                            "text": text,
+                            "text": tts_text,
                            "voice": xtts_voice,
                            "language": "de",
                            "requestId": str(uuid.uuid4()),
                        },
                        "timestamp": int(asyncio.get_event_loop().time() * 1000),
                    })
-                    logger.info("[core] XTTS-Request gesendet (%s): '%s'", xtts_voice or "default", text[:60])
+                    logger.info("[core] XTTS-Request gesendet (%s): '%s'", xtts_voice or "default", tts_text[:60])
                except Exception as e:
                    logger.warning("[core] XTTS-Request fehlgeschlagen: %s — Fallback auf Piper", e)
                    # Fallback auf Piper
@@ -885,7 +1041,7 @@ class ARIABridge:
                        audio_b64 = base64.b64encode(audio_data).decode("ascii")
                        await self._send_to_rvs({
                            "type": "audio",
-                            "payload": {"base64": audio_b64, "mimeType": "audio/wav", "voice": voice_name},
+                            "payload": {"base64": audio_b64, "mimeType": "audio/wav", "voice": voice_name, "messageId": message_id},
                            "timestamp": int(asyncio.get_event_loop().time() * 1000),
                        })
            else:
@@ -899,6 +1055,7 @@ class ARIABridge:
                            "base64": audio_b64,
                            "mimeType": "audio/wav",
                            "voice": voice_name,
+                            "messageId": message_id,
                        },
                        "timestamp": int(asyncio.get_event_loop().time() * 1000),
                })
@@ -1063,6 +1220,12 @@ class ARIABridge:
                await self.send_to_core(text, source="app")
            return

+        if msg_type == "cancel_request":
+            logger.info("[rvs] Cancel-Request von App — rufe Diagnostic /api/cancel auf")
+            await self._cancel_via_diagnostic()
+            await self._emit_activity("idle", "")
+            return
+
        elif msg_type == "xtts_response":
            # XTTS-Audio vom Gaming-PC empfangen → an App weiterleiten
            audio_b64 = payload.get("base64", "")
@@ -1142,6 +1305,15 @@ class ARIABridge:
                self.voice_engine.speech_speed["thorsten"] = max(0.3, min(2.0, float(payload["speedThorsten"])))
                logger.info("[rvs] Speed Thorsten: %.1f", self.voice_engine.speech_speed["thorsten"])
                changed = True
+            whisper_reloaded = False
+            if "whisperModel" in payload:
+                new_model = payload["whisperModel"]
+                if new_model and new_model != self.stt_engine.model_size:
+                    logger.info("[rvs] Whisper-Modell Wechsel: %s -> %s (laedt...)", self.stt_engine.model_size, new_model)
+                    loop = asyncio.get_event_loop()
+                    whisper_reloaded = await loop.run_in_executor(None, self.stt_engine.reload, new_model)
+                    if whisper_reloaded:
+                        changed = True
            # Persistent speichern in Shared Volume
            if changed:
                try:
@@ -1154,6 +1326,7 @@ class ARIABridge:
                        "xttsVoice": getattr(self, "xtts_voice", ""),
                        "speedRamona": self.voice_engine.speech_speed.get("ramona", 1.0),
                        "speedThorsten": self.voice_engine.speech_speed.get("thorsten", 1.0),
+                        "whisperModel": self.stt_engine.model_size,
                    }
                    with open("/shared/config/voice_config.json", "w") as f:
                        json.dump(config_data, f, indent=2)
@@ -1396,6 +1569,43 @@ class ARIABridge:

    # ── Log-Streaming an die App ─────────────────────────────

+    async def _cancel_via_diagnostic(self) -> None:
+        """Ruft das Diagnostic /api/cancel an — dort laeuft die volle Abbruch-Logik
+        (openclaw doctor --fix mit Docker-Socket)."""
+        def _do_request():
+            try:
+                req = urllib.request.Request(
+                    f"{self._diagnostic_url}/api/cancel",
+                    method="POST",
+                    data=b"",
+                )
+                with urllib.request.urlopen(req, timeout=5) as resp:
+                    return resp.status
+            except Exception as e:
+                return f"error: {e}"
+
+        status = await asyncio.get_event_loop().run_in_executor(None, _do_request)
+        logger.info("[cancel] Diagnostic /api/cancel: %s", status)
+
+    async def _emit_activity(self, activity: str, tool: str = "") -> None:
+        """Sendet agent_activity an die App — nur wenn sich der State geaendert hat.
+
+        Trailing Agent-Events nach chat:final werden 3s lang unterdrueckt
+        (nur 'idle' kommt immer durch)."""
+        if activity != "idle" and self._last_chat_final_at > 0:
+            since_final = asyncio.get_event_loop().time() - self._last_chat_final_at
+            if since_final < 3.0:
+                return
+        state = (activity, tool)
+        if state == self._last_activity_state:
+            return
+        self._last_activity_state = state
+        await self._send_to_rvs({
+            "type": "agent_activity",
+            "payload": {"activity": activity, "tool": tool},
+            "timestamp": int(asyncio.get_event_loop().time() * 1000),
+        })
+
    async def send_log_to_app(self, source: str, message: str, level: str = "info") -> None:
        """Sendet einen Log-Eintrag an die App (erscheint im Log-Viewer)."""
        await self._send_to_rvs({
@@ -0,0 +1,44 @@
+#!/bin/bash
+# ARIA Docker Cleanup
+#
+# Standard:  docker builder prune + image prune (sicher, loescht keine Volumes)
+# --full:    Volle Reinigung inkl. --volumes (Vorsicht bei ungenutzten Volumes!)
+#
+# Usage:
+#   ./cleanup.sh           # sicherer Cleanup
+#   ./cleanup.sh --full    # aggressiver Cleanup (inkl. Volumes)
+
+set -e
+
+FULL=0
+for arg in "$@"; do
+  case "$arg" in
+    --full|-f) FULL=1 ;;
+    -h|--help)
+      grep '^#' "$0" | sed 's/^# \{0,1\}//'
+      exit 0
+      ;;
+  esac
+done
+
+echo "── Docker Speicher VOR Cleanup ───────────────────"
+docker system df
+echo
+
+if [ "$FULL" = "1" ]; then
+  echo ">>> VOLLE Reinigung (inkl. ungenutzter Volumes)"
+  read -p "Wirklich? [y/N] " -n 1 -r REPLY
+  echo
+  [[ ! $REPLY =~ ^[Yy]$ ]] && { echo "Abgebrochen."; exit 0; }
+  docker system prune -a --volumes -f
+else
+  echo ">>> Sicherer Cleanup (Build-Cache + ungenutzte Images)"
+  docker builder prune -a -f
+  docker image prune -a -f
+fi
+
+echo
+echo "── Docker Speicher NACH Cleanup ──────────────────"
+docker system df
+echo
+df -h / | head -2
@@ -201,7 +201,7 @@
        <button class="btn secondary" onclick="toggleChatFullscreen()" id="btn-chat-fs" style="padding:4px 10px;font-size:11px;">Vollbild</button>
      </div>
      <div class="chat-box" id="chat-box"></div>
-      <div id="thinking-indicator" style="display:none;padding:6px 10px;font-size:12px;color:#FFD60A;background:#1E1E2E;border-radius:0 0 6px 6px;margin-top:-8px;margin-bottom:8px;display:flex;align-items:center;justify-content:space-between;">
+      <div id="thinking-indicator" style="display:none;padding:6px 10px;font-size:12px;color:#FFD60A;background:#1E1E2E;border-radius:0 0 6px 6px;margin-top:-8px;margin-bottom:8px;align-items:center;justify-content:space-between;">
        <span><span style="animation:pulse 1s infinite;">&#x1F4AD;</span> <span id="thinking-text">ARIA denkt...</span></span>
        <button class="btn secondary" onclick="cancelRequest()" style="padding:2px 10px;font-size:11px;color:#FF3B30;border-color:#FF3B30;">Abbrechen</button>
      </div>
@@ -499,6 +499,93 @@
      </div>
    </div>

+    <!-- Whisper (STT) -->
+    <div class="settings-section">
+      <h2>Whisper (Spracherkennung)</h2>
+      <div style="font-size:11px;color:#8888AA;margin-bottom:8px;">
+        Aenderungen werden sofort an die Bridge gesendet und das Modell neu geladen
+        (kann bei medium/large 10-30s dauern — waehrend dieser Zeit ist STT kurz pausiert).
+      </div>
+      <div class="card" style="max-width:500px;">
+        <div style="display:flex;align-items:center;gap:12px;margin-bottom:8px;">
+          <label style="color:#8888AA;font-size:12px;min-width:80px;">Modell:</label>
+          <select id="diag-whisper-model" onchange="sendVoiceConfig()" style="flex:1;background:#1E1E2E;color:#fff;border:1px solid #2A2A3E;border-radius:6px;padding:6px 10px;font-size:13px;">
+            <option value="tiny">tiny (39MB, schnell, niedrige Qualitaet)</option>
+            <option value="base">base (74MB, schnell, ok)</option>
+            <option value="small">small (244MB, mittel)</option>
+            <option value="medium" selected>medium (769MB, gut — Empfehlung)</option>
+            <option value="large-v3">large-v3 (1.5GB, beste Qualitaet, langsam auf CPU)</option>
+          </select>
+        </div>
+        <div style="font-size:10px;color:#555570;">
+          Tipp: <code>medium</code> ist der beste Kompromiss fuer CPU. <code>large-v3</code> nur bei GPU sinnvoll.
+        </div>
+      </div>
+    </div>
+
+    <!-- Runtime-Konfiguration (migriert von .env) -->
+    <div class="settings-section">
+      <h2>Runtime-Konfiguration</h2>
+      <div style="font-size:11px;color:#8888AA;margin-bottom:8px;">
+        Werte werden in <code>/shared/config/runtime.json</code> persistiert und
+        ueberschreiben die ENV-Variablen aus <code>aria.env</code>. Bridge liest
+        sie beim naechsten Start — nach Aenderung <b>Bridge-Container neu starten</b>
+        (Diagnostic-Container bleibt auf ENV).
+      </div>
+      <div class="card" style="max-width:600px;">
+        <div style="display:grid;grid-template-columns:140px 1fr;gap:8px 10px;align-items:center;font-size:13px;">
+          <label style="color:#8888AA;">RVS Host:</label>
+          <input type="text" id="rc-rvs-host" style="width:100%;box-sizing:border-box;background:#1E1E2E;border:1px solid #2A2A3E;border-radius:4px;padding:6px;color:#fff;">
+          <label style="color:#8888AA;">RVS Port:</label>
+          <input type="text" id="rc-rvs-port" style="width:100%;box-sizing:border-box;background:#1E1E2E;border:1px solid #2A2A3E;border-radius:4px;padding:6px;color:#fff;">
+          <label style="color:#8888AA;">RVS TLS:</label>
+          <select id="rc-rvs-tls" style="width:100%;box-sizing:border-box;background:#1E1E2E;border:1px solid #2A2A3E;border-radius:4px;padding:6px;color:#fff;">
+            <option value="true">true (wss://)</option>
+            <option value="false">false (ws://)</option>
+          </select>
+          <label style="color:#8888AA;">RVS Token:</label>
+          <div style="display:flex;gap:4px;min-width:0;">
+            <input type="password" id="rc-rvs-token" style="flex:1;min-width:0;box-sizing:border-box;background:#1E1E2E;border:1px solid #2A2A3E;border-radius:4px;padding:6px;color:#fff;font-family:monospace;">
+            <button type="button" class="btn secondary" onclick="toggleSecret('rc-rvs-token', this)" style="padding:4px 10px;flex-shrink:0;" title="Anzeigen/Verbergen">&#128065;</button>
+          </div>
+          <label style="color:#8888AA;">Aria Auth Token:</label>
+          <div style="display:flex;gap:4px;min-width:0;">
+            <input type="password" id="rc-auth-token" style="flex:1;min-width:0;box-sizing:border-box;background:#1E1E2E;border:1px solid #2A2A3E;border-radius:4px;padding:6px;color:#fff;font-family:monospace;">
+            <button type="button" class="btn secondary" onclick="toggleSecret('rc-auth-token', this)" style="padding:4px 10px;flex-shrink:0;" title="Anzeigen/Verbergen">&#128065;</button>
+          </div>
+        </div>
+        <div style="display:flex;gap:8px;margin-top:12px;">
+          <button class="btn" onclick="saveRuntimeConfig()" style="flex:1;">Speichern</button>
+          <button class="btn secondary" onclick="loadRuntimeConfig()" style="flex:1;">Neu laden</button>
+        </div>
+        <div id="rc-status" style="font-size:11px;color:#555570;margin-top:6px;"></div>
+      </div>
+    </div>
+
+    <!-- App-Onboarding via QR-Code -->
+    <div class="settings-section">
+      <h2>App-Onboarding (QR-Code)</h2>
+      <div style="font-size:11px;color:#8888AA;margin-bottom:8px;">
+        RVS-Credentials als QR-Code — App scannt, keine manuelle Eingabe.
+        Enthaelt Host, Port, TLS-Flag und Token.
+      </div>
+      <div class="card" style="max-width:500px;">
+        <div style="display:flex;gap:12px;align-items:flex-start;">
+          <div id="onboarding-qr" style="width:220px;height:220px;flex-shrink:0;background:#1E1E2E;border-radius:6px;overflow:hidden;display:flex;align-items:center;justify-content:center;color:#555570;font-size:11px;text-align:center;">
+            QR-Code wird geladen...
+          </div>
+          <div style="flex:1;font-size:11px;color:#8888AA;line-height:1.5;">
+            <div style="color:#FF9500;font-weight:bold;margin-bottom:4px;">Achtung</div>
+            Dieser QR enthaelt den RVS-Token im Klartext — zeige ihn niemandem,
+            speichere keine Screenshots davon in unsicheren Cloud-Diensten.
+            <button class="btn" onclick="loadOnboardingQR()" style="margin-top:10px;width:100%;">
+              QR neu generieren
+            </button>
+          </div>
+        </div>
+      </div>
+    </div>
+
    <!-- Highlight-Trigger -->
    <div class="settings-section">
      <h2>Highlight-Trigger</h2>
@@ -763,6 +850,11 @@
          }
          xttsSelect.value = xttsVoice;
          toggleXTTSPanel();
+          // Whisper-Modell wiederherstellen (falls gesetzt)
+          if (msg.whisperModel) {
+            const wSel = document.getElementById('diag-whisper-model');
+            if (wSel) wSel.value = msg.whisperModel;
+          }
          return;
        }

@@ -891,6 +983,18 @@
          else alert('Loeschen fehlgeschlagen: ' + (msg.error || '?'));
          return;
        }
+        if (msg.type === 'session_export') {
+          if (!msg.ok) { alert('Export fehlgeschlagen: ' + (msg.error || '?')); return; }
+          const blob = new Blob([msg.markdown], { type: 'text/markdown;charset=utf-8' });
+          const url = URL.createObjectURL(blob);
+          const a = document.createElement('a');
+          a.href = url;
+          a.download = msg.filename;
+          document.body.appendChild(a);
+          a.click();
+          setTimeout(() => { URL.revokeObjectURL(url); a.remove(); }, 100);
+          return;
+        }
        if (msg.type === 'active_session') {
          updateActiveSessionBar(msg.sessionKey);
          loadSessions(); // Tabelle neu rendern
@@ -1263,7 +1367,11 @@
        label = 'ARIA schreibt...';
      }

-      indicators.forEach(el => { if (el) el.style.display = 'block'; });
+      indicators.forEach((el, i) => {
+        if (!el) return;
+        // Haupt-Indicator ist flex (Abbrechen-Button rechts), Vollbild-Variante block
+        el.style.display = i === 0 ? 'flex' : 'block';
+      });
      texts.forEach(el => { if (el) el.textContent = label; });

      // Auto-Hide nach 2min (falls idle Event verpasst wird — ARIA arbeitet max 15min)
@@ -1392,7 +1500,120 @@
      const speedThorsten = parseFloat(document.getElementById('diag-speed-thorsten').value);
      const ttsEngine = document.getElementById('diag-tts-engine').value;
      const xttsVoice = document.getElementById('diag-xtts-voice').value;
-      send({ action: 'send_voice_config', defaultVoice, highlightVoice, ttsEnabled, speedRamona, speedThorsten, ttsEngine, xttsVoice });
+      const whisperModel = document.getElementById('diag-whisper-model').value;
+      send({ action: 'send_voice_config', defaultVoice, highlightVoice, ttsEnabled, speedRamona, speedThorsten, ttsEngine, xttsVoice, whisperModel });
+    }
+
+    // ── Passwort-Feld Anzeigen/Verbergen ─────────────────────
+    function toggleSecret(inputId, btn) {
+      const el = document.getElementById(inputId);
+      if (!el) return;
+      if (el.type === 'password') {
+        el.type = 'text';
+        btn.innerHTML = '&#128064;'; // 👀
+        btn.title = 'Verbergen';
+      } else {
+        el.type = 'password';
+        btn.innerHTML = '&#128065;'; // 👁
+        btn.title = 'Anzeigen';
+      }
+    }
+
+    // ── Runtime-Konfiguration ─────────────────────
+    async function loadRuntimeConfig() {
+      const statusEl = document.getElementById('rc-status');
+      statusEl.textContent = 'Lade...';
+      try {
+        const resp = await fetch('/api/runtime-config');
+        const cfg = await resp.json();
+        document.getElementById('rc-rvs-host').value = cfg.RVS_HOST || '';
+        document.getElementById('rc-rvs-port').value = cfg.RVS_PORT || '443';
+        document.getElementById('rc-rvs-tls').value = String(cfg.RVS_TLS) === 'false' ? 'false' : 'true';
+        document.getElementById('rc-rvs-token').value = cfg.RVS_TOKEN || '';
+        document.getElementById('rc-auth-token').value = cfg.ARIA_AUTH_TOKEN || '';
+        statusEl.textContent = 'Geladen.';
+        statusEl.style.color = '#34C759';
+        loadOnboardingQR(); // QR bei Config-Wechsel neu generieren
+      } catch (e) {
+        statusEl.textContent = 'Fehler: ' + e.message;
+        statusEl.style.color = '#FF6B6B';
+      }
+    }
+
+    async function saveRuntimeConfig() {
+      const statusEl = document.getElementById('rc-status');
+      statusEl.textContent = 'Speichere...';
+      const patch = {
+        RVS_HOST: document.getElementById('rc-rvs-host').value.trim(),
+        RVS_PORT: document.getElementById('rc-rvs-port').value.trim(),
+        RVS_TLS: document.getElementById('rc-rvs-tls').value,
+        RVS_TOKEN: document.getElementById('rc-rvs-token').value.trim(),
+        ARIA_AUTH_TOKEN: document.getElementById('rc-auth-token').value.trim(),
+      };
+      try {
+        const resp = await fetch('/api/runtime-config', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify(patch),
+        });
+        const data = await resp.json();
+        if (data.ok) {
+          statusEl.textContent = 'Gespeichert — Bridge-Container fuer Uebernahme neu starten.';
+          statusEl.style.color = '#FFD60A';
+          loadOnboardingQR(); // QR mit neuem Token
+        } else {
+          throw new Error(data.error || 'Unbekannt');
+        }
+      } catch (e) {
+        statusEl.textContent = 'Fehler: ' + e.message;
+        statusEl.style.color = '#FF6B6B';
+      }
+    }
+
+    // ── App-Onboarding QR-Code ────────────────────
+    let qrLibReady = false;
+    function ensureQRLib() {
+      return new Promise((resolve) => {
+        if (qrLibReady || window.qrcode) { qrLibReady = true; resolve(); return; }
+        const s = document.createElement('script');
+        s.src = 'https://cdn.jsdelivr.net/npm/qrcode-generator@1.4.4/qrcode.min.js';
+        s.onload = () => { qrLibReady = true; resolve(); };
+        s.onerror = () => resolve(); // silent fail
+        document.head.appendChild(s);
+      });
+    }
+
+    async function loadOnboardingQR() {
+      const box = document.getElementById('onboarding-qr');
+      box.textContent = 'Lade...';
+      try {
+        await ensureQRLib();
+        if (!window.qrcode) throw new Error('QR-Library nicht geladen');
+        const resp = await fetch('/api/onboarding');
+        const cfg = await resp.json();
+        if (!cfg.rvsHost || !cfg.rvsToken) {
+          box.innerHTML = '<div style="color:#FF6B6B;">RVS nicht konfiguriert (ENV Variablen fehlen)</div>';
+          return;
+        }
+        // Format kompatibel mit android/src/components/QRScanner.tsx parseQRData()
+        const payload = JSON.stringify({
+          host: cfg.rvsHost,
+          port: Number(cfg.rvsPort) || 443,
+          tls: cfg.rvsTLS !== false,
+          token: cfg.rvsToken,
+        });
+        const qr = window.qrcode(0, 'M');
+        qr.addData(payload);
+        qr.make();
+        // Als SVG rendern — skaliert sauber auf Container-Groesse
+        box.innerHTML = qr.createSvgTag({ cellSize: 4, margin: 2, scalable: true });
+        const svg = box.querySelector('svg');
+        if (svg) {
+          svg.style.cssText = 'width:100%;height:100%;background:#fff;border-radius:4px;padding:6px;box-sizing:border-box;display:block;';
+        }
+      } catch (e) {
+        box.innerHTML = `<div style="color:#FF6B6B;">Fehler: ${e.message}</div>`;
+      }
    }

    // ── Highlight-Trigger ────────────────────────
@@ -1657,32 +1878,60 @@
          : '<div style="color:#555570;padding:8px;text-align:center;">Keine Sessions gefunden</div>';
        return;
      }
-      let html = '<table style="width:100%;border-collapse:collapse;">';
-      html += '<tr style="color:#8888AA;font-size:10px;text-align:left;border-bottom:1px solid #1E1E2E;">'
+
+      const active = data.sessions.filter(s => !s.archived);
+      const archives = data.sessions.filter(s => s.archived);
+
+      const headerRow = '<tr style="color:#8888AA;font-size:10px;text-align:left;border-bottom:1px solid #1E1E2E;">'
            + '<th style="padding:4px 6px;">Session</th>'
            + '<th style="padding:4px 6px;">Msgs</th>'
            + '<th style="padding:4px 6px;">Zuletzt</th>'
            + '<th style="padding:4px 6px;"></th></tr>';
-      for (const s of data.sessions) {
+
+      const rowFor = (s, opts) => {
        const date = s.modified ? new Date(s.modified * 1000).toLocaleString('de-DE', {day:'2-digit',month:'2-digit',hour:'2-digit',minute:'2-digit'}) : '?';
        const key = escapeHtml(s.sessionKey || s.path.split('/').pop());
        const orphanBadge = s.orphan ? ' <span style="background:#FF3B30;color:#fff;font-size:9px;padding:1px 4px;border-radius:3px;">verwaist</span>' : '';
+        const archivedBadge = s.archived ? ' <span style="background:#555570;color:#fff;font-size:9px;padding:1px 4px;border-radius:3px;">archiv</span>' : '';
        const modelBadge = s.model ? `<div style="font-size:9px;color:#555570;">${escapeHtml(s.model)}</div>` : '';
-        const isActive = (s.sessionKey === currentActiveSession);
-        const keyColor = isActive ? '#34C759' : (s.orphan ? '#555570' : '#E0E0F0');
+        const isActive = (s.sessionKey === currentActiveSession) && !s.archived;
+        const keyColor = isActive ? '#34C759' : (s.archived || s.orphan ? '#8888AA' : '#E0E0F0');
        const activeBadge = isActive ? ' <span style="background:#34C759;color:#000;font-size:9px;padding:1px 4px;border-radius:3px;">aktiv</span>' : '';
-        const rowBg = isActive ? 'background:rgba(52,199,89,0.08);' : '';
-        html += `<tr style="border-bottom:1px solid #0D0D1A;cursor:pointer;${rowBg}" onmouseover="this.style.background='#1E1E2E'" onmouseout="this.style.background='${isActive ? 'rgba(52,199,89,0.08)' : ''}'">`
+        const rowBg = isActive ? 'background:rgba(52,199,89,0.08);' : (s.archived ? 'background:rgba(136,136,170,0.04);' : '');
+
+        let actions = '';
+        if (s.archived) {
+          // Archive: nur Export + Loeschen (kein Aktivieren — wuerde aktive Session ueberschreiben)
+          actions = `<button class="btn secondary" onclick="event.stopPropagation();deleteSession('${escapeHtml(s.path)}')" style="padding:2px 6px;font-size:10px;color:#FF6B6B;margin-right:2px;" title="Archiv endgueltig loeschen">X</button>`
+                  + `<button class="btn secondary" onclick="event.stopPropagation();exportSession('${escapeHtml(s.path)}','${escapeHtml(s.sessionKey)}')" style="padding:2px 6px;font-size:10px;color:#8888AA;" title="Als Markdown exportieren">&#x2B07;</button>`;
+        } else {
+          actions = (isActive ? '' : `<button class="btn secondary" onclick="event.stopPropagation();activateSession('${escapeHtml(s.sessionKey)}')" style="padding:2px 6px;font-size:10px;color:#34C759;margin-right:2px;" title="Aktivieren">&#9654;</button>`)
+                  + `<button class="btn secondary" onclick="event.stopPropagation();deleteSession('${escapeHtml(s.path)}')" style="padding:2px 6px;font-size:10px;color:#FF6B6B;margin-right:2px;" title="Loeschen">X</button>`
+                  + `<button class="btn secondary" onclick="event.stopPropagation();exportSession('${escapeHtml(s.path)}','${escapeHtml(s.sessionKey)}')" style="padding:2px 6px;font-size:10px;color:#8888AA;" title="Als Markdown exportieren">&#x2B07;</button>`;
+        }
+
+        return `<tr style="border-bottom:1px solid #0D0D1A;cursor:pointer;${rowBg}" onmouseover="this.style.background='#1E1E2E'" onmouseout="this.style.background='${isActive ? 'rgba(52,199,89,0.08)' : (s.archived ? 'rgba(136,136,170,0.04)' : '')}'">`
              + `<td style="padding:4px 6px;" onclick="viewSession('${escapeHtml(s.path)}')">`
-              + `<div style="color:${keyColor};">${key}${activeBadge}${orphanBadge}</div>${modelBadge}</td>`
+              + `<div style="color:${keyColor};">${key}${activeBadge}${orphanBadge}${archivedBadge}</div>${modelBadge}</td>`
              + `<td style="padding:4px 6px;color:#8888AA;">${s.lines}</td>`
              + `<td style="padding:4px 6px;color:#8888AA;font-size:10px;">${date}</td>`
-              + `<td style="padding:4px 6px;white-space:nowrap;">`
-              + (isActive ? '' : `<button class="btn secondary" onclick="event.stopPropagation();activateSession('${escapeHtml(s.sessionKey)}')" style="padding:2px 6px;font-size:10px;color:#34C759;margin-right:2px;" title="Aktivieren">&#9654;</button>`)
-              + `<button class="btn secondary" onclick="event.stopPropagation();deleteSession('${escapeHtml(s.path)}')" style="padding:2px 6px;font-size:10px;color:#FF6B6B;" title="Loeschen">X</button>`
-              + `</td></tr>`;
-      }
+              + `<td style="padding:4px 6px;white-space:nowrap;">${actions}</td></tr>`;
+      };
+
+      let html = '<table style="width:100%;border-collapse:collapse;">' + headerRow;
+      for (const s of active) html += rowFor(s);
      html += '</table>';
+
+      if (archives.length > 0) {
+        html += `<details style="margin-top:12px;" ${archives.length <= 5 ? 'open' : ''}>`
+              + `<summary style="color:#8888AA;font-size:11px;cursor:pointer;padding:4px 0;">`
+              + `Archivierte Versionen (${archives.length}) — von OpenClaw beim Session-Reset gesichert`
+              + `</summary>`
+              + `<table style="width:100%;border-collapse:collapse;margin-top:6px;">` + headerRow;
+        for (const s of archives) html += rowFor(s);
+        html += '</table></details>';
+      }
+
      container.innerHTML = html;
    }

@@ -1743,6 +1992,10 @@
      send({ action: 'delete_session', sessionPath: path });
    }

+    function exportSession(path, sessionKey) {
+      send({ action: 'export_session', sessionPath: path, sessionKey });
+    }
+
    function activateSession(sessionKey) {
      send({ action: 'set_active_session', sessionKey });
    }
@@ -1843,10 +2096,12 @@
      document.querySelectorAll('.main-nav-btn').forEach(b => {
        if (b.textContent.trim().toLowerCase().includes(tab === 'main' ? 'main' : 'einstellung')) b.classList.add('active');
      });
-      // Einstellungen: Config + Trigger laden
+      // Einstellungen: Config + Trigger + QR laden
      if (tab === 'settings') {
        loadHighlightTriggers();
        send({ action: 'get_voice_config' });
+        loadRuntimeConfig();
+        loadOnboardingQR();
      }
    }

@@ -37,15 +37,76 @@ const state = {
 };
 const SESSION_KEY_FILE = "/data/active-session";
 // /data Verzeichnis sicherstellen (Volume Mount)
-try { fs.mkdirSync("/data", { recursive: true }); } catch {}
+try { fs.mkdirSync("/data", { recursive: true }); } catch (e) {
+  console.error(`[startup] /data mkdir fehlgeschlagen: ${e.message}`);
+}
+// sessionFromFile zeigt an, ob der aktive Key aus der Datei kam.
+// Wenn true, darf resolveActiveSession NICHT mehr auto-picken (Wahl respektieren).
+let sessionFromFile = false;
 let activeSessionKey = (() => {
  try {
    const saved = fs.readFileSync(SESSION_KEY_FILE, "utf-8").trim();
-    if (saved) { console.log(`[startup] Gespeicherte Session geladen: '${saved}'`); return saved; }
-  } catch {}
+    if (saved) {
+      console.log(`[startup] Gespeicherte Session geladen: '${saved}'`);
+      sessionFromFile = true;
+      return saved;
+    }
+  } catch (e) {
+    console.error(`[startup] SESSION_KEY_FILE read: ${e.code || e.message}`);
+  }
  console.log("[startup] Keine gespeicherte Session — Fallback 'main'");
  return "main";
 })();
+
+// ── Runtime-Config: /shared/config/runtime.json ─────────────
+// ENV-Werte sind Defaults; Werte aus runtime.json haben Vorrang.
+// Bridge und ggf. andere Komponenten lesen dieselbe Datei.
+const RUNTIME_CONFIG_FILE = "/shared/config/runtime.json";
+const RUNTIME_CONFIG_FIELDS = [
+  "RVS_HOST", "RVS_PORT", "RVS_TLS", "RVS_TOKEN",
+  "ARIA_AUTH_TOKEN", "WHISPER_MODEL", "WHISPER_LANGUAGE",
+];
+function readRuntimeConfig() {
+  const envDefaults = {
+    RVS_HOST, RVS_PORT, RVS_TLS, RVS_TOKEN,
+    ARIA_AUTH_TOKEN: process.env.ARIA_AUTH_TOKEN || "",
+    WHISPER_MODEL: process.env.WHISPER_MODEL || "medium",
+    WHISPER_LANGUAGE: process.env.WHISPER_LANGUAGE || "de",
+  };
+  try {
+    const raw = fs.readFileSync(RUNTIME_CONFIG_FILE, "utf-8");
+    const parsed = JSON.parse(raw);
+    return { ...envDefaults, ...parsed };
+  } catch {
+    return envDefaults;
+  }
+}
+function writeRuntimeConfig(patch) {
+  let current = {};
+  try { current = JSON.parse(fs.readFileSync(RUNTIME_CONFIG_FILE, "utf-8")); } catch {}
+  for (const key of Object.keys(patch)) {
+    if (RUNTIME_CONFIG_FIELDS.includes(key)) current[key] = patch[key];
+  }
+  fs.mkdirSync("/shared/config", { recursive: true });
+  const tmp = RUNTIME_CONFIG_FILE + ".tmp";
+  fs.writeFileSync(tmp, JSON.stringify(current, null, 2));
+  fs.renameSync(tmp, RUNTIME_CONFIG_FILE);
+}
+
+// Atomic write: temp-file + rename, laute Logs bei Fehler.
+function persistActiveSession(key) {
+  try {
+    const tmp = SESSION_KEY_FILE + ".tmp";
+    fs.writeFileSync(tmp, key);
+    fs.renameSync(tmp, SESSION_KEY_FILE);
+    sessionFromFile = true;
+    console.log(`[session] Aktive Session persistiert: '${key}'`);
+    return true;
+  } catch (e) {
+    console.error(`[session] FEHLER beim Persistieren von '${key}': ${e.message}`);
+    return false;
+  }
+}
 const logs = [];
 let gatewayWs = null;
 let rvsWs = null;
@@ -56,6 +117,12 @@ const browserClients = new Set();
 let pipelineActive = false;
 let pipelineStartTime = 0;

+// Nach chat:final kommen oft noch Trailing Agent-Events. Waehrend dieses
+// Fensters unterdruecken wir agent_activity-Broadcasts, damit der
+// Thinking-Indicator nicht wieder anspringt.
+let lastChatFinalAt = 0;
+const SETTLED_WINDOW_MS = 3000;
+
 function plog(message, level) {
  const elapsed = pipelineActive ? `+${Date.now() - pipelineStartTime}ms` : "";
  const entry = { ts: new Date().toISOString(), level: level || "info", source: "pipeline", message: `${elapsed ? `[${elapsed}] ` : ""}${message}` };
@@ -91,6 +158,9 @@ function pipelineEnd(ok, detail) {
  }
  plog(`━━━ Pipeline Ende ━━━`);
  pipelineActive = false;
+  // Thinking-Indikator IMMER zuruecksetzen — auch bei Timeout/Fehler/Abbruch
+  broadcast({ type: "agent_activity", activity: "idle" });
+  pendingMessageTime = 0;
 }

 // ── Auto-Restart bei Netzwerk-Namespace-Verlust ──────
@@ -257,8 +327,10 @@ async function connectGateway() {
      state.gateway.handshakeOk = false;
      gatewayWs = null;
      broadcastState();
+      // Stuck "ARIA denkt..." vermeiden, falls Gateway waehrend Pipeline abkackt
+      if (pipelineActive) pipelineEnd(false, `Gateway-Verbindung verloren (${code})`);
+      else broadcast({ type: "agent_activity", activity: "idle" });
      checkGatewayHealth();
-      // Auto-Reconnect nach 5s
      setTimeout(connectGateway, 5000);
    });

@@ -325,17 +397,22 @@ function handleGatewayMessage(msg) {
        broadcast({ type: "chat_delta", delta, payload });
      }

+      // Nach chat:final trickeln noch Aufraeum-Events rein — unterdruecken,
+      // damit der Thinking-Indicator nicht wieder anspringt.
+      const settled = lastChatFinalAt && (Date.now() - lastChatFinalAt) < SETTLED_WINDOW_MS;
+
      // Tool-Nutzung erkennen und broadcasten
      if (stream === "tool_use" || data.type === "tool_use") {
        const toolName = data.name || data.tool || payload.tool || "";
-        if (toolName) {
+        if (toolName && !settled) {
          broadcast({ type: "agent_activity", activity: "tool", tool: toolName, data });
          log("info", "gateway", `Tool: ${toolName}`);
        }
      }

-      // Genereller Activity-Heartbeat (ARIA denkt)
-      broadcast({ type: "agent_activity", activity: stream || "thinking" });
+      if (!settled) {
+        broadcast({ type: "agent_activity", activity: stream || "thinking" });
+      }
      updateAgentActivity();
      return;
    }
@@ -349,7 +426,21 @@ function handleGatewayMessage(msg) {
        const runId = payload.runId || "";
        if (runId && seenFinalRuns.has(runId)) return; // Duplikat
        if (runId) { seenFinalRuns.add(runId); setTimeout(() => seenFinalRuns.delete(runId), 60000); }
+
+        // NO_REPLY → ARIA signalisiert "nicht antworten", Pipeline beenden aber nichts zeigen
+        const trimmed = (text || "").trim().replace(/^["'`*.\s]+|["'`*.\s]+$/g, "").toUpperCase();
+        if (trimmed === "NO_REPLY" || trimmed.startsWith("NO_REPLY")) {
+          log("info", "gateway", "NO_REPLY empfangen — still verworfen");
+          lastChatFinalAt = Date.now();
+          if (pipelineActive) pipelineEnd(true, "NO_REPLY (stumm)");
+          broadcast({ type: "agent_activity", activity: "idle" });
+          pendingMessageTime = 0;
+          updateAgentActivity();
+          return;
+        }
+
        log("info", "gateway", `ANTWORT: "${text.slice(0, 200)}"`);
+        lastChatFinalAt = Date.now();
        if (pipelineActive) pipelineEnd(true, `"${text.slice(0, 120)}"`);
        broadcast({ type: "chat_final", text, payload });
        broadcast({ type: "agent_activity", activity: "idle" });
@@ -372,6 +463,7 @@ function handleGatewayMessage(msg) {
        const error = payload.error || text || "Unbekannt";
        log("error", "gateway", `Chat-Fehler: ${error}`);
        if (pipelineActive) pipelineEnd(false, error);
+        else broadcast({ type: "agent_activity", activity: "idle" });
        broadcast({ type: "chat_error", error, payload });
        return;
      }
@@ -392,7 +484,9 @@ function handleGatewayMessage(msg) {
      if (runId) { seenFinalRuns.add(runId); setTimeout(() => seenFinalRuns.delete(runId), 60000); }
      const text = extractChatText(payload) || payload.text || "";
      log("info", "gateway", `ANTWORT: "${text.slice(0, 200)}"`);
+      lastChatFinalAt = Date.now();
      if (pipelineActive) pipelineEnd(true, `"${text.slice(0, 120)}"`);
+      else broadcast({ type: "agent_activity", activity: "idle" });
      broadcast({ type: "chat_final", text, payload });
      return;
    }
@@ -400,6 +494,7 @@ function handleGatewayMessage(msg) {
      const error = payload.error || payload.message || "Unbekannt";
      log("error", "gateway", `Chat-Fehler: ${error}`);
      if (pipelineActive) pipelineEnd(false, error);
+      else broadcast({ type: "agent_activity", activity: "idle" });
      broadcast({ type: "chat_error", error, payload });
      return;
    }
@@ -1109,6 +1204,45 @@ const server = http.createServer((req, res) => {
  } else if (req.url === "/api/session") {
    res.writeHead(200, { "Content-Type": "application/json" });
    res.end(JSON.stringify({ sessionKey: activeSessionKey }));
+  } else if (req.url === "/api/runtime-config" && req.method === "GET") {
+    // Zentrale Runtime-Config (ENV + Override aus /shared/config/runtime.json)
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify(readRuntimeConfig()));
+  } else if (req.url === "/api/runtime-config" && req.method === "POST") {
+    let body = "";
+    req.on("data", chunk => { body += chunk; if (body.length > 32768) req.destroy(); });
+    req.on("end", () => {
+      try {
+        const patch = JSON.parse(body);
+        writeRuntimeConfig(patch);
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ ok: true, config: readRuntimeConfig() }));
+        log("info", "server", `Runtime-Config aktualisiert: ${Object.keys(patch).join(", ")}`);
+      } 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" });
+    res.end(JSON.stringify({
+      rvsHost: RVS_HOST,
+      rvsPort: RVS_PORT,
+      rvsTLS: RVS_TLS === "true" || RVS_TLS === true,
+      rvsToken: RVS_TOKEN,
+    }));
+  } else if (req.url === "/api/cancel" && req.method === "POST") {
+    log("warn", "server", "HTTP /api/cancel — Cancel-Request (von Bridge)");
+    pendingMessageTime = 0;
+    watchdogWarned = false;
+    watchdogFixAttempted = false;
+    if (pipelineActive) pipelineEnd(false, "Vom Benutzer abgebrochen (App)");
+    else broadcast({ type: "agent_activity", activity: "idle" });
+    dockerExec("aria-core", "openclaw doctor --fix 2>/dev/null || true").catch(() => {});
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ ok: true }));
  } else if (req.url.startsWith("/shared/")) {
    // Dateien aus Shared Volume ausliefern (Bilder, Uploads)
    const filePath = decodeURIComponent(req.url);
@@ -1209,7 +1343,11 @@ wss.on("connection", (ws) => {
        handleGetVoiceConfig(ws);
      } else if (msg.action === "send_voice_config") {
        // Stimmen-Config persistent speichern + an Bridge via RVS senden
+        // Bestehende Config lesen um Felder zu mergen die dieser Call nicht setzt
+        let existing = {};
+        try { existing = JSON.parse(fs.readFileSync("/shared/config/voice_config.json", "utf-8")); } catch {}
        const voiceConfig = {
+          ...existing,
          defaultVoice: msg.defaultVoice || "ramona",
          highlightVoice: msg.highlightVoice || "thorsten",
          ttsEnabled: msg.ttsEnabled !== false,
@@ -1218,12 +1356,13 @@ wss.on("connection", (ws) => {
          speedRamona: msg.speedRamona || 1.0,
          speedThorsten: msg.speedThorsten || 1.0,
        };
+        if (msg.whisperModel !== undefined) voiceConfig.whisperModel = msg.whisperModel;
        try {
          fs.mkdirSync("/shared/config", { recursive: true });
          fs.writeFileSync("/shared/config/voice_config.json", JSON.stringify(voiceConfig, null, 2));
        } catch {}
        sendToRVS_raw({ type: "config", payload: voiceConfig, timestamp: Date.now() });
-        log("info", "server", `Voice-Config gespeichert+gesendet: default=${voiceConfig.defaultVoice}, highlight=${voiceConfig.highlightVoice}, tts=${voiceConfig.ttsEnabled}`);
+        log("info", "server", `Voice-Config gespeichert+gesendet: default=${voiceConfig.defaultVoice}, whisper=${voiceConfig.whisperModel || "-"}`);
      } else if (msg.action === "get_triggers") {
        handleGetTriggers(ws);
      } else if (msg.action === "save_triggers") {
@@ -1240,6 +1379,8 @@ wss.on("connection", (ws) => {
        handleListSessions(ws);
      } else if (msg.action === "read_session") {
        handleReadSession(ws, msg.sessionPath);
+      } else if (msg.action === "export_session") {
+        handleExportSession(ws, msg.sessionPath, msg.sessionKey);
      } else if (msg.action === "delete_session") {
        handleDeleteSession(ws, msg.sessionPath);
      } else if (msg.action === "set_active_session") {
@@ -1511,17 +1652,17 @@ async function handleListSessions(clientWs) {
  try {
    log("info", "server", "Lade Sessions aus aria-core...");

-    // sessions.json als Index lesen + Datei-Details holen
+    // sessions.json als Index lesen + Datei-Details holen (inkl. .reset.* Archive)
    const raw = await dockerExec("aria-core", `
      cat ${SESSIONS_DIR}/sessions.json 2>/dev/null || echo '{}' &&
      echo '===FILE_DETAILS===' &&
-      for f in ${SESSIONS_DIR}/*.jsonl; do
+      for f in ${SESSIONS_DIR}/*.jsonl ${SESSIONS_DIR}/*.jsonl.reset.*; do
        [ -f "$f" ] || continue
        name=$(basename "$f")
-        lines=$(wc -l < "$f" 2>/dev/null || echo 0)
+        msgs=$(grep -cE '"role":"(user|assistant)"' "$f" 2>/dev/null || echo 0)
        size=$(du -h "$f" 2>/dev/null | cut -f1)
        modified=$(stat -c '%Y' "$f" 2>/dev/null || echo 0)
-        echo "FILE:$name|LINES:$lines|SIZE:$size|MODIFIED:$modified"
+        echo "FILE:$name|LINES:$msgs|SIZE:$size|MODIFIED:$modified"
      done
    `.trim());

@@ -1576,8 +1717,29 @@ async function handleListSessions(clientWs) {
      delete fileDetails[filename];
    }

-    // Dateien die nicht im Index stehen (Waisen / Reset-Files)
+    // Dateien die nicht im Index stehen (Waisen ODER Reset-Archive)
    for (const [filename, details] of Object.entries(fileDetails)) {
+      // .jsonl.reset.<ISO-Timestamp>Z → archivierte Session (OpenClaw-Reset)
+      // Format: 528f4d70-...jsonl.reset.2026-04-18T09-49-44.814Z
+      const resetMatch = filename.match(/^([a-f0-9-]+)\.jsonl\.reset\.(.+Z)$/);
+      if (resetMatch) {
+        const id = resetMatch[1];
+        // Timestamp ISO-8601 parsen: 2026-04-18T09-49-44.814Z → 2026-04-18T09:49:44.814Z
+        const tsStr = resetMatch[2].replace(/T(\d{2})-(\d{2})-(\d{2})/, "T$1:$2:$3");
+        const resetAt = Math.floor(new Date(tsStr).getTime() / 1000) || parseInt(details.MODIFIED) || 0;
+        sessions.push({
+          path: `${SESSIONS_DIR}/${filename}`,
+          sessionKey: id.slice(0, 8) + "… (archiv)",
+          sessionId: id,
+          lines: parseInt(details.LINES) || 0,
+          size: details.SIZE || "?",
+          modified: resetAt,
+          archived: true,
+          resetAt,
+        });
+        continue;
+      }
+      // Echte Waisen (UUID.jsonl ohne Eintrag in sessions.json)
      const id = filename.replace(".jsonl", "");
      sessions.push({
        path: `${SESSIONS_DIR}/${filename}`,
@@ -1622,6 +1784,68 @@ async function handleReadSession(clientWs, sessionPath) {
  }
 }

+async function handleExportSession(clientWs, sessionPath, sessionKey) {
+  if (!sessionPath || sessionPath.includes("..") || !sessionPath.startsWith(SESSIONS_DIR)) {
+    clientWs.send(JSON.stringify({ type: "session_export", ok: false, error: "Ungueltiger Pfad" }));
+    return;
+  }
+  try {
+    const safePath = sessionPath.replace(/'/g, "");
+    const raw = await dockerExec("aria-core", `cat '${safePath}'`);
+    const lines = raw.split("\n").filter(l => l.trim());
+
+    const blocks = [];
+    for (const line of lines) {
+      let obj;
+      try { obj = JSON.parse(line); } catch { continue; }
+      if (obj.type !== "message" || !obj.message) continue;
+      const role = obj.message.role;
+      if (role !== "user" && role !== "assistant") continue;
+
+      let text = "";
+      const content = obj.message.content;
+      if (typeof content === "string") text = content;
+      else if (Array.isArray(content)) text = content.filter(c => c.type === "text").map(c => c.text || "").join("\n");
+      if (!text) continue;
+
+      if (role === "user") {
+        text = text.replace(/^Sender \(untrusted metadata\):[\s\S]*?```[\s\S]*?```\s*\n*/m, "").trim();
+        text = text.replace(/^\[.*?\]\s*/, "").trim();
+      } else {
+        text = text.replace(/^\[\[reply_to_\w+\]\]\s*/g, "").trim();
+      }
+      if (!text) continue;
+
+      const ts = obj.message.timestamp || obj.timestamp || 0;
+      const when = ts ? new Date(ts).toISOString().replace("T", " ").slice(0, 19) : "";
+      const heading = role === "user" ? "## 🧑 User" : "## 🤖 ARIA";
+      blocks.push(`${heading}${when ? ` — ${when}` : ""}\n\n${text}`);
+    }
+
+    const exportedAt = new Date().toISOString().replace("T", " ").slice(0, 19);
+    const title = sessionKey || sessionPath.split("/").pop().replace(".jsonl", "");
+    const markdown = [
+      `# Session: ${title}`,
+      ``,
+      `Exportiert: ${exportedAt}  `,
+      `Quelle: ${sessionPath}`,
+      ``,
+      `---`,
+      ``,
+      blocks.join("\n\n---\n\n"),
+      ``,
+    ].join("\n");
+
+    const safeKey = (sessionKey || "session").replace(/[^a-zA-Z0-9_-]/g, "_");
+    const filename = `${exportedAt.slice(0, 10)}_${safeKey}.md`;
+    clientWs.send(JSON.stringify({ type: "session_export", ok: true, filename, markdown }));
+    log("info", "server", `Session exportiert: ${filename} (${blocks.length} Nachrichten)`);
+  } catch (err) {
+    log("error", "server", `Session-Export fehlgeschlagen: ${err.message}`);
+    clientWs.send(JSON.stringify({ type: "session_export", ok: false, error: err.message }));
+  }
+}
+
 async function handleDeleteSession(clientWs, sessionPath) {
  if (!sessionPath || sessionPath.includes("..") || !sessionPath.startsWith(SESSIONS_DIR)) {
    clientWs.send(JSON.stringify({ type: "session_deleted", ok: false, error: "Ungueltiger Pfad" }));
@@ -1662,13 +1886,11 @@ async function handleDeleteSession(clientWs, sessionPath) {
 }

 // ── Session-Aufloesung: letzte aktive Session finden ────
+// Wird nach Gateway-(Re-)Connect aufgerufen. Darf die explizit gewaehlte
+// Session NIE ueberschreiben — nur beim absoluten Erststart auto-picken.
 async function resolveActiveSession() {
-  // Nur bei Fallback-Key "main" automatisch aufloesen — gespeicherte Wahl respektieren
-  const hasSavedSession = (() => {
-    try { return !!fs.readFileSync(SESSION_KEY_FILE, "utf-8").trim(); } catch { return false; }
-  })();
-  if (hasSavedSession && activeSessionKey !== "main") {
-    log("info", "server", `Gespeicherte Session '${activeSessionKey}' wird beibehalten`);
+  if (sessionFromFile) {
+    log("info", "server", `Session '${activeSessionKey}' aus /data — keine Auto-Wahl`);
    return;
  }

@@ -1687,10 +1909,19 @@ async function resolveActiveSession() {
  const keys = entries.map(e => (e.key || e.sessionKey || e.name || "?").replace(/^agent:main:/, ""));
  log("info", "server", `Verfuegbare Sessions: [${keys.join(", ")}]`);

-  // Neueste Session nehmen
+  // Neueste Session nehmen — aber user-definierte bevorzugen.
+  // aria-bridge / aria-diagnostic werden von den Services auto-erstellt;
+  // bei erstem Start soll lieber eine "echte" Session gewaehlt werden,
+  // falls vorhanden.
+  const AUTO_KEYS = new Set(["aria-bridge", "aria-diagnostic"]);
+  const normalise = (e) => (e.key || e.sessionKey || e.name || "").replace(/^agent:main:/, "");
+
+  const userEntries = entries.filter(e => !AUTO_KEYS.has(normalise(e)));
+  const pool = userEntries.length > 0 ? userEntries : entries;
+
  let newest = null;
  let newestTime = 0;
-  for (const entry of entries) {
+  for (const entry of pool) {
    const t = entry.updatedAt || entry.createdAt || 0;
    if (t >= newestTime) {
      newestTime = t;
@@ -1699,12 +1930,11 @@ async function resolveActiveSession() {
  }

  if (newest) {
-    const rawKey = newest.key || newest.sessionKey || newest.name || "";
-    const key = rawKey.replace(/^agent:main:/, "");
+    const key = normalise(newest);
    if (key) {
      activeSessionKey = key;
-      try { fs.writeFileSync(SESSION_KEY_FILE, activeSessionKey); } catch {}
-      log("info", "server", `Aktive Session auf neueste gewechselt: '${activeSessionKey}'`);
+      persistActiveSession(activeSessionKey);
+      log("info", "server", `Auto-Wahl Erststart: '${activeSessionKey}'`);
      for (const c of browserClients) {
        c.send(JSON.stringify({ type: "active_session", sessionKey: activeSessionKey }));
      }
@@ -1793,8 +2023,11 @@ function handleSetActiveSession(clientWs, sessionKey) {
    return;
  }
  activeSessionKey = sessionKey;
-  try { fs.writeFileSync(SESSION_KEY_FILE, activeSessionKey); } catch {}
-  log("info", "server", `Aktive Session: ${activeSessionKey}`);
+  const ok = persistActiveSession(activeSessionKey);
+  log("info", "server", `Aktive Session: ${activeSessionKey}${ok ? "" : " (WARN: nicht persistiert!)"}`);
+  if (!ok) {
+    clientWs.send(JSON.stringify({ type: "active_session", ok: false, sessionKey: activeSessionKey, error: "Persistierung fehlgeschlagen — /data Volume pruefen" }));
+  }
  // Allen Clients mitteilen
  for (const c of browserClients) {
    c.send(JSON.stringify({ type: "active_session", sessionKey: activeSessionKey }));
@@ -1810,7 +2043,7 @@ async function handleCreateSession(clientWs, sessionName) {
  try {
    // Session wird automatisch erstellt wenn man die erste Nachricht sendet
    activeSessionKey = sessionName;
-    try { fs.writeFileSync(SESSION_KEY_FILE, activeSessionKey); } catch {}
+    persistActiveSession(activeSessionKey);
    log("info", "server", `Neue Session erstellt und aktiviert: ${sessionName}`);
    // Allen Clients mitteilen
    for (const c of browserClients) {
@@ -6,9 +6,9 @@
 - [x] Sprachnachrichten werden als Text angezeigt (STT → Chat-Bubble)
 - [x] Cache leeren + Auto-Download von Anhaengen
 - [x] ARIA liest Nachrichten vor (TTS via Piper)
- [x] Autoscroll zur letzten Nachricht
+- [x] Autoscroll zur letzten Nachricht (inverted FlatList)
 - [x] Bilder im Chat groesser + Vollbild-Vorschau
- [x] Ohr-Button Absturz gefixt (LiveAudioStream entfernt, Phase 1 Placeholder)
+- [x] Ohr-Button → Gespraechsmodus (Auto-Aufnahme nach ARIA-Antwort)
 - [x] Play-Button in ARIA-Nachrichten fuer Sprachwiedergabe
 - [x] Chat-Suche in der App (Lupe in Statusleiste)
 - [x] Watchdog mit Container-Restart (2min Warnung → 5min doctor --fix → 8min Restart)
@@ -22,33 +22,60 @@
 - [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] Auto-Update: APK-Installation via FileProvider
+- [x] Auto-Update: "Auf Updates pruefen" Button in App-Einstellungen
 - [x] Audio-Queue (sequentielle Wiedergabe, kein Ueberlappen)
+- [x] Textnachrichten werden von ARIA beantwortet (Bridge chat handler fix)
+- [x] Mehrere Anhaenge + Text vor dem Senden (Pending-Vorschau)
+- [x] Paste-Support fuer Bilder in Diagnostic Chat
+- [x] Markdown-Bereinigung fuer TTS (fett, kursiv, code, links, etc.)
+- [x] SSH Volume read-write fuer Proxy (kein -F Workaround mehr)
+- [x] Diagnostic: Sessions als Markdown exportieren (Download-Button)
+- [x] Speech Gate: Aufnahme wird verworfen wenn keine Sprache erkannt (verhindert dass Umgebungsgeraeusche an Whisper gehen)
+- [x] Session-Persistenz: Gewaehlte Session bleibt ueber Container-Restarts erhalten (sessionFromFile-Flag, atomic write)
+- [x] Diagnostic: "ARIA denkt..." bleibt nicht mehr stehen (pipelineEnd broadcastet immer idle, auch bei Timeout/Fehler/Disconnect)
+- [x] App: "ARIA denkt..." Indicator + Abbrechen-Button (Bridge spiegelt agent_activity via RVS)
+- [x] Whisper STT: Model-Auswahl in Diagnostic (tiny/base/small/medium/large-v3), Hot-Reload in Bridge, Default auf medium
+- [x] App: Audio-Aufnahme explizit 16kHz mono (spart Resample, optimal fuer Whisper)
+- [x] Gespraechsmodus: Speech-Gate strenger (-28dB / 500ms) — keine Umgebungsgeraeusche mehr
+- [x] Gespraechsmodus: Max-Dauer 30s pro Aufnahme, Cache-Cleanup alter Files, Messages-Array gekappt (500)
+- [x] Diagnostic: Archivierte Session-Versionen (.reset.*) werden angezeigt + exportierbar — OpenClaw resettet Sessions bei erster Nutzung nach Container-Restart, Inhalt ist aber in .reset.<timestamp> Dateien gesichert
+- [x] tools/export-jsonl-to-md.js: CLI-Konverter fuer beliebige Session-JSONL zu Markdown
+- [x] NO_REPLY-Filter in Bridge + Diagnostic — still verworfen (kein Chat, kein TTS)
+- [x] Audio-Ducking + Exklusiv-Focus (Kotlin AudioFocusModule): andere Apps leiser bei TTS, pausiert bei Aufnahme
+- [x] TTS-Cleanup serverseitig: Code-Bloecke raus, Einheiten ausgeschrieben (22GB → Gigabyte), Abkuerzungen buchstabiert (CPU), URLs zu "ein Link". `<voice></voice>` Tag wird bevorzugt wenn ARIA ihn liefert.
+- [x] QR-Code Onboarding: Diagnostic generiert QR, App scannt (bestehender QRScanner funktioniert out of the box)
+- [x] TTS-Audio-Cache im Filesystem: Piper-Audio wird mit messageId verknuepft, als WAV in DocumentDirectory/tts_cache gespeichert, Play-Button spielt aus Cache statt regenerieren
+- [x] Config via Diagnostic: RVS-Credentials + Aria-Auth-Token via /api/runtime-config, persistiert in /shared/config/runtime.json, Bridge liest beim Start (Overrides der ENV)

 ## Offen

 ### Bugs (Prioritaet)
- [ ] Session-Persistenz: Bei Container-Restart wird immer aria-bridge geladen statt die zuletzt gewaehlte Session. Wird nicht persistent gespeichert.
- [x] App: Textnachrichten werden von ARIA beantwortet (Bridge chat handler fix)
 - [ ] App: Audioausgabe hoert ab und zu einfach auf (mitten im Satz oder zwischen Chunks)
- [x] Auto-Update: APK-Installation via FileProvider (content:// URI)
- [x] Auto-Update: "Auf Updates pruefen" Button in App-Einstellungen
- [x] App: Auto-Scroll zur letzten Nachricht beim App-Start (direkt, ohne Animation)
- [x] App: Bei neuen Nachrichten automatisch zur letzten Nachricht scrollen
+- [ ] NO_REPLY wird als "NO" im Chat angezeigt — sollte still verworfen werden (Token nicht gesaeubert)

 ### App Features
- [x] App: Zu Anhaengen Text hinzufuegen vor dem Senden (Pending-Vorschau + optionaler Text)
- [x] Gespraechsmodus (Ohr-Button): Auto-Aufnahme nach ARIA-Antwort (Walkie-Talkie)
 - [ ] Wake Word on-device (Porcupine "ARIA" Keyword, Phase 2 — passives Lauschen)
 - [ ] Chat-History zuverlaessiger laden (AsyncStorage Race Condition)
 - [ ] Background Audio Service (TTS auch bei minimierter App)
+- [ ] Audio-Ducking: andere App-Audio-Ausgaben leiser stellen waehrend ARIA spricht (AudioFocus API)
+- [ ] Audio-Muten waehrend Aufnahme/Ohr-Modus: andere Audio stumm (wie WhatsApp-Sprachaufnahme)
+- [ ] Spracheingabe-Timeout erhoehen fuer laengere Texte
+- [ ] Generierte TTS-Audiodaten in der Chat-Nachricht einbetten (oder lokal cachen), Play-Button spielt aus Cache statt Regenerierung via XTTS. Base64 im Tag <soundfile></soundfile> (invisible) oder lokaler Datei-Cache mit Referenz in der Message.
+- [ ] QR-Code Onboarding: Diagnostic generiert QR mit RVS-Credentials, App scannt — keine manuelle Eingabe mehr

 ### TTS / Audio
- [ ] XTTS Audio-Streaming verbessern (minimales Stottern bei Chunk-Uebergaengen)
+- [ ] XTTS Audio-Streaming (PCM-Stream statt WAV-Dateien, eliminiert Stottern komplett)
 - [ ] Audio-Normalisierung (Lautstaerke zwischen Chunks angleichen)
 - [ ] Piper Voices Download ueber Diagnostic (neue Sprachen/Stimmen)
+- [ ] TTS-Text-Aufbereitung: Code-Bloecke rausfiltern, Einheiten ausschreiben ("22GB" → "zweiundzwanzig Gigabyte"). Zwei Varianten denkbar: (a) server-side Cleanup in Bridge, (b) ARIA schreibt `<voice></voice>` Block der in UI hidden bleibt aber fuer TTS genutzt wird.
+- [ ] Piper evtl. komplett entfernen (klingt schlecht vs. XTTS) — oder nur als Fallback wenn XTTS offline ist

 ### 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?)
+- [ ] RVS Zombie-Connections endgueltig loesen
+- [ ] Alle .env-Variablen ueber Diagnostic konfigurierbar machen (kein File-Sync mehr noetig, da alle ARIA-Container auf der gleichen VM laufen). Fallback .env bleibt fuer initialen Bootstrap.
+- [ ] XTTS-Container: kleine Web-Oberflaeche fuer Credentials/Server-Config, oder zentral aus Diagnostic per RVS push
+- [ ] Root-Cause OpenClaw Session-Reset: Herausfinden warum Sessions beim ersten chat.send nach Container-Restart verworfen werden (abortedLastRun / systemSent Theorie pruefen, ggf. Flag preemptiv patchen)
@@ -16,6 +16,7 @@ const ALLOWED_TYPES = new Set([
  "file_request", "file_response", "file_saved", "stt_result", "config", "tts_request",
  "xtts_request", "xtts_response", "xtts_list_voices", "xtts_voices_list", "voice_upload", "xtts_voice_saved",
  "update_check", "update_available", "update_download", "update_data",
+  "agent_activity", "cancel_request",
 ]);

 // Token-Raum: token -> { clients: Set<ws> }
@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+/**
+ * Exportiert ein OpenClaw Session-JSONL (auch .reset.*) als Markdown.
+ *
+ * Nutzung:
+ *   node export-jsonl-to-md.js <input.jsonl> [output.md]
+ *
+ * Oder direkt aus dem aria-core Container:
+ *   docker exec aria-core cat /home/node/.openclaw/agents/main/sessions/<ID>.jsonl.reset.<TS> \
+ *     | node export-jsonl-to-md.js - > output.md
+ */
+
+const fs = require("fs");
+
+const inputArg = process.argv[2];
+const outputArg = process.argv[3];
+
+if (!inputArg) {
+  console.error("Usage: export-jsonl-to-md.js <input.jsonl|-> [output.md]");
+  process.exit(1);
+}
+
+const raw = inputArg === "-" ? fs.readFileSync(0, "utf-8") : fs.readFileSync(inputArg, "utf-8");
+const lines = raw.split("\n").filter(l => l.trim());
+
+const blocks = [];
+for (const line of lines) {
+  let obj;
+  try { obj = JSON.parse(line); } catch { continue; }
+  if (obj.type !== "message" || !obj.message) continue;
+  const role = obj.message.role;
+  if (role !== "user" && role !== "assistant") continue;
+
+  let text = "";
+  const content = obj.message.content;
+  if (typeof content === "string") text = content;
+  else if (Array.isArray(content)) text = content.filter(c => c.type === "text").map(c => c.text || "").join("\n");
+  if (!text) continue;
+
+  if (role === "user") {
+    text = text.replace(/^Sender \(untrusted metadata\):[\s\S]*?```[\s\S]*?```\s*\n*/m, "").trim();
+    text = text.replace(/^\[.*?\]\s*/, "").trim();
+  } else {
+    text = text.replace(/^\[\[reply_to_\w+\]\]\s*/g, "").trim();
+  }
+  if (!text) continue;
+
+  const ts = obj.message.timestamp || obj.timestamp || 0;
+  const when = ts ? new Date(ts).toISOString().replace("T", " ").slice(0, 19) : "";
+  const heading = role === "user" ? "## 🧑 User" : "## 🤖 ARIA";
+  blocks.push(`${heading}${when ? ` — ${when}` : ""}\n\n${text}`);
+}
+
+const exportedAt = new Date().toISOString().replace("T", " ").slice(0, 19);
+const title = inputArg === "-" ? "Session" : inputArg.split("/").pop().replace(/\.jsonl.*/, "");
+const md = [
+  `# Session: ${title}`,
+  ``,
+  `Exportiert: ${exportedAt}  `,
+  `Quelle: ${inputArg === "-" ? "stdin" : inputArg}`,
+  `Nachrichten: ${blocks.length}`,
+  ``,
+  `---`,
+  ``,
+  blocks.join("\n\n---\n\n"),
+  ``,
+].join("\n");
+
+if (outputArg) {
+  fs.writeFileSync(outputArg, md);
+  console.error(`OK: ${blocks.length} Nachrichten → ${outputArg}`);
+} else {
+  process.stdout.write(md);
+}
Author	SHA1	Message	Date
duffyduck	1fb1fdef9e	release: bump version to 0.0.4.1	2026-04-19 21:00:49 +02:00
duffyduck	593d26e0ff	fix: QR-Code overflowed Container — auf SVG umgestellt mit width/height 100% Der QR wurde mit createImgTag() als fester Pixel-IMG gerendert und ueberlappte den Warnhinweis + Button rechts daneben. Fix: - createSvgTag mit cellSize=4 + scalable=true - SVG skaliert auf width:100%/height:100% der 220x220 Box - Container: flex-shrink:0 (damit Flex ihn nicht weiter schrumpft) - overflow:hidden als Sicherheit Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	2026-04-19 16:28:41 +02:00
duffyduck	394abb58be	fix: Runtime-Config Layout + Eye-Toggle fuer Token-Felder - Eingabefelder haben jetzt width:100% + box-sizing:border-box, keine Ueberlappung mehr im Grid - Token-Felder haben einen Augen-Button daneben (👁/👀) zum Anzeigen/Verbergen des Inhalts - Kleineres Label-Grid (140px statt 150px), grosszuegigerer Gap Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	2026-04-19 16:27:56 +02:00
duffyduck	fc3bee6d05	feat: Runtime-Config via Diagnostic UI — kein .env-Sync mehr Framework fuer zentrale Runtime-Konfiguration: - /api/runtime-config (GET/POST) persistiert in /shared/config/runtime.json - Werte haben Vorrang ueber die ENV-Variablen aus aria.env - Feldliste: RVS_HOST/PORT/TLS/TOKEN, ARIA_AUTH_TOKEN, WHISPER_MODEL/LANGUAGE - Atomic write (tmp + rename) fuer Konsistenz Bridge: - load_config() liest nach aria.env noch runtime.json und ueberschreibt die Werte. Aenderungen werden beim Neustart der Bridge uebernommen. Diagnostic UI: - Neue Sektion "Runtime-Konfiguration" in Einstellungen - Formular fuer RVS-Credentials + Aria-Auth-Token - "Speichern" persistiert, triggert auch QR-Code-Regenerierung - Hinweis: Diagnostic-Container selbst bleibt auf ENV (erstmal) issue.md konsolidiert — 6 groessere Tasks dieser Session als erledigt. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	2026-04-19 16:18:37 +02:00
duffyduck	b203503fd8	feat: QR-Code Onboarding + TTS-Audio-Cache im Filesystem QR-Code Onboarding - Diagnostic: GET /api/onboarding gibt RVS-Credentials zurueck - Einstellungen-UI: neue Sektion mit QR-Code (qrcode-generator via CDN) - Format kompatibel mit bestehendem QRScanner.parseQRData (host/port/tls/token) - App-SettingsScreen hatte QR-Scanner bereits — funktioniert out of the box - Warnhinweis zu Token im Klartext TTS-Audio-Cache - Bridge: jede ARIA-Chat-Nachricht bekommt eine messageId (UUID) Audio-Payload wird mit messageId verknuepft (Piper-Pfade) - ChatScreen: messageId + audioPath in ChatMessage Interface - audioService.cacheAudio(): speichert Base64 in DocumentDirectory/tts_cache/<id>.wav - audioService.playFromPath(): spielt aus Cache ohne Regenerierung - Play-Button: wenn audioPath gesetzt → aus Cache, sonst tts_request - cleanupOldTTSCache(): alte unreferenzierte WAVs (>30 Tage) weg - Persistiert via AsyncStorage — ueberlebt App-Restart Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	2026-04-19 16:16:25 +02:00
duffyduck	8b0a72dc9b	feat: NO_REPLY-Filter + Audio-Ducking + TTS-Cleanup 1) NO_REPLY Token wird in Bridge und Diagnostic erkannt und still verworfen. Toleranz fuer Variationen (Whitespace, Punkt, Quotes). Kein Chat-Eintrag, kein TTS. 2) AudioFocusModule (Kotlin) mit requestDuck / requestExclusive / release. AudioService ruft: - requestExclusive() bei Aufnahme-Start → andere Apps pausieren - requestDuck() bei TTS-Playback-Start → andere Apps leiser - release() bei Stop/Queue-Ende MainApplication registriert AudioFocusPackage. 3) clean_text_for_tts() in Bridge — zentrale Aufbereitung: - <voice>...</voice> Tag wird bevorzugt (falls ARIA es schreibt) - Code-Bloecke (``` und `) komplett raus - Markdown (Fett/Kursiv/Links/Headings/Listen) geschleift - Einheiten ausgeschrieben: 22GB → 22 Gigabyte, 85% → 85 Prozent - Abkuerzungen buchstabiert: CPU → C P U, API → A P I - URLs durch "ein Link" ersetzt Genutzt in VoiceEngine.synthesize und im XTTS-Request — Chat-Text an die App bleibt unveraendert (original Markdown), nur TTS kriegt die aufbereitete Version. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	2026-04-19 16:10:54 +02:00
duffyduck	23add7a107	docs: Neue Issues - TTS-Cleanup, Audio-Ducking, Config-UI, NO_REPLY-Bug - Bug: NO_REPLY wird als "NO" angezeigt - Audio-Ducking + Mute waehrend Aufnahme - Spracheingabe-Timeout erhoehen - TTS-Text-Aufbereitung (Code raus, Einheiten ausschreiben) - Audio-Cache in Messages (kein Regenerieren beim Play-Button) - Piper evtl. entfernen - .env → Diagnostic UI migrieren - QR-Code Onboarding - XTTS Web-Oberflaeche / zentral via Diagnostic - Root-Cause OpenClaw Session-Reset pruefen Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	2026-04-19 14:04:47 +02:00
duffyduck	caf84196fb	fix: Reset-File-Regex - Timestamp endet mit Z (ohne Punkt davor) Die OpenClaw Reset-Files heissen <uuid>.jsonl.reset.<iso>Z (nicht <uuid>.jsonl.reset.<iso>.Z). Der falsche Regex matchte nie, alle Archive wurden als "verwaist" angezeigt statt als "archiv". Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	2026-04-18 12:32:24 +02:00
duffyduck	099b9651a6	release: bump version to 0.0.4.0	2026-04-18 12:28:08 +02:00
duffyduck	76d72a1eef	feat: Archivierte Session-Versionen (OpenClaw .reset.* Files) in Diagnostic OpenClaw resettet Sessions beim ersten chat.send nach Container-Restart (wenn abortedLastRun / systemSent Inkonsistenz erkannt wurde) und benennt die alte .jsonl in .jsonl.reset.<timestamp>.Z um. Der Inhalt war also gar nicht verloren, nur unsichtbar. Diagnostic: - handleListSessions scannt jetzt auch .jsonl.reset. Files - Reset-Files bekommen archived:true + resetAt-Timestamp - Neue UI-Sektion "Archivierte Versionen" (collapsible <details>) mit Export-Button, zeigt aufklappbar alle gesicherten alten Sessions - Aktivieren ist fuer Archive deaktiviert (zerstoert aktive Session) - Loeschen + Export stehen zur Verfuegung tools/export-jsonl-to-md.js: - Standalone Node-Script zum Konvertieren beliebiger .jsonl (auch reset-Files) - Nutzbar via stdin, exakt gleiche Export-Logik wie Diagnostic - Fuer Rettungsaktionen direkt auf der VM Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	2026-04-18 12:24:54 +02:00
duffyduck	87deede078	fix: Session Msgs-Counter zaehlt echte Nachrichten, nicht alle Zeilen Vorher: wc -l auf der .jsonl — zaehlt auch Tool-Calls, Run-Events, Metadata-Eintraege mit. Diagnostic zeigte z.B. "10 Msgs" fuer eine Session mit 6 echten User/Assistant-Nachrichten. Jetzt: grep -cE '"role":"(user\|assistant)"' — zaehlt nur echte Konversations-Messages. Matcht wie der Export und die Chat-History das interpretieren. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	2026-04-18 12:09:01 +02:00
duffyduck	6fec8588c1	fix: Gespraechsmodus - strenger Speech-Gate + Crash-Prevention Probleme: - Hintergrundgeraeusche wurden als Sprache erkannt und an Whisper geschickt - App stuerzte nach laengerem Zuhoeren ab (OOM / Cache-Ueberlauf) Aenderungen: - VAD_SPEECH_THRESHOLD_DB -35 -> -28 (filtert Raum-Ambient) - VAD_SPEECH_MIN_MS 300 -> 500 (keine Huestler/Klopfer mehr) - Max-Aufnahmedauer 30s (Notbremse gegen Runaway-Loops) - _cleanupStaleCacheFiles(): alte aria_recording_/aria_tts_ Files (>30s) werden vor jeder neuen Aufnahme geloescht - ChatScreen: capMessages() begrenzt Messages-Array auf 500 Eintraege (OOM-Schutz in langen Gespraechen) Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	2026-04-18 12:05:15 +02:00
duffyduck	aafdbcd57a	fix: Thinking indicator beim Seitenladen nicht mehr sichtbar Zwei display:-Deklarationen im inline-style der Diagnostic-Chat-Leiste haben sich gegenseitig ueberschrieben — 'display:flex' war die zweite und hat 'display:none' aushebelt. Indicator war so beim Seitenaufbau sichtbar bis JS ein idle-Event empfing. - HTML: 'display:flex' aus inline-style entfernt - JS: beim Anzeigen explizit display='flex' setzen (statt 'block') Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	2026-04-18 11:58:39 +02:00
duffyduck	08da28f475	release: bump version to 0.0.3.9	2026-04-18 11:52:53 +02:00
duffyduck	8c1014d281	fix: Thinking indicator respringt nach chat:final durch trailing events Nach chat:final kommen oft noch agent-Events rein (Core raeumt nach), die den Thinking-Indicator wieder anspringen liessen. - Diagnostic: 3s-Settled-Window nach chat:final, agent_activity-Broadcasts werden in dem Fenster unterdrueckt (idle kommt weiter durch). - Bridge: Gleiches Fenster in _emit_activity() — App bekommt keine trailing thinking/tool-Events mehr nach dem finalen Antwort. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	2026-04-18 11:51:22 +02:00
duffyduck	271fc4edf6	docs: cleanup.sh + README updates for latest features - cleanup.sh: sicherer (default) + aggressiver (--full) Docker-Cleanup mit Speicher-Report vor/nach - README: Phase-1-Liste, Diagnostic-Features und App-Features um die neuen Punkte ergaenzt (Speech Gate, Session-Persistenz, Session-Export, App Thinking-Indicator, Whisper-Modellauswahl, 16kHz-Aufnahme) - README: Neuer Abschnitt "Docker-Cleanup" mit cleanup.sh Usage Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	2026-04-18 11:46:12 +02:00
duffyduck	cd390a4115	release: bump version to 0.0.3.8	2026-04-18 11:41:12 +02:00
duffyduck	a65ed579d2	feat: Whisper model selector + 16kHz mono recording - App: AudioSamplingRateAndroid 16000 + AudioChannelsAndroid 1 → Whisper bekommt direkt sein Ziel-Format, kein Resample mehr - Bridge: STTEngine.reload() laedt Modell zur Laufzeit neu (tiny/base/small/medium/large-v3) - Bridge: Config-Message triggert Hot-Reload wenn whisperModel sich aendert - Bridge: Default auf 'medium' (besser als 'small' bei aehnlicher Latenz) - Diagnostic: Neue Sektion "Whisper (Spracherkennung)" mit Dropdown, auto-save bei Auswahl, beim Laden wird der gespeicherte Wert gesetzt - Diagnostic/Server: send_voice_config merged whisperModel in voice_config.json - aria.env.example: WHISPER_MODEL + WHISPER_LANGUAGE dokumentiert Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	2026-04-18 11:37:27 +02:00
duffyduck	2ad1f57382	feat: Thinking indicator + cancel button in the app - Bridge: _emit_activity() spiegelt OpenClaw agent events als agent_activity an RVS, dedupliziert State-Wechsel. chat:final/error senden idle. - Bridge: Neuer cancel_request-Handler ruft Diagnostic /api/cancel per HTTP. - Diagnostic: Neuer POST /api/cancel Endpoint (gleiche Logik wie WS-Cancel). - RVS: agent_activity + cancel_request in ALLOWED_TYPES. - App: Gelber Indicator ueber der Input-Bar mit Text je nach Activity, roter Abbrechen-Button. Cancel sendet cancel_request via RVS. - issue.md: Erledigte Bugfixes + Features konsolidiert. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	2026-04-18 11:22:02 +02:00
duffyduck	58e3cfd3e6	feat: Session export as markdown in Diagnostic - ⬇ Button per Session-Zeile — exportiert auch inaktive Sessions - Server parst JSONL, extrahiert User/Assistant-Nachrichten mit Timestamp - Metadata-Prefix wird entfernt, Markdown mit # Session-Header generiert - Browser-Download via Blob + download-Attribut Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	2026-04-18 11:14:15 +02:00
duffyduck	7de4ee8f5b	fix: Stuck "ARIA denkt..." indicator after pipeline ends - pipelineEnd() now broadcasts agent_activity: idle unconditionally - chat:error and chat:final paths broadcast idle outside of active pipeline - Gateway close event ends active pipeline + broadcasts idle - Prevents indicator from hanging after timeout/error/disconnect Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	2026-04-18 11:11:12 +02:00
duffyduck	213edac3a7	fix: Session persistence - respect user choice across container restarts - sessionFromFile flag prevents auto-pick after first start - Atomic write (temp + rename) with loud error logging - Auto-pick filters out aria-bridge/aria-diagnostic when user sessions exist - handleSetActiveSession reports persistence failures to client Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	2026-04-18 11:03:26 +02:00
duffyduck	acc13aef6b	fix: Speech gate - only send recording if actual speech detected - VAD_SPEECH_THRESHOLD_DB = -35 (louder than silence threshold) - Needs 300ms of speech before counting as real speech - Recording discarded if only background noise detected - Prevents sending garbage to Whisper in conversation mode Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>	2026-04-11 18:20:05 +02:00
duffyduck	4bbc6f7787	release: bump version to 0.0.3.7	2026-04-11 13:18:17 +02:00
duffyduck	20f2ea1829	fix: Conversation mode starts recording immediately when ear button tapped Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>	2026-04-11 13:15:26 +02:00
duffyduck	2d23f0668b	docs: update README with conversation mode, multi-attachments, markdown cleanup - Conversation mode (ear button) documented in App Features - Multiple attachments + paste support - Markdown cleanup for TTS - Auto-Update FileProvider + check button - Roadmap: 22 items in Phase 1 completed Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>	2026-04-11 12:43:09 +02:00
duffyduck	d6030a06b7	docs: update issue.md - move completed items, clean up open list 28 items completed, 10 remaining open Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>	2026-04-11 12:23:04 +02:00
duffyduck	0df76e2af6	release: bump version to 0.0.3.6	2026-04-11 12:19:00 +02:00
duffyduck	f80fe1df93	fix: Inverted FlatList - newest messages always visible at bottom - No more scrollToEnd/scrollToIndex needed - FlatList inverted=true with reversed data - New messages appear at bottom automatically - User scrolls up to see history (natural chat behavior) Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>	2026-04-11 12:17:32 +02:00
duffyduck	cff421bc53	release: bump version to 0.0.3.5	2026-04-11 12:13:41 +02:00
duffyduck	bca925d385	fix: Use scrollToIndex with viewPosition:1 for reliable bottom scroll - scrollToIndex targets last message at bottom of viewport - onScrollToIndexFailed fallback to scrollToEnd - More reliable than scrollToEnd with dynamic heights Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>	2026-04-11 12:12:24 +02:00