docs: README + issue — Memory-Editor-App + Crash-Reporting + Bugfixes

Heute Tag-2 nach dem Memory-Editor-Hauptbau:

issue.md: neuer Block "App-Memory-Editor + Crash-Reporting" mit 8
Punkten (Bubble-Header dynamic, Tap-Modal, Inbox, Settings-Editor,
RVS-Brain-Proxy, App-Crash-Reporting, memory_search+update Tools,
Bugfixes-Cluster).

README.md:
- App-Features um Notizen-Inbox + Memory-Editor + Bubble-Header
  dynamic + App-Crash-Reporting ergaenzt
- Roadmap um "Memory-Editor in der App" und "App-Crash-Reporting via
  RVS" als eigene Bullets — beide sitzen unter dem letzten
  Memory-Anhaenge-Eintrag und schliessen damit den App-UX-Loop:
  ARIA hat jetzt im Diagnostic UND in der App vollwertiges Memory-
  CRUD inkl. Anhaenge, plus Crashes sind ohne ADB diagnostizierbar.

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

.gitignore

@@ -25,6 +25,10 @@ aria-data/brain-import/*
 !aria-data/brain-import/.gitkeep
 !aria-data/brain-import/README.md
 
+# .aria-debug/ — App-Crash-Logs die tools/fetch-app-logs.sh hier ablegt.
+# Komplett lokal, enthaelt potentiell private Stacktraces / Daten.
+.aria-debug/
+
 # ── ARIAs Gedächtnis (Vector-DB, Skills, Models) ──
 # Backup via Diagnostic → Gehirn-Export (tar.gz), nicht via Git.
 aria-data/brain/data/

README.md

@@ -357,6 +357,9 @@ Erreichbar unter `http://<VM-IP>:3001`. Teilt das Netzwerk mit der Bridge.
 - **Play-Button**: Jede ARIA-Nachricht kann nochmal vorgelesen werden (aus Cache wenn vorhanden, sonst neu rendern)
 - **Chat-Suche**: Lupe in der Statusleiste filtert Nachrichten live
 - **Mülltonne pro Bubble** (mit Confirm): gezielt eine Nachricht loeschen — geht nicht nur aus der UI weg, sondern auch aus `chat_backup.jsonl`, Brain-Conversation-Window und allen anderen Clients (RVS-Broadcast). Wichtig damit ARIA den Turn auch beim naechsten Prompt nicht mehr im Kontext hat
+- **🗂️ Notizen-Inbox + Memory-Editor**: Neben der Lupe oeffnet `🗂️` ein Vollbild-Modal mit allen Memory/Trigger/Skill-Spezial-Bubbles aus dem Chat plus dem vollen DB-Browser. Tap auf eine Memory oeffnet ein **Detail/Edit-Modal**: Felder editieren, Anhaenge hoch-/runterladen + loeschen, Memory komplett loeschen. Identischer Editor auch in Settings → 🧠 Gedaechtnis. Spezial-Bubbles werden aus dem Chat-Stream gefiltert (keine ewig-unten-haengenden Notiz-Bubbles mehr)
+- **Bubble-Header dynamic**: „ARIA hat etwas gemerkt" / „Notiz geaendert" (gelb) / „Notiz geloescht" (rot) — je nach action im memory_saved-Event
+- **App-Crash-Reporting**: ungefangene JS-Errors + React-Render-Fehler landen automatisch in `/shared/logs/app.log` via RVS — kein ADB noetig, Logs holen via `tools/fetch-app-logs.sh` oder Diagnostic GET `/api/app-log`. ErrorBoundary verhindert White-Screen, zeigt stattdessen Error-Box im Modal mit Stack-Trace + Schliessen-Button
 - **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
@@ -871,6 +874,8 @@ docker exec aria-brain curl localhost:8080/memory/stats
 - [x] **Proxy Tool-Use durchreichen**: claude-max-api-proxy patcht via eigene Adapter (`proxy-patches/`) den `tools`/`tool_calls`-Roundtrip — Claude Code rief vorher ihre internen Tools (Bash, sleep) statt der ARIA-Brain-Tools (trigger_timer, skill_*, ...). Jetzt funktioniert Tool-Use End-to-End.
 - [x] **Single Source of Truth — Qdrant**: `memory_save`-Tool fuer ARIA, Claude-Code-Auto-Memory abgeklemmt (tmpfs ueber `~/.claude/projects` im Proxy-Container), `brain-import/` zum reinen Drop-Folder degradiert, Cold-Memory mit Score-Threshold (0.30) gegen Embedder-Noise/Crosstalk, Diagnostic-Gehirn-UI mit Wortlich-/Semantisch-Suche, Advanced Search (AND/OR mit + Button), Memory-Druckansicht, Muelltonne pro Chat-Bubble. DB ist jetzt durchgaengig die einzige Wissensquelle, kein paralleles File-Memory mehr.
 - [x] **Memory-Anhaenge mit Vision-Pipeline**: Pro Memory koennen Bilder/PDFs/beliebige Dateien angehaengt werden (unter `/shared/memory-attachments/<id>/`, max 20 MB). Diagnostic-UI mit Thumbnail-Vorschau + Lightbox, App `memory_saved`-Bubble mit Tap-to-Load via RVS, System-Prompt zeigt Anhang-Pfade. **ARIA sieht Bilder echt** via Claude Code's eingebautes multi-modales `Read`-Tool — kein Proxy-Patch noetig. `memory_save` hat `attach_paths`-Parameter sodass ARIA ein User-Foto im selben Tool-Call lesen, Infos extrahieren (Kennzeichen, Marken, Texte) und als Memory + Anhang persistieren kann. Bilder bleiben am Memory haengen — bei spaeteren Detail-Fragen liest ARIA das Bild einfach nochmal.
+- [x] **Memory-Editor in der App** (5 Etappen): Notizen-Inbox-Button neben der Lupe oeffnet ein Modal mit allen Spezial-Bubbles aus dem aktuellen Chat plus dem vollen DB-Browser. Tap auf eine Memory → Detail-Modal mit Anhang-Vorschau, Stift-Icon wechselt in Edit-Mode (Felder editieren + Anhaenge hoch-/runterladen + loeschen). Identischer Editor unter Settings → 🧠 Gedaechtnis. Bubble-Header dynamic je nach Aktion (created/updated/deleted). RVS-Brain-Proxy als Fundament (`brain_request`/`brain_response`) damit die App beliebige Brain-HTTP-Endpoints adressieren kann. `memory_search` + `memory_update` als ARIA-Tools damit sie aktiv die DB pruefen und Eintraege patchen kann statt zu fragmentieren.
+- [x] **App-Crash-Reporting via RVS**: ErrorBoundary + global JS-Error-Handler + Promise-Rejection-Tracker schicken Crashes als `app_log`-Event durch RVS. Bridge sammelt in `/shared/logs/app.log`, Diagnostic GET `/api/app-log`. `tools/fetch-app-logs.sh` holt die Logs auf die Dev-Maschine (gitignored `.aria-debug/`). Damit kann Stefan unterwegs ohne ADB debuggen — der erste Bug (URLSearchParams in Hermes) wurde so in 5 Minuten gefunden.
 - [x] Sprachmodell-Setting wieder funktional (brainModel in runtime.json statt aria-core)
 - [x] App-Chat-Sync: kompletter Server-Sync bei Reconnect (Server = Source of Truth) + chat_cleared Live-Update. Lokal-only Bubbles (Skill-Notifications, laufende Voice ohne STT) bleiben erhalten.
 - [x] App: Chat-Suche mit Next/Prev Navigation statt Filter

android/App.tsx

@@ -13,7 +13,7 @@ import { createBottomTabNavigator } from '@react-navigation/bottom-tabs';
 import ChatScreen from './src/screens/ChatScreen';
 import SettingsScreen from './src/screens/SettingsScreen';
 import rvs from './src/services/rvs';
-import { initLogger } from './src/services/logger';
+import { initLogger, installGlobalCrashReporter } from './src/services/logger';
 
 // --- Navigation ---
 
@@ -49,6 +49,9 @@ const App: React.FC = () => {
     // initLogger ist async aber blockt nichts — solange er noch laueft,
     // loggen wir normal (Default an), danach respektiert console.log das Setting.
     initLogger().catch(() => {});
+    // Crash-Reporter installieren — ungefangene JS-Errors landen via RVS
+    // bei der Bridge (sichtbar in /shared/logs/app.log + Diagnostic-API)
+    installGlobalCrashReporter();
     const initConnection = async () => {
       const config = await rvs.loadConfig();
       if (config) {

android/android/app/build.gradle

@@ -79,8 +79,8 @@ android {
         applicationId "com.ariacockpit"
         minSdkVersion rootProject.ext.minSdkVersion
         targetSdkVersion rootProject.ext.targetSdkVersion
-        versionCode 10301
-        versionName "0.1.3.1"
+        versionCode 10309
+        versionName "0.1.3.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.3.1",
+  "version": "0.1.3.9",
   "private": true,
   "scripts": {
     "android": "react-native run-android",

android/src/components/ErrorBoundary.tsx

@@ -0,0 +1,89 @@
+/**
+ * ErrorBoundary — fängt React-Render-Fehler und zeigt eine Error-Box
+ * statt White-Screen-of-Death. Plus: Crash wird zum logger geschickt,
+ * der das ueber RVS an die Bridge weiterleitet.
+ *
+ * Einsatz: kritische Komponenten/Modals damit ein Bug nicht die ganze
+ * App killt.
+ */
+
+import React from 'react';
+import { ScrollView, StyleSheet, Text, TouchableOpacity, View } from 'react-native';
+
+import { reportAppError } from '../services/logger';
+
+interface Props {
+  children: React.ReactNode;
+  /** Optional: Bezeichnung der eingegrenzten Section fuer's Log. */
+  scope?: string;
+  /** Optional: Reset-Callback (z.B. Modal schliessen) — Button ist dann sichtbar. */
+  onReset?: () => void;
+}
+
+interface State {
+  err: Error | null;
+  info: string;
+}
+
+export class ErrorBoundary extends React.Component<Props, State> {
+  constructor(props: Props) {
+    super(props);
+    this.state = { err: null, info: '' };
+  }
+
+  static getDerivedStateFromError(err: Error): Partial<State> {
+    return { err };
+  }
+
+  componentDidCatch(err: Error, info: any) {
+    const stack = info?.componentStack || '';
+    this.setState({ info: stack });
+    reportAppError({
+      scope: this.props.scope || 'ErrorBoundary',
+      message: err?.message || String(err),
+      stack: (err?.stack || '') + '\n--- componentStack ---\n' + stack,
+    });
+  }
+
+  render() {
+    if (this.state.err) {
+      return (
+        <View style={s.box}>
+          <Text style={s.title}>⚠️ Etwas ist schiefgegangen</Text>
+          <Text style={s.scope}>{this.props.scope || 'unbekannte Komponente'}</Text>
+          <ScrollView style={s.scroll}>
+            <Text style={s.msg}>{this.state.err.message || String(this.state.err)}</Text>
+            {this.state.info ? <Text style={s.stack}>{this.state.info}</Text> : null}
+          </ScrollView>
+          {this.props.onReset ? (
+            <TouchableOpacity style={s.btn} onPress={() => { this.setState({err:null,info:''}); this.props.onReset?.(); }}>
+              <Text style={s.btnText}>Schliessen + zurueck</Text>
+            </TouchableOpacity>
+          ) : (
+            <TouchableOpacity style={s.btn} onPress={() => this.setState({err:null,info:''})}>
+              <Text style={s.btnText}>Erneut versuchen</Text>
+            </TouchableOpacity>
+          )}
+          <Text style={s.hint}>
+            Crash wurde an die Bridge gemeldet — sichtbar in der Diagnostic-Web-UI unter /api/app-log
+          </Text>
+        </View>
+      );
+    }
+    return this.props.children;
+  }
+}
+
+const s = StyleSheet.create({
+  box: { flex:1, padding:16, backgroundColor:'#1A0A0A' },
+  title: { color:'#FF6B6B', fontWeight:'bold', fontSize:16, marginBottom:6 },
+  scope: { color:'#FF9500', fontSize:12, marginBottom:10 },
+  scroll: { flex:1, backgroundColor:'#0D0D1A', borderRadius:6, padding:10, marginBottom:10 },
+  msg: { color:'#FF6B6B', fontSize:13, marginBottom:8 },
+  stack: { color:'#8888AA', fontSize:11, fontFamily:'monospace' },
+  btn: { backgroundColor:'#0096FF', paddingVertical:10, borderRadius:6, alignItems:'center' },
+  btnText: { color:'#fff', fontWeight:'600' },
+  hint: { color:'#555570', fontSize:10, marginTop:8, textAlign:'center' },
+});
+
+export default ErrorBoundary;

android/src/components/MemoryBrowser.tsx

@@ -37,9 +37,11 @@ interface Props {
   title?: string;
   /** Style-Erweiterung fuer den Container. */
   flatStyle?: boolean;
+  /** Wenn gesetzt: kein eigenes DetailModal mounten — Parent kuemmert sich. */
+  onOpenMemory?: (id: string) => void;
 }
 
-export const MemoryBrowser: React.FC<Props> = ({ restrictToIds, title, flatStyle }) => {
+export const MemoryBrowser: React.FC<Props> = ({ restrictToIds, title, flatStyle, onOpenMemory }) => {
   const [items, setItems] = useState<Memory[]>([]);
   const [filtered, setFiltered] = useState<Memory[]>([]);
   const [loading, setLoading] = useState(false);
@@ -82,38 +84,35 @@ export const MemoryBrowser: React.FC<Props> = ({ restrictToIds, title, flatStyle
     setFiltered(out);
   }, [items, q, typeFilter, pinnedFilter, restrictToIds]);
 
+  const [showNewMemoryDialog, setShowNewMemoryDialog] = useState(false);
+  const [newMemoryTitle, setNewMemoryTitle] = useState('');
+
   const onAddNew = () => {
-    Alert.prompt(
-      'Neue Memory',
-      'Titel:',
-      [
-        { text: 'Abbrechen', style: 'cancel' },
-        {
-          text: 'Anlegen',
-          onPress: async (title?: string) => {
-            const t = (title || '').trim();
-            if (!t) return;
-            try {
-              const m = await brainApi.saveMemory({
-                type: 'fact', title: t,
-                content: '(noch leer — bitte editieren)',
-              });
-              load();
-              setOpenId(m.id);
-            } catch (e: any) {
-              Alert.alert('Fehler', String(e?.message || e));
-            }
-          },
-        },
-      ],
-      'plain-text',
-    );
+    setNewMemoryTitle('');
+    setShowNewMemoryDialog(true);
+  };
+
+  const confirmAddNew = async () => {
+    const t = newMemoryTitle.trim();
+    if (!t) { setShowNewMemoryDialog(false); return; }
+    setShowNewMemoryDialog(false);
+    try {
+      const m = await brainApi.saveMemory({
+        type: 'fact', title: t,
+        content: '(noch leer — bitte editieren)',
+      });
+      load();
+      if (onOpenMemory) onOpenMemory(m.id);
+      else setOpenId(m.id);
+    } catch (e: any) {
+      Alert.alert('Fehler', String(e?.message || e));
+    }
   };
 
   const renderItem = ({ item }: { item: Memory }) => {
     const attCount = (item.attachments || []).length;
     return (
-      <TouchableOpacity style={s.row} onPress={() => setOpenId(item.id)}>
+      <TouchableOpacity style={s.row} onPress={() => onOpenMemory ? onOpenMemory(item.id) : setOpenId(item.id)}>
         <View style={{flex:1}}>
           <Text style={s.rowTitle} numberOfLines={1}>
             {item.pinned ? '📌 ' : ''}{item.title || '(ohne Titel)'}
@@ -170,6 +169,12 @@ export const MemoryBrowser: React.FC<Props> = ({ restrictToIds, title, flatStyle
           data={filtered}
           keyExtractor={m => m.id}
           renderItem={renderItem}
+          // nestedScrollEnabled: notwendig damit die FlatList auf Android
+          // scrollt wenn sie in einer aeusseren ScrollView haengt (Settings-
+          // Screen ist ScrollView). Ohne das frisst der aeussere ScrollView
+          // alle Gesten und die innere Liste ist tot.
+          nestedScrollEnabled={true}
+          keyboardShouldPersistTaps="handled"
           ListEmptyComponent={
             <Text style={{color:'#555570',textAlign:'center',padding:20,fontStyle:'italic'}}>
               {items.length === 0 ? '(keine Memories in der DB)' : '(keine Treffer für diese Filter)'}
@@ -202,12 +207,42 @@ export const MemoryBrowser: React.FC<Props> = ({ restrictToIds, title, flatStyle
         </TouchableOpacity>
       </Modal>
 
-      <MemoryDetailModal
-        memoryId={openId}
-        visible={!!openId}
-        onClose={() => { setOpenId(null); load(); }}
-        onDeleted={() => { setOpenId(null); load(); }}
-      />
+      {/* Eigenes DetailModal nur wenn der Parent kein Callback uebergibt
+          (vermeidet Modal-in-Modal-Stacking auf Android). */}
+      {!onOpenMemory && (
+        <MemoryDetailModal
+          memoryId={openId}
+          visible={!!openId}
+          onClose={() => { setOpenId(null); load(); }}
+          onDeleted={() => { setOpenId(null); load(); }}
+        />
+      )}
+
+      {/* "Neue Memory"-Dialog (Alert.prompt ist iOS-only, daher eigenes Modal) */}
+      <Modal visible={showNewMemoryDialog} transparent animationType="fade" onRequestClose={() => setShowNewMemoryDialog(false)}>
+        <View style={s.menuBack}>
+          <View style={[s.menuBox, {padding:16, minWidth:280}]}>
+            <Text style={{color:'#FFD60A', fontWeight:'bold', fontSize:14, marginBottom:10}}>Neue Memory anlegen</Text>
+            <Text style={{color:'#8888AA', fontSize:11, marginBottom:6}}>Titel:</Text>
+            <TextInput
+              value={newMemoryTitle}
+              onChangeText={setNewMemoryTitle}
+              autoFocus
+              placeholder="z.B. Stefans Auto"
+              placeholderTextColor="#555570"
+              style={{backgroundColor:'#1E1E2E', color:'#E0E0F0', padding:8, borderRadius:4, fontSize:13, marginBottom:12}}
+            />
+            <View style={{flexDirection:'row', gap:8, justifyContent:'flex-end'}}>
+              <TouchableOpacity onPress={() => setShowNewMemoryDialog(false)} style={{padding:8}}>
+                <Text style={{color:'#8888AA'}}>Abbrechen</Text>
+              </TouchableOpacity>
+              <TouchableOpacity onPress={confirmAddNew} style={{backgroundColor:'#0096FF', paddingHorizontal:14, paddingVertical:8, borderRadius:4}}>
+                <Text style={{color:'#fff', fontWeight:'600'}}>Anlegen</Text>
+              </TouchableOpacity>
+            </View>
+          </View>
+        </View>
+      </Modal>
     </View>
   );
 };

android/src/screens/ChatScreen.tsx

@@ -30,6 +30,7 @@ import { Dimensions } from 'react-native';
 import ZoomableImage from '../components/ZoomableImage';
 import MemoryDetailModal from '../components/MemoryDetailModal';
 import MemoryBrowser from '../components/MemoryBrowser';
+import ErrorBoundary from '../components/ErrorBoundary';
 import rvs, { RVSMessage, ConnectionState } from '../services/rvs';
 import audioService from '../services/audio';
 import wakeWordService from '../services/wakeword';
@@ -1026,7 +1027,15 @@ const ChatScreen: React.FC = () => {
   }, [messages]);
 
   // Inverted FlatList: neueste Nachrichten unten, kein manuelles Scrollen noetig
-  const invertedMessages = useMemo(() => [...messages].reverse(), [messages]);
+  // Spezial-Bubbles (memorySaved/triggerCreated/skillCreated) sollen im Chat
+  // NICHT mehr erscheinen — sie werden in der Notizen-Inbox angezeigt.
+  // Das verhindert dass sie chronologisch unten im Chat haengen und der
+  // eigentliche Chat-Verlauf darunter verschwindet.
+  const chatVisibleMessages = useMemo(
+    () => messages.filter(m => !m.memorySaved && !m.triggerCreated && !m.skillCreated),
+    [messages],
+  );
+  const invertedMessages = useMemo(() => [...chatVisibleMessages].reverse(), [chatVisibleMessages]);
 
   // Such-Treffer: alle Message-IDs die zur Query passen, in chronologischer
   // Reihenfolge (aelteste zuerst). Bei Query-Change resetten wir den Index.
@@ -1366,17 +1375,30 @@ const ChatScreen: React.FC = () => {
               <TouchableOpacity
                 key={`${item.id}-att-${idx}`}
                 style={styles.memoryAttachmentRow}
-                onPress={() => {
+                onPress={async () => {
                   if (!a.path) return;
                   if (a.localUri) {
-                    if (isImage) setFullscreenImage(a.localUri);
-                    else openFileWithIntent(a.localUri.replace(/^file:\/\//, ''), a.mime || '');
-                  } else {
-                    // Datei via Bridge nachladen — file_response hat den
-                    // memorySaved-Match-Path und cached + zeigt direkt
-                    autoOpenPaths.current.add(a.path);
-                    rvs.send('file_request' as any, { serverPath: a.path, requestId: `memAtt_${item.id}_${idx}` });
+                    const localPath = a.localUri.replace(/^file:\/\//, '');
+                    const exists = await RNFS.exists(localPath).catch(() => false);
+                    if (exists) {
+                      if (isImage) setFullscreenImage(a.localUri);
+                      else openFileWithIntent(localPath, a.mime || '');
+                      return;
+                    }
+                    // Cache weg → localUri leeren + neu laden
+                    setMessages(prev => prev.map(mm => mm.id === item.id && mm.memorySaved
+                      ? { ...mm, memorySaved: { ...mm.memorySaved,
+                          attachments: mm.memorySaved.attachments?.map(x =>
+                            x.path === a.path ? { ...x, localUri: undefined } : x) } }
+                      : mm));
+                    if (Platform.OS === 'android') {
+                      ToastAndroid.show('Cache leer — lade nach...', ToastAndroid.SHORT);
+                    }
                   }
+                  // Datei via Bridge nachladen — file_response hat den
+                  // memorySaved-Match-Path und cached + zeigt direkt
+                  autoOpenPaths.current.add(a.path);
+                  rvs.send('file_request' as any, { serverPath: a.path, requestId: `memAtt_${item.id}_${idx}` });
                 }}
               >
                 <Text style={styles.memoryAttachmentIcon}>{icon}</Text>
@@ -1480,17 +1502,32 @@ const ChatScreen: React.FC = () => {
             ) : (
               <TouchableOpacity
                 style={styles.attachmentFile}
-                onPress={() => {
-                  // Lokal vorhanden \u2192 direkt mit System-Intent oeffnen
+                onPress={async () => {
+                  // Lokal vorhanden? Cache koennte geleert worden sein \u2014
+                  // Datei-Existenz pruefen bevor wir den Intent feuern.
                   if (att.uri) {
-                    openFileWithIntent(att.uri.replace(/^file:\/\//, ''), att.mimeType || '');
-                    return;
+                    const localPath = att.uri.replace(/^file:\/\//, '');
+                    const exists = await RNFS.exists(localPath).catch(() => false);
+                    if (exists) {
+                      openFileWithIntent(localPath, att.mimeType || '');
+                      return;
+                    }
+                    // Cache weg \u2192 uri im State leeren damit UI "tippen zum Laden" zeigt
+                    setMessages(prev => prev.map(m => m.id === item.id
+                      ? { ...m, attachments: m.attachments?.map(a =>
+                          a.serverPath === att.serverPath ? { ...a, uri: undefined } : a) }
+                      : m));
+                    if (Platform.OS === 'android') {
+                      ToastAndroid.show('Cache leer \u2014 lade nach...', ToastAndroid.SHORT);
+                    }
                   }
-                  // Sonst: file_request \u2192 bei file_response wird die Datei
-                  // gespeichert UND geoeffnet (autoOpenPaths-Tracking).
+                  // Re-Download via file_request \u2192 bei file_response wird die
+                  // Datei gespeichert UND geoeffnet (autoOpenPaths-Tracking).
                   if (att.serverPath) {
                     autoOpenPaths.current.add(att.serverPath);
                     rvs.send('file_request' as any, { serverPath: att.serverPath, requestId: item.id });
+                  } else if (Platform.OS === 'android') {
+                    ToastAndroid.show('Datei kann nicht nachgeladen werden (kein serverPath)', ToastAndroid.LONG);
                   }
                 }}
               >
@@ -1597,7 +1634,7 @@ const ChatScreen: React.FC = () => {
            connectionState === 'connecting' ? 'Verbinde...' : 'Getrennt'}
         </Text>
         <TouchableOpacity onPress={() => setInboxVisible(true)} style={{marginLeft: 'auto', paddingHorizontal: 6}} hitSlop={{top:8,bottom:8,left:6,right:6}}>
-          <Text style={{fontSize: 18}}>\uD83D\uDDC2\uFE0F</Text>
+          <Text style={{fontSize: 18}}>{'\uD83D\uDDC2\uFE0F'}</Text>
         </TouchableOpacity>
         <TouchableOpacity onPress={() => setSearchVisible(!searchVisible)} style={{paddingHorizontal: 6}} hitSlop={{top:8,bottom:8,left:6,right:6}}>
           <Text style={{fontSize: 16}}>{'\uD83D\uDD0D'}</Text>
@@ -1831,26 +1868,108 @@ const ChatScreen: React.FC = () => {
       </View>
 
       {/* Memory-Detail/Edit-Modal — wird durch Tap auf eine memorySaved-Bubble geoeffnet */}
-      <MemoryDetailModal
-        memoryId={memoryDetailId}
-        visible={!!memoryDetailId}
-        onClose={() => setMemoryDetailId(null)}
-        onDeleted={() => setMemoryDetailId(null)}
-      />
+      {memoryDetailId ? (
+        <ErrorBoundary scope="ChatScreen.MemoryDetailModal" onReset={() => setMemoryDetailId(null)}>
+          <MemoryDetailModal
+            memoryId={memoryDetailId}
+            visible={!!memoryDetailId}
+            onClose={() => setMemoryDetailId(null)}
+            onDeleted={() => setMemoryDetailId(null)}
+          />
+        </ErrorBoundary>
+      ) : null}
 
       {/* Notizen-Inbox — Listet alle Memories aus dem aktuellen Chat (Special-Bubbles).
           Bestes-Aus-beiden-Welten: nur die Memory-IDs aus den memorySaved-Bubbles
           des aktuellen Chats, plus den vollen Browser darunter wenn der User mehr will. */}
       <Modal visible={inboxVisible} animationType="slide" onRequestClose={() => setInboxVisible(false)}>
+        <ErrorBoundary scope="ChatScreen.InboxModal" onReset={() => setInboxVisible(false)}>
         <View style={{flex:1, backgroundColor:'#0D0D1A'}}>
           <View style={{flexDirection:'row', alignItems:'center', padding:14, borderBottomWidth:1, borderBottomColor:'#1E1E2E'}}>
-            <Text style={{color:'#FFD60A', fontWeight:'bold', fontSize:16, flex:1}}>🗂️ Notizen-Inbox</Text>
+            <Text style={{color:'#FFD60A', fontWeight:'bold', fontSize:16, flex:1}}>{'🗂️'} Notizen-Inbox</Text>
             <TouchableOpacity onPress={() => setInboxVisible(false)} hitSlop={{top:8,bottom:8,left:8,right:8}}>
               <Text style={{color:'#8888AA', fontSize:24}}>×</Text>
             </TouchableOpacity>
           </View>
-          <MemoryBrowser />
+          {/* Aus aktuellem Chat: Spezial-Bubbles (memory/trigger/skill) kompakt
+              auflisten — neueste oben. Klick auf Memory oeffnet Detail-Modal. */}
+          {(() => {
+            const specials = messages
+              .filter(m => m.memorySaved || m.triggerCreated || m.skillCreated)
+              .slice().reverse();
+            if (specials.length === 0) {
+              return (
+                <View style={{padding:14, borderBottomWidth:1, borderBottomColor:'#1E1E2E'}}>
+                  <Text style={{color:'#555570', fontSize:11, fontStyle:'italic'}}>
+                    (keine Notizen-Bubbles im aktuellen Chat)
+                  </Text>
+                </View>
+              );
+            }
+            return (
+              <View style={{maxHeight:260, borderBottomWidth:1, borderBottomColor:'#1E1E2E'}}>
+                <Text style={{color:'#8888AA', fontSize:11, paddingHorizontal:14, paddingTop:8, paddingBottom:4, textTransform:'uppercase', letterSpacing:0.5}}>
+                  Aus diesem Chat
+                </Text>
+                <ScrollView style={{paddingHorizontal:8}}>
+                  {specials.map(m => {
+                    if (m.memorySaved) {
+                      const ms = m.memorySaved;
+                      const action = ms.action || 'created';
+                      const verb = action === 'updated' ? 'geändert' : action === 'deleted' ? 'gelöscht' : 'angelegt';
+                      const dotColor = action === 'deleted' ? '#FF6B6B' : '#FFD60A';
+                      return (
+                        <TouchableOpacity
+                          key={m.id}
+                          style={styles.inboxRow}
+                          onPress={() => { if (ms.id && action !== 'deleted') { setInboxVisible(false); setMemoryDetailId(ms.id); } }}
+                          disabled={!ms.id || action === 'deleted'}
+                        >
+                          <Text style={{fontSize:16}}>{'🧠'}</Text>
+                          <View style={{flex:1}}>
+                            <Text style={styles.inboxRowTitle} numberOfLines={1}>{ms.title}</Text>
+                            <Text style={[styles.inboxRowMeta, {color: dotColor}]}>Memory · {verb} · {ms.type}</Text>
+                          </View>
+                          {ms.id && action !== 'deleted' ? <Text style={{color:'#0096FF', fontSize:14}}>›</Text> : null}
+                        </TouchableOpacity>
+                      );
+                    }
+                    if (m.triggerCreated) {
+                      const t = m.triggerCreated;
+                      return (
+                        <View key={m.id} style={styles.inboxRow}>
+                          <Text style={{fontSize:16}}>{'⏰'}</Text>
+                          <View style={{flex:1}}>
+                            <Text style={styles.inboxRowTitle} numberOfLines={1}>{t.name}</Text>
+                            <Text style={styles.inboxRowMeta}>Trigger · {t.type}{t.fires_at ? ` · ${t.fires_at.slice(0,16).replace('T',' ')}` : ''}</Text>
+                          </View>
+                        </View>
+                      );
+                    }
+                    if (m.skillCreated) {
+                      const sk = m.skillCreated;
+                      return (
+                        <View key={m.id} style={styles.inboxRow}>
+                          <Text style={{fontSize:16}}>{'🛠'}</Text>
+                          <View style={{flex:1}}>
+                            <Text style={styles.inboxRowTitle} numberOfLines={1}>{sk.name}</Text>
+                            <Text style={styles.inboxRowMeta}>Skill · {sk.execution}</Text>
+                          </View>
+                        </View>
+                      );
+                    }
+                    return null;
+                  })}
+                </ScrollView>
+              </View>
+            );
+          })()}
+          <Text style={{color:'#8888AA', fontSize:11, paddingHorizontal:14, paddingTop:10, paddingBottom:4, textTransform:'uppercase', letterSpacing:0.5}}>
+            Alle Memories aus der DB
+          </Text>
+          <MemoryBrowser onOpenMemory={(id) => { setInboxVisible(false); setMemoryDetailId(id); }} />
         </View>
+        </ErrorBoundary>
       </Modal>
 
       {/* Bild-Vollbild Modal */}
@@ -2181,6 +2300,25 @@ const styles = StyleSheet.create({
   playButtonText: {
     fontSize: 16,
   },
+  inboxRow: {
+    flexDirection: 'row',
+    alignItems: 'center',
+    gap: 10,
+    backgroundColor: '#1E1E2E',
+    padding: 10,
+    borderRadius: 6,
+    marginBottom: 4,
+  },
+  inboxRowTitle: {
+    color: '#E0E0F0',
+    fontSize: 13,
+    fontWeight: '600',
+  },
+  inboxRowMeta: {
+    color: '#8888AA',
+    fontSize: 11,
+    marginTop: 1,
+  },
   memoryAttachmentRow: {
     flexDirection: 'row',
     alignItems: 'center',

android/src/screens/SettingsScreen.tsx

@@ -868,7 +868,7 @@ const SettingsScreen: React.FC = () => {
         })()}
       </View>
     </Modal>
-    <ScrollView style={styles.container} contentContainerStyle={styles.content}>
+    <ScrollView style={styles.container} contentContainerStyle={styles.content} nestedScrollEnabled={true}>
 
       {currentSection === null && (
         <>

android/src/services/brainApi.ts

@@ -54,6 +54,18 @@ function _newRequestId(): string {
   return `brain_${Date.now().toString(36)}_${_nextId}`;
 }
 
+/** Mini-Query-String-Builder ohne URLSearchParams (Hermes-Polyfill kennt
+ *  kein URLSearchParams.set, crasht). Akzeptiert object mit string/number/
+ *  bool-Values; undefined/null/leere Strings werden ausgelassen. */
+function _qs(params: Record<string, unknown>): string {
+  const parts: string[] = [];
+  for (const [k, v] of Object.entries(params)) {
+    if (v === undefined || v === null || v === '') continue;
+    parts.push(`${encodeURIComponent(k)}=${encodeURIComponent(String(v))}`);
+  }
+  return parts.length ? `?${parts.join('&')}` : '';
+}
+
 interface SendOpts {
   method?: 'GET' | 'POST' | 'PATCH' | 'DELETE';
   body?: AnyJson;
@@ -119,29 +131,31 @@ export const brainApi = {
 
   /** Liste aller Memories, optional nach Type gefiltert. */
   listMemories(opts: { type?: string; limit?: number } = {}): Promise<Memory[]> {
-    const qs = new URLSearchParams();
-    if (opts.type) qs.set('type', opts.type);
-    qs.set('limit', String(opts.limit || 500));
-    return _send(`/memory/list?${qs.toString()}`);
+    const qs = _qs({ type: opts.type, limit: opts.limit || 500 });
+    return _send(`/memory/list${qs}`);
   },
 
   /** Volltext-Substring-Suche. */
   searchText(q: string, opts: { type?: string; includePinned?: boolean; k?: number } = {}): Promise<Memory[]> {
-    const qs = new URLSearchParams({ q });
-    if (opts.type) qs.set('type', opts.type);
-    qs.set('include_pinned', String(opts.includePinned !== false));
-    qs.set('k', String(opts.k || 50));
-    return _send(`/memory/search-text?${qs.toString()}`);
+    const qs = _qs({
+      q,
+      type: opts.type,
+      include_pinned: opts.includePinned !== false,
+      k: opts.k || 50,
+    });
+    return _send(`/memory/search-text${qs}`);
   },
 
   /** Semantische Suche (Embedder). */
   searchSemantic(q: string, opts: { type?: string; includePinned?: boolean; k?: number; threshold?: number } = {}): Promise<Memory[]> {
-    const qs = new URLSearchParams({ q });
-    if (opts.type) qs.set('type', opts.type);
-    qs.set('include_pinned', String(opts.includePinned !== false));
-    qs.set('k', String(opts.k || 10));
-    qs.set('score_threshold', String(opts.threshold ?? 0.30));
-    return _send(`/memory/search?${qs.toString()}`);
+    const qs = _qs({
+      q,
+      type: opts.type,
+      include_pinned: opts.includePinned !== false,
+      k: opts.k || 10,
+      score_threshold: opts.threshold ?? 0.30,
+    });
+    return _send(`/memory/search${qs}`);
   },
 
   /** Memory anlegen. */

android/src/services/logger.ts

@@ -7,6 +7,8 @@
  */
 
 import AsyncStorage from '@react-native-async-storage/async-storage';
+import { Platform } from 'react-native';
+import rvs from './rvs';
 
 export const VERBOSE_LOGGING_KEY = 'aria_verbose_logging';
 
@@ -39,3 +41,77 @@ export function setVerboseLogging(verbose: boolean): void {
   applyState();
   AsyncStorage.setItem(VERBOSE_LOGGING_KEY, String(verbose)).catch(() => {});
 }
+
+// ─── App-Crash-Reporting via RVS ────────────────────────────────────
+//
+// Wenn die App crasht — egal ob React-Render-Fehler (ErrorBoundary) oder
+// ungefangener JS-Error (ErrorUtils-Handler) — schicken wir den Crash
+// als RVS-Message vom Typ "app_log" an die Bridge. Die schreibt in
+// /shared/logs/app.log, sodass wir/Diagnostic die Crashes mitlesen
+// koennen ohne ADB.
+
+interface AppErrorEvent {
+  scope: string;
+  message: string;
+  stack?: string;
+  level?: 'error' | 'warn' | 'info';
+}
+
+let _reportingInstalled = false;
+
+/** Schickt einen App-Fehler via RVS an die Bridge. */
+export function reportAppError(ev: AppErrorEvent): void {
+  try {
+    rvs.send('app_log' as any, {
+      ts: Date.now(),
+      platform: Platform.OS,
+      level: ev.level || 'error',
+      scope: ev.scope,
+      message: ev.message,
+      stack: (ev.stack || '').slice(0, 8000),
+    });
+  } catch {
+    // RVS noch nicht connected — Fehler geht im console weiter.
+  }
+  // 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 || '');
+}
+
+/** Installiert einen globalen JS-Error-Handler der ungefangene Errors via
+ *  RVS an die Bridge schickt. Beim App-Start aufrufen. */
+export function installGlobalCrashReporter(): void {
+  if (_reportingInstalled) return;
+  _reportingInstalled = true;
+  try {
+    const g: any = global as any;
+    const prev = g.ErrorUtils?.getGlobalHandler?.();
+    g.ErrorUtils?.setGlobalHandler?.((err: any, isFatal: boolean) => {
+      reportAppError({
+        scope: isFatal ? 'global-fatal' : 'global-nonfatal',
+        message: (err && err.message) || String(err),
+        stack: err && err.stack,
+      });
+      // Original-Handler weiterhin aufrufen damit React-Native das System-
+      // Crash-Overlay zeigt (im Dev-Build) bzw. in Production sauber stirbt.
+      if (typeof prev === 'function') {
+        try { prev(err, isFatal); } catch {}
+      }
+    });
+    // unhandled Promise-Rejections — manche RN-Versionen haben das nicht
+    // automatisch im ErrorUtils.
+    g.HermesInternal?.enablePromiseRejectionTracker?.({
+      allRejections: true,
+      onUnhandled: (id: number, err: any) => {
+        reportAppError({
+          scope: 'promise-unhandled',
+          level: 'warn',
+          message: (err && err.message) || String(err),
+          stack: err && err.stack,
+        });
+      },
+    });
+  } catch {
+    // ErrorUtils nicht da → nix machen
+  }
+}

bridge/aria_bridge.py

@@ -1824,6 +1824,29 @@ class ARIABridge:
                 logger.warning("[rvs] delete_message fehlgeschlagen: %s", result.get("error"))
             return
 
+        elif msg_type == "app_log":
+            # App schickt Crash/Error/Info-Log via RVS — wir schreiben das
+            # in /shared/logs/app.log (JSONL) damit Diagnostic + Claude
+            # mitlesen koennen, auch ohne ADB-Zugriff aufs Handy.
+            try:
+                log_dir = Path("/shared/logs")
+                log_dir.mkdir(parents=True, exist_ok=True)
+                line = {
+                    "ts": payload.get("ts") or int(time.time() * 1000),
+                    "platform": payload.get("platform", "?"),
+                    "level": payload.get("level", "info"),
+                    "scope": payload.get("scope", ""),
+                    "message": payload.get("message", ""),
+                    "stack": payload.get("stack", ""),
+                }
+                with (log_dir / "app.log").open("a", encoding="utf-8") as f:
+                    f.write(json.dumps(line, ensure_ascii=False) + "\n")
+                logger.info("[app-log] %s %s: %s",
+                            line["level"], line["scope"], line["message"][:120])
+            except Exception as exc:
+                logger.warning("[app-log] schreiben fehlgeschlagen: %s", exc)
+            return
+
         elif msg_type == "brain_request":
             # Generischer RVS-Proxy fuer die Brain-HTTP-API.
             # payload: {requestId, method, path, body?, bodyBase64?, contentType?}

diagnostic/server.js

@@ -1338,6 +1338,42 @@ const server = http.createServer((req, res) => {
     else broadcast({ type: "agent_activity", activity: "idle" });
     res.writeHead(200, { "Content-Type": "application/json" });
     res.end(JSON.stringify({ ok: true }));
+  } else if (req.url.startsWith("/api/app-log") && req.method === "GET") {
+    // App-Crash-Reporting-Log lesen — die App schickt JS-Errors via RVS,
+    // Bridge schreibt JSONL nach /shared/logs/app.log. Wir liefern die
+    // letzten 200 Eintraege (oder ?limit=N).
+    const url = new URL(req.url, "http://x");
+    const limit = Math.max(1, Math.min(2000, parseInt(url.searchParams.get("limit") || "200", 10) || 200));
+    try {
+      const file = "/shared/logs/app.log";
+      if (!fs.existsSync(file)) {
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ count: 0, entries: [] }));
+        return;
+      }
+      const raw = fs.readFileSync(file, "utf-8");
+      const lines = raw.split("\n").filter(l => l.trim());
+      const tail = lines.slice(-limit);
+      const entries = tail.map(l => { try { return JSON.parse(l); } catch { return null; } }).filter(Boolean);
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ count: entries.length, entries }));
+    } catch (err) {
+      res.writeHead(500, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: err.message }));
+    }
+    return;
+  } else if (req.url === "/api/app-log/clear" && req.method === "POST") {
+    // App-Log leeren — nach erfolgreichem Debug.
+    try {
+      const file = "/shared/logs/app.log";
+      if (fs.existsSync(file)) fs.unlinkSync(file);
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ ok: true }));
+    } catch (err) {
+      res.writeHead(500, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ ok: false, error: err.message }));
+    }
+    return;
   } else if (req.url === "/api/files-list" && req.method === "GET") {
     // Liste alle Dateien in /shared/uploads/ — die kommen entweder vom User
     // (Upload aus App/Diagnostic) oder von ARIA (aria_<name>.<ext> Pattern).

issue.md

@@ -297,6 +297,17 @@ Skills mit Tool-Use.
 - [x] **Gehirn-Kategorien standardmaessig eingeklappt**: Beim ersten Aufruf alle Type-Sections collapsed, Stefan klappt gezielt auf was er sehen will. State persistiert in localStorage
 - [x] **Klappbare Type-Header + Category-AutoSuggest + Info-Modal**: Type-Header (▼/▶) klappbar, Category-Feld im Neu/Edit-Modal mit `<datalist>`-Vorschlaegen aller existierenden Categories, ℹ-Button-Modal erklaert welche Types FEST im System-Prompt vs. Cold Memory sind
 
+### App-Memory-Editor + Crash-Reporting
+
+- [x] **Bubble-Header dynamic** (created/updated/deleted): Die `🧠`-Bubble zeigt jetzt was passiert ist — "ARIA hat etwas gemerkt" / "Notiz geändert" / "Notiz gelöscht" (rot bei delete). Brain-Tools schicken `action`-Feld im memory_saved-Event mit
+- [x] **Tap auf Memory-Bubble → Detail-Modal**: Komponente `MemoryDetailModal` zeigt alle Felder (Titel, Type, Category, Tags, voller Content, Anhang-Vorschau mit Thumbnails). Stift-Icon wechselt in Edit-Mode mit Form-Feldern + 📌 Pinned-Toggle. **Anhänge hoch-/runterladen + löschen** im Modal (DocumentPicker, multipart-Upload via RVS-Brain-Proxy). Memory komplett löschen mit Confirm
+- [x] **Notizen-Inbox-Button (`🗂️`)** neben der Lupe in der Status-Leiste: Vollbild-Modal mit zwei Sections — „Aus diesem Chat" (kompakte Liste der Spezial-Bubbles aus dem aktuellen Verlauf, klickbar) + „Alle Memories aus der DB" mit dem `MemoryBrowser`. Spezial-Bubbles (memorySaved/triggerCreated/skillCreated) werden im Chat-Stream gefiltert (statt unten zu kleben)
+- [x] **Memory-Editor in App-Settings**: neue Sektion 🧠 „Gedächtnis" in den App-Einstellungen. Komplette CRUD-UI mit Wortlich-Suche, Type-Dropdown, Pinned/Cold-Filter, „+ Neu" anlegen. Selbe `MemoryBrowser`-Komponente wie in der Inbox
+- [x] **RVS-Brain-Proxy als Fundament**: Bridge implementiert generischen `brain_request` / `brain_response`-Channel — die App kann beliebige Brain-HTTP-Endpoints via RVS adressieren (GET/POST/PATCH/DELETE, JSON+Base64-Body, base64-encoded Binär-Antworten). `services/brainApi.ts` als Promise-basierter Client mit Request-ID-Routing, Timeout, automatischem Listener-Setup
+- [x] **App-Crash-Reporting via RVS**: ErrorBoundary-Komponente fängt React-Render-Fehler, `installGlobalCrashReporter` haengt sich an `ErrorUtils.setGlobalHandler` + `HermesInternal.enablePromiseRejectionTracker`. Crashes wandern als `app_log`-Event durch RVS, Bridge schreibt JSONL in `/shared/logs/app.log`. Diagnostic-Server liefert GET `/api/app-log[?limit=N]` + POST `/api/app-log/clear`. **`tools/fetch-app-logs.sh`** holt die Logs auf die Dev-Maschine (über `ARIA_DIAG_URL` aus `.claude/aria-vm.env`), speichert in `.aria-debug/` (gitignored), zeigt Stack-Trace kompakt auf stdout
+- [x] **`memory_search` + `memory_update` Tools**: ARIA kann die DB jetzt aktiv durchsuchen (Volltext/Semantic) und existierende Einträge per ID patchen statt fragmentierende neue anzulegen. Tool-Description sagt explizit „Memory ist Truth über Conversation-Window" — wenn der User korrigiert hat, gilt das was im Memory steht. Wichtig nach Diagnostic-Edits damit ARIA die neue Wahrheit sieht statt aus dem Window zu raten
+- [x] **App-Bugfixes**: (a) URLSearchParams crasht in Hermes — durch Mini-Query-Builder ersetzt (`brainApi._qs()`). (b) Cache leer + Datei-Tap → Auto-Re-Download via file_request statt Toast-Sackgasse, plus State-Cleanup (uri/localUri auf undefined). (c) Memory-Liste in Settings scrollt jetzt (nestedScrollEnabled auf FlatList + äußere ScrollView). (d) Modal-im-Modal auf Android gefixt — MemoryBrowser nimmt optionalen `onOpenMemory`-Callback, kein verschachteltes DetailModal mehr. (e) Alert.prompt (iOS-only) durch eigenes Text-Input-Modal ersetzt fuer „Neue Memory anlegen"
+
 ### Memory-Anhaenge mit Vision (Stufe A-E + attach_paths)
 
 - [x] **Anhaenge an Memory-Eintraege** — Bilder/PDFs/beliebige Dateien koennen an jede Memory gehaengt werden, liegen physisch unter `/shared/memory-attachments/<memory-id>/`. Cleanup beim Memory-Delete automatisch. Limit 20 MB pro Datei

rvs/server.js

@@ -31,6 +31,7 @@ const ALLOWED_TYPES = new Set([
   "chat_history_request", "chat_history_response", "chat_cleared",
   "delete_message_request", "chat_message_deleted",
   "brain_request", "brain_response",
+  "app_log",
   "file_delete_batch_request", "file_delete_batch_response",
   "file_zip_request", "file_zip_response",
   "xtts_delete_voice",

tools/README.md

@@ -0,0 +1,34 @@
+# tools/
+
+Hilfsskripte für die Dev-Maschine. Brauchen `.claude/aria-vm.env` (aus
+`.example` kopieren + lokale VM-IP eintragen).
+
+## fetch-app-logs.sh
+
+Holt App-Crash-Logs von der VM und speichert sie unter `.aria-debug/`
+(gitignored). Die App schickt JS-Errors und ungefangene Promise-
+Rejections via RVS an die Bridge — Bridge sammelt in
+`/shared/logs/app.log`, Diagnostic-Server gibt sie via
+`GET /api/app-log` raus.
+
+```bash
+tools/fetch-app-logs.sh                # 200 neueste Eintraege
+tools/fetch-app-logs.sh --limit 50     # weniger
+tools/fetch-app-logs.sh --watch        # alle 5s pollen, neue rausgeben
+tools/fetch-app-logs.sh --clear        # nach Abholen Log auf VM leeren
+```
+
+Ausgabe enthaelt pro Eintrag: Uhrzeit, Level (error/warn/info), Scope
+(z.B. `ChatScreen.InboxModal` oder `global-fatal`), Message, und die
+ersten ~8 Stack-Frames. Die kompletten Daten liegen als JSON in
+`.aria-debug/app-log-<timestamp>.json`.
+
+Workflow nach einem Crash:
+
+1. App rebuilden mit Crash-Reporting (passiert automatisch ab dem
+   `21a315c`-Commit)
+2. Crash in der App ausloesen
+3. `tools/fetch-app-logs.sh` auf der Dev-Maschine
+4. Stacktrace lesen / Claude geben
+5. Fix bauen
+6. `tools/fetch-app-logs.sh --clear` damit der Log wieder sauber ist

tools/fetch-app-logs.sh

@@ -0,0 +1,105 @@
+#!/usr/bin/env bash
+# fetch-app-logs.sh — App-Crash-Logs von der VM holen
+#
+# Nutzt .claude/aria-vm.env als Quelle fuer $ARIA_DIAG_URL und ruft
+# GET /api/app-log?limit=N. Speichert die Roh-Response unter
+# .aria-debug/app-log-<timestamp>.json und gibt eine kompakte
+# Zusammenfassung auf stdout aus (letzte Eintraege mit Stack-Trace).
+#
+# Verwendung:
+#   tools/fetch-app-logs.sh                # Default limit=200
+#   tools/fetch-app-logs.sh --limit 50     # nur 50 holen
+#   tools/fetch-app-logs.sh --clear        # nach Abholen Log loeschen
+#   tools/fetch-app-logs.sh --watch        # alle 5s pollen, neue Eintraege ausgeben
+
+set -euo pipefail
+
+LIMIT=200
+CLEAR=0
+WATCH=0
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --limit)  LIMIT="$2"; shift 2 ;;
+    --limit=*) LIMIT="${1#*=}"; shift ;;
+    --clear)  CLEAR=1; shift ;;
+    --watch)  WATCH=1; shift ;;
+    -h|--help)
+      sed -n '1,/^set/p' "$0" | sed '$d' | sed 's/^# \{0,1\}//'
+      exit 0 ;;
+    *) echo "Unbekannte Option: $1" >&2; exit 1 ;;
+  esac
+done
+
+ROOT="$(cd "$(dirname "$0")/.." && pwd)"
+ENV_FILE="$ROOT/.claude/aria-vm.env"
+OUT_DIR="$ROOT/.aria-debug"
+
+if [[ ! -f "$ENV_FILE" ]]; then
+  echo "FEHLER: $ENV_FILE nicht vorhanden. Aus .example kopieren und IP anpassen." >&2
+  exit 1
+fi
+
+# shellcheck disable=SC1090
+source "$ENV_FILE"
+
+if [[ -z "${ARIA_DIAG_URL:-}" ]]; then
+  echo "FEHLER: ARIA_DIAG_URL nicht gesetzt in $ENV_FILE" >&2
+  exit 1
+fi
+
+mkdir -p "$OUT_DIR"
+
+fetch_once() {
+  local ts json file
+  ts="$(date +%Y%m%d_%H%M%S)"
+  json="$(curl -s --max-time 10 "${ARIA_DIAG_URL%/}/api/app-log?limit=$LIMIT")" || {
+    echo "FEHLER: curl gegen $ARIA_DIAG_URL fehlgeschlagen" >&2
+    return 1
+  }
+  file="$OUT_DIR/app-log-$ts.json"
+  echo "$json" > "$file"
+  python3 - "$file" <<'PY'
+import json, sys
+from pathlib import Path
+data = json.loads(Path(sys.argv[1]).read_text())
+entries = data.get("entries") or []
+print(f"=== {len(entries)} Eintrag{'e' if len(entries)!=1 else ''} (gespeichert unter {sys.argv[1]}) ===")
+for e in entries[-20:]:
+    ts = e.get("ts") or 0
+    from datetime import datetime
+    when = datetime.fromtimestamp(ts/1000).strftime("%H:%M:%S") if ts else "?"
+    lvl = e.get("level","?")
+    scope = e.get("scope","?")
+    msg = (e.get("message") or "").splitlines()[0][:200]
+    print(f"\n[{when}] {lvl:5} {scope}: {msg}")
+    stack = (e.get("stack") or "").strip()
+    if stack:
+        for line in stack.splitlines()[:8]:
+            print(f"   {line}")
+        if len(stack.splitlines()) > 8:
+            print(f"   ... ({len(stack.splitlines())-8} weitere Zeilen — siehe JSON)")
+PY
+  return 0
+}
+
+if [[ "$WATCH" == "1" ]]; then
+  echo "Watching $ARIA_DIAG_URL/api/app-log — Ctrl+C zum Beenden"
+  SEEN=""
+  while true; do
+    cur=$(curl -s --max-time 10 "${ARIA_DIAG_URL%/}/api/app-log?limit=$LIMIT") || cur=""
+    hash=$(echo "$cur" | md5sum | awk '{print $1}')
+    if [[ "$hash" != "$SEEN" && -n "$cur" ]]; then
+      SEEN="$hash"
+      fetch_once
+    fi
+    sleep 5
+  done
+else
+  fetch_once
+fi
+
+if [[ "$CLEAR" == "1" ]]; then
+  echo
+  echo "→ Log auf der VM leeren..."
+  curl -s --max-time 5 -X POST "${ARIA_DIAG_URL%/}/api/app-log/clear" | python3 -m json.tool || true
+fi