feat(app): manueller Aufnahme-Knopf nutzt jetzt auch Streaming-STT

VoiceButton rewrite — dB/VAD-Pfad endgueltig raus. Knopf ist jetzt nur
noch UI-Trigger:
  - onTapStart   (ChatScreen baut Bubble + startStreamingRecording)
  - onTapStop    (ChatScreen ruft stopStreamingRecording)
  - audioService.onStateChange treibt die Animation (statt internem
    isRecording-Flag)
  - onSilenceDetected-Subscription weg

ChatScreen:
  - handleVoiceRecording (Legacy) → handleVoiceButtonStart +
    handleVoiceButtonStop
  - Bubble wird beim Tap SOFORT gebaut (vorher: erst nach Stop), Text
    landet via audioRequestId-Match im chat-Handler-Update-Pfad
  - noSpeechTimeoutMs=0 (manueller Modus, User kontrolliert via Tap),
    hardCapMs=300_000 (5 Minuten Notbremse)
  - Wake-Word-conversing + manueller Stop = endConversation (User
    will nicht in Multi-Turn-Modus)
  - RecordingResult-Import entfaellt (nicht mehr genutzt)

Damit ist die komplette App-seitige Aufnahme auf Streaming + ML-
Endpointer. Der ganze dB/VAD-Apparat (vadEnabled, vadBaselineSamples,
loadVadSilenceDbOverride, vadTimer, noSpeechTimer, etc.) ist jetzt
nur noch Dead-Code — wird in einem Folge-Commit gemeinsam mit dem
zugehoerigen Settings-Slider abgeraeumt.

android/src/components/VoiceButton.tsx

@@ -1,12 +1,19 @@
 /**
- * VoiceButton - Push-to-Talk + Auto-Stop Aufnahmeknopf
+ * VoiceButton — Tap-to-Talk-Aufnahmeknopf (Streaming-Variante).
  *
- * Zwei Modi:
- * 1. Push-to-Talk: gedrueckt halten zum Aufnehmen, loslassen zum Senden
- * 2. Tap-to-Talk: einmal tippen startet Aufnahme, VAD stoppt automatisch bei Stille
- *    (auch genutzt fuer Wake-Word-getriggerte Aufnahme)
+ * Push-to-Talk gibt's nicht mehr. Tap startet Streaming-Aufnahme an die
+ * Whisper-Bridge. Tap nochmal sendet stt_stream_end → Whisper liefert den
+ * finalen Text → aria-bridge forwardet direkt an Brain. Keine dB/VAD-
+ * Stille-Erkennung mehr — Whisper hoert auf semantische Stille (kein
+ * neuer Text mehr).
  *
- * Visuelles Feedback durch pulsierende Animation waehrend der Aufnahme.
+ * Diese Komponente ist absichtlich "dumm": sie kapselt nur den
+ * Tap-Lifecycle + die Animation. Recording-Optionen (voice/speed/
+ * location/interrupted) baut ChatScreen, die User-Bubble ebenfalls.
+ *
+ * Visuelles Feedback: pulsierende Animation + Dauer + dB-Pegel via
+ * audioService.onMeterUpdate (das macht audio.ts noch fuer alte Records;
+ * neu kommt der Pegel via NativeEventEmitter (PcmStreamMeter) — folgt).
  */
 
 import React, { useState, useRef, useEffect, useCallback } from 'react';
@@ -17,25 +24,28 @@ import {
   StyleSheet,
   Easing,
   TouchableOpacity,
-  Pressable,
 } from 'react-native';
-import audioService, { RecordingResult } from '../services/audio';
+import audioService, { RecordingState } from '../services/audio';
 
 // --- Typen ---
 
 interface VoiceButtonProps {
-  /** Wird aufgerufen wenn die Aufnahme fertig ist */
-  onRecordingComplete: (result: RecordingResult) => void;
+  /** User hat getippt — ChatScreen soll Bubble bauen + startStreamingRecording.
+   *  Returns true wenn die Aufnahme tatsaechlich gestartet ist. */
+  onTapStart: () => Promise<boolean>;
+  /** User hat nochmal getippt — ChatScreen soll stopStreamingRecording rufen. */
+  onTapStop: () => Promise<void>;
   /** Button deaktivieren */
   disabled?: boolean;
-  /** Wake-Word-Modus aktiv (zeigt Indikator) */
+  /** Wake-Word-Modus aktiv (zeigt gruenen Indikator-Dot) */
   wakeWordActive?: boolean;
 }
 
 // --- Komponente ---
 
 const VoiceButton: React.FC<VoiceButtonProps> = ({
-  onRecordingComplete,
+  onTapStart,
+  onTapStop,
   disabled = false,
   wakeWordActive = false,
 }) => {
@@ -45,6 +55,21 @@ const VoiceButton: React.FC<VoiceButtonProps> = ({
   const pulseAnim = useRef(new Animated.Value(1)).current;
   const durationTimer = useRef<ReturnType<typeof setInterval> | null>(null);
 
+  // State via audioService.onStateChange spiegeln — der Service ist die
+  // Quelle der Wahrheit (Streaming-Session, Wake-Word-Multi-Turn, etc.
+  // koennen den Recording-State von extern aendern). isStreamingRecording
+  // ist auch true wenn die Wake-Word-Konversation gerade aufzeichnet —
+  // dann zeigt der Button "stop"-Symbol, und Tap stoppt die laufende
+  // Aufnahme (egal ob via Wake-Word oder Knopf gestartet).
+  useEffect(() => {
+    const unsub = audioService.onStateChange((next: RecordingState) => {
+      setIsRecording(next === 'recording');
+    });
+    // Initial-State synchronisieren
+    setIsRecording(audioService.getRecordingState() === 'recording');
+    return unsub;
+  }, []);
+
   // Puls-Animation starten/stoppen
   useEffect(() => {
     if (isRecording) {
@@ -71,14 +96,13 @@ const VoiceButton: React.FC<VoiceButtonProps> = ({
     }
   }, [isRecording, pulseAnim]);
 
-  // Aufnahmedauer zaehlen + Metering
+  // Aufnahmedauer zaehlen + Metering (Pegel-Bar)
   useEffect(() => {
     if (isRecording) {
       setDurationMs(0);
       durationTimer.current = setInterval(() => {
         setDurationMs(prev => prev + 100);
       }, 100);
-
       const unsubMeter = audioService.onMeterUpdate(setMeterDb);
       return () => {
         unsubMeter();
@@ -89,74 +113,28 @@ const VoiceButton: React.FC<VoiceButtonProps> = ({
         clearInterval(durationTimer.current);
         durationTimer.current = null;
       }
+      setMeterDb(-160);
     }
   }, [isRecording]);
 
-  // VAD Silence Callback — Auto-Stop.
-  // WICHTIG: NICHT auf isRecording prüfen (Closure ist stale) — stattdessen
-  // audioService selber fragen. Empty deps → Listener wird EINMAL registriert.
-  // audioService garantiert jetzt dass der Callback pro Aufnahme nur einmal
-  // feuert (silenceFired-Latch).
-  const onCompleteRef = useRef(onRecordingComplete);
-  useEffect(() => { onCompleteRef.current = onRecordingComplete; }, [onRecordingComplete]);
-  useEffect(() => {
-    const unsubSilence = audioService.onSilenceDetected(async () => {
-      if (audioService.getRecordingState() !== 'recording') return;
-      const result = await audioService.stopRecording();
-      setIsRecording(false);
-      if (result && result.durationMs > 500) {
-        onCompleteRef.current(result);
-      }
-    });
-    return unsubSilence;
-  }, []);
-
-  // Auto-Start fuer Wake Word (extern getriggert)
-  const startAutoRecording = useCallback(async () => {
-    if (disabled || isRecording) return;
-    const started = await audioService.startRecording(true); // autoStop = true
-    if (started) {
-      setIsRecording(true);
-    }
-  }, [disabled, isRecording]);
-
-  // Tap-to-Talk: Einmal tippen startet mit Auto-Stop.
-  // Guard gegen Doppel-Tap während asyncer Start/Stop.
+  // Tap-Handler. Guard gegen Doppel-Tap waehrend asyncer Start/Stop.
   const tapBusy = useRef(false);
-  const handleTap = async () => {
+  const handleTap = useCallback(async () => {
     if (disabled || tapBusy.current) return;
     tapBusy.current = true;
     try {
-      // Fragen WIR den Service, nicht den React-State (Closure kann stale sein)
+      // Service-State fragen statt React-State (Closure koennte stale sein)
       const svcState = audioService.getRecordingState();
       if (svcState === 'recording') {
-        // Aufnahme manuell stoppen
-        const result = await audioService.stopRecording();
-        setIsRecording(false);
-        if (result && result.durationMs > 300) {
-          onRecordingComplete(result);
-        }
+        await onTapStop();
       } else if (svcState === 'idle') {
-        // Aufnahme mit Auto-Stop starten
-        const started = await audioService.startRecording(true);
-        if (started) {
-          setIsRecording(true);
-        }
+        await onTapStart();
       }
-      // svcState === 'processing': Stopp in progress — nichts tun, User
-      // muss nochmal tippen wenn fertig. Aber wir blockieren mit tapBusy
-      // kurz damit der User's UI-Feedback synchron bleibt.
+      // 'processing': Stop laeuft gerade — nichts tun, User muss nochmal tippen
     } finally {
       tapBusy.current = false;
     }
-  };
-
-  // Expose startAutoRecording via ref fuer Wake Word
-  React.useImperativeHandle(
-    React.createRef(),
-    () => ({ startAutoRecording }),
-    [startAutoRecording],
-  );
+  }, [disabled, onTapStart, onTapStop]);
 
   const formatDuration = (ms: number): string => {
     const seconds = Math.floor(ms / 1000);
@@ -164,7 +142,11 @@ const VoiceButton: React.FC<VoiceButtonProps> = ({
     return `${seconds}.${tenths}s`;
   };
 
-  // Meter-Visualisierung (0-1 Skala)
+  // Meter-Visualisierung (-60..0 dB → 0..1). Bei Streaming-Mode liefert
+  // audio.ts (noch) keinen Pegel, also bleibt der Balken leer — wird in
+  // einem Folge-Commit nachgerueckt (PcmStreamRecorder-Module muss dafuer
+  // einen RMS-Wert mit-emitten). Tut der Streaming-Funktion keinen Abbruch,
+  // ist reines UI-Beiwerk.
   const meterLevel = Math.max(0, Math.min(1, (meterDb + 60) / 60));
 
   return (
@@ -198,9 +180,6 @@ const VoiceButton: React.FC<VoiceButtonProps> = ({
   );
 };
 
-// Expose startAutoRecording fuer externe Aufrufe (Wake Word)
-export type VoiceButtonHandle = { startAutoRecording: () => Promise<void> };
-
 // --- Styles ---
 
 const styles = StyleSheet.create({