release: bump version to 0.1.5.0

fix(chat): Such-Scroll springt nicht mehr endlos (Retry-Limit + Skip)
Symptom: Suche zeigt Treffer, springt aber permanent zwischen Bubbles hin und her in Endlosschleife. Zwei Ursachen, beide angeschlossen: 1) agent_activity-Handler rief setMessages mit prev.map() — auch wenn keine sending-Bubble da war. Das erzeugte trotzdem ein neues Array bei jedem Tool-Event (5-10x pro Brain-Call). invertedMessages neu → FlatList-Layouts invalidiert mitten in einer aktiven Scroll-Sequenz. Fix: prev.some() vor map() — wenn nichts zu aendern ist, prev unveraendert returnen (reference-stable, kein Re-Render). 2) onScrollToIndexFailed retried unbegrenzt. Jeder failed Retry rief den Handler erneut auf → neuer setTimeout → neuer Versuch → fail → loop. Vorher waren cascading 3 Retries, dann auf 1 reduziert um den 3-9-27-Cascade zu fixen, aber EIN ungebremster Retry-Schluss pro fail bleibt eine Endlos-Schleife wenn Layouts nie stabil werden. Fix: harter Counter (MAX_SCROLL_RETRIES = 3). Counter wird bei jedem neuen Search-Hit via clearPendingScrollRetry resettet. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
2026-05-15 12:03:39 +02:00 · 2026-05-15 11:58:54 +02:00 · 2026-05-15 11:51:57 +02:00 · 2026-05-15 11:48:39 +02:00 · 2026-05-15 11:45:53 +02:00 · 2026-05-15 11:43:04 +02:00
18 changed files with 1644 additions and 124 deletions
@@ -200,7 +200,7 @@ Die Diagnostic-UI hat sechs Top-Tabs:
 - **Main** — Live-Chat-Test, Status (Brain / RVS / Proxy), End-to-End-Trace
 - **Gehirn** — Memory-Verwaltung (Vector-DB), Token/Call-Metrics (Subscription-Quota), Bootstrap & Migration, Komplett-Gehirn Export/Import
 - **Skills** — Liste mit Logs, Run, Activate/Deactivate, Export/Import als tar.gz
- **Trigger** — Timer + Watcher anlegen/anzeigen/loeschen, Live-Variablen-Anzeige (disk_free, current_lat, hour_of_day, …), near(lat, lon, m) als Condition-Funktion
+- **Trigger** — Timer + Watcher anlegen/anzeigen/loeschen, Live-Variablen-Anzeige (disk_free, current_lat, hour_of_day, …), GPS-Funktionen `near() / entered_near() / left_near()` für unterschiedliche Geofencing-Modi
 - **Dateien** — alle Dateien aus `/shared/uploads/` mit Multi-Select, Bulk-Download (ZIP) + Bulk-Delete
 - **Einstellungen** — Reparatur (Container-Restart), Wipe, Sprachausgabe, Whisper, Sprachmodell, Runtime-Config, App-Onboarding (QR), Komplett-Reset

@@ -219,11 +219,15 @@ Der Proxy-Container (`node:22-alpine`) installiert bei jedem Start:
 Danach wird der Proxy gepatcht:
 1. **Host-Binding** (sed): Server hoert auf `0.0.0.0` statt localhost
 2. **Tool-Permissions** (sed): `--dangerously-skip-permissions` Flag injizieren
-3. **Tool-Use-Adapter** (Datei-Overwrite aus [`proxy-patches/`](proxy-patches/)):
+3. **CLI-Timeout** (sed): `DEFAULT_TIMEOUT 300000 → 1200000` (5 → 20 Min) im subprocess-manager. Multi-Tool-Workflows mit echtem Bash + curl + DB-Inserts brauchen oft 8–15 Min; 5 Min war chronisch zu kurz
+4. **Tool-Use-Adapter** (Datei-Overwrite aus [`proxy-patches/`](proxy-patches/)):
   - `openai-to-cli.js` injiziert das OpenAI-`tools`-Feld als `<system>`-Block mit Schema-Beschreibungen + Anweisung `<tool_call name="X">{json}</tool_call>` als Antwortformat. `role=tool`-Messages werden als `<tool_result>`-Bloecke eingewoben. Multimodal-Content (Array von Parts) bleibt String-kompatibel.
   - `cli-to-openai.js` parsed `<tool_call>`-Bloecke aus Claudes Antwort und liefert sie als echte OpenAI `tool_calls` mit `finish_reason="tool_calls"`. Pre-Tool-Text bleibt im `content`. Mehrere parallele Calls werden korrekt aufgeteilt. Model-Name null-safe.
+   - `routes.js` hookt die `assistant`-Events des Subprozesses und feuert pro `tool_use`-Block (Bash, Read, Edit, Grep, …) einen HTTP-POST an die Bridge (`/internal/agent-activity`). Bridge spiegelt das als RVS `agent_activity` an App+Diagnostic → der Gedanken-Stream zeigt live mit was ARIA gerade tut. Fire-and-forget, fail-open — Brain-Call bricht nicht ab wenn die Bridge mal nicht da ist.

-   **Warum?** Die npm-Version des Proxys ignoriert das `tools`-Feld komplett und reicht nur einen Prompt-String an die CLI weiter. Claude Code nutzt dann ihre internen Tools (Bash, Read, …) und „simuliert" Aktionen — z.B. `sleep 120` statt `trigger_timer`. Mit den eigenen Adaptern landen ARIA-Tools wieder auf der Linie und Side-Effects (Trigger anlegen, Skills aufrufen, GPS-Tracking schalten) funktionieren.
+   **Warum?** Die npm-Version des Proxys ignoriert das `tools`-Feld komplett und reicht nur einen Prompt-String an die CLI weiter. Claude Code nutzt dann ihre internen Tools (Bash, Read, …) und „simuliert" Aktionen — z.B. `sleep 120` statt `trigger_timer`. Mit den eigenen Adaptern landen ARIA-Tools wieder auf der Linie und Side-Effects (Trigger anlegen, Skills aufrufen, GPS-Tracking schalten) funktionieren. Der Tool-Hook im `routes.js` macht zusaetzlich das interne Claude-Code-Werkzeug-Geschehen fuer den User sichtbar.
+
+**Brain ↔ Bridge ist async**: `_handle_rvs_message` ruft `send_to_core` als `asyncio.create_task` statt `await` — sonst blockierte der WS-recv-Loop bis zu 20 Min und der RVS-Server (mobil.hacker-net.de) droppte die Bridge nach ~4 Min Idle-Timeout. Brain laeuft jetzt im Hintergrund-Task, RVS-Verbindung bleibt waehrend ARIA arbeitet aktiv.

 **Wichtige Umgebungsvariablen im Proxy:**
 - `HOST=0.0.0.0` — API von aussen erreichbar (Docker-Netz)
@@ -316,10 +320,17 @@ Erreichbar unter `http://<VM-IP>:3001`. Teilt das Netzwerk mit der Bridge.

 ### Tabs

- **Main**: Brain/RVS/Proxy-Status, Chat-Test, "ARIA denkt..."-Indikator, End-to-End-Trace, Container-Logs
+- **Main**: Brain/RVS/Proxy-Status, Chat-Test, "ARIA denkt..."-Indikator, **💭 Gedanken-Stream** (zentrales Modal, zeigt live alle Tool-Calls + Phasen mit Zeitstempel und Trennlinien bei langen Pausen), End-to-End-Trace, Container-Logs
 - **Gehirn**: Memory-Browser (Vector-DB), Suche mit zwei Modi (**📝 Wortlich** = Substring-Match Default + **🧠 Semantisch** mit Score-Threshold), **Advanced Search** (aufklappbares Panel, beliebig viele AND/OR-verknuepfte Felder, + Button fuer mehr Zeilen), Type+Pinned-Filter (greifen auch in der Suche), klappbare Type-Kategorien (Default eingeklappt), Add/Edit/Delete mit Category-Autosuggest, **📎 Anhaenge** pro Memory (Bilder/PDFs/...): Upload + Thumbnail-Vorschau + Lightbox + Lösch-Button, 📎N-Badge in der Liste, automatischer Cleanup beim Memory-Delete. ℹ-Info-Modal das erklaert welche Types FEST in den Prompt vs. Cold Memory wandern. **📄 Druckansicht** (Strg+P → PDF). Konversation-Status mit Destillat-Trigger, **Token/Call-Metrics mit Subscription-Quota-Tracking**, Bootstrap & Migration (3 Wiederherstellungs-Wege), Gehirn-Export/Import (tar.gz)
 - **Skills**: Liste aller Skills mit Logs pro Run, Activate/Deactivate, Export/Import als tar.gz, "von ARIA"-Badge fuer selbst gebaute
- **Trigger**: passive Aufweck-Quellen. **Timer** (einmalig, ISO-Timestamp oder via `in_seconds` als Server-Berechnung) + **Watcher** (recurring, mit Condition + Throttle). Liste aktiver Trigger + Logs pro Feuer-Event. Modal mit Type-Dropdown, Live-Anzeige aller verfuegbaren Condition-Variablen (`disk_free_gb`, `hour_of_day`, `current_lat/lon`, `last_user_message_ago_sec`, …) und Condition-Funktionen (`near(lat, lon, m)` fuer GPS-Geofencing). Sicherer Condition-Parser via Python `ast` (Whitelist, kein `eval`). Der System-Prompt enthaelt zusaetzlich einen `## Aktuelle Zeit`-Block (UTC + Europa/Berlin) damit ARIA Timer-Zeitpunkte korrekt setzen kann.
+- **Trigger**: passive Aufweck-Quellen. **Timer** (einmalig, ISO-Timestamp oder via `in_seconds` als Server-Berechnung) + **Watcher** (recurring, mit Condition + Throttle). Liste aktiver Trigger + Logs pro Feuer-Event. Modal mit Type-Dropdown, Live-Anzeige aller verfuegbaren Condition-Variablen (`disk_free_gb`, `hour_of_day`, `current_lat/lon`, `last_user_message_ago_sec`, …). **Drei GPS-Funktionen** mit unterschiedlicher Semantik:
+  - `near(lat, lon, r)` — SOLANGE im Radius (mit Throttle gegen Spam). Use-Case: „bin ich noch in der Nähe von X?"
+  - `entered_near(lat, lon, r)` — EINMAL beim Eintritt (Übergang außen→innen). Use-Case: Blitzer-Warner mit r=2000 → 2 km Vorwarnung, oder Ankunfts-Erinnerung mit r=100
+  - `left_near(lat, lon, r)` — EINMAL beim Verlassen (Übergang innen→außen). Use-Case: „Hast du am Parkplatz X was vergessen?"
+
+  Sicherer Condition-Parser via Python `ast` (Whitelist, kein `eval`). Der System-Prompt enthaelt zusaetzlich einen `## Aktuelle Zeit`-Block (UTC + Europa/Berlin) damit ARIA Timer-Zeitpunkte korrekt setzen kann.
+
+  **Auflösung**: Background-Loop tickt alle 8s (vorher 30s — bei 100 km/h durch einen 300m-Radius war eine Vorbeifahrt nur ~22s drin und konnte verpasst werden). Plus event-getrieben: Bridge ruft nach jedem `location_update` von der App sofort einen `/triggers/check-now` im Brain — Watcher sehen die frische Position in Millisekunden statt im Polling-Takt. `near()`-Funktionen ignorieren GPS-Daten älter als 5 Minuten (verhindert Phantom-Fires bei abgeschaltetem Tracking).
 - **Dateien**: Browser fuer `/shared/uploads/` mit Multi-Select + "Alle markieren" + Bulk-Download (ZIP bei 2+) + Bulk-Delete. Live-Update der Chat-Bubbles beim Delete.
 - **Einstellungen**: Reparatur (Container-Restart fuer Brain/Bridge/Qdrant), Komplett-Reset, Betriebsmodi, Sprachausgabe + Voice-Cloning + F5-TTS-Tuning + Voice Export/Import, Whisper, Sprachmodell (brainModel), Onboarding-QR, App-Cleanup

@@ -355,8 +366,14 @@ Erreichbar unter `http://<VM-IP>:3001`. Teilt das Netzwerk mit der Bridge.
 - **Lokale Voice-Wahl**: Pro Geraet eigene Stimme moeglich (in Settings). Diagnostic-Wechsel ueberschreibt alle App-Wahlen.
 - **Voice-Ready Toast**: Beim Wechsel zeigt die App "Stimme X bereit (X.Ys)" sobald der Preload durch ist
 - **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
+- **Chat-Suche**: Lupe in der Statusleiste — Highlight + Next/Prev springt zum Treffer (Bubble landet am Text-Anfang oben am Viewport)
+- **Jump-to-Bottom-Button**: erscheint rechts unten sobald man weg von der neuesten Nachricht scrollt, ein Tap fuehrt zurueck
+- **Delivery-Status pro User-Bubble** (WhatsApp-Style): `⏱` (queued, wartet auf Verbindung) → `⏳` (sending) → `✓` (Bridge hat ACK gesendet) → `✓✓` (ARIA hat verarbeitet). Bei Netzausfall werden Nachrichten lokal als queued gehalten und beim Reconnect automatisch geflusht. Bei drei ACK-Timeouts → `⚠ tippen f. Retry`. Idempotenz auf der Bridge (LRU ueber `clientMsgId`) verhindert Doppelte beim Retry
 - **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
+- **💭 Gedanken-Stream**: chronologisches Log was ARIA intern macht — gefuettert aus `agent_activity`-Events (denkt / 🔧 Tool-Name / schreibt / ✓ fertig). Live-Update waehrend Brain arbeitet: pro Tool-Call (Bash, Read, Edit, Grep, …) erscheint sofort ein Eintrag, durchgereicht vom claude-max-api-proxy via `proxy-patches/routes.js`-Hook. Lange Pausen zwischen Denk-Phasen werden als Trennlinie mit Minuten-Hint sichtbar. App: Icon in der Statusleiste oeffnet ein Bottom-Sheet, persistiert in AsyncStorage (capped 500). Diagnostic: identische Funktion als zentrales Modal im Chat-Test-Header
+- **🗂️ 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
@@ -867,10 +884,12 @@ docker exec aria-brain curl localhost:8080/memory/stats
 - [x] **Phase B Punkt 2:** Migration aus `aria-data/brain-import/` → atomare Memory-Punkte (Identity / Rule / Preference / Tool / Skill, idempotent ueber migration_key) + Bootstrap-Snapshot Export/Import (nur pinned)
 - [x] **Phase B Punkt 3:** Brain Conversation-Loop (Single-Chat UI, Rolling Window 50 Turns, Schwelle 60 → automatisches Destillat, manueller Trigger)
 - [x] **Phase B Punkt 4:** Skills-System (Python-only via local-venv, skill_create als Tool, dynamische run_<skill> Tools, Diagnostic Skills-Tab mit Logs/Toggle/Export/Import, skill_created Live-Notification in App+Diagnostic, harte Schwelle "pip → Skill")
- [x] **Phase B Punkt 5:** Triggers-System (passive Aufweck-Quellen — Timer + Watcher mit safe Condition-Parser, GPS-near(), Diagnostic Trigger-Tab, kontinuierliches GPS-Tracking in der App fuer Use-Cases wie Blitzer-Warner). Inklusive Brain → Bridge HTTP-Push (Port 8090 intern) damit Trigger-Antworten ueber RVS in App + Diagnostic + TTS landen.
+- [x] **Phase B Punkt 5:** Triggers-System (passive Aufweck-Quellen — Timer + Watcher mit safe Condition-Parser, drei GPS-Funktionen `near()` / `entered_near()` / `left_near()` für unterschiedliche Geofencing-Modi, Diagnostic Trigger-Tab, kontinuierliches GPS-Tracking in der App fuer Use-Cases wie Blitzer-Warner). Tick-Frequenz 8s + event-getriebene Auswertung bei jedem `location_update` (statt 30s-Polling) damit auch Auto-Vorbeifahrten bei 100+ km/h durch kleine Radien zuverlässig erwischt werden. `near()`-Funktionen ignorieren GPS-Daten älter als 5 Minuten. Inklusive Brain → Bridge HTTP-Push (Port 8090 intern) damit Trigger-Antworten ueber RVS in App + Diagnostic + TTS landen.
 - [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
@@ -79,8 +79,8 @@ android {
        applicationId "com.ariacockpit"
        minSdkVersion rootProject.ext.minSdkVersion
        targetSdkVersion rootProject.ext.targetSdkVersion
-        versionCode 10307
-        versionName "0.1.3.7"
+        versionCode 10500
+        versionName "0.1.5.0"
        // Fallback fuer Libraries mit Product Flavors
        missingDimensionStrategy 'react-native-camera', 'general'
    }
@@ -1,6 +1,6 @@
 {
  "name": "aria-cockpit",
-  "version": "0.1.3.7",
+  "version": "0.1.5.0",
  "private": true,
  "scripts": {
    "android": "react-native run-android",
@@ -169,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)'}
@@ -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 && (
        <>
@@ -134,10 +134,19 @@ META_TOOLS = [
        "function": {
            "name": "trigger_watcher",
            "description": (
-                "Lege einen Watcher-Trigger an — pollt alle paar Minuten eine Condition, "
+                "Lege einen Watcher-Trigger an — pollt eine Condition, "
                "feuert wenn sie wahr wird (mit Throttle damit's nicht spammt). "
                "Use-Case: 'sag bescheid wenn Disk unter 5GB', 'pingt mich wenn um 8 Uhr'. "
-                "Welche Variablen verfuegbar sind und ihre Bedeutung steht im System-Prompt."
+                "Welche Variablen verfuegbar sind und ihre Bedeutung steht im System-Prompt.\n\n"
+                "Fuer GPS-Trigger gibt es DREI Modi — waehle nach Use-Case:\n"
+                "- **`near(lat, lon, r)`**: SOLANGE im Radius (mit Throttle gegen Spam). "
+                "Use-Case: 'bin ich noch in der Naehe von X?'. Empfohlener throttle 300-3600s.\n"
+                "- **`entered_near(lat, lon, r)`**: EINMAL beim Eintritt (Uebergang draussen→innen). "
+                "Use-Case: Blitzer-Warner, Ankunfts-Erinnerung. Mit grossem r (z.B. 2000) "
+                "wird's zur Vorwarnung 2 km vor dem Ziel. Empfohlener throttle: kurz (30-60s, "
+                "nur gegen GPS-Jitter).\n"
+                "- **`left_near(lat, lon, r)`**: EINMAL beim Verlassen (Uebergang innen→draussen). "
+                "Use-Case: 'Hast du am Parkplatz X was vergessen?'. Empfohlener throttle: kurz."
            ),
            "parameters": {
                "type": "object",
@@ -27,7 +27,12 @@ import watcher as watcher_mod

 logger = logging.getLogger(__name__)

-TICK_SEC = 30
+# Polling-Frequenz des Background-Loops. Vorher 30s → Auto-Vorbeifahrt
+# durch einen 300m-Radius bei >50 km/h konnte zwischen zwei Ticks komplett
+# verpasst werden. Mit 8s ist auch eine 18-Sekunden-Durchfahrt (120 km/h
+# durch 300m) garantiert mind. einmal getroffen. Der Loop ist billig
+# (paar Dateilesungen + AST-Eval), das macht Brain nicht warm.
+TICK_SEC = 8
 BRIDGE_URL = os.environ.get("BRIDGE_URL", "http://aria-bridge:8090")


@@ -159,7 +164,12 @@ async def _fire(trigger: dict, agent_factory) -> None:


 async def _tick(agent_factory) -> None:
-    """Ein Pruefdurchlauf. Geht ueber alle Triggers, feuert was zu feuern ist."""
+    """Ein Pruefdurchlauf. Geht ueber alle Triggers, feuert was zu feuern ist.
+
+    near()-State-Tracking: entered_near/left_near brauchen die Information
+    ob ein near()-Aufruf beim letzten Tick true war (Uebergang erkennen).
+    Wir halten das pro Trigger als near_states-Dict im Manifest und
+    aktualisieren es nach jedem Eval — auch wenn nicht gefeuert wird."""
    try:
        all_triggers = triggers_mod.list_triggers(active_only=True)
    except Exception as e:
@@ -168,35 +178,74 @@ async def _tick(agent_factory) -> None:
    if not all_triggers:
        return
    now = datetime.now(timezone.utc)
-    # Variablen einmal pro Tick sammeln (nicht pro Trigger — Disk-Stat ist teuer)
-    try:
-        vars_ = watcher_mod.collect_variables()
-    except Exception as e:
-        logger.warning("collect_variables: %s", e)
-        vars_ = {}
-
-    # Watcher: last_checked_at jetzt updaten (auch wenn nicht gefeuert wird,
-    # damit der Check-Interval respektiert wird)
-    for t in all_triggers:
-        if t.get("type") == "watcher":
-            try:
-                t["last_checked_at"] = _now_iso()
-                triggers_mod.write(t["name"], t)
-            except Exception:
-                pass

    for trigger in all_triggers:
+        if trigger.get("type") != "watcher":
+            continue
        try:
-            if _should_fire(trigger, vars_, now):
+            # Variablen pro Trigger sammeln — wegen prev_near_states-Closure
+            prev = trigger.get("near_states") or {}
+            vars_ = watcher_mod.collect_variables(prev_near_states=prev)
+
+            # Condition evaluieren via _should_fire (intern ruft watcher.evaluate)
+            fired = _should_fire(trigger, vars_, now)
+
+            # State immer updaten, egal ob gefeuert wurde — sonst greift
+            # entered_near/left_near nicht
+            new_states = vars_.get("_new_near_states") or {}
+            trigger["near_states"] = new_states
+            trigger["last_checked_at"] = _now_iso()
+            try:
+                triggers_mod.write(trigger["name"], trigger)
+            except Exception as e:
+                logger.warning("trigger.write %s: %s", trigger.get("name"), e)
+
+            if fired:
                # Feuern als eigener Task — wenn ARIA langsam antwortet,
                # darf der naechste Tick nicht blockieren
                asyncio.create_task(_fire(trigger, agent_factory))
        except Exception as e:
            logger.warning("Trigger-Check %s: %s", trigger.get("name"), e)

+    # Timer (one-shot) — separat ohne near-State
+    timer_vars = None
+    for trigger in all_triggers:
+        if trigger.get("type") != "timer":
+            continue
+        try:
+            if timer_vars is None:
+                timer_vars = watcher_mod.collect_variables()
+            if _should_fire(trigger, timer_vars, now):
+                asyncio.create_task(_fire(trigger, agent_factory))
+        except Exception as e:
+            logger.warning("Timer-Check %s: %s", trigger.get("name"), e)
+
+
+# Module-Level-Slot fuer die agent_factory damit on-demand-Ticks (von
+# z.B. POST /triggers/check-now) Zugang haben ohne durch den ganzen
+# Lifespan-Pfad geschleust zu werden.
+_AGENT_FACTORY = None
+
+
+async def tick_now() -> dict:
+    """Sofortiger Trigger-Check — nicht warten auf den naechsten Loop-Tick.
+    Wird genutzt wenn ein neues GPS-Update reinkommt: Bridge ruft das nach
+    _persist_location, damit Watcher mit near() den frischen Wert sofort
+    sehen statt bis zu TICK_SEC Sekunden zu warten."""
+    if _AGENT_FACTORY is None:
+        return {"ok": False, "error": "Background-Loop noch nicht gestartet"}
+    try:
+        await _tick(_AGENT_FACTORY)
+        return {"ok": True}
+    except Exception as exc:
+        logger.exception("tick_now: %s", exc)
+        return {"ok": False, "error": str(exc)}
+

 async def run_loop(agent_factory) -> None:
    """Endlosschleife — wird vom main lifespan gestartet + gestoppt."""
+    global _AGENT_FACTORY
+    _AGENT_FACTORY = agent_factory
    logger.info("Trigger-Loop gestartet (TICK_SEC=%d)", TICK_SEC)
    while True:
        try:
@@ -657,6 +657,16 @@ def triggers_list(active_only: bool = False):
    return {"triggers": triggers_mod.list_triggers(active_only=active_only)}


+@app.post("/triggers/check-now")
+async def triggers_check_now():
+    """Sofortiger Trigger-Check, statt auf den naechsten Background-Tick
+    zu warten. Wird von der Bridge nach jedem location_update gerufen
+    damit GPS-Watcher (near()) den frischen Wert SOFORT sehen — bei
+    Auto-Vorbeifahrt durch einen 300m-Radius hat man sonst nur ~20s
+    Drinnen-Zeit, was unter TICK_SEC fallen kann."""
+    return await background_mod.tick_now()
+
+
@app.get("/triggers/conditions")
 def triggers_conditions():
    """Verfuegbare Variablen + Funktionen fuer Watcher-Conditions
@@ -164,15 +164,17 @@ def build_skills_section(skills: List[dict]) -> str:
                 "static-ffmpeg, beautifulsoup4, …). Falls etwas WIRKLICH nur via apt geht: "
                 "Stefan fragen ob es ins Brain-Dockerfile soll.")
    lines.append("")
-    lines.append("**Harte Regel — IMMER Skill anlegen wenn:** die Loesung erfordert eine "
-                 "pip-Library. Begruendung: Brain-Container hat keinen persistenten State "
-                 "ausser /data/skills/. Ohne Skill wuerde der Install bei jedem "
-                 "Container-Restart wiederholt.")
+    lines.append("**Goldene Regel: NIE ungefragt Skills anlegen.** Selbst wenn die Aufgabe "
+                 "eine pip-Library braucht — erst die Aufgabe loesen (mit Bash, `pip install` "
+                 "im Brain ist ok, oder Workaround), und nur wenn Stefan EXPLIZIT sagt "
+                 "'mach daraus einen Skill' / 'leg den als Skill an' / 'dafuer einen Skill' "
+                 "rufst du `skill_create` auf. Begruendung: Skill-Setup (venv + pip install) "
+                 "blockt das Brain bis zu 12 Minuten. Ein unaufgefordert angelegter Skill "
+                 "macht ARIA stumm und nervt Stefan jedes Mal.")
    lines.append("")
-    lines.append("**Sonst — Skill nur wenn alle vier zutreffen:**")
+    lines.append("**Wenn Stefan einen Skill explizit moechte, pruef:**")
    lines.append("")
-    lines.append("1. **Wiederkehrend** — die Aufgabe wird realistisch nochmal gestellt. "
-                 "Einmal-Faelle (\"wie spaet ist es jetzt\") kein Skill.")
+    lines.append("1. **Wiederkehrend** — die Aufgabe wird realistisch nochmal gestellt.")
    lines.append("2. **Nicht-trivial** — mehrere Schritte. Ein einzelner Shell-Befehl "
                 "(`date`, `hostname`, `ls`) ist KEIN Skill — das macht Bash direkt.")
    lines.append("3. **Parametrisierbar** — der Skill nimmt Eingaben (URL, Datei, Suchbegriff) "
@@ -180,9 +182,8 @@ def build_skills_section(skills: List[dict]) -> str:
    lines.append("4. **Wiederverwendbar als ganzes** — Stefan wuerde es zukuenftig per Name "
                 "ansprechen (\"mach mir den YouTube zu MP3\") statt jedes Mal zu erklaeren.")
    lines.append("")
-    lines.append("Wenn nichts installiert werden muss UND nicht alle vier zutreffen: einfach "
-                 "die Aufgabe loesen ohne Skill anzulegen. Stefan kann jederzeit sagen "
-                 "'bau daraus einen Skill'.")
+    lines.append("Wenn auch nur EINE der vier nicht zutrifft: hoeflich nachfragen ob er "
+                 "wirklich einen permanenten Skill will oder die Aufgabe einmalig reicht.")
    return "\n".join(lines)


@@ -25,7 +25,7 @@ logger = logging.getLogger(__name__)
 RUNTIME_CONFIG_FILE = Path("/shared/config/runtime.json")
 ENV_MODEL = os.environ.get("BRAIN_MODEL", "claude-sonnet-4")
 PROXY_URL = os.environ.get("PROXY_URL", "http://proxy:3456")
-PROXY_TIMEOUT_SEC = float(os.environ.get("PROXY_TIMEOUT_SEC", "300"))
+PROXY_TIMEOUT_SEC = float(os.environ.get("PROXY_TIMEOUT_SEC", "1200"))


 def _read_model_from_runtime() -> str:
@@ -25,7 +25,7 @@ import shutil
 import time
 from datetime import datetime
 from pathlib import Path
-from typing import Any
+from typing import Any, Dict, Optional

 logger = logging.getLogger(__name__)

@@ -91,6 +91,12 @@ def _cpu_load_1min() -> float:

 _DAYS = ["mon", "tue", "wed", "thu", "fri", "sat", "sun"]

+# Maximales GPS-Alter fuer near()-Auswertung. Wenn die App laenger nicht
+# gepushed hat (z.B. Tracking aus, Mobilfunk weg, App geschlossen), gilt
+# die Position als "unbekannt" und near() liefert False — verhindert
+# Phantom-Fires basierend auf einer wochen-alten Position.
+NEAR_MAX_AGE_SEC = 5 * 60
+

 def _gps_state() -> dict[str, Any]:
    """Letzte bekannte Position aus /shared/state/location.json.
@@ -119,8 +125,22 @@ def _user_activity_age() -> int:
    return int(time.time() - ts)


-def collect_variables() -> dict[str, Any]:
-    """Liefert aktuellen Snapshot aller Built-in-Variablen + near()-Helper."""
+def _near_key(lat: float, lon: float, radius_m: float) -> str:
+    """Stabiler Schluessel pro near()-Aufruf — fuer entered_near/left_near
+    State-Tracking pro Trigger pro Aufrufstelle."""
+    return f"{float(lat):.6f},{float(lon):.6f},{int(float(radius_m))}"
+
+
+def collect_variables(prev_near_states: Optional[Dict[str, bool]] = None) -> Dict[str, Any]:
+    """Liefert aktuellen Snapshot aller Built-in-Variablen + near()-Helper.
+
+    prev_near_states: pro Trigger gespeicherter Zustand vom letzten Eval
+    (für entered_near/left_near). Wird vom background-Loop reingegeben.
+    Nach dem Eval kann man `vars_['_new_near_states']` auslesen, um den
+    Update-Snapshot zurueck ins Trigger-Manifest zu schreiben."""
+    if prev_near_states is None:
+        prev_near_states = {}
+    new_near_states: Dict[str, bool] = {}
    free_gb, free_pct = _disk_stats()
    now = datetime.now()
    gps = _gps_state()
@@ -176,12 +196,17 @@ def collect_variables() -> dict[str, Any]:

    # Funktion-Helper — wird vom Parser als ast.Call mit Name "near" erkannt.
    # Closure ueber die GPS-Werte, damit eval keine extra Variablen braucht.
-    def _near(lat: float, lon: float, radius_m: float) -> bool:
-        """Haversine-Distanz: True wenn aktuelle Position < radius_m vom Punkt."""
+    def _compute_near(lat: float, lon: float, radius_m: float) -> bool:
+        """Haversine-Distanz: True wenn aktuelle Position < radius_m vom Punkt.
+        Plus Age-Schutz: GPS-Daten aelter als NEAR_MAX_AGE_SEC werden als
+        veraltet betrachtet → False."""
        cur_lat = vars_.get("current_lat")
        cur_lon = vars_.get("current_lon")
        if cur_lat is None or cur_lon is None:
            return False
+        age = vars_.get("location_age_sec")
+        if isinstance(age, (int, float)) and age >= 0 and age > NEAR_MAX_AGE_SEC:
+            return False
        try:
            R = 6371000.0
            phi1 = math.radians(float(cur_lat))
@@ -194,7 +219,39 @@ def collect_variables() -> dict[str, Any]:
        except Exception:
            return False

+    def _near(lat: float, lon: float, radius_m: float) -> bool:
+        """True solange im Radius drin. Plus State-Tracking fuer
+        entered_near/left_near — wir merken uns das letzte Ergebnis
+        damit Uebergaenge erkannt werden koennen."""
+        current = _compute_near(lat, lon, radius_m)
+        new_near_states[_near_key(lat, lon, radius_m)] = current
+        return current
+
+    def _entered_near(lat: float, lon: float, radius_m: float) -> bool:
+        """True NUR beim Uebergang draussen → innen. Use-Case: einmal
+        feuern wenn der User in den Radius reinfaehrt (Blitzer-Warner,
+        Ankunft-Erinnerung). Bei groesserem Radius = Vorwarnung."""
+        current = _compute_near(lat, lon, radius_m)
+        key = _near_key(lat, lon, radius_m)
+        new_near_states[key] = current
+        prev = bool(prev_near_states.get(key, False))
+        return current and not prev
+
+    def _left_near(lat: float, lon: float, radius_m: float) -> bool:
+        """True NUR beim Uebergang innen → draussen. Use-Case: 'Hast
+        du am Parkplatz X was vergessen?' beim Verlassen."""
+        current = _compute_near(lat, lon, radius_m)
+        key = _near_key(lat, lon, radius_m)
+        new_near_states[key] = current
+        prev = bool(prev_near_states.get(key, False))
+        return prev and not current
+
    vars_["near"] = _near
+    vars_["entered_near"] = _entered_near
+    vars_["left_near"] = _left_near
+    # Update-Snapshot fuer den Caller (background-Loop schreibt das pro
+    # Trigger zurueck damit beim naechsten Tick prev_near_states stimmt)
+    vars_["_new_near_states"] = new_near_states
    return vars_


@@ -236,8 +293,25 @@ def describe_functions() -> list[dict]:
        {
            "name": "near",
            "signature": "near(lat, lon, radius_m)",
-            "desc": "True wenn die aktuelle GPS-Position innerhalb von radius_m Metern "
-                    "vom Punkt (lat, lon) liegt. Haversine. Bei unbekannter Position: False.",
+            "desc": "True SOLANGE die aktuelle GPS-Position innerhalb von radius_m "
+                    "Metern vom Punkt (lat, lon) liegt. Feuert wiederholt (mit throttle). "
+                    "Use-Case: 'bin noch in der Naehe von X?'. "
+                    "Haversine. Bei unbekannter oder > 5min alter Position: False.",
+        },
+        {
+            "name": "entered_near",
+            "signature": "entered_near(lat, lon, radius_m)",
+            "desc": "True NUR im Moment des Eintritts in den Radius (Uebergang "
+                    "draussen → innen). Use-Case: einmaliger Fire bei Ankunft / "
+                    "Blitzer-Warnung. Mit grossem Radius (z.B. 2000) wird das zur "
+                    "Vorwarnung bevor man am Punkt ist.",
+        },
+        {
+            "name": "left_near",
+            "signature": "left_near(lat, lon, radius_m)",
+            "desc": "True NUR im Moment des Verlassens des Radius (Uebergang "
+                    "innen → draussen). Use-Case: 'Hast du am Parkplatz X was "
+                    "vergessen?' beim Wegfahren.",
        },
    ]

@@ -25,6 +25,7 @@ import time
 import sys
 import tempfile
 import uuid
+from collections import OrderedDict
 from pathlib import Path
 from typing import Optional

@@ -475,6 +476,13 @@ class ARIABridge:
        self.current_mode = self._load_persisted_mode()
        self.running = False

+        # Idempotenz: zuletzt gesehene clientMsgIds (App-seitig generiert).
+        # Beim Reconnect/Retry sendet die App dieselbe ID nochmal — wir
+        # antworten erneut mit ACK aber leiten NICHT doppelt an Brain weiter.
+        # OrderedDict als FIFO mit Capping (Insertion-Order).
+        self._seen_client_msg_ids: "OrderedDict[str, float]" = OrderedDict()
+        self._SEEN_CLIENT_MSG_LIMIT = 200
+
        # Komponenten (TTS: F5-TTS remote auf der Gamebox, lokales TTS wurde entfernt)
        self.tts_enabled = True
        self.xtts_voice = ""
@@ -938,7 +946,12 @@ class ARIABridge:
    def _persist_location(self, location: Optional[dict]) -> None:
        """Speichert die letzte bekannte GPS-Position fuer Watcher.
        Erwartet {lat, lon} oder {lat, lng}. Nicht-Dicts und fehlende
-        Koordinaten werden ignoriert."""
+        Koordinaten werden ignoriert.
+
+        Plus: triggert sofort einen on-demand Trigger-Check im Brain
+        (POST /triggers/check-now). Ohne das wartet der Watcher-Loop
+        bis zu TICK_SEC Sekunden — bei Auto-Vorbeifahrt durch einen
+        300m-Radius (18-43s drin) kann das den Trigger verpassen."""
        if not isinstance(location, dict):
            return
        try:
@@ -950,9 +963,31 @@ class ARIABridge:
                "lat": float(lat),
                "lon": float(lon),
            })
+        except Exception:
+            return
+        # Fire-and-forget: Brain-on-demand-Tick. Wenn Brain nicht antwortet
+        # oder langsam ist, blockt das nicht den GPS-Pfad.
+        try:
+            asyncio.create_task(self._trigger_brain_check_now())
        except Exception:
            pass

+    async def _trigger_brain_check_now(self) -> None:
+        """Brain-Endpoint POST /triggers/check-now anstossen."""
+        brain_url = os.environ.get("BRAIN_URL", "http://aria-brain:8080")
+        def _post():
+            try:
+                req = urllib.request.Request(
+                    f"{brain_url}/triggers/check-now",
+                    data=b"", method="POST",
+                    headers={"Content-Type": "application/json"},
+                )
+                with urllib.request.urlopen(req, timeout=8) as r:
+                    return r.status
+            except Exception:
+                return None
+        await asyncio.get_event_loop().run_in_executor(None, _post)
+
    def _persist_user_activity(self) -> None:
        """Markiert dass der User gerade etwas gemacht hat (Chat/Voice).
        Watcher: last_user_message_ago_sec basiert darauf."""
@@ -962,8 +997,13 @@ class ARIABridge:
        """Schreibt eine Zeile in /shared/config/chat_backup.jsonl.
        Wird von Diagnostic + App als History-Quelle gelesen.
        entry braucht mindestens {role, text}; ts wird ergaenzt.
-        Returns den ts (auch fuer Bubble-Loeschen-Tracking)."""
-        ts = int(asyncio.get_event_loop().time() * 1000)
+        Returns den ts (auch fuer Bubble-Loeschen-Tracking).
+
+        WICHTIG: ts ist UNIX-ms (time.time()*1000), NICHT loop-time.
+        Loop-time ist Container-monotonic — bei jedem Restart wieder 0.
+        Das brach die App-History-Sortierung weil App-side Date.now()
+        (echtes UNIX-ms) mit Bridge-Container-Uptime gemischt wurde."""
+        ts = int(time.time() * 1000)
        try:
            line = {"ts": ts}
            line.update(entry)
@@ -1281,10 +1321,12 @@ class ARIABridge:
        self._pending_files_flush_task = None
        text = self._build_pending_files_message(user_text)
        self._pending_files = []
-        await self.send_to_core(text, source="app-file+chat")
+        # create_task statt await — sonst blockt der RVS-recv-Loop bis Brain
+        # fertig ist (siehe chat-handler oben).
+        asyncio.create_task(self.send_to_core(text, source="app-file+chat"))
        return True

-    async def send_to_core(self, text: str, source: str = "bridge") -> None:
+    async def send_to_core(self, text: str, source: str = "bridge", client_msg_id: Optional[str] = None) -> None:
        """Sendet Text an aria-brain (HTTP /chat) und broadcastet die Antwort.

        Nicht-Streaming: wir warten bis Brain fertig ist, dann pushen wir
@@ -1298,8 +1340,13 @@ class ARIABridge:
        logger.info("[brain] chat ← %s '%s'", source, text[:80])

        # User-Nachricht in chat_backup.jsonl loggen — wird beim App-Reconnect
-        # / Diagnostic-Reload als History-Quelle gelesen.
-        self._append_chat_backup({"role": "user", "text": text, "source": source})
+        # / Diagnostic-Reload als History-Quelle gelesen. clientMsgId speichern
+        # damit die App beim chat_history_response ihre lokale Bubble
+        # dedupen kann (sonst verschwindet sie nach Offline→Online-Race).
+        entry: dict = {"role": "user", "text": text, "source": source}
+        if client_msg_id:
+            entry["clientMsgId"] = client_msg_id
+        self._append_chat_backup(entry)

        # agent_activity → thinking. _emit_activity statt direktem _send_to_rvs
        # damit der State-Cache fuer die spaetere idle-Dedup richtig steht.
@@ -1311,8 +1358,10 @@ class ARIABridge:
                    url, data=payload, method="POST",
                    headers={"Content-Type": "application/json"},
                )
-                # Cold-Start kann lange dauern, 5min Timeout
-                with urllib.request.urlopen(req, timeout=300) as resp:
+                # 20 Min Timeout — lange Multi-Tool-Workflows (Karten,
+                # PDFs, viele curl-Calls) brauchen das. 5 Min waren chronisch
+                # zu knapp und haben ARIA mitten in der Arbeit gekappt.
+                with urllib.request.urlopen(req, timeout=1200) as resp:
                    return resp.status, resp.read().decode("utf-8", errors="ignore")
            except Exception as exc:
                return None, str(exc)
@@ -1503,6 +1552,36 @@ class ARIABridge:
                except Exception:
                    break

+    async def _send_chat_ack(self, client_msg_id: Optional[str]) -> None:
+        """Bestaetigt der App den Empfang einer chat/audio-Nachricht.
+        App nutzt das fuer Delivery-Status (✓ = sent). Ohne ACK wuerde die
+        App nach Timeout retryen — gegen Verlust bei Netz-Hicksern.
+        """
+        if not client_msg_id:
+            return
+        await self._send_to_rvs({
+            "type": "chat_ack",
+            "payload": {"clientMsgId": client_msg_id},
+            "timestamp": int(asyncio.get_event_loop().time() * 1000),
+        })
+
+    def _is_duplicate_client_msg(self, client_msg_id: Optional[str]) -> bool:
+        """Prueft ob wir diese clientMsgId schon verarbeitet haben.
+        Wenn ja → True (Caller soll ACK senden aber NICHT an Brain forwarden).
+        Wenn nein → in den Seen-Cache aufnehmen + False zurueck.
+        """
+        if not client_msg_id:
+            return False
+        if client_msg_id in self._seen_client_msg_ids:
+            logger.info("[rvs] Idempotenz: cmid=%s bereits verarbeitet, ignoriere",
+                        client_msg_id)
+            return True
+        self._seen_client_msg_ids[client_msg_id] = time.time()
+        # Capping: aelteste Eintraege rauswerfen
+        while len(self._seen_client_msg_ids) > self._SEEN_CLIENT_MSG_LIMIT:
+            self._seen_client_msg_ids.popitem(last=False)
+        return False
+
    async def _handle_rvs_message(self, raw_message: str) -> None:
        """Verarbeitet Nachrichten von der App (via RVS).

@@ -1527,6 +1606,13 @@ class ARIABridge:
            sender = payload.get("sender", "")
            if sender in ("aria", "stt"):
                return
+            # Delivery-ACK: immer zurueckschicken (auch bei Idempotenz-Hit),
+            # damit die App den Status auf 'sent' setzen kann. Idempotenz-
+            # Check VERHINDERT aber die Doppel-Weiterleitung an Brain.
+            client_msg_id = payload.get("clientMsgId") or None
+            await self._send_chat_ack(client_msg_id)
+            if self._is_duplicate_client_msg(client_msg_id):
+                return
            text = payload.get("text", "")
            # Voice-Override fuer Folgenachrichten setzen — gilt bis zum naechsten
            # chat-Event. Leerer String "" = explizit Default-Voice (override loeschen).
@@ -1562,7 +1648,16 @@ class ARIABridge:
                                " [BARGE-IN]" if interrupted else "",
                                " [GPS]" if location else "",
                                text[:80])
-                    await self.send_to_core(core_text, source="app" + (" [barge-in]" if interrupted else ""))
+                    # KEIN await: send_to_core kann 20 Min dauern. Wenn wir
+                    # hier awaiten, blockt der `async for raw_message in ws`-
+                    # Loop solange → RVS-Server droppt uns nach ~4 Min idle.
+                    # Als Task: Brain laeuft im Hintergrund, RVS-recv bleibt
+                    # bedienbar, Pings werden beantwortet, Verbindung lebt.
+                    asyncio.create_task(self.send_to_core(
+                        core_text,
+                        source="app" + (" [barge-in]" if interrupted else ""),
+                        client_msg_id=client_msg_id,
+                    ))
            return

        if msg_type == "cancel_request":
@@ -1738,7 +1833,8 @@ class ARIABridge:

            if not file_b64:
                text = f"Stefan hat eine Datei gesendet ({file_name}, {file_type}) aber die Daten sind leer angekommen."
-                await self.send_to_core(text, source="app-file")
+                # create_task statt await — RVS-recv darf nicht blocken
+                asyncio.create_task(self.send_to_core(text, source="app-file"))
                return

            if file_type.startswith("image/"):
@@ -2126,6 +2222,12 @@ class ARIABridge:

        elif msg_type == "audio":
            # Audio von der App → decodieren → STT → an aria-core
+            # Delivery-ACK + Idempotenz wie bei chat — App nutzt die ACKs
+            # auch fuer Sprach-Bubbles (Status auf der Bubble: ✓ sent).
+            client_msg_id = payload.get("clientMsgId") or None
+            await self._send_chat_ack(client_msg_id)
+            if self._is_duplicate_client_msg(client_msg_id):
+                return
            audio_b64 = payload.get("base64", "")
            mime_type = payload.get("mimeType", "audio/mp4")
            duration_ms = payload.get("durationMs", 0)
@@ -2156,7 +2258,8 @@ class ARIABridge:
                        " [GPS]" if location else "",
                        f" reqId={audio_request_id[:16]}" if audio_request_id else "")
            asyncio.create_task(self._process_app_audio(
-                audio_b64, mime_type, interrupted, audio_request_id, location))
+                audio_b64, mime_type, interrupted, audio_request_id, location,
+                client_msg_id=client_msg_id))

        elif msg_type == "stt_response":
            # Antwort der whisper-bridge auf unseren stt_request
@@ -2215,7 +2318,8 @@ class ARIABridge:
    async def _process_app_audio(self, audio_b64: str, mime_type: str,
                                  interrupted: bool = False,
                                  audio_request_id: str = "",
-                                  location: Optional[dict] = None) -> None:
+                                  location: Optional[dict] = None,
+                                  client_msg_id: Optional[str] = None) -> None:
        """App-Audio → STT → aria-core. Primaer via whisper-bridge (RVS), Fallback lokal.

        interrupted=True wenn der User waehrend ARIA noch sprach/dachte aufgenommen hat
@@ -2271,7 +2375,9 @@ class ARIABridge:

            # Dann an Brain — der blockt synchron bis ARIA fertig ist.
            core_text = self._build_core_text(text, interrupted, location)
-            await self.send_to_core(core_text, source="app-voice" + (" [barge-in]" if interrupted else ""))
+            await self.send_to_core(core_text,
+                                    source="app-voice" + (" [barge-in]" if interrupted else ""),
+                                    client_msg_id=client_msg_id)
        else:
            logger.info("[rvs] Keine Sprache erkannt — ignoriert")

@@ -2418,17 +2524,22 @@ class ARIABridge:
        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:
+    async def _emit_activity(self, activity: str, tool: str = "", force: bool = False) -> 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)."""
+        (nur 'idle' kommt immer durch).
+
+        force=True: kein State-Dedup — wird vom Proxy-Tool-Hook genutzt
+        damit auch wiederholte gleiche Tool-Aufrufe (z.B. 3x Bash
+        hintereinander) im Gedanken-Stream als eigene Eintraege sichtbar
+        bleiben."""
        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:
+        if not force and state == self._last_activity_state:
            return
        self._last_activity_state = state
        await self._send_to_rvs({
@@ -2576,6 +2687,24 @@ class ARIABridge:
                        self._handle_trigger_fired(reply, trigger_name, ttype, events)
                    )
                    await _send_response(writer, 200, {"ok": True})
+                elif method == "POST" and path == "/internal/agent-activity":
+                    # Vom Proxy gefeuert bei jedem Claude-Code-tool_use-Event
+                    # (Bash, Read, Edit, Grep, ...). Wir spiegeln das als
+                    # RVS agent_activity an App+Diagnostic damit der Gedanken-
+                    # Stream live mitlaufen kann.
+                    try:
+                        data = json.loads(body.decode("utf-8", "ignore"))
+                    except Exception as exc:
+                        await _send_response(writer, 400, {"error": f"bad json: {exc}"})
+                        return
+                    tool = (data.get("tool") or "").strip()
+                    if not tool:
+                        await _send_response(writer, 400, {"error": "tool erforderlich"})
+                        return
+                    # Force-emit (kein Dedup): User soll JEDEN Tool-Call sehen
+                    # selbst wenn derselbe Name zweimal in Folge kommt.
+                    asyncio.create_task(self._emit_activity("tool", tool, force=True))
+                    await _send_response(writer, 200, {"ok": True})
                elif method == "POST" and path == "/internal/delete-chat-message":
                    try:
                        data = json.loads(body.decode("utf-8", "ignore"))
@@ -301,6 +301,7 @@
            <input type="checkbox" id="gps-debug-toggle" onchange="toggleGpsDebug()" style="margin-right:4px;vertical-align:middle;">
            GPS-Position einblenden
          </label>
+          <button class="btn secondary" onclick="openThoughtStream()" id="btn-thoughts" title="Gedanken-Stream — was ARIA intern tut" style="padding:4px 10px;font-size:11px;">&#x1F4AD; Gedanken <span id="thoughts-count" style="color:#8888AA;"></span></button>
          <button class="btn secondary" onclick="toggleChatFullscreen()" id="btn-chat-fs" style="padding:4px 10px;font-size:11px;">Vollbild</button>
        </div>
      </div>
@@ -342,6 +343,22 @@
    </div>
  </div>

+  <!-- Gedanken-Stream Modal — chronologisches Log was ARIA intern tut.
+       Zentrales Modal (max 720px breit), Liste mit Auto-Scroll ans Ende
+       wenn neue Eintraege reinkommen. -->
+  <div id="thought-stream-modal" style="display:none;position:fixed;top:0;left:0;width:100vw;height:100vh;background:rgba(0,0,0,0.7);z-index:1100;align-items:center;justify-content:center;padding:24px;" onclick="if(event.target===this) closeThoughtStream();">
+    <div style="background:#0D0D1A;border:1px solid #1E1E2E;border-radius:12px;width:100%;max-width:720px;height:70vh;display:flex;flex-direction:column;">
+      <div style="display:flex;align-items:center;padding:14px;border-bottom:1px solid #1E1E2E;">
+        <h2 style="margin:0;color:#FFD60A;flex:1;font-size:16px;">&#x1F4AD; Gedanken-Stream <span id="thoughts-count-modal" style="color:#8888AA;font-weight:normal;"></span></h2>
+        <button class="btn secondary" onclick="clearThoughtStream()" id="btn-clear-thoughts" title="Stream leeren" style="padding:4px 10px;font-size:11px;color:#FF3B30;border-color:#FF3B30;margin-right:6px;">&#x1F5D1; Leeren</button>
+        <button class="btn secondary" onclick="closeThoughtStream()" style="padding:4px 12px;">Schliessen</button>
+      </div>
+      <div id="thought-stream-list" style="flex:1;overflow-y:auto;padding:8px 0;font-size:13px;font-family:monospace;">
+        <!-- gefuellt durch renderThoughtStream() -->
+      </div>
+    </div>
+  </div>
+
  <!-- Sessions + alter Brain-Viewer entfernt — Memories laufen jetzt
       komplett ueber den Gehirn-Tab gegen die Vector-DB im aria-brain. -->

@@ -2166,6 +2183,9 @@
    }

    function updateThinkingIndicator(msg) {
+      // Gedanken-Stream fuettern — JEDES Event (auch idle als ✓ fertig)
+      pushThought(msg.activity || '', msg.tool || '');
+
      const indicators = [
        document.getElementById('thinking-indicator'),
        document.getElementById('thinking-indicator-fs'),
@@ -2202,6 +2222,114 @@
      }, 120000);
    }

+    // ── Gedanken-Stream ─────────────────────────────
+    // Chronologisches Log von agent_activity-Events. Wird in localStorage
+    // persistiert (ueberlebt Page-Reload), capped auf MAX_THOUGHTS.
+    const THOUGHT_STORAGE_KEY = 'aria_thought_stream';
+    const MAX_THOUGHTS = 500;
+    let thoughtStream = [];
+    let lastThoughtKey = '';
+    let _thoughtSaveTimer = null;
+
+    function loadThoughtStream() {
+      try {
+        const raw = localStorage.getItem(THOUGHT_STORAGE_KEY);
+        if (!raw) return;
+        const parsed = JSON.parse(raw);
+        if (Array.isArray(parsed)) thoughtStream = parsed.slice(-MAX_THOUGHTS);
+      } catch {}
+      updateThoughtsBadge();
+    }
+
+    function persistThoughtStream() {
+      if (_thoughtSaveTimer) clearTimeout(_thoughtSaveTimer);
+      _thoughtSaveTimer = setTimeout(() => {
+        try {
+          if (thoughtStream.length === 0) localStorage.removeItem(THOUGHT_STORAGE_KEY);
+          else localStorage.setItem(THOUGHT_STORAGE_KEY, JSON.stringify(thoughtStream.slice(-MAX_THOUGHTS)));
+        } catch {}
+      }, 500);
+    }
+
+    function pushThought(activity, tool) {
+      // Dedup gegen direkt aufeinanderfolgende identische Events. Tool-
+      // Events NIE dedupen — drei Bash-Calls in Folge sollen drei Eintraege
+      // ergeben, nicht einen.
+      const key = `${activity}|${tool || ''}`;
+      if (activity !== 'tool' && key === lastThoughtKey) return;
+      lastThoughtKey = key;
+      thoughtStream.push({ ts: Date.now(), activity, tool: tool || '' });
+      if (thoughtStream.length > MAX_THOUGHTS) thoughtStream = thoughtStream.slice(-MAX_THOUGHTS);
+      updateThoughtsBadge();
+      // Wenn das Modal offen ist: live nachrendern + ans Ende scrollen
+      const modal = document.getElementById('thought-stream-modal');
+      if (modal && modal.style.display !== 'none') renderThoughtStream(true);
+      persistThoughtStream();
+    }
+
+    function updateThoughtsBadge() {
+      const a = document.getElementById('thoughts-count');
+      if (a) a.textContent = thoughtStream.length ? `(${thoughtStream.length})` : '';
+      const b = document.getElementById('thoughts-count-modal');
+      if (b) b.textContent = thoughtStream.length ? `(${thoughtStream.length})` : '';
+    }
+
+    function openThoughtStream() {
+      const modal = document.getElementById('thought-stream-modal');
+      if (!modal) return;
+      modal.style.display = 'flex';
+      renderThoughtStream(true);
+    }
+
+    function closeThoughtStream() {
+      const modal = document.getElementById('thought-stream-modal');
+      if (modal) modal.style.display = 'none';
+    }
+
+    function clearThoughtStream() {
+      if (thoughtStream.length === 0) return;
+      if (!confirm(`Gedanken-Stream leeren? ${thoughtStream.length} Eintraege werden geloescht.`)) return;
+      thoughtStream = [];
+      lastThoughtKey = '';
+      updateThoughtsBadge();
+      renderThoughtStream(false);
+      persistThoughtStream();
+    }
+
+    function _escapeHtml(s) {
+      return String(s).replace(/[&<>"']/g, c => ({'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;',"'":'&#39;'}[c]));
+    }
+
+    function renderThoughtStream(autoscroll) {
+      const list = document.getElementById('thought-stream-list');
+      if (!list) return;
+      if (thoughtStream.length === 0) {
+        list.innerHTML = '<div style="padding:24px;text-align:center;color:#555570;font-style:italic;">Noch keine Gedanken aufgezeichnet.<br>Sobald ARIA was tut, taucht\'s hier auf.</div>';
+        return;
+      }
+      const rows = [];
+      let prevTs = 0;
+      for (const t of thoughtStream) {
+        const gapMin = prevTs ? Math.floor((t.ts - prevTs) / 60000) : 0;
+        if (gapMin >= 1) {
+          const label = gapMin < 60 ? `${gapMin} Min` : `${Math.floor(gapMin/60)}h ${gapMin%60}m`;
+          rows.push(`<div style="display:flex;align-items:center;padding:6px 16px;gap:8px;"><div style="flex:1;height:1px;background:#1E1E2E;"></div><span style="color:#555570;font-size:10px;">${label}</span><div style="flex:1;height:1px;background:#1E1E2E;"></div></div>`);
+        }
+        prevTs = t.ts;
+        const d = new Date(t.ts);
+        const time = `${String(d.getHours()).padStart(2,'0')}:${String(d.getMinutes()).padStart(2,'0')}:${String(d.getSeconds()).padStart(2,'0')}`;
+        let icon, label, color;
+        if (t.activity === 'idle')        { icon = '✓';      label = 'fertig';            color = '#34C759'; }
+        else if (t.activity === 'tool')   { icon = '🔧'; label = t.tool || 'tool';    color = '#E0E0F0'; }
+        else if (t.activity === 'assistant'){ icon = '✍️'; label = 'schreibt';        color = '#E0E0F0'; }
+        else if (t.activity === 'thinking'){ icon = '💭'; label = 'denkt';            color = '#E0E0F0'; }
+        else                              { icon = '•';      label = t.activity;          color = '#E0E0F0'; }
+        rows.push(`<div style="display:flex;padding:4px 16px;align-items:baseline;"><span style="color:#555570;width:78px;font-size:11px;">${time}</span><span style="width:24px;">${icon}</span><span style="color:${color};flex:1;">${_escapeHtml(label)}</span></div>`);
+      }
+      list.innerHTML = rows.join('');
+      if (autoscroll) list.scrollTop = list.scrollHeight;
+    }
+
    // ── XTTS Panel ─────────────────────────────
    function renderVoiceList(voices) {
      const box = document.getElementById('xtts-voice-list');
@@ -4696,6 +4824,7 @@
      });
    }

+    loadThoughtStream();
    connectWS();
  </script>
 </body>
@@ -12,8 +12,10 @@ services:
      DIST=$$(find /usr/local/lib -path '*/claude-max-api-proxy/dist' -type d | head -1) &&
      sed -i 's/startServer({ port })/startServer({ port, host: process.env.HOST || \"127.0.0.1\" })/' $$DIST/server/standalone.js &&
      sed -i 's/\"--no-session-persistence\",/\"--no-session-persistence\",\"--dangerously-skip-permissions\",/' $$DIST/subprocess/manager.js &&
+      sed -i 's/const DEFAULT_TIMEOUT = 300000;/const DEFAULT_TIMEOUT = 1200000;/' $$DIST/subprocess/manager.js &&
      cp /proxy-patches/openai-to-cli.js $$DIST/adapter/openai-to-cli.js &&
      cp /proxy-patches/cli-to-openai.js $$DIST/adapter/cli-to-openai.js &&
+      cp /proxy-patches/routes.js $$DIST/server/routes.js &&
      claude-max-api"
    volumes:
      - ~/.claude:/root/.claude                      # Claude CLI Auth (Credentials in /root/.claude/.credentials.json)
@@ -297,6 +297,23 @@ 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

+### GPS-Trigger-Verbesserungen (entered_near + left_near + Timing-Fix)
+
+- [x] **near() bei Auto-Vorbeifahrten verpasst — gefixt**: Background-Loop tickte alle 30s, Vorbeifahrt durch 300m-Radius bei 50-120 km/h dauert nur 18-43s → Tick konnte komplett dazwischen liegen. Fix: `TICK_SEC` 30 → 8 (Loop ist billig, Brain merkt das nicht). Plus event-getrieben: Bridge ruft nach jedem `location_update` ein POST `/triggers/check-now` im Brain → Watcher sehen die frische Position in Millisekunden statt im Polling-Takt. Polling läuft parallel als Fallback für Watcher ohne GPS-Bezug
+- [x] **near() Age-Schutz**: GPS-Daten älter als 5 Minuten (`NEAR_MAX_AGE_SEC=300`) gelten als veraltet → `near()` liefert False. Vorher hätte ein wochen-alter Wert die Funktion weiter als „in der Nähe" eingeordnet → Phantom-Fires wenn Tracking aus war
+- [x] **Drei GPS-Modi statt einem**: `near()` bleibt = „solange drin". Neu: **`entered_near(lat, lon, r)`** feuert NUR beim Übergang außen→innen (Blitzer-Warner mit r=2000 = 2 km Vorwarnung, Ankunft mit r=100), **`left_near(lat, lon, r)`** feuert NUR beim Übergang innen→außen („Hast du am Parkplatz was vergessen?"). State-Tracking pro Trigger pro near-Aufruf (`near_states`-Dict im Manifest) — Background-Loop schreibt den letzten Auswertungswert immer zurück, damit beim nächsten Tick die Übergangs-Erkennung greift. ARIA's `trigger_watcher`-Tool-Description erklärt die drei Modi inkl. empfohlener Throttle-Werte (kurz für entered/left, lang für near)
+
+### 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
@@ -324,14 +341,36 @@ Skills mit Tool-Use.
 - [x] Info-Buttons mit Modal-Erklaerungen im Gehirn-Tab
 - [x] Token/Call-Metrics + Subscription-Quota-Tracking: pro Claude-Call ein Log-Eintrag mit Token-Schaetzung (chars/4). Gehirn-Tab zeigt 1h/5h/24h/30d-Aggregat + Progress-Bar gegen Plan-Limit (Pro=45/5h, Max 5x=225/5h, Max 20x=900/5h, Custom). Warn-Schwelle 80%, kritisch 90%.

+### Chat-Stabilitaet: Such-Scroll, Stuck-Watchdog, Delivery-Handshake
+
+- [x] **Such-Scroll springt nicht mehr permanent**: `onScrollToIndexFailed` hatte 3 cascading `setTimeout`s (120/320/600 ms) — jeder failed Retry triggerte den Handler wieder → 3, 9, 27 Scrolls in der Pipeline. Plus `invertedMessages` war in den useEffect-Deps: jede neue ARIA-Nachricht re-triggerte den Such-Scroll. Fix: nur EIN Retry nach 300 ms, in einer Ref-getrackten Timer-Variable; bei neuem Such-Hit wird der pending Retry gecancelt. `invertedMessages`-Snapshot via Ref statt Dep
+- [x] **Jump-to-Bottom-Button** rechts unten in der Chat-Liste — taucht ab ~250 px Scroll-Weg auf, scrollt zur neuesten Nachricht (bei inverted FlatList `scrollToOffset(0)`)
+- [x] **AsyncStorage-Init-Race**: zwischen Mount und „Verlauf aus AsyncStorage geladen" konnte eine User-Nachricht oder ein WS-Event ankommen — `setMessages(parsed)` ueberschrieb's mit dem alten Stand und die frische Nachricht war spurlos weg. Fix: Merge per `id` (frischere `prev`-Eintraege schlagen Gespeichertes), sortiert nach `timestamp`. `messageIdCounter` wird nur noch erhoeht, nie zurueckgesetzt
+- [x] **Stuck-Thinking-Watchdog**: „ARIA denkt..." blieb gelegentlich kleben (Brain-Crash, WS-Disconnect ohne idle-Event, Cancel mit Race). Fix: jeder `agent_activity != idle` armiert einen 180s-Timer; ohne neues Lebenszeichen geht's auto-idle + Bubble „⚠ Habe gerade keine Verbindung zurueck bekommen". Watchdog wird beim ARIA-Reply, beim Cancel/Barge-In und beim Screen-Unmount gecleart
+- [x] **Delivery-Handshake (WhatsApp-Style)**: pro User-Bubble ein lokaler `clientMsgId` + `deliveryStatus` (queued/sending/sent/delivered/failed). Bridge sendet `chat_ack` zurueck (✓ sent) und schreibt die ID ins `chat_backup.jsonl`. ARIA-Reply markiert alle vorigen User-Bubbles als delivered (✓✓). LRU-Idempotenz auf der Bridge (200 cmids) verhindert Doppelte beim Retry. Offline-Queue: Nachrichten im Flugmodus bleiben lokal als ⏱-queued, beim Reconnect feuert `flushQueuedMessages`. ACK-Timeout 30 s, bis zu 3 Retries, danach ⚠ + Tap-fuer-Retry
+- [x] **Offline-Bubble verschwand nach Reconnect (Race)**: parallel laufen `chat_history_request` und `flushQueuedMessages` beim Reconnect; die History-Antwort kam an bevor die Bridge die Bubble persistiert hatte → Merge ersetzte den lokalen Stand → Bubble weg (war aber in Diagnostic drin). Fix: Bridge spiegelt `clientMsgId` im `chat_backup.jsonl`, App-Merge dedupt per cmid und behaelt lokale Bubbles deren ID der Server noch nicht kennt
+- [x] **Doppel-Bubble nach Retry**: Backup-Eintraege von vor dem cmid-Patch hatten keine `clientMsgId` — Server-Bubble (ohne cmid) und lokale failed-Bubble (mit cmid) standen beide im Merge. Plus ACK-Timer lief gelegentlich weiter obwohl die Bubble schon `delivered` war → Retry pushte den Status zurueck auf `sending`. Fix: Merge faellt zusaetzlich auf `text+timestamp`-Heuristik im 5-Min-Fenster zurueck; `dispatchWithAck` prueft per Ref ob die Bubble inzwischen `delivered` ist und cancelt dann; bei ARIA-Reply werden alle laufenden ACK-Timer gecleart
+- [x] **chat_backup ts war Container-Uptime statt UNIX-ms**: `_append_chat_backup` nutzte `asyncio.get_event_loop().time()` (Monotonic, bei jedem Restart wieder 0) statt `time.time()`. Folge: Server-Bubbles mit ts wie 394M (6 min Uptime) wurden in der App-History neben App-side Bubbles mit Date.now() (1.778e12) sortiert — Hello-Kitty-Konversation von gestern landete chronologisch nach heutigen Karten-Routen, neue Nachrichten verschwanden unter dem 500er-Cap. Plus: Doppelpost-Schutz griff nicht weil das 5-Min-ts-Fenster bei 1.7 Bio ms Diff nie zutraf. Fix: Bridge schreibt jetzt UNIX-ms, Migration-Script `tools/migrate_chat_backup_ts.py` repariert vorhandene jsonl (284/299 ts umgeschrieben auf der VM, Datei-Reihenfolge bleibt). App-Merge dedupt zusaetzlich per blossem Text-Match (ohne ts-Diff) — schuetzt auch gegen vorhandene lokale Duplikate
+- [x] **User-Bubble ⏳→failed bei langsamen ARIA-Antworten**: ACK-Timer (30 s × 3 Retries) lief durch obwohl Brain laengst arbeitete — wenn `chat_ack` aus irgendwelchen Gruenden nicht durchkam (RVS-Frame verloren etc.), wurde die Bubble nach 90 s auf failed gesetzt obwohl die Antwort gleich danach kam. Fix: jedes `agent_activity != idle`-Event ist impliziter ACK — Brain wuerde nicht arbeiten wenn es die Nachricht nicht haette. Beim ersten non-idle Event werden alle laufenden ACK-Timer gecanceled und sending-Bubbles auf 'sent' gesetzt. ACK_TIMEOUT_MS zusaetzlich von 30 s auf 60 s als Backup
+- [x] **Gedanken-Stream Modal scrollte nicht**: innerer `TouchableOpacity` (eigentlich nur fuer close-on-tap-outside-Schutz) hat alle Touch-Events konsumiert. Fix: durch `View` mit `onStartShouldSetResponder={true}` + `onResponderTerminationRequest={false}` ersetzt — blockt Tap-Propagation ohne Scrolls der Children zu verschlucken
+
+### Brain-Hang: Multi-Tool-Timeouts + RVS-Block + Skill-Aggressivitaet
+
+- [x] **Skill-Erstellung aggressiver als gewollt**: Prompt sagte „Harte Regel — IMMER Skill anlegen wenn pip-Library noetig". ARIA hat das wortwoertlich genommen und bei einer simplen pdf-extract-Frage sofort `skill_create` aufgerufen → Brain 12 Min blockiert (venv 2 min + pip install 10 min Timeout in `skills.py`). App zeigt „ARIA denkt", Bridge emitted nach 5 Min Timeout idle, User ohne Antwort. Fix in `prompts.py`: „Goldene Regel: NIE ungefragt Skills anlegen" + nur bei expliziter Anfrage („mach daraus einen Skill") und auch dann nur wenn die 4 Kriterien (wiederkehrend / nicht-trivial / parametrisierbar / wiederverwendbar) zutreffen. Greift auf der VM nach `docker compose restart aria-brain` ohne Re-Build
+- [x] **Brain-Timeouts 5 Min → 20 Min**: drei verkettete 5-Min-Timeouts (Bridge `urlopen`, Brain `proxy_client`, Proxy `DEFAULT_TIMEOUT` im claude-max-api-proxy npm-Modul) feuerten exakt gleichzeitig. Live in den Logs nachvollzogen: ein Proxy-Call brauchte 4m51s und wurde von der Bridge auf den Sekundenbruchteil genau gekappt. Aufgabenstellungen wie Karten-Rekonstruktion mit 10+ curl-Calls oder PDF-Verarbeitung brauchen aber locker 8–15 Min. Fix: alle drei Timeouts auf 1200 s, plus dritter sed-Patch im docker-compose proxy-Service (`DEFAULT_TIMEOUT = 300000 → 1200000`). App-Stuck-Watchdog auf 1260 s (21 Min, knapp drueber)
+- [x] **RVS-Block waehrend Brain-Call** (mobil.hacker-net.de:444 droppt nach 4 Min idle): `async for raw_message in ws: await _handle_rvs_message(...)` — das await blockierte den recv-Loop solange `send_to_core` lief. Die websockets-Lib beantwortete Pings im Hintergrund, aber der RVS-Server zaehlt nur echte App-Frames und droppt sonst die Verbindung. Symptom: App+Diagnostic zeigten „abgebrochen" obwohl Brain noch arbeitete. Fix: `send_to_core` als `asyncio.create_task` statt `await` — RVS-recv-Loop bleibt frei, neue Messages werden weiter verarbeitet, Verbindung bleibt lebendig
+
+### Gedanken-Stream + Live-Tool-Events
+
+- [x] **Gedanken-Stream in App + Diagnostic**: chronologisches Log was ARIA intern macht, gefuettert aus `agent_activity`-Events (thinking/tool/assistant/idle). Bleibt zwischen Denk-Phasen stehen, lange Pausen sichtbar als Trennlinie mit Minuten-Hint. App: 💭-Icon in der Statusleiste oeffnet Bottom-Sheet mit chronologischer Liste, 🗑-Confirm zum Leeren. Diagnostic: 💭 Gedanken-Button im Chat-Test-Header oeffnet zentrales Modal, Live-Update wenn neue Eintraege kommen (autoscroll ans Ende). Persistierung in AsyncStorage / localStorage, capped auf 500 Eintraege
+- [x] **Live-Tool-Events vom Proxy**: dritter Proxy-Patch (`proxy-patches/routes.js`) hookt Claude-CLI `assistant`-Events — bei jedem `tool_use`-Block (Bash, Read, Edit, Grep, ...) wird per HTTP-POST an die Bridge gemeldet. Bridge spiegelt das als `agent_activity tool=<name>` an RVS-Clients. Vorher kam pro Brain-Call nur EIN „💭 denkt" am Anfang und EIN „✓ fertig" am Ende — jetzt sieht man **live** in beiden UIs wie ARIA durch die Tools haengt. Hook ist fire-and-forget (ARIA_TOOL_HOOK_URL Env-Variable, default http://aria-bridge:8090/internal/agent-activity)
+
 ## Offen

 ### App Features
- [ ] Chat-History zuverlaessiger laden (AsyncStorage Race Condition)
 - [ ] Custom-Wake-Word-Upload via Diagnostic (eigene .onnx-Files ohne App-Rebuild)

 ### Architektur
- [ ] Bilder: Claude Vision direkt nutzen (aktuell nur Dateipfad an ARIA)
 - [ ] Diagnostic: System-Info Tab (Container-Status, Disk, RAM, CPU)
 - [ ] RVS Zombie-Connections endgueltig loesen
 - [ ] Gamebox: kleine Web-Oberflaeche fuer Credentials/Server-Config oder zentral aus Diagnostic per RVS push
@@ -0,0 +1,309 @@
+/**
+ * ARIA-patched API Route Handlers
+ *
+ * Erweiterung der npm-Version von claude-max-api-proxy:
+ *  - Bei jedem Claude-CLI-`assistant`-Event mit tool_use-Block (Bash, Read,
+ *    Edit, Grep, …) wird ein HTTP-POST an die Bridge gefeuert
+ *    (ARIA_TOOL_HOOK_URL, default http://aria-bridge:8090/internal/agent-activity).
+ *    Bridge spiegelt das als RVS `agent_activity` an App+Diagnostic →
+ *    Gedanken-Stream zeigt live was ARIA gerade tool-maessig macht.
+ *  - Fire-and-forget, fail-open. Wenn die Bridge nicht antwortet, bricht
+ *    der Brain-Call NICHT ab.
+ *
+ * Wird zur Container-Startzeit ueber die npm-Version geschrieben
+ * (siehe docker-compose.yml proxy-Block).
+ */
+import { v4 as uuidv4 } from "uuid";
+import http from "http";
+import { ClaudeSubprocess } from "../subprocess/manager.js";
+import { openaiToCli } from "../adapter/openai-to-cli.js";
+import { cliResultToOpenai, createDoneChunk, } from "../adapter/cli-to-openai.js";
+
+const TOOL_HOOK_URL = process.env.ARIA_TOOL_HOOK_URL
+    || "http://aria-bridge:8090/internal/agent-activity";
+
+/**
+ * Pusht einen Tool-Use-Event an die Bridge. Fire-and-forget — keine Awaits,
+ * keine Fehler nach oben. Logged Fehler still.
+ */
+function _emitToolEvent(toolName) {
+    if (!toolName) return;
+    try {
+        const u = new URL(TOOL_HOOK_URL);
+        const body = JSON.stringify({ tool: String(toolName) });
+        const req = http.request({
+            method: "POST",
+            hostname: u.hostname,
+            port: u.port || 80,
+            path: u.pathname,
+            headers: { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(body) },
+            timeout: 2000,
+        }, (res) => { res.resume(); });
+        req.on("error", () => {});
+        req.on("timeout", () => req.destroy());
+        req.write(body);
+        req.end();
+    } catch (_) { /* niemals weiterwerfen */ }
+}
+
+/**
+ * Hookt die `assistant`-Events des Subprozesses. Jedes assistant-Message
+ * kann mehrere content-Bloecke haben — tool_use-Bloecke pushen wir live.
+ */
+function _attachToolHook(subprocess) {
+    subprocess.on("assistant", (message) => {
+        try {
+            const blocks = message?.message?.content || [];
+            for (const b of blocks) {
+                if (b && b.type === "tool_use" && b.name) {
+                    _emitToolEvent(b.name);
+                }
+            }
+        } catch (_) { /* fail-open */ }
+    });
+}
+/**
+ * Handle POST /v1/chat/completions
+ *
+ * Main endpoint for chat requests, supports both streaming and non-streaming
+ */
+export async function handleChatCompletions(req, res) {
+    const requestId = uuidv4().replace(/-/g, "").slice(0, 24);
+    const body = req.body;
+    const stream = body.stream === true;
+    try {
+        // Validate request
+        if (!body.messages || !Array.isArray(body.messages) || body.messages.length === 0) {
+            res.status(400).json({
+                error: {
+                    message: "messages is required and must be a non-empty array",
+                    type: "invalid_request_error",
+                    code: "invalid_messages",
+                },
+            });
+            return;
+        }
+        // Convert to CLI input format
+        const cliInput = openaiToCli(body);
+        const subprocess = new ClaudeSubprocess();
+        // ARIA-Patch: Tool-Use-Events live an die Bridge weiterleiten.
+        // Greift fuer beide Branches (stream + non-stream).
+        _attachToolHook(subprocess);
+        if (stream) {
+            await handleStreamingResponse(req, res, subprocess, cliInput, requestId);
+        }
+        else {
+            await handleNonStreamingResponse(res, subprocess, cliInput, requestId);
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        console.error("[handleChatCompletions] Error:", message);
+        if (!res.headersSent) {
+            res.status(500).json({
+                error: {
+                    message,
+                    type: "server_error",
+                    code: null,
+                },
+            });
+        }
+    }
+}
+/**
+ * Handle streaming response (SSE)
+ *
+ * IMPORTANT: The Express req.on("close") event fires when the request body
+ * is fully received, NOT when the client disconnects. For SSE connections,
+ * we use res.on("close") to detect actual client disconnection.
+ */
+async function handleStreamingResponse(req, res, subprocess, cliInput, requestId) {
+    // Set SSE headers
+    res.setHeader("Content-Type", "text/event-stream");
+    res.setHeader("Cache-Control", "no-cache");
+    res.setHeader("Connection", "keep-alive");
+    res.setHeader("X-Request-Id", requestId);
+    // CRITICAL: Flush headers immediately to establish SSE connection
+    // Without this, headers are buffered and client times out waiting
+    res.flushHeaders();
+    // Send initial comment to confirm connection is alive
+    res.write(":ok\n\n");
+    return new Promise((resolve, reject) => {
+        let isFirst = true;
+        let lastModel = "claude-sonnet-4";
+        let isComplete = false;
+        // Handle actual client disconnect (response stream closed)
+        res.on("close", () => {
+            if (!isComplete) {
+                // Client disconnected before response completed - kill subprocess
+                subprocess.kill();
+            }
+            resolve();
+        });
+        // Handle streaming content deltas
+        subprocess.on("content_delta", (event) => {
+            const text = event.event.delta?.text || "";
+            if (text && !res.writableEnded) {
+                const chunk = {
+                    id: `chatcmpl-${requestId}`,
+                    object: "chat.completion.chunk",
+                    created: Math.floor(Date.now() / 1000),
+                    model: lastModel,
+                    choices: [{
+                            index: 0,
+                            delta: {
+                                role: isFirst ? "assistant" : undefined,
+                                content: text,
+                            },
+                            finish_reason: null,
+                        }],
+                };
+                res.write(`data: ${JSON.stringify(chunk)}\n\n`);
+                isFirst = false;
+            }
+        });
+        // Handle final assistant message (for model name)
+        subprocess.on("assistant", (message) => {
+            lastModel = message.message.model;
+        });
+        subprocess.on("result", (_result) => {
+            isComplete = true;
+            if (!res.writableEnded) {
+                // Send final done chunk with finish_reason
+                const doneChunk = createDoneChunk(requestId, lastModel);
+                res.write(`data: ${JSON.stringify(doneChunk)}\n\n`);
+                res.write("data: [DONE]\n\n");
+                res.end();
+            }
+            resolve();
+        });
+        subprocess.on("error", (error) => {
+            console.error("[Streaming] Error:", error.message);
+            if (!res.writableEnded) {
+                res.write(`data: ${JSON.stringify({
+                    error: { message: error.message, type: "server_error", code: null },
+                })}\n\n`);
+                res.end();
+            }
+            resolve();
+        });
+        subprocess.on("close", (code) => {
+            // Subprocess exited - ensure response is closed
+            if (!res.writableEnded) {
+                if (code !== 0 && !isComplete) {
+                    // Abnormal exit without result - send error
+                    res.write(`data: ${JSON.stringify({
+                        error: { message: `Process exited with code ${code}`, type: "server_error", code: null },
+                    })}\n\n`);
+                }
+                res.write("data: [DONE]\n\n");
+                res.end();
+            }
+            resolve();
+        });
+        // Start the subprocess
+        subprocess.start(cliInput.prompt, {
+            model: cliInput.model,
+            sessionId: cliInput.sessionId,
+        }).catch((err) => {
+            console.error("[Streaming] Subprocess start error:", err);
+            reject(err);
+        });
+    });
+}
+/**
+ * Handle non-streaming response
+ */
+async function handleNonStreamingResponse(res, subprocess, cliInput, requestId) {
+    return new Promise((resolve) => {
+        let finalResult = null;
+        subprocess.on("result", (result) => {
+            finalResult = result;
+        });
+        subprocess.on("error", (error) => {
+            console.error("[NonStreaming] Error:", error.message);
+            res.status(500).json({
+                error: {
+                    message: error.message,
+                    type: "server_error",
+                    code: null,
+                },
+            });
+            resolve();
+        });
+        subprocess.on("close", (code) => {
+            if (finalResult) {
+                res.json(cliResultToOpenai(finalResult, requestId));
+            }
+            else if (!res.headersSent) {
+                res.status(500).json({
+                    error: {
+                        message: `Claude CLI exited with code ${code} without response`,
+                        type: "server_error",
+                        code: null,
+                    },
+                });
+            }
+            resolve();
+        });
+        // Start the subprocess
+        subprocess
+            .start(cliInput.prompt, {
+            model: cliInput.model,
+            sessionId: cliInput.sessionId,
+        })
+            .catch((error) => {
+            res.status(500).json({
+                error: {
+                    message: error.message,
+                    type: "server_error",
+                    code: null,
+                },
+            });
+            resolve();
+        });
+    });
+}
+/**
+ * Handle GET /v1/models
+ *
+ * Returns available models
+ */
+export function handleModels(_req, res) {
+    res.json({
+        object: "list",
+        data: [
+            {
+                id: "claude-opus-4",
+                object: "model",
+                owned_by: "anthropic",
+                created: Math.floor(Date.now() / 1000),
+            },
+            {
+                id: "claude-sonnet-4",
+                object: "model",
+                owned_by: "anthropic",
+                created: Math.floor(Date.now() / 1000),
+            },
+            {
+                id: "claude-haiku-4",
+                object: "model",
+                owned_by: "anthropic",
+                created: Math.floor(Date.now() / 1000),
+            },
+        ],
+    });
+}
+/**
+ * Handle GET /health
+ *
+ * Health check endpoint
+ */
+export function handleHealth(_req, res) {
+    res.json({
+        status: "ok",
+        provider: "claude-code-cli",
+        timestamp: new Date().toISOString(),
+    });
+}
+//# sourceMappingURL=routes.js.map
@@ -0,0 +1,93 @@
+#!/usr/bin/env python3
+"""
+Migration: chat_backup.jsonl ts-Werte von Container-Uptime-ms auf UNIX-ms umstellen.
+
+Hintergrund: vor dem Fix nutzte _append_chat_backup() `asyncio.get_event_loop().time()`,
+was Container-Monotonic ist (bei Restart wieder 0). Mischte sich mit App-side
+`Date.now()` (echtes UNIX-ms) → falsche Sortierung in der App-History.
+
+Strategie: ts < 1e12 (keine UNIX-ms) werden umgeschrieben. Anker = file-mtime,
+decay 60 Sekunden pro Eintrag rueckwaerts. Datei-Reihenfolge bleibt erhalten
+(append-only war chronologisch korrekt, nur ts-Werte waren Unsinn).
+
+Vorhandene UNIX-ms-Eintraege (file_deleted-Marker, neue Eintraege ab Bridge-Fix)
+werden unveraendert gelassen.
+
+Idempotent: zweimal laufen lassen ist sicher — beim zweiten Mal sind alle ts
+schon UNIX-ms und werden nicht angefasst.
+
+Backup: schreibt erst chat_backup.jsonl.bak, dann atomar replace.
+"""
+
+import json
+import os
+import shutil
+import sys
+import time
+from pathlib import Path
+
+UNIX_MS_THRESHOLD = 10 ** 12  # < 1e12 ms = vor 2001 = unrealistisch fuer UNIX
+GAP_SECONDS = 60  # 1 Eintrag pro Minute rueckwaerts ab mtime
+
+
+def migrate(path: Path) -> None:
+    if not path.exists():
+        print(f"Datei nicht da: {path}")
+        sys.exit(1)
+
+    raw = path.read_text(encoding="utf-8").splitlines()
+    entries = []
+    for raw_line in raw:
+        s = raw_line.strip()
+        if not s:
+            continue
+        try:
+            entries.append(json.loads(s))
+        except Exception as e:
+            print(f"  ueberspringe kaputte Zeile: {e}")
+            continue
+
+    if not entries:
+        print("Datei leer")
+        return
+
+    file_mtime_ms = int(os.path.getmtime(path) * 1000)
+    n = len(entries)
+    fixed = 0
+
+    # Wir bauen einen Ersatz-ts (file_mtime - gap*minutes_back) nur fuer
+    # Eintraege deren ts < UNIX_MS_THRESHOLD. file_deleted etc. mit echtem
+    # UNIX-ms bleiben unangetastet.
+    for i, entry in enumerate(entries):
+        ts = entry.get("ts", 0)
+        if not isinstance(ts, (int, float)) or ts < UNIX_MS_THRESHOLD:
+            # Synth-ts vergeben: aelteste = mtime - n*gap, neueste = mtime
+            new_ts = file_mtime_ms - (n - 1 - i) * GAP_SECONDS * 1000
+            entry["ts"] = new_ts
+            fixed += 1
+
+    if fixed == 0:
+        print(f"Nichts zu migrieren ({n} Eintraege, alle ts schon UNIX-ms)")
+        return
+
+    # Backup
+    bak = path.with_suffix(path.suffix + ".bak")
+    shutil.copy2(path, bak)
+    print(f"Backup: {bak}")
+
+    # Atomic rewrite
+    tmp = path.with_suffix(path.suffix + ".tmp")
+    with open(tmp, "w", encoding="utf-8") as f:
+        for entry in entries:
+            f.write(json.dumps(entry, ensure_ascii=False) + "\n")
+    tmp.replace(path)
+
+    print(f"Migration fertig: {fixed}/{n} ts umgeschrieben")
+    print(f"  aelteste neu : {time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(entries[0]['ts'] / 1000))}")
+    print(f"  neueste neu  : {time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(entries[-1]['ts'] / 1000))}")
+
+
+if __name__ == "__main__":
+    default = Path("/var/lib/docker/volumes/aria-agent_aria-shared/_data/config/chat_backup.jsonl")
+    path = Path(sys.argv[1]) if len(sys.argv) > 1 else default
+    migrate(path)