feat(brain): Listen-API-Pagination strukturell loesen + seed-rule

Stefan-Reproduktion vom 31.05.2026: bei 'Such Playlist Prodigy raus'
hat ARIA die Spotify-Pagination drei Mal hintereinander laufen lassen,
jedes Mal eine andere Playlist-ID gefunden, am Ende falsche abgespielt.
Spotify sortiert /v1/me/playlists nach recently-played — die Reihen-
folge aendert sich zwischen Calls wenn parallel was laeuft, also
liefern aufeinanderfolgende paginierte Runs inkonsistente Snapshots.

Loesungen:

1. **spotify-Skill _all=true** (via skill_update angewendet, lebt nur
   in /data/skills/spotify/ im Container, nicht in git): Skill prueft
   _all=true im URL-Query, paginiert dann intern ueber Spotifys
   next-Field bis MAX_PAGES (20) oder fertig. Liefert konsolidiertes
   JSON {items, total, fetched_count, fetched_pages}. EIN Tool-Call,
   konsistenter Snapshot.

2. **skills.py: Stdout-Truncation entkoppeln**. Vorher: 8000-char-Cap
   sowohl fuer Disk-Log als auch fuer Return-Value an Agent.
   Konsequenz: _all=true Output (50 KB JSON) wurde fuer ARIA auf 8 KB
   gekuerzt, sie sah nur die ersten ~20 Playlists. Jetzt:
     - Disk-Log: weiterhin 8 KB pro stdout (Disk-Schoner)
     - Return-Value: ungekuerzt, agent.py macht 50 KB downstream-Cap
   Skills.py:687 — record-Dict aufgesplittet in log_record + record.

3. **seed_rule list-api-pagination-snapshot**: dokumentiert das
   Pattern fuer ARIA — bei Pagination-Resultaten IMMER vollstaendig
   laden bevor Entscheidung; _all=true bevorzugen wo verfuegbar;
   bei inkonsistenten Match-Resultaten ehrlich nachfragen statt
   raten. Mit konkreter Antipattern-Sammlung aus Stefans Test.

Deployment: brain restart noetig damit (2) und (3) greifen. Skill-
Code (1) ist schon via PATCH /skills/spotify aktiv.

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)
-    record = {
+    # Log auf der Disk wird gekuerzt (8000 chars) — sonst sammeln sich
+    # 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
-    record["log_path"] = str(log_path)
+    # Return-Value: nicht kuerzen (Agent kuerzt downstream selbst). Nur
+    # 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