release: bump version to 0.1.8.9

Stefan-Symptom: Spotify pausiert wenn ARIA zuhoert/spricht ✓, aber
resumed nach TTS-Ende NICHT (oder nur unzuverlaessig).

Diagnose aus dem Log-Trace:

  Manual-Button-Flow:
    recording start → AudioFocus.requestExclusive (Spotify pausiert)
    STT-Endpoint    → _cleanupStreamLocal → _releaseFocusDeferred → 800ms
                      Timer → release+nudge (Spotify wuerde resumen)
    Brain processing 50s lang...
    TTS-Start       → KEIN expliziter Focus-Request! AudioTrack-USAGE_
                      ASSISTANT pausiert Spotify nur IMPLIZIT (versions-
                      abhaengig). Wir wissen nicht ob Spotify gerade
                      gepaust ist.
    TTS-End         → release+nudge — aber wenn Spotify implizit-paused
                      ist, hat es keinen sauberen Focus-Owner gesehen
                      und nudge alleine reicht nicht zum Resume.

  Wake-Word-Flow:
    Aehnliches Problem wenn state schon armed ist beim TTS-Ende
    (vom 'no-speech in conv-window'-Pfad), dann ist mein
    endConversation ein noop → releaseConversationFocus laeuft nie,
    nur die PcmPlaybackFinished-Direkt-Release greift, hat aber
    dasselbe nudge-zu-schwach-Problem.

Fix in _firePlaybackStarted (audio.ts): EXPLIZITES AudioFocus.requestDuck
beim ersten TTS-PCM-Chunk. Damit IST Spotify ueber unseren Focus
gepaused, statt nur implizit. Der spaetere release beim Pcm-Playback-
Finished ist dann das normale 'Owner ist fertig'-Pattern das Spotify
zuverlaessig zum Resume triggert.

Idempotenz: requestDuck released vorher den vorigen Focus (in Kotlin),
also harmlos wenn wake-word-acquireConversationFocus eh schon requestDuck
gerufen hat. Plus _cancelDeferredFocusRelease vorne, damit kein noch
pendender 800ms-Timer mitten in der TTS Spotify falsch resumed.

Stefan testet im Auto und auf dem Tisch — beide Spotify-Versionen
sollten mit explizitem Focus-Owner-Wechsel sauber pausieren+resumen.

.claude/settings.json

@@ -0,0 +1,7 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(ssh root@172.0.2.33 \"ls -la /root/ARIA-AGENT/aria-shared/logs/\")"
+    ]
+  }
+}

android/android/app/build.gradle

@@ -79,8 +79,8 @@ android {
         applicationId "com.ariacockpit"
         minSdkVersion rootProject.ext.minSdkVersion
         targetSdkVersion rootProject.ext.targetSdkVersion
-        versionCode 10807
+        versionCode 10809
-        versionName "0.1.8.7"
+        versionName "0.1.8.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.8.7",
+  "version": "0.1.8.9",
   "private": true,
   "scripts": {
     "android": "react-native run-android",

android/src/services/audio.ts

@@ -1518,6 +1518,18 @@ class AudioService {
       this.playbackStartTime = Date.now();
       this.currentPlaybackMsgId = this.pcmMessageId;
     }
+    // AudioFocus EXPLIZIT fuer TTS halten — sonst pausiert Spotify zwar
+    // beim Recording-requestExclusive, der wird aber 800ms nach STT-Endpoint
+    // released (Brain-Processing-Gap), und wenn dann TTS startet ist niemand
+    // mehr Focus-Owner. Spotify pausiert evtl. implizit beim AudioTrack-
+    // USAGE_ASSISTANT, aber unsere nachtraegliche release+nudge-Sequenz
+    // kann es dann nicht zuverlaessig wieder anstossen. Mit explizitem
+    // requestDuck IST Spotify sauber-via-Focus pausiert, und der Release
+    // beim PcmPlaybackFinished triggert das normale "Owner fertig → resume"-
+    // Pattern in Spotify — funktioniert versionsunabhaengig.
+    // Pending Release-Timer canceln damit der nicht mitten in der TTS feuert.
+    this._cancelDeferredFocusRelease();
+    AudioFocus?.requestDuck().catch(() => {});
     this.playbackStartedListeners.forEach(cb => {
       try { cb(); } catch (e) { console.warn('[Audio] playbackStarted listener err:', e); }
     });

android/src/services/wakeword.ts

@@ -344,23 +344,38 @@ class WakeWordService {
   /** Konversation beenden — User hat im Window nichts gesagt.
    *  Mit Wake-Word: zurueck zu 'armed' (Listener wieder an).
    *  Ohne: zurueck zu 'off'.
+   *
+   *  WICHTIG: setzt bargeListening=false BEVOR OpenWakeWord.start() laeuft.
+   *  Grund: wenn endConversation aus dem onPlaybackFinished-Handler kommt,
+   *  feuert direkt danach ein zweiter Listener (stopBargeListening) — der
+   *  wuerde sonst OpenWakeWord.stop() rufen weil bargeListening noch true
+   *  ist, und unseren frisch re-armierten Listener killen.
    */
   async endConversation(): Promise<void> {
     if (this.state !== 'conversing') {
-      // Nicht in conversing — typ. nach App-Resume bevor Streaming endete.
-      // Trotzdem loggen damit wir's im Diagnostic sehen.
       import('./logger').then(m => m.reportAppDebug('wake.end',
         `endConversation called but state=${this.state} → noop`)).catch(()=>{});
       return;
     }
+    const wasBarge = this.bargeListening;
+    // Flag NULLEN bevor wir die Listener triggern. Sonst killt der parallele
+    // stopBargeListening-Listener (TTS-end) gleich danach unseren Native-
+    // OpenWakeWord, weil er bargeListening=true sieht und annimmt er muss
+    // den Listener stoppen.
+    this.bargeListening = false;
     import('./logger').then(m => m.reportAppDebug('wake.end',
-      `endConversation called, nativeReady=${this.nativeReady}, calling OpenWakeWord.start()`)).catch(()=>{});
+      `endConversation called, wasBarge=${wasBarge}, nativeReady=${this.nativeReady}`)).catch(()=>{});
     if (this.nativeReady && OpenWakeWord) {
+      // Wenn wakeword schon laeuft (war Barge-Listener waehrend TTS):
+      // OpenWakeWord.start() ist idempotent (Kotlin checkt running.get()
+      // und resolved sofort). Wir koennen es trotzdem rufen — billiger
+      // als state extra zu fragen, garantiert dass nach diesem Pfad
+      // Native auch wirklich an ist falls es out-of-band gestoppt wurde.
       try {
         await OpenWakeWord.start();
-        console.log('[WakeWord] Konversation zu Ende — zurueck zu armed');
+        console.log('[WakeWord] Konversation zu Ende — zurueck zu armed (wasBarge=%s)', wasBarge);
         import('./logger').then(m => m.reportAppDebug('wake.end',
-          `OpenWakeWord.start() OK → state=armed, keyword=${this.keyword}`)).catch(()=>{});
+          `OpenWakeWord.start() OK → state=armed, wasBarge=${wasBarge}`)).catch(()=>{});
         ToastAndroid.show(`Lausche wieder auf "${KEYWORD_LABELS[this.keyword]}"`, ToastAndroid.SHORT);
         this.setState('armed');
         return;

aria-brain/agent.py

@@ -940,11 +940,19 @@ class Agent:
                     # Tools ausfuehren + Ergebnis als role=tool zurueck
                     for tc in result.tool_calls:
                         tool_result = self._dispatch_tool(tc["name"], tc["arguments"])
+                        # Cap auf 50 KB — passt zur Cap in _dispatch_tool fuer
+                        # Skill-Outputs (siehe agent.py weiter unten). 8 KB war
+                        # viel zu wenig: Spotify _all=true mit 90 Playlists
+                        # liefert ~34 KB compact, das wurde hier auf 8 KB
+                        # zugeschnitten und ARIA glaubte die Liste sei
+                        # abgeschnitten obwohl der Skill alles korrekt
+                        # paginiert hatte. Claude-Context vertraegt locker
+                        # 50 KB pro Tool-Result.
                         messages.append(ProxyMessage(
                             role="tool",
                             tool_call_id=tc["id"],
                             name=tc["name"],
-                            content=tool_result[:8000],
+                            content=tool_result[:50000],
                         ))
                     continue  # next iteration mit Tool-Results
                 # Kein Tool-Call mehr → final reply

aria-brain/seed_rules.py

@@ -602,6 +602,135 @@ SEED_RULES: List[dict] = [
             "'API Key' im Auth-Kapitel). Nicht raten."
         ),
     },
+    {
+        "migration_key": "seed/voice/tts-voice-tag",
+        "type": "rule",
+        "title": "TTS-sprechbar: `<voice>...</voice>`-Tag fuer Antworten mit Einheiten/Zahlen/Markdown",
+        "category": "voice",
+        "content": (
+            "Die App spielt jede ARIA-Antwort als TTS ab. Der Brain-Bridge "
+            "filtert Markdown raus (Sternchen, Code-Bloecke, URLs), kennt "
+            "aber keine Einheiten-/Zahlen-Konvention — der Sprecher liest "
+            "dann '15 kt' als 'fuenfzehn k t' und '23,5°C' als 'dreiund-"
+            "zwanzig komma fuenf grad c'. Klingt scheisse.\n"
+            "\n"
+            "LOESUNG: Wenn deine Antwort eine der folgenden Eigenschaften hat, "
+            "haenge einen `<voice>...</voice>`-Block ans ENDE der Antwort. "
+            "Was DRIN steht ersetzt komplett den TTS-Text — Markdown im "
+            "Chat-Display bleibt unangetastet, gesprochen wird ausschliess-"
+            "lich die <voice>-Variante.\n"
+            "\n"
+            "WANN <voice>-Tag setzen:\n"
+            "  - Einheiten-Abkuerzungen: kt, kg, km/h, °C, hPa, mbar, mph, "
+            "    psi, dB, GB, MB, kWh, mAh ...\n"
+            "  - Zahlen mit Komma (23,5 → 'dreiundzwanzig komma fuenf')\n"
+            "  - Uhrzeiten mit Minuten (8:42 → 'acht Uhr zweiundvierzig')\n"
+            "  - Wettervorhersagen / Statusberichte mit mehreren Daten\n"
+            "  - Tabellen oder Listen mit Werten\n"
+            "  - Lange Zahlen / IDs / Codes ('spotify:playlist:abc' nicht "
+            "    vorlesen)\n"
+            "  - Code-Bloecke (sollte ARIA in Sprache eh nicht zitieren)\n"
+            "\n"
+            "WANN NICHT (Overhead vermeiden):\n"
+            "  - Kurze Statussaetze ('OK', 'mach ich', 'klar', 'spielt')\n"
+            "  - Reine Prosa ohne Zahlen oder Einheiten\n"
+            "  - Antworten unter 15 Worten ohne komplexes Element\n"
+            "\n"
+            "FORMAT:\n"
+            "  Erst die Chat-Display-Variante (mit Markdown OK), dann an einer "
+            "  neuen Zeile der <voice>-Block:\n"
+            "\n"
+            "  Antwort-Text mit **Markdown**, Zahlen, Einheiten\n"
+            "  <voice>Antwort-Text fuer den Lautsprecher, ausgeschrieben</voice>\n"
+            "\n"
+            "BEISPIEL Wetter:\n"
+            "  **Wetter Berlin:** 23,5°C, Wind 15 kt aus NW, Druck 1018 hPa.\n"
+            "  <voice>Das Wetter in Berlin: dreiundzwanzig Grad fuenf, "
+            "  Wind mit fuenfzehn Knoten aus Nordwest, Luftdruck "
+            "  tausendachtzehn Hektopascal.</voice>\n"
+            "\n"
+            "BEISPIEL Uhrzeit:\n"
+            "  Stefan, dein Termin ist um **8:42** — noch 25 Minuten.\n"
+            "  <voice>Stefan, dein Termin ist um acht Uhr zweiundvierzig. "
+            "  Du hast noch fuenfundzwanzig Minuten.</voice>\n"
+            "\n"
+            "BEISPIEL Akku/Speicher:\n"
+            "  Server: 87% Last, 12,4 GB RAM frei, Uptime 142h.\n"
+            "  <voice>Server bei siebenundachtzig Prozent Last, zwoelf "
+            "  Komma vier Gigabyte RAM frei, Laufzeit hundertzweiundvierzig "
+            "  Stunden.</voice>\n"
+            "\n"
+            "BEISPIEL Multi-Track (NICHT vorlesen was nicht sprechbar ist):\n"
+            "  Spielt jetzt: **Firestarter** (3:47) auf duffy-desktop.\n"
+            "  <voice>Spielt jetzt Firestarter, drei Minuten siebenund-"
+            "  vierzig.</voice>  ← Device weglassen, war im Chat zur Info, "
+            "  fuer Stefan akustisch redundant\n"
+            "\n"
+            "Der Voice-Tag wird automatisch aus Chat-Bubble und Chat-Backup "
+            "gestrippt — Stefan sieht NUR die Markdown-Variante in der App. "
+            "Voice-Text geht ausschliesslich an F5-TTS. Beide Welten happy.\n"
+            "\n"
+            "Sicherheitsnetz: wenn Du den Tag mal vergisst, faellt clean_text_"
+            "for_tts auf die alte Regex-Cleanup-Pipeline zurueck (Markdown weg, "
+            "Uhrzeiten teilweise ausgeschrieben). Aber 'kt' wird dann literal "
+            "vorgelesen. Also: lieber Tag setzen wenn unsicher."
+        ),
+    },
+    {
+        "migration_key": "seed/skill-rule/list-api-pagination-snapshot",
+        "type": "rule",
+        "title": "Listen-API: einmal vollstaendig laden, DANN entscheiden",
+        "category": "verhalten",
+        "content": (
+            "Wenn ein Tool-Resultat ein Pagination-Schema hat (limit/offset/"
+            "next oder total > limit): ALLE Seiten in EINEM Tool-Call holen, "
+            "in EINEM Snapshot durchsuchen, ERST DANN handeln.\n"
+            "\n"
+            "Antipattern (31.05.2026, Stefan reproduziert mit 'Playlist Prodigy "
+            "raussuchen'):\n"
+            "  - run_spotify path=/v1/me/playlists?limit=50\n"
+            "    → 'nicht dabei'\n"
+            "  - run_spotify path=/v1/me/playlists?limit=50&offset=50\n"
+            "    → 'gefunden, ID=X' (46 Tracks)\n"
+            "  - run_spotify path=/v1/me/player/play body={context_uri: ...:X}\n"
+            "    → spielt aber FALSCHE Playlist\n"
+            "  - Neue Suche, wieder paginiert → drittes Match ID=Y (15 Tracks)\n"
+            "  - Insgesamt drei verschiedene IDs fuer dieselbe gesuchte Playlist\n"
+            "    generiert, am Ende die falsche gespielt.\n"
+            "\n"
+            "Wurzel: Spotify sortiert /v1/me/playlists nach recently-played. "
+            "Zwischen aufeinanderfolgenden paginierten Calls AENDERT SICH die "
+            "Reihenfolge wenn parallel was abgespielt wird. Teilresultate aus "
+            "verschiedenen Calls vergleichen → inkonsistent.\n"
+            "\n"
+            "Richtig fuer Spotify (seit 31.05.2026 unterstuetzt):\n"
+            "  run_spotify path=/v1/me/playlists?limit=50&_all=true\n"
+            "  → Skill paginiert intern, liefert {items, total, fetched_count}.\n"
+            "  → In items[] suchen, EINE ID waehlen, sofort handeln.\n"
+            "  → Match-Logik: bevorzugt exakter Name (case-insensitive). "
+            "Wenn mehrere Substring-Matches: explizit nachfragen statt raten.\n"
+            "\n"
+            "Wann _all=true sinnvoll:\n"
+            "  - /v1/me/playlists (alle eigenen Playlists)\n"
+            "  - /v1/playlists/{id}/tracks (alle Tracks einer Playlist)\n"
+            "  - /v1/me/tracks (Liked Songs)\n"
+            "  - /v1/search?type=playlist&q=... (Such-Ergebnisse mit next)\n"
+            "  - Andere Endpunkte mit items+next-Schema.\n"
+            "\n"
+            "Wann NICHT _all=true:\n"
+            "  - /v1/me/player/currently-playing (kein Listen-Endpunkt)\n"
+            "  - /v1/me/player/devices (kurze Liste, kein next)\n"
+            "  - Wenn Du explizit nur 'die ersten 10' willst.\n"
+            "\n"
+            "Fuer andere Skills (yt-dlp, andere APIs) die noch kein _all "
+            "unterstuetzen: manuell paginieren bis total erreicht, ALLES in "
+            "EINEM mentalen Snapshot mergen, NIEMALS auf Teilresultaten "
+            "Entscheidungen treffen. Wenn zwei Pagination-Runs unterschiedliche "
+            "Matches liefern: ehrlich melden ('zwei verschiedene Playlists "
+            "namens X gefunden — welche meinst Du?') statt sich auf eine "
+            "festzulegen."
+        ),
+    },
 ]
 
 

aria-brain/skills.py

@@ -683,8 +683,13 @@ def run_skill(name: str, args: Optional[dict] = None, timeout_sec: int = 300) ->
         timed_out = True
     duration = time.time() - t0
 
-    # Log schreiben (gekuerzt damit es nicht explodiert)
+    # Log auf der Disk wird gekuerzt (8000 chars) — sonst sammeln sich
-    record = {
+    # logs/*.json mit MBs an grossen Skill-Outputs an. Der Return-Value
+    # an den Caller (Agent) bekommt aber den vollen Output, dort wird
+    # nochmal in agent.py auf 50000 gecappt. Stefan-Fall: spotify-Skill
+    # mit _all=true liefert 50+ KB JSON, das hier wurde vorher auf 8 KB
+    # gekappt → ARIA sah immer nur den Anfang der Liste.
+    log_record = {
         "ts": _now(),
         "args": args or {},
         "exit_code": exit_code,
@@ -694,7 +699,7 @@ def run_skill(name: str, args: Optional[dict] = None, timeout_sec: int = 300) ->
         "timed_out": timed_out,
     }
     try:
-        log_path.write_text(json.dumps(record, indent=2, ensure_ascii=False), encoding="utf-8")
+        log_path.write_text(json.dumps(log_record, indent=2, ensure_ascii=False), encoding="utf-8")
     except Exception:
         pass
 
@@ -703,8 +708,19 @@ def run_skill(name: str, args: Optional[dict] = None, timeout_sec: int = 300) ->
     manifest["use_count"] = int(manifest.get("use_count", 0)) + 1
     write_manifest(name, manifest)
 
-    record["ok"] = exit_code == 0
+    # Return-Value: nicht kuerzen (Agent kuerzt downstream selbst). Nur
-    record["log_path"] = str(log_path)
+    # die Disk-Log-Variante war beschnitten.
+    record = {
+        "ts": log_record["ts"],
+        "args": log_record["args"],
+        "exit_code": exit_code,
+        "duration_sec": log_record["duration_sec"],
+        "stdout": out_text or "",
+        "stderr": err_text or "",
+        "timed_out": timed_out,
+        "ok": exit_code == 0,
+        "log_path": str(log_path),
+    }
     return record
 
 

bridge/aria_bridge.py

@@ -208,6 +208,30 @@ _UNIT_WORDS = [
 ]
 
 
+def strip_voice_tag_for_display(text: str) -> str:
+    """Entfernt `<voice>...</voice>`-Bloecke aus dem Chat-Display-Text.
+
+    ARIA kann einen <voice>-Block ANHAENGEN um eine TTS-freundliche Variante
+    ihrer Antwort zu liefern (Zahlen ausgeschrieben, Einheiten als Wort,
+    Markdown entfernt). Der Block wird dann von clean_text_for_tts als
+    TTS-Quelle benutzt — fuer die Chat-Bubble in der App soll er aber NICHT
+    sichtbar sein, sonst sieht Stefan literal '<voice>...' in seinem Chat.
+
+    Beispiel-Input (Stefan-typisch fuer Wetterbericht):
+        '**Wetter:** 23,5°C, Wind 15 kt NW\\n<voice>Wetter: dreiundzwanzig
+         komma fuenf Grad, Wind fuenfzehn Knoten Nordwest.</voice>'
+    Output:
+        '**Wetter:** 23,5°C, Wind 15 kt NW'
+
+    Mehrere Voice-Bloecke werden alle entfernt (ARIA koennte theoretisch
+    mehrere setzen, machen wir robust). Trailing-Whitespace nach dem Block
+    auch wegtrimmen.
+    """
+    if not text or "<voice>" not in text.lower():
+        return text
+    return _re_tts.sub(r'\s*<voice>[\s\S]*?</voice>\s*', '\n', text, flags=_re_tts.IGNORECASE).strip()
+
+
 def clean_text_for_tts(text: str) -> str:
     """Bereitet Chat-Text fuer Sprachausgabe auf.
 
@@ -1150,11 +1174,15 @@ class ARIABridge:
                     f"aber nicht erstellt:\n{missing_list}\n"
                     "Bitte ARIA bitten, sie wirklich zu schreiben.").strip()
 
-        # Antwort in chat_backup.jsonl loggen (gecleanter Text, ohne File-Marker)
+        # Antwort in chat_backup.jsonl loggen (gecleanter Text, ohne File-Marker
+        # UND ohne <voice>-Tag — der ist eine TTS-Annotation, gehoert nicht in
+        # die Chat-Historie weil ARIA ihre eigene Vorgaenger-Antwort sonst mit
+        # Voice-Tag-Noise als Kontext sieht).
         # File-Marker werden separat als file_from_aria-Events ausgeliefert.
+        display_text = strip_voice_tag_for_display(text)
         assistant_backup_ts = self._append_chat_backup({
             "role": "assistant",
-            "text": text,
+            "text": display_text,
             "files": [{"serverPath": f["serverPath"], "name": f["name"],
                        "mimeType": f["mimeType"], "size": f["size"]} for f in aria_files],
         })
@@ -1181,11 +1209,14 @@ class ARIABridge:
         # TTS-aufbereitete Variante fuer Debug (Diagnostic zeigt optional)
         tts_text_preview = clean_text_for_tts(text)
 
-        # Antwort an die App weiterleiten (als Chat-Nachricht)
+        # Antwort an die App weiterleiten (als Chat-Nachricht).
+        # display_text == text aber ohne <voice>-Tag — der lebt nur transient
+        # in `text` damit clean_text_for_tts weiter unten daraus die TTS-
+        # Variante zieht. Im Chat-Bubble soll der Tag nicht erscheinen.
         await self._send_to_rvs({
             "type": "chat",
             "payload": {
-                "text": text,
+                "text": display_text,
                 "sender": "aria",
                 "messageId": message_id,
                 # backupTs = der ts in chat_backup.jsonl. Wird von Clients als