From 6581fd0187ac83ab981f00435a1945412d924651 Mon Sep 17 00:00:00 2001
From: Richard <asmorous@googlemail.com>
Date: Mon, 14 Sep 2026 15:40:56 +0200
Subject: [PATCH] Befunde aus dem Testbetrieb auf der Linux-VM behoben (#572)

- #578: Abgebrochene Laeufe (Schrittgrenze, Zeitueberschreitung, Abbruch,
  Ausnahme) tragen ihre bezahlten Token - vorher 0 in RunUsage, fuer das
  Budget unsichtbar.
- #580: WebFetch prueft die aufgeloeste Zieladresse beim Verbinden; ein
  erlaubter Name, der auf 127.0.0.1 aufloest, wird gesperrt.
- #575: Dateien entstehen unter Unix mit 0600 (AtomicFile, Protokolle,
  FileRW-Anhaengen, state.db), Protokollverzeichnisse mit 0700.
- #576: SIGTERM/SIGINT beenden auch mit Fenster geordnet.
- #593: OpenRouter-Statusdienst wird gestartet.
- #589: Auftragsnachricht nennt aktuelle Zeit, Zeitzone und Termin.
- #581: Unvollstaendiges Argument-JSON erreicht das Werkzeug nicht mehr;
  das Modell bekommt eine verstaendliche Rueckmeldung statt Parsertext.
- #591: Weboberflaeche liest die Felder, die API und Ereignisstrom liefern
  (Freigaben, Protokoll, Taskboard mit Termin, Werkzeug-Einstellungen,
  Tokennutzung); Ereignisstrom in camelCase.
- #592: Chat zeigt Nachrichten nicht mehr doppelt.
- #536 (teilweise): A2A-Antworten tragen Absender und Empfaenger, Parser
  wirft nicht mehr; Datums- und Volltextfilter in Agenten-Chats.
- deploy/publish.py: Packager-Pfad net10.0, Schalter --agent-file.
- Version 0.1.4.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
---
 Directory.Build.props                         |   2 +-
 deploy/publish.py                             |  22 +-
 src/ClawdDotNet.App/AppHost.cs                |   9 +
 src/ClawdDotNet.Core/Engine/AgentEngine.cs    |  63 ++++-
 src/ClawdDotNet.Core/Logging/FileLogWriter.cs |  19 +-
 src/ClawdDotNet.Core/Storage/AtomicFile.cs    |   7 +-
 src/ClawdDotNet.Core/Storage/OwnerOnlyFile.cs |  35 +++
 src/ClawdDotNet.Core/Storage/SqliteStorage.cs |  10 +
 .../Tasks/EngineTaskDispatcher.cs             |  42 +++-
 src/ClawdDotNet.Desktop/App.axaml.cs          |  52 ++++
 .../wwwroot/views/agent-chats.js              | 226 +++++++++++-------
 .../wwwroot/views/agents.js                   |   8 +-
 .../wwwroot/views/chat.js                     |  28 ++-
 .../wwwroot/views/logs.js                     |  12 +-
 .../wwwroot/views/staging.js                  |  25 +-
 .../wwwroot/views/tasks.js                    |  12 +-
 .../wwwroot/views/usage.js                    |  45 +++-
 src/ClawdDotNet.Tools.FileRW/FileRWTool.cs    |   7 +-
 src/ClawdDotNet.Tools.WebFetch/UrlGuard.cs    |  81 ++++++-
 .../WebFetchTool.cs                           |  11 +-
 src/ClawdDotNet.Web/Contracts/Dtos.cs         |  13 +-
 src/ClawdDotNet.Web/Contracts/Mapping.cs      |   8 +-
 .../Endpoints/AgentCommunicationBuilder.cs    | 100 ++++++++
 src/ClawdDotNet.Web/Endpoints/ApiEndpoints.cs |  49 +---
 .../Endpoints/EventEndpoints.cs               |  12 +-
 .../Engine/TestbetriebRegressionTests.cs      | 147 ++++++++++++
 .../Storage/OwnerOnlyFileTests.cs             |  74 ++++++
 .../WebFetch/UrlGuardAufloesungTests.cs       |  67 ++++++
 .../TestbetriebWebTests.cs                    | 132 ++++++++++
 29 files changed, 1128 insertions(+), 190 deletions(-)
 create mode 100644 src/ClawdDotNet.Core/Storage/OwnerOnlyFile.cs
 create mode 100644 src/ClawdDotNet.Web/Endpoints/AgentCommunicationBuilder.cs
 create mode 100644 tests/ClawdDotNet.Core.Tests/Engine/TestbetriebRegressionTests.cs
 create mode 100644 tests/ClawdDotNet.Core.Tests/Storage/OwnerOnlyFileTests.cs
 create mode 100644 tests/ClawdDotNet.Tools.Tests/WebFetch/UrlGuardAufloesungTests.cs
 create mode 100644 tests/ClawdDotNet.Web.Tests/TestbetriebWebTests.cs

diff --git a/Directory.Build.props b/Directory.Build.props
index d5bef64..c49d6a1 100644
--- a/Directory.Build.props
+++ b/Directory.Build.props
@@ -18,7 +18,7 @@
       ClawdDotNet.Core.BuildInfo bleibt daneben bestehen: das ist ein von Hand
       gefuehrter Zaehler mit Aenderungstext, keine Versionsangabe.
     -->
-    <Version>0.1.2</Version>
+    <Version>0.1.4</Version>
 
     <!--
       Symbole in die Assembly einbetten statt als .pdb daneben zu legen.
diff --git a/deploy/publish.py b/deploy/publish.py
index f1d2375..54ae3d4 100644
--- a/deploy/publish.py
+++ b/deploy/publish.py
@@ -37,7 +37,7 @@ PROJECT = REPO / "src" / "ClawdDotNet.Desktop" / "ClawdDotNet.Desktop.csproj"
 CONFIG = REPO / "deploy" / "packager.config.json"
 PACKAGER = Path(
     "J:/Softwareprojekte/Deploymentcenter/client-dotnet/Deploymentcenter.Packager"
-    "/bin/Release/net8.0/pack-and-deploy.exe"
+    "/bin/Release/net10.0/win-x64/pack-and-deploy.exe"
 )
 INSTALLER_BASE = "https://dc.mhdf.de/installer"
 
@@ -69,13 +69,18 @@ def publish(rid: str, out_dir: Path) -> None:
     ])
 
 
-def fetch_agent(rid: str, out_dir: Path) -> None:
+def fetch_agent(rid: str, out_dir: Path, agent_file: Path | None = None) -> None:
     """Holt den update-agent und prueft die Pruefsumme.
 
     Bewusst das ausgelieferte Binary statt eines selbst gebauten: Es ist
     dasselbe, das die Erstinstallation verwendet, und wird zentral gepflegt.
     Ohne Pruefsummenvergleich waere das ein Download, der spaeter fremden Code
     ausfuehrt - genau der Pfad, den eine Signatur schuetzen soll.
+
+    agent_file ersetzt nur den Download, nicht die Pruefung: Die Ablage liefert
+    zeitweise um 100 KB/s, und urllib blieb dabei am 2026-09-14 ohne Meldung
+    stehen. Eine vorhandene Kopie muss dieselbe Pruefsumme tragen wie das
+    Manifest - sonst ist sie nicht das ausgelieferte Binary.
     """
     with urllib.request.urlopen(f"{INSTALLER_BASE}/installer.json", timeout=30) as r:
         manifest = json.load(r)
@@ -86,8 +91,12 @@ def fetch_agent(rid: str, out_dir: Path) -> None:
 
     print(f"  update-agent {manifest.get('version')} fuer {rid} ({entry['sizeBytes']} Bytes)")
 
-    with urllib.request.urlopen(f"{INSTALLER_BASE}/{entry['file']}", timeout=180) as r:
-        payload = r.read()
+    if agent_file is not None:
+        print(f"  aus Datei: {agent_file}")
+        payload = agent_file.read_bytes()
+    else:
+        with urllib.request.urlopen(f"{INSTALLER_BASE}/{entry['file']}", timeout=180) as r:
+            payload = r.read()
 
     actual = hashlib.sha256(payload).hexdigest()
     if actual != entry["sha256"].lower():
@@ -109,6 +118,9 @@ def main() -> None:
     parser.add_argument("--changelog", default="")
     parser.add_argument("--no-agent", action="store_true",
                         help="update-agent nicht mitliefern")
+    parser.add_argument("--agent-file", type=Path,
+                        help="vorhandene Kopie des update-agent statt Download; "
+                             "die Pruefsumme wird trotzdem gegen installer.json geprueft")
     parser.add_argument("--dry-run", action="store_true",
                         help="nur bauen und pruefen, nicht hochladen")
     args = parser.parse_args()
@@ -125,7 +137,7 @@ def main() -> None:
     if args.no_agent:
         print("  uebersprungen (--no-agent)")
     else:
-        fetch_agent(args.rid, out_dir)
+        fetch_agent(args.rid, out_dir, args.agent_file)
 
     total = sum(f.stat().st_size for f in out_dir.rglob("*") if f.is_file())
     print(f"\n  {len(list(out_dir.rglob('*')))} Eintraege, {total / 1_048_576:.1f} MB")
diff --git a/src/ClawdDotNet.App/AppHost.cs b/src/ClawdDotNet.App/AppHost.cs
index 2ab982a..44d9ccd 100644
--- a/src/ClawdDotNet.App/AppHost.cs
+++ b/src/ClawdDotNet.App/AppHost.cs
@@ -580,6 +580,15 @@ public sealed class AppHost : IAsyncDisposable
 
         host._shutdown.Add(() => { openRouter.Dispose(); return ValueTask.CompletedTask; });
 
+        // #593: Angelegt wurde der Dienst schon immer, gestartet nie — weder kopflos noch
+        // mit Fenster. Die Kopfzeile der Weboberflaeche stand deshalb dauerhaft auf
+        // "OpenRouter: —" und /api/status auf "Prüfe…".
+        if (host.Status is { } status)
+        {
+            status.Start();
+            host._shutdown.Add(status.DisposeAsync);
+        }
+
         logger.LogInformation("AgentEngine und Scanner erstellt, Chat-Verläufe geladen");
 
         return host;
diff --git a/src/ClawdDotNet.Core/Engine/AgentEngine.cs b/src/ClawdDotNet.Core/Engine/AgentEngine.cs
index ff56fc7..32c7c74 100644
--- a/src/ClawdDotNet.Core/Engine/AgentEngine.cs
+++ b/src/ClawdDotNet.Core/Engine/AgentEngine.cs
@@ -183,6 +183,11 @@ public sealed class AgentEngine : IAgentMessageRouter, Staging.IFrozenCallExecut
         logger.LogInformation("Agent run started: {AgentId}, model={Model}",
             agentConfig.AgentId, agentConfig.Model);
 
+        // #578: Vor dem try, damit auch die Abbruchzweige wissen, was bis dahin bezahlt
+        // wurde. Vorher lag sie im try, und ein Lauf an der Schrittgrenze ging mit 0 Token
+        // und 0 USD in RunUsage - fuer das Tagesbudget unsichtbar.
+        var tally = new TokenTally();
+
         try
         {
             var tools = _toolRegistry.GetForAgent(agentConfig);
@@ -198,7 +203,6 @@ public sealed class AgentEngine : IAgentMessageRouter, Staging.IFrozenCallExecut
 
             string? finalMessage = null;
             var truncated = false;
-            var tally = new TokenTally();
             var cachingEnabled = PromptCache.IsEnabledFor(agentConfig.PromptCaching, agentConfig.Model);
 
             while (true)
@@ -315,7 +319,7 @@ public sealed class AgentEngine : IAgentMessageRouter, Staging.IFrozenCallExecut
 
             var result = new AgentRunResult(
                 agentConfig.AgentId, AgentRunStatus.Cancelled, null,
-                loopGuard.Steps, loopGuard.Tokens, sw.Elapsed);
+                loopGuard.Steps, loopGuard.Tokens, sw.Elapsed) with { PromptTokens = tally.Prompt, CompletionTokens = tally.Completion, CachedTokens = tally.Cached, ReportedCostUsd = tally.ReportedCost };
             OnRunCompleted?.Invoke(agentConfig.Model, result);
             return result;
         }
@@ -326,7 +330,7 @@ public sealed class AgentEngine : IAgentMessageRouter, Staging.IFrozenCallExecut
 
             var result = new AgentRunResult(
                 agentConfig.AgentId, AgentRunStatus.Cancelled, null,
-                loopGuard.Steps, loopGuard.Tokens, sw.Elapsed);
+                loopGuard.Steps, loopGuard.Tokens, sw.Elapsed) with { PromptTokens = tally.Prompt, CompletionTokens = tally.Completion, CachedTokens = tally.Cached, ReportedCostUsd = tally.ReportedCost };
             OnRunCompleted?.Invoke(agentConfig.Model, result);
             return result;
         }
@@ -338,7 +342,7 @@ public sealed class AgentEngine : IAgentMessageRouter, Staging.IFrozenCallExecut
 
             var result = new AgentRunResult(
                 agentConfig.AgentId, AgentRunStatus.LoopLimitExceeded, null,
-                loopGuard.Steps, loopGuard.Tokens, sw.Elapsed, ex);
+                loopGuard.Steps, loopGuard.Tokens, sw.Elapsed, ex) with { PromptTokens = tally.Prompt, CompletionTokens = tally.Completion, CachedTokens = tally.Cached, ReportedCostUsd = tally.ReportedCost };
             OnRunCompleted?.Invoke(agentConfig.Model, result);
             return result;
         }
@@ -349,7 +353,7 @@ public sealed class AgentEngine : IAgentMessageRouter, Staging.IFrozenCallExecut
 
             var result = new AgentRunResult(
                 agentConfig.AgentId, AgentRunStatus.Failed, null,
-                loopGuard.Steps, loopGuard.Tokens, sw.Elapsed, ex);
+                loopGuard.Steps, loopGuard.Tokens, sw.Elapsed, ex) with { PromptTokens = tally.Prompt, CompletionTokens = tally.Completion, CachedTokens = tally.Cached, ReportedCostUsd = tally.ReportedCost };
             OnRunCompleted?.Invoke(agentConfig.Model, result);
             return result;
         }
@@ -441,6 +445,9 @@ public sealed class AgentEngine : IAgentMessageRouter, Staging.IFrozenCallExecut
         using var linkedCts = CancellationTokenSource.CreateLinkedTokenSource(runCt, timeoutCts.Token);
         var ct = linkedCts.Token;
 
+        // #578: siehe RunCoreAsync - auch Abbrueche tragen ihre bezahlten Token.
+        var tally = new TokenTally();
+
         try
         {
             var tools = _toolRegistry.GetForAgent(agentConfig);
@@ -472,7 +479,6 @@ public sealed class AgentEngine : IAgentMessageRouter, Staging.IFrozenCallExecut
 
             string? finalMessage = null;
             var truncated = false;
-            var tally = new TokenTally();
             var cachingEnabled = PromptCache.IsEnabledFor(agentConfig.PromptCaching, agentConfig.Model);
 
             while (true)
@@ -587,7 +593,7 @@ public sealed class AgentEngine : IAgentMessageRouter, Staging.IFrozenCallExecut
             AddChatEntry(agentConfig.AgentId, "assistant", cancelMsg, source);
             var result = new AgentRunResult(
                 agentConfig.AgentId, AgentRunStatus.Cancelled, cancelMsg,
-                loopGuard.Steps, loopGuard.Tokens, sw.Elapsed);
+                loopGuard.Steps, loopGuard.Tokens, sw.Elapsed) with { PromptTokens = tally.Prompt, CompletionTokens = tally.Completion, CachedTokens = tally.Cached, ReportedCostUsd = tally.ReportedCost };
             OnRunCompleted?.Invoke(agentConfig.Model, result);
             return result;
         }
@@ -599,7 +605,7 @@ public sealed class AgentEngine : IAgentMessageRouter, Staging.IFrozenCallExecut
             AddChatEntry(agentConfig.AgentId, "assistant", limitMsg, source);
             var result = new AgentRunResult(
                 agentConfig.AgentId, AgentRunStatus.LoopLimitExceeded, limitMsg,
-                loopGuard.Steps, loopGuard.Tokens, sw.Elapsed, ex);
+                loopGuard.Steps, loopGuard.Tokens, sw.Elapsed, ex) with { PromptTokens = tally.Prompt, CompletionTokens = tally.Completion, CachedTokens = tally.Cached, ReportedCostUsd = tally.ReportedCost };
             OnRunCompleted?.Invoke(agentConfig.Model, result);
             return result;
         }
@@ -611,7 +617,7 @@ public sealed class AgentEngine : IAgentMessageRouter, Staging.IFrozenCallExecut
             AddChatEntry(agentConfig.AgentId, "assistant", errorMsg, source);
             var result = new AgentRunResult(
                 agentConfig.AgentId, AgentRunStatus.Failed, errorMsg,
-                loopGuard.Steps, loopGuard.Tokens, sw.Elapsed, ex);
+                loopGuard.Steps, loopGuard.Tokens, sw.Elapsed, ex) with { PromptTokens = tally.Prompt, CompletionTokens = tally.Completion, CachedTokens = tally.Cached, ReportedCostUsd = tally.ReportedCost };
             OnRunCompleted?.Invoke(agentConfig.Model, result);
             return result;
         }
@@ -1244,6 +1250,18 @@ public sealed class AgentEngine : IAgentMessageRouter, Staging.IFrozenCallExecut
                 return JsonSerializer.Serialize(ToolResult.Fail($"Tool '{toolName}' not found."));
             }
 
+            // #581: Unvollstaendiges Argument-JSON gar nicht erst ans Tool reichen. Vorher
+            // bekam das Modell den Parsertext ("Expected depth to be zero...") und
+            // wiederholte denselben Aufruf bis zur Schrittgrenze. Beobachtet bei sehr
+            // grossen Argumenten: Das JSON brach genau vor dem grossen Wert ab.
+            if (!string.IsNullOrWhiteSpace(arguments) && !IstVollstaendigesJson(arguments))
+            {
+                var hinweis = UnvollstaendigeArgumente(toolName, arguments, agentConfig.LoopGuard.MaxResponseTokens);
+                logger.LogWarning("Unvollstaendige Argumente fuer {Tool} ({Laenge} Zeichen)", toolName, arguments.Length);
+                await Audit(AuditStatus.Error, hinweis);
+                return JsonSerializer.Serialize(new { error = hinweis });
+            }
+
             // Staging-Durchsetzung (A2): irreversible Aktionen werden vorgeschlagen statt
             // ausgeführt. Eine Prompt-Injection kann so nur einen Vorschlag erzeugen.
             if (_stagingGate is not null)
@@ -1332,6 +1350,33 @@ public sealed class AgentEngine : IAgentMessageRouter, Staging.IFrozenCallExecut
         }
     }
 
+    /// <summary>Ob die Argumente eines Werkzeugaufrufs vollstaendiges JSON sind (#581).</summary>
+    internal static bool IstVollstaendigesJson(string arguments)
+    {
+        try
+        {
+            using var _ = JsonDocument.Parse(arguments);
+            return true;
+        }
+        catch (JsonException)
+        {
+            return false;
+        }
+    }
+
+    /// <summary>
+    /// Die Rueckmeldung ans Modell, wenn Argumente abgeschnitten ankamen (#581): was los
+    /// ist und was stattdessen zu tun ist - nicht der Text eines JSON-Parsers.
+    /// </summary>
+    internal static string UnvollstaendigeArgumente(string toolName, string arguments, int maxResponseTokens)
+    {
+        var ende = arguments.Length <= 40 ? arguments : "..." + arguments[^40..];
+        return $"Die Argumente fuer '{toolName}' sind kein vollstaendiges JSON ({arguments.Length} Zeichen, "
+             + $"enden mit: {ende}). Meist war ein Argument zu gross fuer eine einzelne Antwort "
+             + $"(Ausgabegrenze {maxResponseTokens} Tokens) und wurde abgeschnitten. Denselben Aufruf "
+             + "nicht wiederholen - den Inhalt auf mehrere kleinere Aufrufe verteilen.";
+    }
+
     private AgentToolContext BuildToolContext(
         AgentConfig agentConfig, string instanceId, string toolName, CancellationToken ct,
         DelegationChain? chain = null)
diff --git a/src/ClawdDotNet.Core/Logging/FileLogWriter.cs b/src/ClawdDotNet.Core/Logging/FileLogWriter.cs
index 8d65139..319fd35 100644
--- a/src/ClawdDotNet.Core/Logging/FileLogWriter.cs
+++ b/src/ClawdDotNet.Core/Logging/FileLogWriter.cs
@@ -1,5 +1,6 @@
 using System.Collections.Concurrent;
 using System.Text;
+using ClawdDotNet.Core.Storage;
 
 namespace ClawdDotNet.Core.Logging;
 
@@ -7,6 +8,10 @@ namespace ClawdDotNet.Core.Logging;
 /// Schreibt Log-Einträge asynchron in datei- und datumsgetrennte Logfiles.
 /// Struktur: {LogDirectory}/{Datum}/{Modul}.log
 /// Thread-safe durch ConcurrentQueue + dediziertem Writer-Task.
+///
+/// <para>Verzeichnisse <c>0700</c>, Dateien <c>0600</c> (#575): Im Protokoll stehen Pfade,
+/// Fehlermeldungen von Werkzeugen und Anfänge von Aufträgen. Vorher entstanden sie mit der
+/// Standardmaske, auf der Test-VM also <c>0775</c>/<c>0664</c>.</para>
 /// </summary>
 public sealed class FileLogWriter : IAsyncDisposable
 {
@@ -20,7 +25,7 @@ public sealed class FileLogWriter : IAsyncDisposable
     public FileLogWriter(FileLoggerOptions options)
     {
         _options = options;
-        Directory.CreateDirectory(_options.LogDirectory);
+        AppPaths.EnsureDirectory(_options.LogDirectory);
         _writerTask = Task.Run(ProcessQueueAsync);
     }
 
@@ -73,7 +78,10 @@ public sealed class FileLogWriter : IAsyncDisposable
             _options.LogDirectory,
             entry.Timestamp.ToString(_options.DateFormat));
 
-        Directory.CreateDirectory(dateDir);
+        // Nur beim Anlegen einschränken: EnsureDirectory setzt die Rechte, und das je
+        // Zeile zu tun hiesse einen Systemaufruf je Protokolleintrag.
+        if (!Directory.Exists(dateDir))
+            AppPaths.EnsureDirectory(dateDir);
 
         var safeModule = SanitizeModuleName(entry.Module);
         var filePath = Path.Combine(dateDir, $"{safeModule}.log");
@@ -83,7 +91,12 @@ public sealed class FileLogWriter : IAsyncDisposable
         lock (fileLock)
         {
             var line = entry.Format(_options.TimestampFormat) + Environment.NewLine;
-            File.AppendAllText(filePath, line, Encoding.UTF8);
+
+            // Wie vorher File.AppendAllText mit UTF-8: Die Präambel steht nur am Anfang
+            // einer neuen Datei, weil der StreamWriter sie nur bei Position 0 schreibt.
+            using var stream = OwnerOnlyFile.OpenAppend(filePath);
+            using var writer = new StreamWriter(stream, Encoding.UTF8);
+            writer.Write(line);
         }
     }
 
diff --git a/src/ClawdDotNet.Core/Storage/AtomicFile.cs b/src/ClawdDotNet.Core/Storage/AtomicFile.cs
index ae800a3..14cef50 100644
--- a/src/ClawdDotNet.Core/Storage/AtomicFile.cs
+++ b/src/ClawdDotNet.Core/Storage/AtomicFile.cs
@@ -139,8 +139,13 @@ public static class AtomicFile
         return (fullPath, tempPath);
     }
 
+    /// <summary>
+    /// Die Nebendatei ersetzt die Zieldatei — und mit ihr deren Rechte. Deshalb entsteht sie
+    /// unter Unix mit <c>0600</c> (#575); mit der Standardmaske wurde aus einer geschützten
+    /// <c>InstanceSettings.json</c> beim ersten Speichern eine für die Gruppe lesbare.
+    /// </summary>
     private static FileStream CreateTempStream(string tempPath)
-        => new(tempPath, FileMode.CreateNew, FileAccess.Write, FileShare.None);
+        => new(tempPath, OwnerOnlyFile.Options(FileMode.CreateNew, FileAccess.Write, FileShare.None));
 
     /// <summary>Versuche für das Ersetzen — siehe <see cref="Commit"/>.</summary>
     private const int CommitAttempts = 20;
diff --git a/src/ClawdDotNet.Core/Storage/OwnerOnlyFile.cs b/src/ClawdDotNet.Core/Storage/OwnerOnlyFile.cs
new file mode 100644
index 0000000..89100d7
--- /dev/null
+++ b/src/ClawdDotNet.Core/Storage/OwnerOnlyFile.cs
@@ -0,0 +1,35 @@
+namespace ClawdDotNet.Core.Storage;
+
+/// <summary>
+/// Legt Dateien so an, dass sie unter Unix von Anfang an nur dem Besitzer gehören (#575).
+///
+/// <para><b>Warum beim Anlegen und nicht hinterher.</b> .NET erzeugt neue Dateien mit
+/// <c>0666 &amp; ~umask</c> — auf Ubuntu mit der Maske <c>0002</c> also <c>0664</c>. Ein
+/// nachträgliches <see cref="AppPaths.RestrictToOwner"/> lässt ein Fenster offen und
+/// wird an jeder neuen Schreibstelle vergessen: <c>InstanceSettings.json</c> ging auf der
+/// Test-VM beim ersten Speichern von <c>0600</c> auf <c>0664</c>.</para>
+///
+/// <para>Unter Windows wirkungslos; dort regelt die Vererbung aus dem Profil die Rechte.</para>
+/// </summary>
+public static class OwnerOnlyFile
+{
+    private const UnixFileMode OwnerReadWrite = UnixFileMode.UserRead | UnixFileMode.UserWrite;
+
+    /// <summary>Öffnungsangaben, die eine neu entstehende Datei auf <c>0600</c> setzen.</summary>
+    public static FileStreamOptions Options(FileMode mode, FileAccess access, FileShare share)
+    {
+        var options = new FileStreamOptions { Mode = mode, Access = access, Share = share };
+
+        if (!OperatingSystem.IsWindows())
+            options.UnixCreateMode = OwnerReadWrite;
+
+        return options;
+    }
+
+    /// <summary>
+    /// Öffnet zum Anhängen. Eine vorhandene Datei behält ihre Rechte — nur was hier neu
+    /// entsteht, gehört dem Besitzer allein.
+    /// </summary>
+    public static FileStream OpenAppend(string path)
+        => new(path, Options(FileMode.Append, FileAccess.Write, FileShare.Read));
+}
diff --git a/src/ClawdDotNet.Core/Storage/SqliteStorage.cs b/src/ClawdDotNet.Core/Storage/SqliteStorage.cs
index 2738853..9a87ee8 100644
--- a/src/ClawdDotNet.Core/Storage/SqliteStorage.cs
+++ b/src/ClawdDotNet.Core/Storage/SqliteStorage.cs
@@ -39,6 +39,16 @@ public sealed class SqliteStorage
         }.ToString();
 
         Initialize();
+
+        // #575: SQLite legt die Datenbank mit der Standardmaske an (auf der Test-VM 0644),
+        // und WAL- und Shared-Memory-Datei erben deren Rechte. Darin stehen Chatverläufe,
+        // Gedächtnis und die Argumente jedes Werkzeugaufrufs. Auch für bestehende Dateien,
+        // die noch aus der Zeit vor dieser Zeile stammen.
+        foreach (var datei in new[] { databasePath, databasePath + "-wal", databasePath + "-shm" })
+        {
+            if (File.Exists(datei))
+                AppPaths.RestrictToOwner(datei);
+        }
     }
 
     public SqliteConnection OpenConnection()
diff --git a/src/ClawdDotNet.Core/Tasks/EngineTaskDispatcher.cs b/src/ClawdDotNet.Core/Tasks/EngineTaskDispatcher.cs
index cc539c6..de1ed35 100644
--- a/src/ClawdDotNet.Core/Tasks/EngineTaskDispatcher.cs
+++ b/src/ClawdDotNet.Core/Tasks/EngineTaskDispatcher.cs
@@ -1,6 +1,7 @@
 using System.Text;
 using ClawdDotNet.Core.Config;
 using ClawdDotNet.Core.Engine;
+using ClawdDotNet.Core.Scheduling;
 using ClawdDotNet.Core.State;
 using ClawdDotNet.Core.Tools;
 using Microsoft.Extensions.Logging;
@@ -28,6 +29,7 @@ public sealed class EngineTaskDispatcher : ITaskDispatcher
     private readonly ToolRegistry _toolRegistry;
     private readonly IStateStore _stateStore;
     private readonly ILogger _logger;
+    private readonly TimeProvider _clock;
 
     public EngineTaskDispatcher(
         AgentEngine engine,
@@ -35,7 +37,8 @@ public sealed class EngineTaskDispatcher : ITaskDispatcher
         string instanceId,
         ToolRegistry toolRegistry,
         IStateStore stateStore,
-        ILoggerFactory loggerFactory)
+        ILoggerFactory loggerFactory,
+        TimeProvider? clock = null)
     {
         _engine = engine;
         _agents = agents;
@@ -43,6 +46,7 @@ public sealed class EngineTaskDispatcher : ITaskDispatcher
         _toolRegistry = toolRegistry;
         _stateStore = stateStore;
         _logger = loggerFactory.CreateLogger("ClawdDotNet.Core.Tasks.Dispatcher");
+        _clock = clock ?? TimeProvider.System;
     }
 
     public async Task<bool> DispatchAsync(TaskItem task, CancellationToken ct)
@@ -148,11 +152,16 @@ public sealed class EngineTaskDispatcher : ITaskDispatcher
         return agents.Count == 1 ? agents[0] : null;
     }
 
-    private static string BuildMessage(TaskItem task)
+    internal string BuildMessage(TaskItem task)
     {
         var sb = new StringBuilder();
         sb.AppendLine($"[Aufgabe {task.Id}] {task.Title}");
 
+        // #589: Weder Systemprompt noch Auftrag nannten bisher die Zeit. Fast jede
+        // wiederkehrende Aufgabe braucht sie (Dateiname je Tag, "Bericht ueber gestern"),
+        // und ein Modell ohne diese Zeile raet aus seinem Trainingsstand.
+        sb.AppendLine(Zeitangabe(task, _clock.GetUtcNow()));
+
         if (!string.IsNullOrWhiteSpace(task.Body))
         {
             sb.AppendLine();
@@ -168,4 +177,33 @@ public sealed class EngineTaskDispatcher : ITaskDispatcher
 
         return sb.ToString().TrimEnd();
     }
+
+    /// <summary>
+    /// Aktuelle Zeit in der Zeitzone der Aufgabe (sonst der des Systems), dazu UTC und -
+    /// bei wiederkehrenden Aufgaben - der Termin selbst.
+    /// </summary>
+    internal static string Zeitangabe(TaskItem task, DateTimeOffset jetzt)
+    {
+        var zoneId = string.IsNullOrWhiteSpace(task.When?.TimeZone) ? TimeZones.LocalIanaId : task.When!.TimeZone;
+        TimeZoneInfo zone;
+        try
+        {
+            zone = TimeZoneInfo.FindSystemTimeZoneById(zoneId);
+        }
+        catch (Exception ex) when (ex is TimeZoneNotFoundException or InvalidTimeZoneException)
+        {
+            zone = TimeZoneInfo.Local;
+            zoneId = TimeZones.LocalIanaId;
+        }
+
+        var lokal = TimeZoneInfo.ConvertTime(jetzt, zone);
+        var invariant = System.Globalization.CultureInfo.InvariantCulture;
+        var zeile = string.Format(invariant,
+            "Aktuelle Zeit: {0:dd.MM.yyyy HH:mm} Uhr ({1}, UTC{0:zzz}); in UTC {2:yyyy-MM-ddTHH:mm}Z.",
+            lokal, zoneId, jetzt.UtcDateTime);
+
+        return task.When is { } when
+            ? zeile + $" Termin der Aufgabe: {when.Kind.ToString().ToLowerInvariant()} \"{when.Value}\"."
+            : zeile;
+    }
 }
diff --git a/src/ClawdDotNet.Desktop/App.axaml.cs b/src/ClawdDotNet.Desktop/App.axaml.cs
index d622925..26e002a 100644
--- a/src/ClawdDotNet.Desktop/App.axaml.cs
+++ b/src/ClawdDotNet.Desktop/App.axaml.cs
@@ -46,6 +46,56 @@ public partial class App : Application
     /// </summary>
     private bool _managed;
 
+    // #576: Muessen leben, solange die Anwendung laeuft - eine eingesammelte
+    // Registrierung meldet sich ab.
+    private System.Runtime.InteropServices.PosixSignalRegistration? _sigterm;
+    private System.Runtime.InteropServices.PosixSignalRegistration? _sigint;
+
+    /// <summary>
+    /// SIGTERM und SIGINT beenden auch mit Fenster geordnet (#576).
+    ///
+    /// <para>Kopflos war das seit HeadlessRun verdrahtet, mit Fenster nicht: Unter Linux
+    /// reagierte die Instanz auf SIGTERM gar nicht und wurde nach Ablauf jeder Frist hart
+    /// abgeschossen - beim Abmelden, bei systemctl stop, beim Herunterfahren. Derselbe Weg
+    /// wie die Bitte des Instanzmanagers: das Fenster ohne Rueckfrage schliessen, das
+    /// geordnete Ende laeuft von dort.</para>
+    /// </summary>
+    private void RegisterSignals(IClassicDesktopStyleApplicationLifetime desktop)
+    {
+        void Beenden(System.Runtime.InteropServices.PosixSignalContext context)
+        {
+            // Abfangen, nicht durchlassen: Sonst raeumte die Laufzeit den Prozess ab,
+            // waehrend das geordnete Ende noch laeuft.
+            context.Cancel = true;
+            var signal = context.Signal.ToString();
+
+            Dispatcher.UIThread.Post(() =>
+            {
+                _host?.LoggerFactory.CreateLogger("ClawdDotNet.Shutdown")
+                    .LogInformation("Signal {Signal} empfangen - die Instanz endet geordnet.", signal);
+
+                if (_host is null)
+                    desktop.Shutdown();
+                else if (desktop.MainWindow is MainWindow fenster)
+                    fenster.BeendenOhneRueckfrage();
+                else
+                    _ = BeendeGeordnetAsync(desktop, signal);
+            });
+        }
+
+        try
+        {
+            _sigterm = System.Runtime.InteropServices.PosixSignalRegistration.Create(
+                System.Runtime.InteropServices.PosixSignal.SIGTERM, Beenden);
+            _sigint = System.Runtime.InteropServices.PosixSignalRegistration.Create(
+                System.Runtime.InteropServices.PosixSignal.SIGINT, Beenden);
+        }
+        catch (PlatformNotSupportedException)
+        {
+            // Ohne Signale bleibt es beim Schliessen ueber Fenster und Manager.
+        }
+    }
+
     public override void Initialize() => AvaloniaXamlLoader.Load(this);
 
     public override void OnFrameworkInitializationCompleted()
@@ -71,6 +121,8 @@ public partial class App : Application
                 if (_host is not null) await _host.DisposeAsync();
             };
 
+            RegisterSignals(desktop);
+
             // Nicht abwarten: OnFrameworkInitializationCompleted muss zurückkehren,
             // damit die Nachrichtenschleife anläuft — sonst gäbe es keinen Faden, auf
             // dem die Fenster des Startvorgangs überhaupt erscheinen könnten.
diff --git a/src/ClawdDotNet.Manager.Web/wwwroot/views/agent-chats.js b/src/ClawdDotNet.Manager.Web/wwwroot/views/agent-chats.js
index 65d437d..f0275d2 100644
--- a/src/ClawdDotNet.Manager.Web/wwwroot/views/agent-chats.js
+++ b/src/ClawdDotNet.Manager.Web/wwwroot/views/agent-chats.js
@@ -1,8 +1,8 @@
 // ClawdDotNet — Interne Agenten-Kommunikation A2A (Vorhaben #208)
 //
 // Analyse und Protokollierung des Nachrichtenaustauschs zwischen Agenten.
-// - Filterbar nach beteiligten Agenten
-// - Dialog-Timeline zwischen Quelle und Ziel
+// - Filterbar nach beteiligtem Agenten, Zeitraum und Volltext
+// - Jede Zeile trägt Absender ➔ Empfänger — auch Antworten (#536)
 // - Live-Aktualisierung über Server-Sent Events (SSE "chat" mit source === "agentcomm")
 // Strikt DOM API, kein innerHTML.
 
@@ -19,6 +19,30 @@ import {
 
 let sseAbmeldung = null;
 
+const PRAEFIX = "[Nachricht von Agent \"";
+
+/**
+ * Liest aus "[Nachricht von Agent "Name" (id)]\n\nText" Kennung, Name und Text — dieselbe
+ * Regel wie AgentCommunicationBuilder.LeseAbsender auf dem Server (nur für Live-Ereignisse).
+ */
+function leseAbsender(content) {
+  if (!content.startsWith(PRAEFIX)) return { id: null, name: null, inhalt: content };
+
+  let name = null;
+  let id = null;
+  const endQuote = content.indexOf('"', PRAEFIX.length);
+  if (endQuote > PRAEFIX.length) {
+    name = content.slice(PRAEFIX.length, endQuote);
+    const openParen = content.indexOf("(", endQuote);
+    const closeParen = openParen < 0 ? -1 : content.indexOf(")", openParen);
+    if (openParen > 0 && closeParen > openParen) {
+      id = content.slice(openParen + 1, closeParen);
+    }
+  }
+  const doubleNl = content.indexOf("\n\n");
+  return { id, name, inhalt: doubleNl > 0 ? content.slice(doubleNl + 2) : content };
+}
+
 export async function rendereAgentenChats() {
   const container = document.getElementById("ansicht-inhalt");
   if (!container) return;
@@ -44,10 +68,26 @@ export async function rendereAgentenChats() {
   const agentSelect = erstelleElement("select", {
     klasse: "eingabe",
     stil: { minWidth: "180px" },
-    title: "Nach Agent filtern"
+    title: "Nach beteiligtem Agenten filtern (Absender oder Empfänger)"
+  });
+  agentSelect.append(erstelleElement("option", { value: "", text: "Alle Agenten" }));
+
+  const vonEingabe = erstelleElement("input", {
+    klasse: "eingabe",
+    type: "date",
+    title: "Nachrichten ab diesem Tag"
+  });
+  const bisEingabe = erstelleElement("input", {
+    klasse: "eingabe",
+    type: "date",
+    title: "Nachrichten bis einschließlich diesem Tag"
+  });
+  const suchEingabe = erstelleElement("input", {
+    klasse: "eingabe",
+    type: "search",
+    placeholder: "Volltext…",
+    title: "Suche im Nachrichtentext und in den Agentennamen"
   });
-  const optAlle = erstelleElement("option", { value: "", text: "Alle Agenten" });
-  agentSelect.append(optAlle);
 
   const aktualisierenBtn = erstelleElement(
     "button",
@@ -60,7 +100,15 @@ export async function rendereAgentenChats() {
     erstelleElement("span", { text: " Aktualisieren" })
   );
 
-  filterGruppe.append(agentSelect, aktualisierenBtn);
+  filterGruppe.append(
+    agentSelect,
+    erstelleElement("span", { klasse: "gedaempft", text: "von" }),
+    vonEingabe,
+    erstelleElement("span", { klasse: "gedaempft", text: "bis" }),
+    bisEingabe,
+    suchEingabe,
+    aktualisierenBtn
+  );
   kopf.append(titelGruppe, filterGruppe);
   layout.append(kopf);
 
@@ -81,37 +129,41 @@ export async function rendereAgentenChats() {
   const infoKarte = erstelleKarte("Interne Kommunikation", [
     erstelleElement("p", {
       klasse: "gedaempft",
-      text: "Hier wird der direkte Nachrichtenaustausch zwischen Agenten (A2A) protokolliert, wenn Agenten über das Werkzeug 'SendMessage' miteinander interagieren."
+      text: "Hier wird der direkte Nachrichtenaustausch zwischen Agenten protokolliert, wenn Agenten über das Werkzeug AgentComm (Aktion send_message) miteinander sprechen."
     })
   ]);
   layout.append(infoKarte);
 
   // Verlauf-Container
+  const trefferZeile = erstelleElement("p", { klasse: "gedaempft text-klein", text: "" });
   const verlaufContainer = erstelleElement("div", { klasse: "a2a-timeline" });
-  layout.append(verlaufContainer);
+  layout.append(trefferZeile, verlaufContainer);
   container.append(layout);
 
   let alleNachrichten = [];
   let agentenListe = [];
 
+  // Wer hat einen Agenten zuletzt angeschrieben? Für die Empfänger live eintreffender Antworten.
+  const letzterFragender = new Map();
+
   // Agenten laden für Filter
   try {
     const agenten = await api("/agents");
     agentenListe = Array.isArray(agenten) ? agenten : [];
     for (const a of agentenListe) {
-      const opt = erstelleElement("option", {
+      agentSelect.append(erstelleElement("option", {
         value: a.agentId,
         text: a.displayName || a.agentId
-      });
-      agentSelect.append(opt);
+      }));
     }
   } catch {
     // Wenn Agenten nicht ladbar sind, Filter leer lassen
   }
 
-  agentSelect.addEventListener("change", () => {
-    rendereNachrichten();
-  });
+  for (const eingabe of [agentSelect, vonEingabe, bisEingabe]) {
+    eingabe.addEventListener("change", () => rendereNachrichten());
+  }
+  suchEingabe.addEventListener("input", () => rendereNachrichten());
 
   async function ladeVerlauf() {
     verlaufContainer.replaceChildren(
@@ -121,6 +173,11 @@ export async function rendereAgentenChats() {
     try {
       const daten = await api("/agents/communications");
       alleNachrichten = Array.isArray(daten) ? daten : [];
+      for (const m of alleNachrichten) {
+        if (m.role === "user" && m.sourceAgentId) {
+          letzterFragender.set(m.targetAgentId, { id: m.sourceAgentId, name: m.sourceAgentName });
+        }
+      }
       rendereNachrichten();
     } catch (err) {
       verlaufContainer.replaceChildren(
@@ -134,23 +191,41 @@ export async function rendereAgentenChats() {
     }
   }
 
+  function passtZumFilter(m) {
+    const agent = agentSelect.value;
+    if (agent && m.targetAgentId !== agent && m.sourceAgentId !== agent) return false;
+
+    // Die Datumsfelder liefern "JJJJ-MM-TT" im Ortskalender; verglichen wird der lokale Tag.
+    const zeit = new Date(m.timestamp);
+    if (vonEingabe.value && zeit < new Date(`${vonEingabe.value}T00:00:00`)) return false;
+    if (bisEingabe.value && zeit > new Date(`${bisEingabe.value}T23:59:59.999`)) return false;
+
+    const suche = suchEingabe.value.trim().toLowerCase();
+    if (suche) {
+      const heuhaufen = [
+        m.content, m.sourceAgentName, m.sourceAgentId, m.targetAgentName, m.targetAgentId
+      ].filter(Boolean).join(" ").toLowerCase();
+      if (!heuhaufen.includes(suche)) return false;
+    }
+
+    return true;
+  }
+
   function rendereNachrichten() {
-    const gewaehlterAgent = agentSelect.value;
-    const gefiltert = gewaehlterAgent
-      ? alleNachrichten.filter(
-          (m) =>
-            m.targetAgentId === gewaehlterAgent ||
-            m.sourceAgentId === gewaehlterAgent
-        )
-      : alleNachrichten;
+    const gefiltert = alleNachrichten.filter(passtZumFilter);
+    const filterAktiv = agentSelect.value || vonEingabe.value || bisEingabe.value || suchEingabe.value.trim();
+
+    trefferZeile.textContent = filterAktiv
+      ? `${gefiltert.length} von ${alleNachrichten.length} Nachrichten`
+      : `${alleNachrichten.length} Nachrichten`;
 
     if (gefiltert.length === 0) {
       verlaufContainer.replaceChildren(
         erstelleKarte("Keine Nachrichten", [
           erstelleElement("p", {
             klasse: "gedaempft",
-            text: gewaehlterAgent
-              ? "Für den ausgewählten Agenten liegt noch keine interne Kommunikation vor."
+            text: filterAktiv
+              ? "Für diese Filter liegt keine interne Kommunikation vor."
               : "In dieser Instanz wurde bisher keine interne Agent-zu-Agent-Kommunikation protokolliert."
           })
         ])
@@ -158,12 +233,7 @@ export async function rendereAgentenChats() {
       return;
     }
 
-    verlaufContainer.replaceChildren();
-
-    for (const m of gefiltert) {
-      const eintrag = erstelleNachrichtElement(m);
-      verlaufContainer.append(eintrag);
-    }
+    verlaufContainer.replaceChildren(...gefiltert.map(erstelleNachrichtElement));
   }
 
   function erstelleNachrichtElement(m) {
@@ -175,22 +245,14 @@ export async function rendereAgentenChats() {
     const kopf = erstelleElement("div", { klasse: "a2a-eintrag-kopf" });
     const absenderGruppe = erstelleElement("div", { klasse: "gruppe-horizontal" });
 
-    if (istAntwort) {
-      // Antwort vom Zielagenten
-      absenderGruppe.append(
-        erstellePlakette(m.targetAgentName || m.targetAgentId, "erfolg"),
-        erstelleElement("span", { klasse: "a2a-pfeil", text: "➔ Antwort" })
-      );
-    } else {
-      // Anfrage/Nachricht von Quelle an Ziel
-      const quelleName = m.sourceAgentName || m.sourceAgentId || "Agent";
-      const zielName = m.targetAgentName || m.targetAgentId;
-      absenderGruppe.append(
-        erstellePlakette(quelleName, "neutral"),
-        erstelleElement("span", { klasse: "a2a-pfeil", text: "➔" }),
-        erstellePlakette(zielName, "primaer")
-      );
-    }
+    const quelleName = m.sourceAgentName || m.sourceAgentId || "unbekannt";
+    const zielName = m.targetAgentName || m.targetAgentId || "unbekannt";
+
+    absenderGruppe.append(
+      erstellePlakette(quelleName, istAntwort ? "erfolg" : "neutral"),
+      erstelleElement("span", { klasse: "a2a-pfeil", text: istAntwort ? "➔ Antwort an" : "➔" }),
+      erstellePlakette(zielName, istAntwort ? "neutral" : "primaer")
+    );
 
     const zeit = erstelleElement("span", {
       klasse: "a2a-zeit",
@@ -210,57 +272,41 @@ export async function rendereAgentenChats() {
 
   // SSE Live-Aktualisierung
   sseAbmeldung = abonnieren("chat", (daten) => {
-    if (daten?.source === "agentcomm") {
-      // Neue Nachricht kam live herein: an die Liste anhängen
-      const zielAgent = agentenListe.find((a) => a.agentId === daten.agentId);
-      const zielName = zielAgent ? zielAgent.displayName : daten.agentId;
+    if (daten?.source !== "agentcomm") return;
 
-      let senderId = null;
-      let senderName = null;
-      let content = daten.content || "";
+    const agent = agentenListe.find((a) => a.agentId === daten.agentId);
+    const agentName = agent ? agent.displayName : daten.agentId;
+    let neueNachricht;
 
-      if (daten.role === "user" && content.startsWith("[Nachricht von Agent \"")) {
-        const endQuote = content.indexOf('"', 22);
-        if (endQuote > 22) {
-          senderName = content.slice(22, endQuote);
-          const openParen = content.indexOf("(", endQuote);
-          const closeParen = content.indexOf(")", openParen);
-          if (openParen > 0 && closeParen > openParen) {
-            senderId = content.slice(openParen + 1, closeParen);
-          }
-        }
-        const doubleNl = content.indexOf("\n\n");
-        if (doubleNl > 0) {
-          content = content.slice(doubleNl + 2);
-        }
-      }
-
-      const neueNachricht = {
+    if (daten.role === "user") {
+      const { id, name, inhalt } = leseAbsender(daten.content || "");
+      if (id) letzterFragender.set(daten.agentId, { id, name });
+      neueNachricht = {
         targetAgentId: daten.agentId,
-        targetAgentName: zielName,
-        sourceAgentId: senderId,
-        sourceAgentName: senderName,
+        targetAgentName: agentName,
+        sourceAgentId: id,
+        sourceAgentName: name,
         role: daten.role,
-        content: content,
+        content: inhalt,
         timestamp: daten.timestamp || new Date().toISOString()
       };
-
-      alleNachrichten.push(neueNachricht);
-
-      const gewaehlterAgent = agentSelect.value;
-      if (
-        !gewaehlterAgent ||
-        neueNachricht.targetAgentId === gewaehlterAgent ||
-        neueNachricht.sourceAgentId === gewaehlterAgent
-      ) {
-        // Falls vorher "Keine Nachrichten" da stand:
-        const leerKarte = verlaufContainer.querySelector(".karte");
-        if (leerKarte) verlaufContainer.replaceChildren();
-
-        const el = erstelleNachrichtElement(neueNachricht);
-        verlaufContainer.append(el);
-      }
+    } else if (daten.role === "assistant") {
+      const fragender = letzterFragender.get(daten.agentId);
+      neueNachricht = {
+        targetAgentId: fragender?.id || "",
+        targetAgentName: fragender?.name || fragender?.id || "",
+        sourceAgentId: daten.agentId,
+        sourceAgentName: agentName,
+        role: daten.role,
+        content: daten.content || "",
+        timestamp: daten.timestamp || new Date().toISOString()
+      };
+    } else {
+      return;
     }
+
+    alleNachrichten.push(neueNachricht);
+    rendereNachrichten();
   });
 
   ladeVerlauf();
diff --git a/src/ClawdDotNet.Manager.Web/wwwroot/views/agents.js b/src/ClawdDotNet.Manager.Web/wwwroot/views/agents.js
index af4e0d7..2793638 100644
--- a/src/ClawdDotNet.Manager.Web/wwwroot/views/agents.js
+++ b/src/ClawdDotNet.Manager.Web/wwwroot/views/agents.js
@@ -215,7 +215,7 @@ async function rendereDetails(agentId) {
       const zeile = erstelleElement("div", { klasse: "werkzeug-zeile" });
 
       const links = erstelleElement("div", { klasse: "werkzeug-info" });
-      const toolTitel = erstelleElement("strong", { text: tool.toolName });
+      const toolTitel = erstelleElement("strong", { text: tool.name });
       const toolDesc = erstelleElement("div", {
         klasse: "werkzeug-beschreibung gedaempft",
         text: tool.description || ""
@@ -229,7 +229,7 @@ async function rendereDetails(agentId) {
         {
           klasse: "schaltflaeche flach klein",
           title: "Werkzeug-Einstellungen einsehen",
-          onclick: () => zeigeWerkzeugEinstellungen(agent.agentId, tool.toolName)
+          onclick: () => zeigeWerkzeugEinstellungen(agent.agentId, tool.name)
         },
         erstelleIcon(PFADE.einstellungen, 14),
         erstelleElement("span", { text: " Konfiguration" })
@@ -243,11 +243,11 @@ async function rendereDetails(agentId) {
           const aktiv = e.target.checked;
           try {
             await api(
-              `/agents/${encodeURIComponent(agent.agentId)}/tools/${encodeURIComponent(tool.toolName)}?enabled=${aktiv}`,
+              `/agents/${encodeURIComponent(agent.agentId)}/tools/${encodeURIComponent(tool.name)}?enabled=${aktiv}`,
               { method: "PUT" }
             );
             tool.enabled = aktiv;
-            zeigeMeldung(`Werkzeug '${tool.toolName}' ${aktiv ? "aktiviert" : "deaktiviert"}.`, "info");
+            zeigeMeldung(`Werkzeug '${tool.name}' ${aktiv ? "aktiviert" : "deaktiviert"}.`, "info");
           } catch (err) {
             e.target.checked = !aktiv;
             zeigeMeldung(`Änderung fehlgeschlagen: ${err.message}`, "gefahr");
diff --git a/src/ClawdDotNet.Manager.Web/wwwroot/views/chat.js b/src/ClawdDotNet.Manager.Web/wwwroot/views/chat.js
index 3f56946..6500f95 100644
--- a/src/ClawdDotNet.Manager.Web/wwwroot/views/chat.js
+++ b/src/ClawdDotNet.Manager.Web/wwwroot/views/chat.js
@@ -24,14 +24,25 @@ let agentenSelector = null;
 let statusPlakette = null;
 let entladeEreignisse = [];
 
+// #592: Zählt die Aufbauten dieser Ansicht. Ein Aufbau, der während seines await von
+// einem neueren überholt wurde, meldet keine Ereignisse mehr an — sonst hingen zwei
+// "chat"-Listener und jede Nachricht erschien doppelt.
+let aufbauZaehler = 0;
+
+function raeumeEreignisseAuf() {
+  entladeEreignisse.forEach((cleanup) => cleanup());
+  entladeEreignisse = [];
+}
+
 export async function rendereChat(parameter = {}) {
   const container = document.getElementById("ansicht-inhalt");
   if (!container) return;
   container.replaceChildren();
 
+  const dieserAufbau = ++aufbauZaehler;
+
   // Alte Ereignisse aufräumen
-  entladeEreignisse.forEach((cleanup) => cleanup());
-  entladeEreignisse = [];
+  raeumeEreignisseAuf();
 
   const chatShell = erstelleElement("div", { klasse: "chat-ansicht" });
 
@@ -128,6 +139,12 @@ export async function rendereChat(parameter = {}) {
   // Lade Agenten und initialisiere
   await ladeAgenten(parameter.agentId);
 
+  // Während des Ladens neu aufgebaut? Dann gehört die Ansicht dem neueren Aufbau.
+  if (dieserAufbau !== aufbauZaehler) return;
+
+  // Falls zwischendurch doch etwas angemeldet wurde: vorher abräumen, nie doppelt.
+  raeumeEreignisseAuf();
+
   // SSE-Abonnements
   entladeEreignisse.push(
     abonnieren("chat", (daten) => {
@@ -203,7 +220,12 @@ async function waehleAgent(agentId) {
   const agent = agentenListe.find((a) => a.agentId === agentId);
   aktualisiereLaufStatus(agent?.isRunning ?? false);
 
-  window.location.hash = `#/chat/${encodeURIComponent(agentId)}`;
+  // Adresse mitführen, ohne hashchange auszulösen (#592): Ein Setzen von location.hash
+  // ließ den Router die ganze Ansicht mitten im Laden ein zweites Mal aufbauen.
+  const ziel = `#/chat/${encodeURIComponent(agentId)}`;
+  if (window.location.hash !== ziel) {
+    history.replaceState(null, "", ziel);
+  }
 
   await ladeChatVerlauf(agentId);
 }
diff --git a/src/ClawdDotNet.Manager.Web/wwwroot/views/logs.js b/src/ClawdDotNet.Manager.Web/wwwroot/views/logs.js
index 28d7a04..01fe248 100644
--- a/src/ClawdDotNet.Manager.Web/wwwroot/views/logs.js
+++ b/src/ClawdDotNet.Manager.Web/wwwroot/views/logs.js
@@ -179,9 +179,19 @@ function starteLogStream() {
   });
 }
 
-function fuegeLogZeileEin(eintrag) {
+function fuegeLogZeileEin(roh) {
   if (!logContainer) return;
 
+  // Seit #591 kommen die Felder klein geschrieben (module/level/text). Instanzen einer
+  // älteren Fassung senden sie noch groß — beide Schreibweisen annehmen, sonst zeigt
+  // die Ansicht bei gemischten Fassungen wieder nur den Instanznamen.
+  const eintrag = {
+    ...roh,
+    module: roh.module ?? roh.Module,
+    level: roh.level ?? roh.Level,
+    text: roh.text ?? roh.Text
+  };
+
   // Filter nach Instanz falls gewählt
   if (instanzFilter && eintrag.instanz && eintrag.instanz !== instanzFilter && eintrag.instanzName !== instanzFilter) {
     return;
diff --git a/src/ClawdDotNet.Manager.Web/wwwroot/views/staging.js b/src/ClawdDotNet.Manager.Web/wwwroot/views/staging.js
index a9dccee..ff94c7f 100644
--- a/src/ClawdDotNet.Manager.Web/wwwroot/views/staging.js
+++ b/src/ClawdDotNet.Manager.Web/wwwroot/views/staging.js
@@ -111,22 +111,24 @@ async function ladeFreigaben() {
         erstelleElement("dt", { text: "Agent" }),
         erstelleElement("dd", { text: anfrage.agentId || "—" }),
         erstelleElement("dt", { text: "Werkzeug" }),
-        erstelleElement("dd", { text: `${anfrage.toolName} → ${anfrage.methodName}` }),
+        erstelleElement("dd", { text: `${anfrage.tool} → ${anfrage.action || "—"}` }),
         erstelleElement("dt", { text: "Zeitpunkt" }),
-        erstelleElement("dd", { text: formatiereDatumZeit(anfrage.requestedAt) })
+        erstelleElement("dd", { text: formatiereDatumZeit(anfrage.createdAt) })
       );
 
       const argBox = erstelleElement("div", { klasse: "staging-argumente" });
       argBox.append(erstelleElement("strong", { text: "Eingefrorene Argumente:" }));
 
-      // Strikt textContent! Argumente können Fremdtext sein
+      // Strikt textContent! Argumente können Fremdtext sein.
+      // Die API liefert sie als rohe Zeichenkette (argumentsJson) — genau das, was bei
+      // Freigabe ausgeführt würde. Lesbar eingerückt, wenn es gültiges JSON ist; sonst roh.
       const pre = erstelleElement("pre", {
         klasse: "code-block",
-        text: JSON.stringify(anfrage.arguments, null, 2)
+        text: formatiereArgumente(anfrage.argumentsJson)
       });
       argBox.append(pre);
 
-      const karte = erstelleKarte(`${anfrage.toolName}.${anfrage.methodName}`, [datenliste, argBox], {
+      const karte = erstelleKarte(`${anfrage.tool}.${anfrage.action || "?"}`, [datenliste, argBox], {
         aktionen: kopfAktionen
       });
 
@@ -144,6 +146,19 @@ async function ladeFreigaben() {
   }
 }
 
+/**
+ * Die eingefrorenen Argumente lesbar machen, ohne sie zu verändern: eingerückt, wenn es
+ * gültiges JSON ist, sonst genau die Zeichenkette, die ausgeführt würde.
+ */
+function formatiereArgumente(argumentsJson) {
+  if (!argumentsJson) return "(keine)";
+  try {
+    return JSON.stringify(JSON.parse(argumentsJson), null, 2);
+  } catch {
+    return argumentsJson;
+  }
+}
+
 function aktualisiereStagingBadge(anzahl) {
   const badge = document.getElementById("staging-badge");
   if (!badge) return;
diff --git a/src/ClawdDotNet.Manager.Web/wwwroot/views/tasks.js b/src/ClawdDotNet.Manager.Web/wwwroot/views/tasks.js
index 1e73bb4..dcbd1ba 100644
--- a/src/ClawdDotNet.Manager.Web/wwwroot/views/tasks.js
+++ b/src/ClawdDotNet.Manager.Web/wwwroot/views/tasks.js
@@ -91,6 +91,10 @@ async function ladeAktivenBereich() {
   if (!container) return;
   container.replaceChildren();
 
+  // "Neuer Job" gehoert nur zum Jobs-Reiter; im Taskboard legte er trotzdem einen Job an (#591).
+  const neuerJob = document.querySelector(".aufgaben-ansicht .ansicht-kopf .schaltflaeche.primaer");
+  if (neuerJob) neuerJob.hidden = aktiverReiter !== "jobs";
+
   if (aktiverReiter === "jobs") {
     await rendereJobs(container);
   } else {
@@ -369,7 +373,13 @@ async function rendereTaskboard(container) {
 
     for (const task of tasks) {
       const karte = erstelleKarte(task.title || `Aufgabe ${task.id}`, [
-        erstelleElement("p", { klasse: "gedaempft text-klein", text: `ID: ${task.id} · Agent: ${task.agentId || "—"}` }),
+        erstelleElement("p", { klasse: "gedaempft text-klein", text: `ID: ${task.id} · Agent: ${task.assignee || "—"}` }),
+        erstelleElement("p", {
+          klasse: "gedaempft text-klein",
+          text: task.when
+            ? `Termin: ${task.when.kind} ${task.when.value} (${task.when.timeZone || "ohne Zeitzone"})`
+            : "Termin: einmalig"
+        }),
         erstelleElement("div", {
           klasse: "task-status-zeile",
           stil: "margin-top: 8px;"
diff --git a/src/ClawdDotNet.Manager.Web/wwwroot/views/usage.js b/src/ClawdDotNet.Manager.Web/wwwroot/views/usage.js
index 04e3830..e5e5cda 100644
--- a/src/ClawdDotNet.Manager.Web/wwwroot/views/usage.js
+++ b/src/ClawdDotNet.Manager.Web/wwwroot/views/usage.js
@@ -1,6 +1,10 @@
 // ClawdDotNet — Token-Verbrauch & Analyse
 //
 // Diagramme (CSS/DOM-Balken ohne externe Bibliothek), Statistiken und Läufetabelle.
+//
+// Feldnamen wie UsageDto (#591): costUsd, costIsKnown, occurredAt, status. Eine
+// Gesamtsumme liefert die API nicht — sie ist Prompt + Completion. Vorher las die Ansicht
+// totalTokens, cost und timestamp und zeigte überall 0 bzw. "—".
 
 import { api } from "../modules/api.js";
 import {
@@ -26,6 +30,10 @@ export async function rendereVerbrauch() {
   await ladeVerbrauch();
 }
 
+function gesamtTokens(lauf) {
+  return (lauf.promptTokens || 0) + (lauf.completionTokens || 0);
+}
+
 async function ladeVerbrauch() {
   const container = document.getElementById("verbrauch-inhalt-bereich");
   if (!container) return;
@@ -55,32 +63,45 @@ async function ladeVerbrauch() {
     let summePrompt = 0;
     let summeCompletion = 0;
     let summeKosten = 0;
+    let unbekannteKosten = 0;
     const nachAgent = new Map();
     const nachModell = new Map();
 
     for (const l of laeufe) {
-      summeTokens += l.totalTokens || 0;
+      const tokens = gesamtTokens(l);
+      summeTokens += tokens;
       summePrompt += l.promptTokens || 0;
       summeCompletion += l.completionTokens || 0;
-      summeKosten += Number(l.cost || 0);
+      summeKosten += Number(l.costUsd || 0);
+      if (!l.costIsKnown) unbekannteKosten++;
 
       const agentKey = l.agentId || "Unbekannt";
-      nachAgent.set(agentKey, (nachAgent.get(agentKey) || 0) + (l.totalTokens || 0));
+      nachAgent.set(agentKey, (nachAgent.get(agentKey) || 0) + tokens);
 
       const modellKey = l.model || "Unbekannt";
-      nachModell.set(modellKey, (nachModell.get(modellKey) || 0) + (l.totalTokens || 0));
+      nachModell.set(modellKey, (nachModell.get(modellKey) || 0) + tokens);
     }
 
     // 1. Kacheln (Statistiken)
     const kachelGitter = erstelleElement("div", { klasse: "kachel-gitter" });
 
     kachelGitter.append(
-      erstelleStatKachel("Gesamtkosten (100 Läufe)", formatiereKosten(summeKosten)),
+      erstelleStatKachel(`Gesamtkosten (${laeufe.length} Läufe)`, formatiereKosten(summeKosten)),
       erstelleStatKachel("Tokens gesamt", formatiereTokens(summeTokens)),
       erstelleStatKachel("Eingabe-Tokens (Prompt)", formatiereTokens(summePrompt)),
       erstelleStatKachel("Ausgabe-Tokens (Completion)", formatiereTokens(summeCompletion))
     );
 
+    const hinweise = [];
+    if (unbekannteKosten > 0) {
+      hinweise.push(
+        erstelleElement("p", {
+          klasse: "gedaempft text-klein",
+          text: `${unbekannteKosten} Lauf/Läufe ohne bekannten Preis — deren Kosten sind in der Summe nicht enthalten.`
+        })
+      );
+    }
+
     // 2. Balkendiagramme (rein CSS/DOM)
     const diagrammGitter = erstelleElement("div", { klasse: "diagramm-gitter" });
 
@@ -99,6 +120,7 @@ async function ladeVerbrauch() {
         erstelleElement("th", { text: "Zeitpunkt" }),
         erstelleElement("th", { text: "Agent" }),
         erstelleElement("th", { text: "Modell" }),
+        erstelleElement("th", { text: "Status" }),
         erstelleElement("th", { text: "Prompt", stil: "text-align: right;" }),
         erstelleElement("th", { text: "Completion", stil: "text-align: right;" }),
         erstelleElement("th", { text: "Gesamt", stil: "text-align: right;" }),
@@ -109,15 +131,20 @@ async function ladeVerbrauch() {
     const tbody = erstelleElement("tbody");
 
     for (const lauf of laeufe) {
+      const kosten = lauf.costIsKnown
+        ? formatiereKosten(lauf.costUsd)
+        : `${formatiereKosten(lauf.costUsd)} (Preis unbekannt)`;
+
       const tr = erstelleElement("tr");
       tr.append(
-        erstelleElement("td", { text: formatiereDatumZeit(lauf.timestamp) }),
+        erstelleElement("td", { text: formatiereDatumZeit(lauf.occurredAt) }),
         erstelleElement("td", {}, erstelleElement("strong", { text: lauf.agentId })),
         erstelleElement("td", { klasse: "gedaempft text-klein", text: lauf.model }),
+        erstelleElement("td", { klasse: "text-klein", text: lauf.status || "—" }),
         erstelleElement("td", { stil: "text-align: right;", text: formatiereTokens(lauf.promptTokens) }),
         erstelleElement("td", { stil: "text-align: right;", text: formatiereTokens(lauf.completionTokens) }),
-        erstelleElement("td", { stil: "text-align: right;", text: formatiereTokens(lauf.totalTokens) }),
-        erstelleElement("td", { stil: "text-align: right;", text: formatiereKosten(lauf.cost) })
+        erstelleElement("td", { stil: "text-align: right;", text: formatiereTokens(gesamtTokens(lauf)) }),
+        erstelleElement("td", { stil: "text-align: right;", text: kosten })
       );
       tbody.append(tr);
     }
@@ -125,7 +152,7 @@ async function ladeVerbrauch() {
     tabelle.append(thead, tbody);
     tabelleKarte.append(tabelle);
 
-    container.append(kachelGitter, diagrammGitter, tabelleKarte);
+    container.append(kachelGitter, ...hinweise, diagrammGitter, tabelleKarte);
   } catch (err) {
     container.replaceChildren(
       erstelleKarte("Verbrauchsdaten nicht verfügbar", [
diff --git a/src/ClawdDotNet.Tools.FileRW/FileRWTool.cs b/src/ClawdDotNet.Tools.FileRW/FileRWTool.cs
index ccd7b9c..f369632 100644
--- a/src/ClawdDotNet.Tools.FileRW/FileRWTool.cs
+++ b/src/ClawdDotNet.Tools.FileRW/FileRWTool.cs
@@ -378,7 +378,10 @@ public sealed class FileRWTool : IAgentTool, IToolStateProbe
             // die ganze Datei neu geschrieben wird — bei einer großen Protokolldatei wäre
             // das der falsche Handel. Hier bleibt ein Riss möglich; genau dafür gibt es
             // die Zustandsprüfung in #555.
-            await File.AppendAllTextAsync(path, content, new UTF8Encoding(false), ct);
+            // #575: Neu entstehende Dateien gehoeren nur dem Besitzer (0600).
+            await using (var stream = ClawdDotNet.Core.Storage.OwnerOnlyFile.OpenAppend(path))
+            await using (var writer = new StreamWriter(stream, new UTF8Encoding(false)))
+                await writer.WriteAsync(content.AsMemory(), ct);
             return ToolResult.Ok($"[{workspace} Workspace] Inhalt erfolgreich angehängt an: {workspace}:/{Path.GetRelativePath(rootPath, path)}");
         }
         finally
@@ -599,7 +602,7 @@ public sealed class FileRWTool : IAgentTool, IToolStateProbe
 
         // Datenpunkt speichern
         var json = JsonSerializer.Serialize(entry, StockJsonOpts);
-        await File.WriteAllTextAsync(filePath, json, new UTF8Encoding(false), ct);
+        await ClawdDotNet.Core.Storage.AtomicFile.WriteAllTextAsync(filePath, json, new UTF8Encoding(false), ct);
 
         // _index.json aktualisieren (thread-safe via per-file SemaphoreSlim, append-only)
         var indexPath = Path.Combine(stockDir, "_index.json");
diff --git a/src/ClawdDotNet.Tools.WebFetch/UrlGuard.cs b/src/ClawdDotNet.Tools.WebFetch/UrlGuard.cs
index e1b8f23..a548529 100644
--- a/src/ClawdDotNet.Tools.WebFetch/UrlGuard.cs
+++ b/src/ClawdDotNet.Tools.WebFetch/UrlGuard.cs
@@ -1,4 +1,5 @@
 using System.Net;
+using System.Net.Http;
 using System.Net.Sockets;
 
 namespace ClawdDotNet.Tools.WebFetch;
@@ -14,6 +15,14 @@ namespace ClawdDotNet.Tools.WebFetch;
 ///
 /// Deshalb: Weiterleitungen werden nicht mehr automatisch verfolgt, sondern einzeln
 /// aufgelöst und JEDER Zwischenschritt erneut geprüft.
+///
+/// <para><b>Und die Adresse wird dort geprüft, wo verbunden wird (#580).</b> Die Prüfung der
+/// URL sieht nur den Namen. <c>localtest.me</c> steht als Name nirgends auf einer Sperrliste
+/// und löst doch auf <c>127.0.0.1</c> auf — im Prüfdurchgang hat WebFetch genau so eine
+/// Verbindung auf Loopback geöffnet. <see cref="ConnectAsync"/> löst den Namen selbst auf,
+/// prüft jede Zieladresse und verbindet nur mit einer geprüften. Damit greift auch
+/// DNS-Rebinding nicht mehr: Eine zweite Auflösung zwischen Prüfung und Verbindung gibt es
+/// nicht.</para>
 /// </summary>
 public static class UrlGuard
 {
@@ -114,9 +123,12 @@ public static class UrlGuard
             return true;
         }
 
-        if (!IPAddress.TryParse(value, out var ip))
-            return false;
+        return IPAddress.TryParse(value, out var ip) && IsPrivateOrLocal(ip);
+    }
 
+    /// <summary>Dieselbe Sperre für eine bereits aufgelöste Adresse.</summary>
+    public static bool IsPrivateOrLocal(IPAddress ip)
+    {
         if (IPAddress.IsLoopback(ip))
             return true;
 
@@ -138,7 +150,7 @@ public static class UrlGuard
 
         if (ip.AddressFamily == AddressFamily.InterNetworkV6)
         {
-            if (ip.IsIPv6LinkLocal || ip.IsIPv6SiteLocal)
+            if (ip.IsIPv6LinkLocal || ip.IsIPv6SiteLocal || ip.Equals(IPAddress.IPv6None))
                 return true;
 
             // Unique Local Addresses fc00::/7
@@ -148,9 +160,70 @@ public static class UrlGuard
 
             // IPv4-gemappte Adressen erneut als IPv4 prüfen
             if (ip.IsIPv4MappedToIPv6)
-                return IsPrivateOrLocal(ip.MapToIPv4().ToString());
+                return IsPrivateOrLocal(ip.MapToIPv4());
         }
 
         return false;
     }
+
+    /// <summary>
+    /// Verbindungsaufbau für den <see cref="SocketsHttpHandler"/> von WebFetch (#580): erst
+    /// auflösen und prüfen, dann mit genau den geprüften Adressen verbinden.
+    /// </summary>
+    public static async ValueTask<Stream> ConnectAsync(
+        SocketsHttpConnectionContext context, CancellationToken ct)
+    {
+        var endpoint = context.DnsEndPoint;
+        var addresses = await ResolveAllowedAsync(
+            endpoint.Host, (host, token) => Dns.GetHostAddressesAsync(host, token), ct);
+
+        var socket = new Socket(SocketType.Stream, ProtocolType.Tcp) { NoDelay = true };
+
+        try
+        {
+            await socket.ConnectAsync(addresses, endpoint.Port, ct);
+            return new NetworkStream(socket, ownsSocket: true);
+        }
+        catch
+        {
+            socket.Dispose();
+            throw;
+        }
+    }
+
+    /// <summary>
+    /// Löst einen Namen auf und gibt die Adressen nur zurück, wenn <b>keine</b> davon im
+    /// lokalen oder privaten Netz liegt.
+    ///
+    /// <para>Alle und nicht „die erste erlaubte": Ein Name mit einer öffentlichen und einer
+    /// internen Adresse ist genau das Werkzeug, mit dem man eine Prüfung überlistet, die nur
+    /// eine Stichprobe nimmt.</para>
+    /// </summary>
+    /// <param name="resolve">Die Namensauflösung — austauschbar, damit sich die Sperre ohne
+    /// Netz prüfen lässt.</param>
+    public static async Task<IPAddress[]> ResolveAllowedAsync(
+        string host,
+        Func<string, CancellationToken, Task<IPAddress[]>> resolve,
+        CancellationToken ct)
+    {
+        var value = host.Trim().Trim('[', ']');
+
+        var addresses = IPAddress.TryParse(value, out var literal)
+            ? [literal]
+            : await resolve(value, ct);
+
+        if (addresses.Length == 0)
+            throw new HttpRequestException($"Adresse '{host}' ließ sich nicht auflösen.");
+
+        foreach (var address in addresses)
+        {
+            if (IsPrivateOrLocal(address))
+            {
+                throw new HttpRequestException(
+                    $"Adresse '{host}' löst auf {address} im lokalen oder privaten Netz auf und ist gesperrt.");
+            }
+        }
+
+        return addresses;
+    }
 }
diff --git a/src/ClawdDotNet.Tools.WebFetch/WebFetchTool.cs b/src/ClawdDotNet.Tools.WebFetch/WebFetchTool.cs
index 7c35f56..5b7c46a 100644
--- a/src/ClawdDotNet.Tools.WebFetch/WebFetchTool.cs
+++ b/src/ClawdDotNet.Tools.WebFetch/WebFetchTool.cs
@@ -295,7 +295,16 @@ public sealed class WebFetchTool : IAgentTool
     {
         // Weiterleitungen bewusst NICHT automatisch verfolgen — sie werden einzeln
         // aufgelöst und geprüft.
-        var handler = new HttpClientHandler { AllowAutoRedirect = false };
+        //
+        // #580: Die Zieladresse wird beim Verbinden geprüft, nicht nur der Name in der URL.
+        // Ohne Proxy, weil über einen Proxy der Proxy auflöst und verbindet — die Prüfung
+        // sähe dann nur dessen Adresse, nie das eigentliche Ziel.
+        var handler = new SocketsHttpHandler
+        {
+            AllowAutoRedirect = false,
+            UseProxy = false,
+            ConnectCallback = UrlGuard.ConnectAsync
+        };
         var client = new HttpClient(handler, disposeHandler: true);
         var timeout = GetConfigInt(config, "timeoutSeconds", 15);
         client.Timeout = TimeSpan.FromSeconds(timeout);
diff --git a/src/ClawdDotNet.Web/Contracts/Dtos.cs b/src/ClawdDotNet.Web/Contracts/Dtos.cs
index 7d661ff..89c6d5c 100644
--- a/src/ClawdDotNet.Web/Contracts/Dtos.cs
+++ b/src/ClawdDotNet.Web/Contracts/Dtos.cs
@@ -137,7 +137,15 @@ public sealed record TaskDto(
     IReadOnlyList<string> BlockedBy,
     string Body,
     DateTime CreatedAt,
-    DateTime UpdatedAt);
+    DateTime UpdatedAt,
+    TaskWhenDto? When = null);
+
+/// <summary>
+/// Der Termin einer Aufgabe (<c>cron</c>, <c>every</c>, <c>at</c>) samt Zeitzone. Ohne ihn
+/// war in der Oberflaeche eine stuendliche Aufgabe von einer einmaligen nicht zu
+/// unterscheiden (#591).
+/// </summary>
+public sealed record TaskWhenDto(string Kind, string Value, string TimeZone);
 
 /// <summary>Ein eingefrorener Aufruf, der auf Freigabe wartet.</summary>
 public sealed record StagedCallDto(
@@ -148,7 +156,8 @@ public sealed record StagedCallDto(
     string? Action,
     string Proposal,
     string Status,
-    string ArgumentsJson);
+    string ArgumentsJson,
+    DateTime CreatedAt);
 
 /// <summary>Warum ein Vorschlag abgelehnt wurde.</summary>
 public sealed record RejectDto(string Reason);
diff --git a/src/ClawdDotNet.Web/Contracts/Mapping.cs b/src/ClawdDotNet.Web/Contracts/Mapping.cs
index 8469049..7cf1a05 100644
--- a/src/ClawdDotNet.Web/Contracts/Mapping.cs
+++ b/src/ClawdDotNet.Web/Contracts/Mapping.cs
@@ -119,7 +119,10 @@ internal static class Mapping
             task.BlockedBy,
             task.Body,
             task.CreatedAt,
-            task.UpdatedAt);
+            task.UpdatedAt,
+            task.When is { } when
+                ? new TaskWhenDto(when.Kind.ToString().ToLowerInvariant(), when.Value, when.TimeZone)
+                : null);
 
     /// <summary>
     /// Ein wartender Aufruf samt seiner eingefrorenen Argumente.
@@ -138,7 +141,8 @@ internal static class Mapping
             call.Action,
             call.Proposal,
             call.Status.ToString(),
-            call.ArgumentsJson);
+            call.ArgumentsJson,
+            call.CreatedAt);
 
     public static UsageDto ToDto(this RunUsage usage)
         => new(
diff --git a/src/ClawdDotNet.Web/Endpoints/AgentCommunicationBuilder.cs b/src/ClawdDotNet.Web/Endpoints/AgentCommunicationBuilder.cs
new file mode 100644
index 0000000..ebf4a99
--- /dev/null
+++ b/src/ClawdDotNet.Web/Endpoints/AgentCommunicationBuilder.cs
@@ -0,0 +1,100 @@
+using ClawdDotNet.Core.Engine;
+using ClawdDotNet.Web.Contracts;
+
+namespace ClawdDotNet.Web.Endpoints;
+
+/// <summary>
+/// Baut aus den Chatverläufen der Agenten die Liste der Nachrichten zwischen Agenten (A2A).
+///
+/// <para><b>Absender und Empfänger heißen hier, was sie sind.</b> Eine Anfrage steht im
+/// Verlauf des Empfängers; ihr Absender kommt aus dem Anzeigetext. Die Antwort steht im
+/// selben Verlauf — Absender ist also der Antwortende, Empfänger der, der zuletzt gefragt
+/// hat. Vorher trug die Antwort den Antwortenden als <c>target</c> und gar keinen
+/// Absender, und der Filter der Weboberfläche fand sie beim Fragenden nicht (#536).</para>
+///
+/// <para><b>Was hier bewusst noch nicht gelöst ist:</b> Der Absender einer Anfrage wird
+/// weiterhin aus dem Anzeigetext gelesen. Strukturiert am Eintrag kommt er erst mit
+/// #207/#208; bis dahin ist das Lesen wenigstens so gebaut, dass ein fehlendes
+/// Klammerpaar nicht mehr wirft.</para>
+/// </summary>
+internal static class AgentCommunicationBuilder
+{
+    /// <summary>So beginnt eine Nachricht, die ein anderer Agent geschickt hat (AgentEngine).</summary>
+    internal const string Praefix = "[Nachricht von Agent \"";
+
+    public static List<AgentCommunicationDto> Build(
+        IEnumerable<(string AgentId, string DisplayName, IEnumerable<ChatEntry> History)> agents)
+    {
+        var list = new List<AgentCommunicationDto>();
+
+        foreach (var (agentId, displayName, history) in agents)
+        {
+            string? fragendeId = null;
+            string? fragenderName = null;
+
+            foreach (var entry in history)
+            {
+                if (!string.Equals(entry.Source, ChatSource.AgentComm, StringComparison.OrdinalIgnoreCase))
+                    continue;
+
+                if (entry.Role == "user")
+                {
+                    var (id, name, inhalt) = LeseAbsender(entry.Content);
+                    fragendeId = id;
+                    fragenderName = name;
+
+                    list.Add(new AgentCommunicationDto(
+                        TargetAgentId: agentId,
+                        TargetAgentName: displayName,
+                        SourceAgentId: id,
+                        SourceAgentName: name,
+                        Role: entry.Role,
+                        Content: inhalt,
+                        Timestamp: entry.Timestamp));
+                }
+                else if (entry.Role == "assistant")
+                {
+                    list.Add(new AgentCommunicationDto(
+                        TargetAgentId: fragendeId ?? "",
+                        TargetAgentName: fragenderName ?? fragendeId ?? "",
+                        SourceAgentId: agentId,
+                        SourceAgentName: displayName,
+                        Role: entry.Role,
+                        Content: entry.Content,
+                        Timestamp: entry.Timestamp));
+                }
+            }
+        }
+
+        return list.OrderBy(c => c.Timestamp).ToList();
+    }
+
+    /// <summary>
+    /// Liest aus <c>[Nachricht von Agent "Name" (id)]\n\nText</c> Kennung, Name und Text.
+    /// Passt die Form nicht, kommt der Inhalt unverändert und ohne Absender zurück.
+    /// </summary>
+    internal static (string? Id, string? Name, string Inhalt) LeseAbsender(string content)
+    {
+        if (!content.StartsWith(Praefix, StringComparison.Ordinal))
+            return (null, null, content);
+
+        string? name = null;
+        string? id = null;
+
+        var endQuote = content.IndexOf('"', Praefix.Length);
+        if (endQuote > Praefix.Length)
+        {
+            name = content[Praefix.Length..endQuote];
+
+            var openParen = content.IndexOf('(', endQuote);
+            var closeParen = openParen < 0 ? -1 : content.IndexOf(')', openParen);
+            if (openParen > 0 && closeParen > openParen)
+                id = content[(openParen + 1)..closeParen];
+        }
+
+        var doubleNl = content.IndexOf("\n\n", StringComparison.Ordinal);
+        var inhalt = doubleNl > 0 ? content[(doubleNl + 2)..] : content;
+
+        return (id, name, inhalt);
+    }
+}
diff --git a/src/ClawdDotNet.Web/Endpoints/ApiEndpoints.cs b/src/ClawdDotNet.Web/Endpoints/ApiEndpoints.cs
index 6114c75..cd3f052 100644
--- a/src/ClawdDotNet.Web/Endpoints/ApiEndpoints.cs
+++ b/src/ClawdDotNet.Web/Endpoints/ApiEndpoints.cs
@@ -107,50 +107,13 @@ internal static class ApiEndpoints
             if (host.Engine is not { } engine)
                 return Unavailable("Agent-Engine ist nicht aktiv (kein API-Schlüssel).");
 
-            var allAgents = host.AgentAdmin.All;
-            var list = new List<AgentCommunicationDto>();
+            var list = AgentCommunicationBuilder.Build(
+                host.AgentAdmin.All.Select(agent => (
+                    agent.AgentId,
+                    agent.DisplayName,
+                    (IEnumerable<Core.Engine.ChatEntry>)engine.GetChatHistory(agent.AgentId))));
 
-            foreach (var agent in allAgents)
-            {
-                var history = engine.GetChatHistory(agent.AgentId);
-                foreach (var entry in history.Where(e => string.Equals(e.Source, Core.Engine.ChatSource.AgentComm, StringComparison.OrdinalIgnoreCase)))
-                {
-                    string? senderId = null;
-                    string? senderName = null;
-                    var content = entry.Content;
-
-                    if (entry.Role == "user" && content.StartsWith("[Nachricht von Agent \""))
-                    {
-                        var endQuote = content.IndexOf('"', 22);
-                        if (endQuote > 22)
-                        {
-                            senderName = content[22..endQuote];
-                            var openParen = content.IndexOf('(', endQuote);
-                            var closeParen = content.IndexOf(')', openParen);
-                            if (openParen > 0 && closeParen > openParen)
-                            {
-                                senderId = content[(openParen + 1)..closeParen];
-                            }
-                        }
-                        var doubleNl = content.IndexOf("\n\n", StringComparison.Ordinal);
-                        if (doubleNl > 0)
-                        {
-                            content = content[(doubleNl + 2)..];
-                        }
-                    }
-
-                    list.Add(new AgentCommunicationDto(
-                        TargetAgentId: agent.AgentId,
-                        TargetAgentName: agent.DisplayName,
-                        SourceAgentId: senderId,
-                        SourceAgentName: senderName,
-                        Role: entry.Role,
-                        Content: content,
-                        Timestamp: entry.Timestamp));
-                }
-            }
-
-            return Results.Ok(list.OrderBy(c => c.Timestamp).ToList());
+            return Results.Ok(list);
         });
 
         agents.MapGet("/{agentId}", (AppHost host, string agentId) =>
diff --git a/src/ClawdDotNet.Web/Endpoints/EventEndpoints.cs b/src/ClawdDotNet.Web/Endpoints/EventEndpoints.cs
index 55ee93c..5aef9ea 100644
--- a/src/ClawdDotNet.Web/Endpoints/EventEndpoints.cs
+++ b/src/ClawdDotNet.Web/Endpoints/EventEndpoints.cs
@@ -252,6 +252,14 @@ internal static class EventEndpoints
         context.Response.Headers["X-Accel-Buffering"] = "no";
     }
 
-    private static string Format(string type, object payload)
-        => $"event: {type}\ndata: {JsonSerializer.Serialize(payload)}\n\n";
+    /// <summary>
+    /// Ein Ereignis in SSE-Form.
+    ///
+    /// <para>Mit den Web-Vorgaben (camelCase) wie jede REST-Antwort (#591). Ohne sie kamen
+    /// Protokollzeilen als <c>Module/Level/Text</c> an, die Ansicht las <c>module/level/text</c>
+    /// — und zeigte von jeder Zeile nur den Instanznamen. Den anonymen Objekten der übrigen
+    /// Ereignisse sah man das nicht an, weil ihre Namen ohnehin klein geschrieben sind.</para>
+    /// </summary>
+    internal static string Format(string type, object payload)
+        => $"event: {type}\ndata: {JsonSerializer.Serialize(payload, JsonSerializerOptions.Web)}\n\n";
 }
diff --git a/tests/ClawdDotNet.Core.Tests/Engine/TestbetriebRegressionTests.cs b/tests/ClawdDotNet.Core.Tests/Engine/TestbetriebRegressionTests.cs
new file mode 100644
index 0000000..20ead96
--- /dev/null
+++ b/tests/ClawdDotNet.Core.Tests/Engine/TestbetriebRegressionTests.cs
@@ -0,0 +1,147 @@
+using ClawdDotNet.Core.Engine;
+using ClawdDotNet.Core.Tasks;
+using ClawdDotNet.Core.Tests.Infrastructure;
+using Microsoft.Extensions.Logging.Abstractions;
+using Shouldly;
+
+namespace ClawdDotNet.Core.Tests.Engine;
+
+/// <summary>
+/// Regressionstests fuer die Befunde aus dem Testbetrieb auf der Linux-VM (#572).
+/// </summary>
+public sealed class TestbetriebRegressionTests
+{
+    // ═══════════════════════════════════════════════════════════
+    //  #578 — Abgebrochene Laeufe tragen ihre bezahlten Token
+    // ═══════════════════════════════════════════════════════════
+
+    [Fact]
+    public async Task RunAsync_an_der_Schrittgrenze_meldet_die_bis_dahin_bezahlten_Token()
+    {
+        var fixture = new EngineFixture().WithTool(FakeTool.Slow(TimeSpan.FromMilliseconds(1)));
+        var agent = fixture.AddAgent("agent-grenze", "TestTool");
+        agent.LoopGuard.MaxSteps = 3;
+
+        // Jede Antwort ist ein Werkzeugaufruf mit 100 Prompt- und 20 Completion-Token.
+        fixture.Client.AlwaysRespondsWithToolCall("TestTool");
+
+        var result = await fixture.Engine.RunAsync(agent, "Arbeite", "test-instance", default);
+
+        result.Status.ShouldBe(AgentRunStatus.LoopLimitExceeded);
+        fixture.Client.CallCount.ShouldBe(3);
+        result.PromptTokens.ShouldBe(300, "drei bezahlte Aufrufe - vorher stand hier 0");
+        result.CompletionTokens.ShouldBe(60);
+    }
+
+    [Fact]
+    public async Task ChatAsync_an_der_Schrittgrenze_meldet_die_bis_dahin_bezahlten_Token()
+    {
+        var fixture = new EngineFixture().WithTool(FakeTool.Slow(TimeSpan.FromMilliseconds(1)));
+        var agent = fixture.AddAgent("agent-chat-grenze", "TestTool");
+        agent.LoopGuard.MaxSteps = 2;
+
+        fixture.Client.AlwaysRespondsWithToolCall("TestTool");
+
+        var result = await fixture.Engine.ChatAsync(agent, "Arbeite", "test-instance", default);
+
+        result.Status.ShouldBe(AgentRunStatus.LoopLimitExceeded);
+        result.PromptTokens.ShouldBe(200);
+        result.CompletionTokens.ShouldBe(40);
+    }
+
+    [Fact]
+    public async Task RunAsync_mit_Fehler_des_Anbieters_meldet_die_bis_dahin_bezahlten_Token()
+    {
+        var fixture = new EngineFixture().WithTool(FakeTool.Slow(TimeSpan.FromMilliseconds(1)));
+        var agent = fixture.AddAgent("agent-fehler", "TestTool");
+
+        fixture.Client
+            .RespondsWithToolCall("TestTool")
+            .Throws(new HttpRequestException("502 vom Anbieter"));
+
+        var result = await fixture.Engine.RunAsync(agent, "Arbeite", "test-instance", default);
+
+        result.Status.ShouldBe(AgentRunStatus.Failed);
+        result.PromptTokens.ShouldBe(100);
+    }
+
+    // ═══════════════════════════════════════════════════════════
+    //  #581 — Unvollstaendiges Argument-JSON
+    // ═══════════════════════════════════════════════════════════
+
+    [Theory]
+    [InlineData("{\"action\": \"write\", \"workspace\": \"personal\", \"path\": \"gross.txt\"", false)]
+    [InlineData("{\"action\": \"send_message\", \"targetAgentId\": \"netzpruefer\"", false)]
+    [InlineData("{\"action\": \"list\"}", true)]
+    public void IstVollstaendigesJson_erkennt_abgeschnittene_Argumente(string arguments, bool erwartet)
+        => AgentEngine.IstVollstaendigesJson(arguments).ShouldBe(erwartet);
+
+    [Fact]
+    public async Task Abgeschnittene_Argumente_erreichen_das_Werkzeug_nicht_und_das_Modell_erfaehrt_warum()
+    {
+        var fixture = new EngineFixture().WithTool(FakeTool.Slow(TimeSpan.FromMilliseconds(1)));
+        var agent = fixture.AddAgent("agent-abgeschnitten", "TestTool");
+
+        // Genau die Form aus dem Pruefstand: Das JSON bricht vor dem grossen Wert ab.
+        fixture.Client
+            .RespondsWithToolCall("TestTool", "{\"action\": \"write\", \"path\": \"gross.txt\"")
+            .RespondsWithText("verstanden");
+
+        await fixture.Engine.RunAsync(agent, "Schreibe viel", "test-instance", default);
+
+        var antwortAnsModell = fixture.Client.ReceivedRequests[1].Messages.Last();
+        antwortAnsModell.Role.ShouldBe("tool");
+        antwortAnsModell.Content.ShouldNotBeNull();
+        antwortAnsModell.Content.ShouldContain("kein vollstaendiges JSON");
+        antwortAnsModell.Content.ShouldContain("mehrere kleinere Aufrufe");
+        antwortAnsModell.Content.ShouldNotContain("Expected depth");
+    }
+
+    // ═══════════════════════════════════════════════════════════
+    //  #589 — Zeit und Termin in der Auftragsnachricht
+    // ═══════════════════════════════════════════════════════════
+
+    [Fact]
+    public void Zeitangabe_nennt_Ortszeit_der_Aufgabe_UTC_und_Termin()
+    {
+        var task = new TaskItem
+        {
+            Id = "t-1",
+            Title = "Wetter",
+            When = new TaskWhen { Kind = TaskWhenKind.Cron, Value = "5 * * * *", TimeZone = "Europe/Berlin" }
+        };
+
+        var text = EngineTaskDispatcher.Zeitangabe(task, new DateTimeOffset(2026, 9, 14, 13, 5, 0, TimeSpan.Zero));
+
+        text.ShouldContain("14.09.2026 15:05 Uhr");
+        text.ShouldContain("Europe/Berlin");
+        text.ShouldContain("2026-09-14T13:05Z");
+        text.ShouldContain("cron \"5 * * * *\"");
+    }
+
+    [Fact]
+    public void Auftragsnachricht_enthaelt_die_Zeitangabe()
+    {
+        var fixture = new EngineFixture();
+        var dispatcher = new EngineTaskDispatcher(
+            fixture.Engine, () => fixture.Agents, "test-instance", fixture.Registry, fixture.StateStore,
+            NullLoggerFactory.Instance, new FesteZeit(new DateTimeOffset(2026, 1, 5, 7, 15, 0, TimeSpan.Zero)));
+
+        var nachricht = dispatcher.BuildMessage(new TaskItem
+        {
+            Id = "t-2",
+            Title = "Morgenbericht",
+            Body = "Schreibe den Bericht.",
+            When = new TaskWhen { Kind = TaskWhenKind.Cron, Value = "15 7 * * *", TimeZone = "Europe/Berlin" }
+        });
+
+        nachricht.ShouldStartWith("[Aufgabe t-2] Morgenbericht");
+        nachricht.ShouldContain("Aktuelle Zeit: 05.01.2026 08:15 Uhr (Europe/Berlin, UTC+01:00)");
+        nachricht.ShouldContain("Schreibe den Bericht.");
+    }
+
+    private sealed class FesteZeit(DateTimeOffset jetzt) : TimeProvider
+    {
+        public override DateTimeOffset GetUtcNow() => jetzt;
+    }
+}
diff --git a/tests/ClawdDotNet.Core.Tests/Storage/OwnerOnlyFileTests.cs b/tests/ClawdDotNet.Core.Tests/Storage/OwnerOnlyFileTests.cs
new file mode 100644
index 0000000..798a6bc
--- /dev/null
+++ b/tests/ClawdDotNet.Core.Tests/Storage/OwnerOnlyFileTests.cs
@@ -0,0 +1,74 @@
+using ClawdDotNet.Core.Storage;
+using ClawdDotNet.Core.Tests.Infrastructure;
+using Shouldly;
+
+namespace ClawdDotNet.Core.Tests.Storage;
+
+/// <summary>
+/// #575: Auf der Test-VM (umask 0002) ging InstanceSettings.json beim ersten Speichern von
+/// 0600 auf 0664, Protokolle entstanden mit 0664. Unter Windows nicht aussagekraeftig.
+/// </summary>
+public sealed class OwnerOnlyFileTests : IDisposable
+{
+    private readonly string _dir = Path.Combine(Path.GetTempPath(), "clawd-owner-" + Guid.NewGuid().ToString("N")[..8]);
+
+    public OwnerOnlyFileTests() => Directory.CreateDirectory(_dir);
+
+    public void Dispose()
+    {
+        try { Directory.Delete(_dir, recursive: true); } catch { /* Aufraeumen ist best effort */ }
+    }
+
+    private const UnixFileMode NurBesitzer = UnixFileMode.UserRead | UnixFileMode.UserWrite;
+
+    [LinuxFact]
+    [System.Runtime.Versioning.SupportedOSPlatform("linux")]
+    public void AtomicFile_ersetzt_eine_offene_Datei_durch_eine_nur_fuer_den_Besitzer()
+    {
+        var pfad = Path.Combine(_dir, "InstanceSettings.json");
+        File.WriteAllText(pfad, "{}");
+        File.SetUnixFileMode(pfad, NurBesitzer | UnixFileMode.GroupRead | UnixFileMode.OtherRead);
+
+        AtomicFile.WriteAllText(pfad, "{\"a\":1}");
+
+        File.GetUnixFileMode(pfad).ShouldBe(NurBesitzer);
+    }
+
+    [LinuxFact]
+    [System.Runtime.Versioning.SupportedOSPlatform("linux")]
+    public void AtomicFile_legt_neue_Dateien_nur_fuer_den_Besitzer_an()
+    {
+        var pfad = Path.Combine(_dir, "neu.json");
+
+        AtomicFile.WriteAllText(pfad, "{}");
+
+        File.GetUnixFileMode(pfad).ShouldBe(NurBesitzer);
+    }
+
+    [LinuxFact]
+    [System.Runtime.Versioning.SupportedOSPlatform("linux")]
+    public void OpenAppend_legt_neue_Dateien_nur_fuer_den_Besitzer_an()
+    {
+        var pfad = Path.Combine(_dir, "protokoll.log");
+
+        using (var stream = OwnerOnlyFile.OpenAppend(pfad))
+            stream.WriteByte((byte)'x');
+
+        File.GetUnixFileMode(pfad).ShouldBe(NurBesitzer);
+    }
+
+    [Fact]
+    public void OpenAppend_haengt_an_statt_zu_ueberschreiben()
+    {
+        var pfad = Path.Combine(_dir, "anhang.txt");
+
+        foreach (var teil in new[] { "eins", "zwei" })
+        {
+            using var stream = OwnerOnlyFile.OpenAppend(pfad);
+            using var writer = new StreamWriter(stream);
+            writer.Write(teil);
+        }
+
+        File.ReadAllText(pfad).ShouldBe("einszwei");
+    }
+}
diff --git a/tests/ClawdDotNet.Tools.Tests/WebFetch/UrlGuardAufloesungTests.cs b/tests/ClawdDotNet.Tools.Tests/WebFetch/UrlGuardAufloesungTests.cs
new file mode 100644
index 0000000..05f4bd3
--- /dev/null
+++ b/tests/ClawdDotNet.Tools.Tests/WebFetch/UrlGuardAufloesungTests.cs
@@ -0,0 +1,67 @@
+using System.Net;
+using System.Net.Http;
+using ClawdDotNet.Tools.WebFetch;
+using Shouldly;
+
+namespace ClawdDotNet.Tools.Tests.WebFetch;
+
+/// <summary>
+/// #580: Die Pruefung der URL sieht nur den Namen. localtest.me steht auf keiner Sperrliste
+/// und loest auf 127.0.0.1 auf - im Pruefdurchgang oeffnete WebFetch damit eine Verbindung
+/// auf Loopback. Geprueft wird deshalb die aufgeloeste Adresse, ohne echtes Netz.
+/// </summary>
+public sealed class UrlGuardAufloesungTests
+{
+    private static Func<string, CancellationToken, Task<IPAddress[]>> Aufloesung(params string[] adressen)
+        => (_, _) => Task.FromResult(adressen.Select(IPAddress.Parse).ToArray());
+
+    [Theory]
+    [InlineData("127.0.0.1")]
+    [InlineData("192.168.40.48")]
+    [InlineData("169.254.169.254")]
+    [InlineData("::1")]
+    [InlineData("::ffff:10.0.0.5")]
+    public async Task Ein_Name_der_ins_lokale_Netz_aufloest_wird_gesperrt(string adresse)
+    {
+        var ex = await Should.ThrowAsync<HttpRequestException>(
+            () => UrlGuard.ResolveAllowedAsync("localtest.me", Aufloesung(adresse), default));
+
+        ex.Message.ShouldContain("localtest.me");
+        ex.Message.ShouldContain("gesperrt");
+    }
+
+    [Fact]
+    public async Task Ein_Name_mit_oeffentlicher_und_interner_Adresse_wird_gesperrt()
+    {
+        // Genau das Muster, mit dem man eine Stichprobenpruefung ueberlistet.
+        await Should.ThrowAsync<HttpRequestException>(
+            () => UrlGuard.ResolveAllowedAsync("gemischt.example", Aufloesung("93.184.215.14", "127.0.0.1"), default));
+    }
+
+    [Fact]
+    public async Task Ein_Name_mit_oeffentlichen_Adressen_wird_zugelassen()
+    {
+        var adressen = await UrlGuard.ResolveAllowedAsync(
+            "example.com", Aufloesung("93.184.215.14", "2606:2800:21f:cb07:6820:80da:af6b:8b2c"), default);
+
+        adressen.Length.ShouldBe(2);
+    }
+
+    [Fact]
+    public async Task Ein_IP_Literal_wird_ohne_Aufloesung_geprueft()
+    {
+        var aufgerufen = false;
+
+        await Should.ThrowAsync<HttpRequestException>(() => UrlGuard.ResolveAllowedAsync(
+            "[::1]",
+            (_, _) => { aufgerufen = true; return Task.FromResult(Array.Empty<IPAddress>()); },
+            default));
+
+        aufgerufen.ShouldBeFalse();
+    }
+
+    [Fact]
+    public async Task Ein_Name_ohne_Adresse_wird_nicht_verbunden()
+        => await Should.ThrowAsync<HttpRequestException>(
+            () => UrlGuard.ResolveAllowedAsync("nirgends.example", Aufloesung(), default));
+}
diff --git a/tests/ClawdDotNet.Web.Tests/TestbetriebWebTests.cs b/tests/ClawdDotNet.Web.Tests/TestbetriebWebTests.cs
new file mode 100644
index 0000000..d090dce
--- /dev/null
+++ b/tests/ClawdDotNet.Web.Tests/TestbetriebWebTests.cs
@@ -0,0 +1,132 @@
+using ClawdDotNet.Core.Engine;
+using ClawdDotNet.Core.Staging;
+using ClawdDotNet.Core.Tasks;
+using ClawdDotNet.Web.Contracts;
+using ClawdDotNet.Web.Endpoints;
+using Shouldly;
+
+namespace ClawdDotNet.Web.Tests;
+
+/// <summary>
+/// Befunde aus der Sichtung der Weboberflaeche im Testbetrieb (#572): #591 (Feldnamen) und
+/// #536 (Richtung der A2A-Antworten).
+/// </summary>
+public sealed class TestbetriebWebTests
+{
+    // ─── #591 Ereignisstrom und Uebertragungstypen ───
+
+    [Fact]
+    public void Protokollzeilen_im_Ereignisstrom_kommen_in_camelCase()
+    {
+        var ereignis = EventEndpoints.Format("log", new LogLineDto("Startup", "INF", "ClawdDotNet startet"));
+
+        ereignis.ShouldStartWith("event: log\n");
+        ereignis.ShouldContain("\"module\":\"Startup\"");
+        ereignis.ShouldContain("\"level\":\"INF\"");
+        ereignis.ShouldContain("\"text\":\"ClawdDotNet startet\"");
+        ereignis.ShouldNotContain("\"Text\"", Case.Sensitive);
+    }
+
+    [Fact]
+    public void Freigabe_traegt_ihren_Zeitpunkt()
+    {
+        var angelegt = new DateTime(2026, 9, 14, 10, 18, 53, DateTimeKind.Utc);
+
+        var dto = new StagedCall
+        {
+            Id = 1, AgentId = "hausmeister", Tool = "FileRW", Action = "delete",
+            ArgumentsJson = "{\"path\":\"betrieb/probe-loeschung.txt\"}", CreatedAt = angelegt
+        }.ToDto();
+
+        dto.CreatedAt.ShouldBe(angelegt);
+        dto.Tool.ShouldBe("FileRW");
+        dto.Action.ShouldBe("delete");
+    }
+
+    [Fact]
+    public void Aufgabe_traegt_ihren_Termin()
+    {
+        var dto = new TaskItem
+        {
+            Id = "t-a66932", Title = "Wetter Berlin stuendlich", Assignee = "@new:wetterdienst",
+            When = new TaskWhen { Kind = TaskWhenKind.Cron, Value = "5 * * * *", TimeZone = "Europe/Berlin" }
+        }.ToDto();
+
+        dto.When.ShouldNotBeNull();
+        dto.When.Kind.ShouldBe("cron");
+        dto.When.Value.ShouldBe("5 * * * *");
+        dto.When.TimeZone.ShouldBe("Europe/Berlin");
+        dto.Assignee.ShouldBe("@new:wetterdienst");
+    }
+
+    [Fact]
+    public void Einmalige_Aufgabe_hat_keinen_Termin()
+        => new TaskItem { Id = "t-1", Title = "Einrichtung" }.ToDto().When.ShouldBeNull();
+
+    // ─── #536 Absender und Empfaenger ───
+
+    private static ChatEntry Anfrage(string vonName, string vonId, string text, int minute)
+        => new("user", $"[Nachricht von Agent \"{vonName}\" ({vonId})]\n\n{text}",
+               new DateTime(2026, 9, 14, 12, minute, 0), ChatSource.AgentComm);
+
+    private static ChatEntry Antwort(string text, int minute)
+        => new("assistant", text, new DateTime(2026, 9, 14, 12, minute, 30), ChatSource.AgentComm);
+
+    [Fact]
+    public void Antwort_geht_vom_Antwortenden_an_den_Fragenden()
+    {
+        var liste = AgentCommunicationBuilder.Build(
+        [
+            ("redaktion", "Redaktion", (IEnumerable<ChatEntry>)
+            [
+                Anfrage("Hausmeister", "hausmeister", "Testnachricht", 48),
+                Antwort("Empfang bestaetigt", 48)
+            ])
+        ]);
+
+        liste.Count.ShouldBe(2);
+
+        var anfrage = liste[0];
+        anfrage.SourceAgentId.ShouldBe("hausmeister");
+        anfrage.TargetAgentId.ShouldBe("redaktion");
+        anfrage.Content.ShouldBe("Testnachricht");
+
+        var antwort = liste[1];
+        antwort.SourceAgentId.ShouldBe("redaktion");
+        antwort.TargetAgentId.ShouldBe("hausmeister", "vorher stand hier der Antwortende selbst");
+        antwort.TargetAgentName.ShouldBe("Hausmeister");
+    }
+
+    [Fact]
+    public void Nur_Agentenkommunikation_wird_aufgenommen()
+    {
+        var liste = AgentCommunicationBuilder.Build(
+        [
+            ("hausmeister", "Hausmeister", (IEnumerable<ChatEntry>)
+            [
+                new ChatEntry("user", "Hey, wie gehts?", DateTime.Now, ChatSource.WebUi),
+                new ChatEntry("assistant", "Moin!", DateTime.Now, ChatSource.WebUi)
+            ])
+        ]);
+
+        liste.ShouldBeEmpty();
+    }
+
+    [Theory]
+    [InlineData("[Nachricht von Agent \"Hausmeister\" ohne Klammer]\n\nText")]
+    [InlineData("[Nachricht von Agent \"Bo\"b\" (bob)]\n\nText")]
+    [InlineData("[Nachricht von Agent \"")]
+    public void Absender_lesen_wirft_bei_unerwarteter_Form_nicht(string inhalt)
+        => Should.NotThrow(() => AgentCommunicationBuilder.LeseAbsender(inhalt));
+
+    [Fact]
+    public void Absender_lesen_liefert_Kennung_Name_und_Text()
+    {
+        var (id, name, text) = AgentCommunicationBuilder.LeseAbsender(
+            "[Nachricht von Agent \"Hausmeister\" (hausmeister)]\n\nHallo Redaktion!");
+
+        id.ShouldBe("hausmeister");
+        name.ShouldBe("Hausmeister");
+        text.ShouldBe("Hallo Redaktion!");
+    }
+}