release: bump version to 0.1.6.9

Stefan: "wir haben live log + events tab in protokoll einstellungen, da
ist aber nie was drin".

Bisher hoerten Live Logs / Events nur auf RVS-Messages type='log'/'event'
von der Bridge — die Bridge schickt aktuell aber keine solchen Messages
zurueck zur App. Plus: reportAppDebug/Error ging nur an die Bridge in
/shared/logs/app.log, lokal in der App war nichts sichtbar.

Loesung: lokaler DeviceEventEmitter-Bus.

logger.ts:
- APP_LOG_EVENT Konstante exportiert
- reportAppError + reportAppDebug emittieren ZUSAETZLICH zum
  RVS-Send ein lokales DeviceEventEmitter-Event (errors immer,
  debug nur wenn Toggle AN)

SettingsScreen.tsx:
- DeviceEventEmitter.addListener auf APP_LOG_EVENT
- Mappt Log-Entries 1:1 in den 'logs'-State (max 200)
- Cleanup in useEffect-return

Damit sieht Stefan beim Debuggen (Debug-Toggle AN, Live-Logs-Tab
offen) live in der App was passiert — ohne curl gegen Bridge.

APK neu bauen erforderlich.

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

android/android/app/build.gradle

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

android/package.json

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

android/src/screens/ChatScreen.tsx

@@ -1270,9 +1270,11 @@ const ChatScreen: React.FC = () => {
   useEffect(() => {
     const unsubWake = wakeWordService.onWakeWord(async () => {
       console.log('[Chat] Gespraechsmodus — starte Auto-Aufnahme');
+      import('../services/logger').then(m => m.reportAppDebug('wake.cb', 'callback fired, calling startRecording')).catch(()=>{});
       // Conversation-Window: User hat X Sekunden um anzufangen, sonst Konversation aus
       const windowMs = await loadConvWindowMs();
       const started = await audioService.startRecording(true, windowMs);
+      import('../services/logger').then(m => m.reportAppDebug('wake.cb', `startRecording returned ${started}`)).catch(()=>{});
       if (started) {
         // Erst JETZT signalisieren dass das Mikro wirklich offen ist —
         // vorher war's noch in der Init-Phase. So weiss der User exakt
@@ -1280,6 +1282,7 @@ const ChatScreen: React.FC = () => {
         // ueber Settings → Wake-Word abschaltbar.
         ToastAndroid.show('🎤 Mikro offen — sprich jetzt', ToastAndroid.SHORT);
         playWakeReadySound().catch(() => {});
+        import('../services/logger').then(m => m.reportAppDebug('wake.cb', 'gong played + recording started')).catch(()=>{});
       } else {
         // Mikrofon nicht verfuegbar, naechsten Versuch
         wakeWordService.resume();

android/src/screens/SettingsScreen.tsx

@@ -20,6 +20,7 @@ import {
   Modal,
   PermissionsAndroid,
   useWindowDimensions,
+  DeviceEventEmitter,
 } from 'react-native';
 import AsyncStorage from '@react-native-async-storage/async-storage';
 import RNFS from 'react-native-fs';
@@ -62,7 +63,7 @@ import MemoryBrowser from '../components/MemoryBrowser';
 import TriggerBrowser from '../components/TriggerBrowser';
 import SkillBrowser from '../components/SkillBrowser';
 import OAuthBrowser from '../components/OAuthBrowser';
-import { isVerboseLogging, setVerboseLogging } from '../services/logger';
+import { isVerboseLogging, setVerboseLogging, isDebugLogsToBridge, setDebugLogsToBridge, APP_LOG_EVENT } from '../services/logger';
 import {
   isWakeReadySoundEnabled,
   setWakeReadySoundEnabled,
@@ -160,6 +161,7 @@ const SettingsScreen: React.FC = () => {
   const [apkCacheInfo, setApkCacheInfo] = useState<{count: number, totalMB: number} | null>(null);
   const [ttsCacheInfo, setTtsCacheInfo] = useState<{count: number, totalMB: number} | null>(null);
   const [verboseLogging, setVerboseLoggingState] = useState<boolean>(isVerboseLogging());
+  const [debugLogsToBridge, setDebugLogsToBridgeState] = useState<boolean>(isDebugLogsToBridge());
   const [ttsSpeed, setTtsSpeed] = useState<number>(TTS_SPEED_DEFAULT);
   const [wakeKeyword, setWakeKeyword] = useState<string>(DEFAULT_KEYWORD);
   const [wakeStatus, setWakeStatus] = useState<string>('');
@@ -387,6 +389,19 @@ const SettingsScreen: React.FC = () => {
       setConnLog(prev => [...prev.slice(-99), entry]);
     });
 
+    // Lokale App-Logs (reportAppDebug/Error) im Live-Logs-Tab anzeigen
+    // — damit Stefan ohne curl direkt in der App sieht was passiert.
+    const localLogSub = DeviceEventEmitter.addListener(APP_LOG_EVENT, (e: any) => {
+      const entry: LogEntry = {
+        id: `applog_${e.ts || Date.now()}_${logIdCounter++}`,
+        timestamp: e.ts || Date.now(),
+        source: e.scope || 'app',
+        message: e.message || '',
+        level: e.level || 'info',
+      };
+      setLogs(prev => [...prev.slice(-200), entry]);
+    });
+
     const unsubMessage = rvs.onMessage((message: RVSMessage) => {
       if (message.type === 'log') {
         const entry: LogEntry = {
@@ -522,6 +537,7 @@ const SettingsScreen: React.FC = () => {
       unsubState();
       unsubMessage();
       unsubLog();
+      localLogSub.remove();
     };
   }, []);
 
@@ -1916,6 +1932,27 @@ const SettingsScreen: React.FC = () => {
           Warnungen und Fehler bleiben immer aktiv. Bei Bedarf einschalten zum
           Debuggen via adb logcat.
         </Text>
+
+        {/* Debug-Logs an Bridge: scharf nur wenn aktiv gebraucht */}
+        <View style={[styles.toggleRow, {marginTop: 12, borderTopWidth: 1, borderTopColor: '#1E1E2E', paddingTop: 12}]}>
+          <Text style={styles.toggleLabel}>Debug-Logs an Bridge</Text>
+          <Switch
+            value={debugLogsToBridge}
+            onValueChange={(v) => {
+              setDebugLogsToBridge(v);
+              setDebugLogsToBridgeState(v);
+            }}
+            trackColor={{ false: '#3A3A52', true: '#FF9500' }}
+            thumbColor={debugLogsToBridge ? '#FFFFFF' : '#666680'}
+          />
+        </View>
+        <Text style={styles.toggleHint}>
+          Schickt detaillierte Diagnose-Logs (Wake-Word-Pipeline, Audio-Focus,
+          Background-Service) per RVS an die Bridge — abrufbar via
+          `curl /api/app-log?lines=N` ohne ADB. Default AUS damit kein
+          unnoetiger Traffic + Disk-Schreiben. Crash-Reports (Errors) gehen
+          IMMER, dieser Toggle betrifft nur Info-Logs.
+        </Text>
       </View>
 
       <View style={styles.card}>

android/src/services/backgroundAudio.ts

@@ -48,6 +48,7 @@ async function applyState(): Promise<void> {
   if (slots.size === 0) {
     try { await BackgroundAudio.stop(); } catch {}
     console.log('[BackgroundAudio] Service gestoppt (keine Slots)');
+    import('./logger').then(m => m.reportAppDebug('bg.stop', 'service stopped')).catch(()=>{});
     return;
   }
   const reason = topReason();
@@ -55,8 +56,10 @@ async function applyState(): Promise<void> {
     await BackgroundAudio.start(reason);
     console.log('[BackgroundAudio] Service aktiv (slot=%s, slots=%s)',
                 reason, [...slots].join('+'));
+    import('./logger').then(m => m.reportAppDebug('bg.start', `slot=${reason} all=[${[...slots].join(',')}]`)).catch(()=>{});
   } catch (err: any) {
     console.warn('[BackgroundAudio] start fehlgeschlagen:', err?.message || err);
+    import('./logger').then(m => m.reportAppDebug('bg.start.fail', err?.message || String(err))).catch(()=>{});
   }
 }
 

android/src/services/logger.ts

@@ -7,10 +7,28 @@
  */
 
 import AsyncStorage from '@react-native-async-storage/async-storage';
-import { Platform } from 'react-native';
+import { Platform, DeviceEventEmitter } from 'react-native';
 import rvs from './rvs';
 
+// Lokales Event damit die SettingsScreen Live Logs / Events Tabs
+// auch das sehen was die App SELBST loggt (reportAppDebug/Error).
+// Bisher gingen die nur via RVS an die Bridge. Lokal sichtbar = Mama-
+// tauglich Debug ohne curl.
+export const APP_LOG_EVENT = 'AriaLocalAppLog';
+
+interface LocalLogEntry {
+  ts: number;
+  level: 'info' | 'warn' | 'error';
+  scope: string;
+  message: string;
+}
+
 export const VERBOSE_LOGGING_KEY = 'aria_verbose_logging';
+// Eigener Toggle fuer Debug-Logs die ueber RVS an die Bridge gehen
+// (/shared/logs/app.log → Diagnostic /api/app-log). Damit der Default-User
+// nicht stuendlich Traffic + Disk-Schreiben hat, dieser ist DEFAULT AUS.
+// Stefan schaltet's nur ein wenn er ein konkretes Problem debuggen muss.
+export const DEBUG_LOGS_TO_BRIDGE_KEY = 'aria_debug_logs_to_bridge';
 
 // Original-console.log retten, damit wir die Wrapper jederzeit wieder
 // "scharf" stellen koennen (sonst waere ein Toggle-an nach -aus tot).
@@ -18,6 +36,7 @@ const originalLog = console.log.bind(console);
 const noop = () => {};
 
 let _verbose = true;
+let _debugLogsToBridge = false;
 
 function applyState(): void {
   console.log = _verbose ? originalLog : noop;
@@ -29,6 +48,10 @@ export async function initLogger(): Promise<void> {
     const v = await AsyncStorage.getItem(VERBOSE_LOGGING_KEY);
     _verbose = v !== 'false'; // default: true
   } catch {}
+  try {
+    const d = await AsyncStorage.getItem(DEBUG_LOGS_TO_BRIDGE_KEY);
+    _debugLogsToBridge = d === 'true'; // default: false
+  } catch {}
   applyState();
 }
 
@@ -42,6 +65,15 @@ export function setVerboseLogging(verbose: boolean): void {
   AsyncStorage.setItem(VERBOSE_LOGGING_KEY, String(verbose)).catch(() => {});
 }
 
+export function isDebugLogsToBridge(): boolean {
+  return _debugLogsToBridge;
+}
+
+export function setDebugLogsToBridge(enabled: boolean): void {
+  _debugLogsToBridge = enabled;
+  AsyncStorage.setItem(DEBUG_LOGS_TO_BRIDGE_KEY, String(enabled)).catch(() => {});
+}
+
 // ─── App-Crash-Reporting via RVS ────────────────────────────────────
 //
 // Wenn die App crasht — egal ob React-Render-Fehler (ErrorBoundary) oder
@@ -61,9 +93,10 @@ let _reportingInstalled = false;
 
 /** Schickt einen App-Fehler via RVS an die Bridge. */
 export function reportAppError(ev: AppErrorEvent): void {
+  const ts = Date.now();
   try {
     rvs.send('app_log' as any, {
-      ts: Date.now(),
+      ts,
       platform: Platform.OS,
       level: ev.level || 'error',
       scope: ev.scope,
@@ -73,11 +106,49 @@ export function reportAppError(ev: AppErrorEvent): void {
   } catch {
     // RVS noch nicht connected — Fehler geht im console weiter.
   }
+  // Lokal in den App-Logs-Tab emitten — Errors gehen IMMER durch
+  // (unabhaengig vom Debug-Toggle).
+  try {
+    const entry: LocalLogEntry = {
+      ts, level: ev.level || 'error', scope: ev.scope, message: ev.message,
+    };
+    DeviceEventEmitter.emit(APP_LOG_EVENT, entry);
+  } catch {}
   // Plus lokal: console.error, damit Stefan's adb (wenn doch mal verfuegbar)
   // den Crash sieht.
   console.error(`[app-error scope=${ev.scope}]`, ev.message, '\n', ev.stack || '');
 }
 
+/** Schickt eine Debug-/Info-Message via RVS an die Bridge. Landet ebenfalls
+ *  in /shared/logs/app.log — abrufbar via `curl /api/app-log?lines=N`.
+ *  Im Gegensatz zu reportAppError: keine Stacktrace, level=info, kein
+ *  console.error. Fuer Live-Diagnose im Hintergrund wenn ADB nicht da ist.
+ *
+ *  Nur aktiv wenn Settings → Protokoll → Debug-Logs an Bridge AN ist.
+ *  Default aus damit Mama-Modus keine Disk-Schreiblast hat. Error-Reports
+ *  (reportAppError) gehen weiterhin IMMER durch. */
+export function reportAppDebug(scope: string, message: string): void {
+  if (!_debugLogsToBridge) return;
+  const ts = Date.now();
+  const trimmed = String(message).slice(0, 2000);
+  try {
+    rvs.send('app_log' as any, {
+      ts,
+      platform: Platform.OS,
+      level: 'info',
+      scope,
+      message: trimmed,
+    });
+  } catch {}
+  // Plus lokal in den App-Logs-Tab emitten — damit Stefan in der App
+  // selbst (Settings → Protokoll → Live Logs) sieht was passiert,
+  // ohne curl gegen Bridge.
+  try {
+    const entry: LocalLogEntry = { ts, level: 'info', scope, message: trimmed };
+    DeviceEventEmitter.emit(APP_LOG_EVENT, entry);
+  } catch {}
+}
+
 /** Installiert einen globalen JS-Error-Handler der ungefangene Errors via
  *  RVS an die Bridge schickt. Beim App-Start aufrufen. */
 export function installGlobalCrashReporter(): void {

android/src/services/wakeword.ts

@@ -179,6 +179,8 @@ class WakeWordService {
       try {
         await OpenWakeWord.start();
         console.log('[WakeWord] armed — warte auf "%s"', this.keyword);
+        // Debug-Log via RVS damit wir auch ohne ADB sehen wann es greift
+        import('./logger').then(m => m.reportAppDebug('wake.start', `armed, keyword=${this.keyword}`)).catch(()=>{});
         ToastAndroid.show(`Lausche auf "${KEYWORD_LABELS[this.keyword]}"`, ToastAndroid.SHORT);
         this.setState('armed');
         return true;
@@ -236,15 +238,24 @@ class WakeWordService {
     }
     console.log('[WakeWord] Wake-Word "%s" erkannt! (state=%s, barge=%s)',
                 this.keyword, this.state, this.bargeListening);
+    import('./logger').then(m => m.reportAppDebug('wake.detect',
+      `keyword=${this.keyword} state=${this.state} barge=${this.bargeListening}`)).catch(()=>{});
     this.lastTriggerAt = now;
     if (this.nativeReady && OpenWakeWord) {
-      try { await OpenWakeWord.stop(); } catch {}
+      try {
+        await OpenWakeWord.stop();
+        import('./logger').then(m => m.reportAppDebug('wake.detect', 'native stop ok')).catch(()=>{});
+      } catch (e: any) {
+        import('./logger').then(m => m.reportAppDebug('wake.detect', `native stop FAIL ${e?.message}`)).catch(()=>{});
+      }
     }
     this.bargeListening = false;
     // Wenn wir bereits in 'conversing' sind und der Trigger waehrend ARIAs TTS
     // kam (Barge-In via Wake-Word), feuern wir einen separaten Callback damit
     // ChatScreen das TTS abbrechen + neue Aufnahme starten kann. Sonst normal.
     if (this.state === 'conversing') {
+      import('./logger').then(m => m.reportAppDebug('wake.detect',
+        `barge path: cbs=${this.bargeCallbacks.length}`)).catch(()=>{});
       this.bargeCallbacks.forEach(cb => {
         try { cb(); } catch (e) { console.warn('[WakeWord] barge cb err:', e); }
       });
@@ -252,7 +263,11 @@ class WakeWordService {
       return;
     }
     this.setState('conversing');
+    import('./logger').then(m => m.reportAppDebug('wake.detect',
+      `state→conversing, wakeCallbacks.length=${this.wakeCallbacks.length}, scheduling 200ms timeout`)).catch(()=>{});
     setTimeout(() => {
+      import('./logger').then(m => m.reportAppDebug('wake.detect',
+        `timeout fired, state=${this.state}, cbs=${this.wakeCallbacks.length}`)).catch(()=>{});
       if (this.state === 'conversing') {
         this.wakeCallbacks.forEach(cb => cb());
       }