B2 beheben: Chat-Laeufe pro Agent serialisieren

Der Konversationskontext _chatContexts[agentId] ist eine geteilte List<ChatMessage>.
Nur der Lookup lief unter Lock, alle Add-Aufrufe im Schleifenkoerper waren
ungeschuetzt. Da WebView, ToolJob-Wakeups und AgentComm denselben Agenten
gleichzeitig ansprechen koennen, verschraenkten sich ihre Nachrichten zu einer
ungueltigen Tool-Sequenz, die die API mit HTTP 400 ablehnt.

ChatAsync laeuft jetzt hinter einem SemaphoreSlim(1,1) pro Agent; verschiedene
Agenten bleiben unabhaengig. Die Timeout-Uhr startet erst nach dem Eintritt,
damit Wartezeit in der Warteschlange den Lauf nicht aufzehrt.

Zwei Folgeprobleme mit demselben Ursprung:

- _runningChats hielt nur EINE CancellationTokenSource je Agent; der zweite Lauf
  ueberschrieb den ersten. AbortChat brach dadurch nur einen ab, der andere lief
  bis ins Run-Timeout. Jetzt eine Liste, die auch wartende Laeufe erfasst.
- ExecuteToolCallAsync fing OperationCanceledException mit ab und gab sie als
  Tool-Ergebnis zurueck, wodurch der Abbruch erst einen Schritt spaeter griff.
  Cancellation wird nun durchgereicht.

Ausserdem: send_message an den eigenen Agenten wird abgelehnt — es waere mit dem
neuen Gate in einen Deadlock gelaufen.

Neu: GetChatContext(agentId) als Momentaufnahme des Kontexts, fuer Diagnose und
Kontextgroessen-Anzeige.

Build-Fix: Das WinForms-Projekt globbt **/*.cs und kompilierte dadurch die
Test-Quellen mit. tests\** wird jetzt wie src\** ausgeschlossen.

Alle 49 Tests gruen.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

tests/ClawdDotNet.Core.Tests/Infrastructure/FakeChatClient.cs

@@ -16,6 +16,7 @@ internal sealed class FakeChatClient : IChatCompletionClient
 {
     private readonly Queue<Func<ChatRequest, ChatResponse>> _responses = new();
     private Func<ChatRequest, ChatResponse>? _fallback;
+    private readonly Lock _gate = new();
 
     /// <summary>Alle empfangenen Requests, als tiefe Kopien.</summary>
     public List<ChatRequest> ReceivedRequests { get; } = new();
@@ -35,20 +36,26 @@ internal sealed class FakeChatClient : IChatCompletionClient
 
     public FakeChatClient RespondsWithToolCalls(params (string Tool, string Args, string? Id)[] calls)
     {
-        var toolCalls = calls.Select((c, i) => new ToolCall
+        _responses.Enqueue(_ => ToolCallResponse(calls));
+        return this;
+    }
+
+    private static ChatResponse ToolCallResponse((string Tool, string Args, string? Id)[] calls)
+    {
+        // Ids müssen pro Antwort eindeutig sein, sonst kollidieren parallele Läufe.
+        var toolCalls = calls.Select(c => new ToolCall
         {
-            Id = c.Id ?? $"call_{Guid.NewGuid():N}"[..12],
+            Id = c.Id ?? "call_" + Guid.NewGuid().ToString("N")[..12],
             Type = "function",
-            Function = new ToolCallFunction { Name =c.Tool, Arguments = c.Args }
+            Function = new ToolCallFunction { Name = c.Tool, Arguments = c.Args }
         }).ToList();
 
-        _responses.Enqueue(_ => new ChatResponse
+        return new ChatResponse
         {
-            Id = "resp_" + ReceivedRequests.Count,
+            Id = "resp",
             Choices = [new Choice { Index = 0, Message = new ChatMessage { Role = "assistant", ToolCalls = toolCalls } }],
             Usage = new Usage { PromptTokens = 100, CompletionTokens = 20, TotalTokens = 120 }
-        });
-        return this;
+        };
     }
 
     /// <summary>Antwortet mit einer bestimmten Prompt-Token-Zahl — für Compaction-Schwellen.</summary>
@@ -76,22 +83,47 @@ internal sealed class FakeChatClient : IChatCompletionClient
         return this;
     }
 
+    public FakeChatClient AlwaysRespondsWithToolCall(string toolName = "TestTool")
+    {
+        _fallback = _ => ToolCallResponse([(toolName, "{}", null)]);
+        return this;
+    }
+
+    /// <summary>
+    /// Antwortet passend zum jeweiligen Gesprächsstand: nach einer Tool-Antwort
+    /// kommt Text, sonst ein Tool-Aufruf. Damit verhält sich der Fake auch dann
+    /// sinnvoll, wenn mehrere Konversationen ineinander verschränkt laufen.
+    /// </summary>
+    public FakeChatClient RespondsContextually(string toolName = "TestTool")
+    {
+        _fallback = req => req.Messages.LastOrDefault()?.Role == "tool"
+            ? TextResponse("Fertig")
+            : ToolCallResponse([(toolName, "{}", null)]);
+        return this;
+    }
+
     // ─── IChatCompletionClient ───
 
     public Task<ChatResponse> CompleteAsync(ChatRequest request, CancellationToken ct)
     {
         ct.ThrowIfCancellationRequested();
-        ReceivedRequests.Add(DeepClone(request));
 
-        if (_responses.Count > 0)
-            return Task.FromResult(_responses.Dequeue()(request));
+        // Erst kopieren, dann auswerten: Die Engine mutiert die Original-Liste
+        // weiter, und bei Nebenläufigkeitstests soll der Fake daran nicht scheitern.
+        var snapshot = DeepClone(request);
+        lock (_gate)
+            ReceivedRequests.Add(snapshot);
 
-        if (_fallback is not null)
-            return Task.FromResult(_fallback(request));
+        Func<ChatRequest, ChatResponse>? responder;
+        lock (_gate)
+            responder = _responses.Count > 0 ? _responses.Dequeue() : _fallback;
 
-        throw new InvalidOperationException(
-            $"FakeChatClient: unerwarteter Aufruf Nr. {ReceivedRequests.Count} — " +
-            "keine Antwort mehr programmiert.");
+        if (responder is null)
+            throw new InvalidOperationException(
+                $"FakeChatClient: unerwarteter Aufruf Nr. {ReceivedRequests.Count} — " +
+                "keine Antwort mehr programmiert.");
+
+        return Task.FromResult(responder(snapshot));
     }
 
     // ─── Helfer ───