release: bump version to 0.1.8.6

Race-Condition entdeckt im Log: nach jeder ARIA-Antwort lief
endConversation 5s nach TTS-Start (= "letzter Chunk eingetroffen"),
nicht wenn der AudioTrack-Hardware-Buffer wirklich am Ende war. ARIA
sprach also noch hoerbar, waehrend OpenWakeWord schon re-armte.

Folge: ARIAs eigene Stimme ging direkt nach AudioRecord.startRecording
ins Mikro. Die OpenWakeWord-Sessions von AudioRecord und AudioTrack
sind verschieden → AcousticEchoCanceler kann den Output nicht
subtrahieren (kein gemeinsamer Reference-Stream). Threshold +
Patience-State der Wake-Word-Inferenz wird durch ARIAs konstante
Audio-Eingabe verwirrt, der naechste echte "Computer"-Trigger geht
unter.

Fix: Listener-Fire aus handlePcmChunk(isFinal=true) raus, dafuer in
den schon existierenden PcmPlaybackFinished-Native-Event-Handler
rein. Die Kotlin-Seite emittiert das Event aus dem Writer-Thread-
finally-Block — also genau dann wenn AudioTrack alle Samples
durchgeschrieben hat.

Side-Effect: UI-Konsumenten von onPlaybackFinished sehen den
"finished"-State jetzt 1-2s spaeter (= ehrlicher zur Realitaet,
ist eigentlich eine UX-Verbesserung).

android/android/app/build.gradle

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

android/package.json

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

android/src/services/audio.ts

@@ -341,8 +341,21 @@ class AudioService {
       try {
         const emitter = new NativeEventEmitter(NativeModules.PcmStreamPlayer as any);
         emitter.addListener('PcmPlaybackFinished', () => {
-          console.log('[Audio] PcmPlaybackFinished — Focus jetzt freigeben');
+          console.log('[Audio] PcmPlaybackFinished — AudioTrack drained');
           this._releaseFocusDeferred();
+          // Erst HIER playbackFinished-Listener feuern — nicht schon beim
+          // Empfang des letzten PCM-Chunks (siehe handlePcmChunk). AudioTrack
+          // braucht nach end() noch 1-2s zum Drainen seines Hardware-Buffers.
+          // Wenn wir die Listener zu frueh feuern, re-armt OpenWakeWord
+          // waehrend ARIA noch hoerbar spricht → ARIAs Stimme verwirrt die
+          // Wake-Word-Detection (kein gemeinsames AEC zwischen AudioTrack-
+          // und AudioRecord-Session). Stefan-Reproduktion: nach jeder ARIA-
+          // Antwort schluckte das Wake-Word den naechsten Trigger.
+          import('./logger').then(m => m.reportAppDebug('audio.playback',
+            'PcmPlaybackFinished native event → fire listeners')).catch(()=>{});
+          this.playbackFinishedListeners.forEach(cb => {
+            try { cb(); } catch (e) { console.warn('[Audio] playbackFinished cb err:', e); }
+          });
         });
       } catch (err) {
         console.warn('[Audio] PcmPlaybackFinished-Subscription fehlgeschlagen:', err);
@@ -1368,12 +1381,13 @@ class AudioService {
         // releasen den AudioFocus NICHT hier — der writer braucht u.U. noch
         // 30+ Sekunden bis der Buffer wirklich abgespielt ist. Den release
         // triggert das native Event "PcmPlaybackFinished" wenn AudioTrack
-        // wirklich am Ende ist (siehe ensurePlaybackFinishedListener).
+        // wirklich am Ende ist (siehe Constructor-PcmPlaybackFinished-Handler).
+        //
+        // playbackFinishedListeners feuern AUCH erst dort — frueher feuerten
+        // sie hier (beim Eintreffen des letzten Chunks), das fuehrte zu
+        // einem Race: OpenWakeWord re-armte waehrend AudioTrack noch hoerbar
+        // ARIAs Stimme abspielte → naechstes Wake-Word ging unter.
         try { await PcmStreamPlayer!.end(); } catch {}
-        // playbackFinished-Listener informieren (UI-Logik)
-        this.playbackFinishedListeners.forEach(cb => {
-          try { cb(); } catch (e) { console.warn('[Audio] playbackFinished cb err:', e); }
-        });
       }
       this.pcmStreamActive = false;
 

android/src/services/wakeword.ts

@@ -346,19 +346,34 @@ class WakeWordService {
    *  Ohne: zurueck zu 'off'.
    */
   async endConversation(): Promise<void> {
-    if (this.state !== 'conversing') return;
+    if (this.state !== 'conversing') {
+      // Nicht in conversing — typ. nach App-Resume bevor Streaming endete.
+      // Trotzdem loggen damit wir's im Diagnostic sehen.
+      import('./logger').then(m => m.reportAppDebug('wake.end',
+        `endConversation called but state=${this.state} → noop`)).catch(()=>{});
+      return;
+    }
+    import('./logger').then(m => m.reportAppDebug('wake.end',
+      `endConversation called, nativeReady=${this.nativeReady}, calling OpenWakeWord.start()`)).catch(()=>{});
     if (this.nativeReady && OpenWakeWord) {
       try {
         await OpenWakeWord.start();
         console.log('[WakeWord] Konversation zu Ende — zurueck zu armed');
+        import('./logger').then(m => m.reportAppDebug('wake.end',
+          `OpenWakeWord.start() OK → state=armed, keyword=${this.keyword}`)).catch(()=>{});
         ToastAndroid.show(`Lausche wieder auf "${KEYWORD_LABELS[this.keyword]}"`, ToastAndroid.SHORT);
         this.setState('armed');
         return;
-      } catch (err) {
+      } catch (err: any) {
         console.warn('[WakeWord] re-arm fehlgeschlagen:', err);
+        import('./logger').then(m => m.reportAppDebug('wake.end',
+          `OpenWakeWord.start() FAIL: ${err?.message || err} → state=off`,
+          )).catch(()=>{});
       }
     }
     console.log('[WakeWord] Konversation zu Ende — Ohr aus');
+    import('./logger').then(m => m.reportAppDebug('wake.end',
+      `fallback: nativeReady=${this.nativeReady} → state=off`)).catch(()=>{});
     ToastAndroid.show('Mikro aus', ToastAndroid.SHORT);
     this.setState('off');
   }