fix(brain): Proxy-Timeout 20min -> 24h Read, split httpx-Timeouts, Cleanup-Pfade

Brain timed bei langen Pentests nach exakt 20:00 min raus, obwohl ARIAs
Subprozess fleissig weiterarbeitete und der Live-View alles zeigte.
Root-Cause: proxy_client.py hatte einen 1200s httpx.Client-Timeout —
genau der Wert, den wir vor 5 Tagen am Proxy auf 24h hochgezogen hatten.
Schicht uebersehen.

- docker-compose.yml: PROXY_TIMEOUT_SEC=86400 als brain-env.
- proxy_client.py: httpx.Timeout split (connect=10, read=86400, write=30,
  pool=10). Toter Proxy wird in 10s erkannt, lange ARIA-Sessions duerfen
  24h laufen.
- routes.js handleNonStreamingResponse: res.on("close") + isComplete-Flag.
  Brain-Disconnect killt jetzt den Subprozess statt ihn verwaisen zu lassen.
- agent.py chat(): try/except — bei Exception nach dem User-Turn wird ein
  Assistant-Error-Marker geschrieben, damit Conversation user->assistant
  konsistent bleibt (kein Tool-Call-Loop-Fail in Folge-Calls).

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

aria-brain/agent.py

@@ -553,40 +553,59 @@ class Agent:
                     len(hot), len(cold), len(active_skills), len(all_skills),
                     len(self.conversation.window()), len(system_prompt))
 
-        # 6. Tool-Use-Loop
+        # 6. Tool-Use-Loop. Bei Exception (z.B. Proxy-Timeout) muss ein
+        # Assistant-Turn als Error-Marker geschrieben werden — der User-Turn
+        # ist bereits in der Conversation. Ohne Gegenpart wird die naechste
+        # Anfrage im Window an Claude geschickt mit user → user als letzten
+        # zwei Turns, was OpenAI/Anthropic verwirrt und bei strict tools-Aufrufen
+        # zu 400-Errors fuehren kann.
         final_reply = ""
-        for iteration in range(self.MAX_TOOL_ITERATIONS):
-            result = self.proxy.chat_full(messages, tools=tools)
-            if result.tool_calls:
-                # Assistant-Turn mit tool_calls in messages anhaengen (nicht in Conversation!)
-                messages.append(ProxyMessage(
-                    role="assistant",
-                    content=result.content or None,
-                    tool_calls=[{
-                        "id": tc["id"], "type": "function",
-                        "function": {"name": tc["name"], "arguments": json.dumps(tc["arguments"])},
-                    } for tc in result.tool_calls],
-                ))
-                # Tools ausfuehren + Ergebnis als role=tool zurueck
-                for tc in result.tool_calls:
-                    tool_result = self._dispatch_tool(tc["name"], tc["arguments"])
+        try:
+            for iteration in range(self.MAX_TOOL_ITERATIONS):
+                result = self.proxy.chat_full(messages, tools=tools)
+                if result.tool_calls:
+                    # Assistant-Turn mit tool_calls in messages anhaengen (nicht in Conversation!)
                     messages.append(ProxyMessage(
-                        role="tool",
-                        tool_call_id=tc["id"],
-                        name=tc["name"],
-                        content=tool_result[:8000],
+                        role="assistant",
+                        content=result.content or None,
+                        tool_calls=[{
+                            "id": tc["id"], "type": "function",
+                            "function": {"name": tc["name"], "arguments": json.dumps(tc["arguments"])},
+                        } for tc in result.tool_calls],
                     ))
-                continue  # next iteration mit Tool-Results
-            # Kein Tool-Call mehr → final reply
-            final_reply = (result.content or "").strip()
-            break
-        else:
-            # Loop-Limit erreicht
-            final_reply = "[Tool-Loop-Limit erreicht — ARIA hat zu viele Tool-Calls gemacht ohne fertig zu werden]"
-            logger.warning("Tool-Loop hit MAX_TOOL_ITERATIONS=%d", self.MAX_TOOL_ITERATIONS)
+                    # Tools ausfuehren + Ergebnis als role=tool zurueck
+                    for tc in result.tool_calls:
+                        tool_result = self._dispatch_tool(tc["name"], tc["arguments"])
+                        messages.append(ProxyMessage(
+                            role="tool",
+                            tool_call_id=tc["id"],
+                            name=tc["name"],
+                            content=tool_result[:8000],
+                        ))
+                    continue  # next iteration mit Tool-Results
+                # Kein Tool-Call mehr → final reply
+                final_reply = (result.content or "").strip()
+                break
+            else:
+                # Loop-Limit erreicht
+                final_reply = "[Tool-Loop-Limit erreicht — ARIA hat zu viele Tool-Calls gemacht ohne fertig zu werden]"
+                logger.warning("Tool-Loop hit MAX_TOOL_ITERATIONS=%d", self.MAX_TOOL_ITERATIONS)
 
-        if not final_reply:
-            raise RuntimeError("Leerer Reply vom Proxy")
+            if not final_reply:
+                raise RuntimeError("Leerer Reply vom Proxy")
+
+        except Exception as exc:
+            # Conversation-Konsistenz: User-Turn ist drin (Schritt 1), Assistant
+            # muss auch rein damit die Paarung stimmt. Wir schreiben einen
+            # Error-Marker statt zu rollback-en (rollback wuerde Race-Conditions
+            # mit der JSONL-Persistenz aufmachen).
+            err_text = f"[Fehler: {exc}]"
+            logger.error("chat() Exception — schreibe Error-Marker als Assistant-Turn: %s", exc)
+            try:
+                self.conversation.add("assistant", err_text)
+            except Exception as add_exc:
+                logger.warning("Konnte Error-Marker nicht persistieren: %s", add_exc)
+            raise
 
         # 7. Assistant-Turn (final reply) in die Conversation
         self.conversation.add("assistant", final_reply)