Bugtracker-Durchgang: 13 Bugs behoben, Build ohne Warnungen

Alle Behebungen auf der Linux-Test-VM gegengeprueft (Ubuntu, .NET 10.0.111):
Build 0 Warnungen / 0 Fehler, 637 Tests gruen, 1 uebersprungen (WindowsFact).

Sicherheit und Zielplattform
  #373 PathBoundary.Canonicalize fiel offen aus. File.ResolveLinkTarget wirft
       fuer einen fehlenden Abschnitt FileNotFoundException; der catch(IOException)
       verliess daraufhin die GANZE Aufloesung mit dem unaufgeloesten Pfad - und
       der besteht jede Praefixpruefung. Der Symlink-Schutz war damit bei jedem
       Schreibvorgang wirkungslos. Jetzt ueber FileSystemInfo.LinkTarget, und
       TryCanonicalize meldet "nicht bestimmbar", statt fail-open durchzureichen.
  #374 WorkspacePath weist den Backslash rundheraus ab, wie den Doppelpunkt.
       Eine Schreibweise statt einer Sonderregel je Windows-Form.
  #375 Log-Verzeichnis: leer heisst "Anwendungseinstellung"; ein relativer Wert
       zaehlt gegen das Instanzverzeichnis, nicht gegen das Arbeitsverzeichnis
       des Prozesses. Ein systemd-Dienst landet nicht mehr auf /Logs.

Agentenkommunikation
  #206 Delegationskette gegen A->B->A (Test A13). Zyklusfrei per Bauart, dazu
       MaxDelegationDepth gegen die Staffel, die niemand beauftragt hat.
  #461 Zwei unabhaengige Ketten ueber Kreuz - beim Beheben von #206 gefunden und
       reproduziert. Ein delegierter Lauf wartet nur noch begrenzt auf ein fremdes
       Gate; ein Chat vom Menschen reiht sich weiter unbegrenzt ein.
  #234 Instanz-Id wird durchgereicht statt aus einem nur beilaeufig gesetzten Feld
       gelesen.

Betrieb und Oberflaeche
  #376 Log-Ansicht chronologisch statt gruppiert je Moduldatei, mit Stacktraces
       an ihrer Meldung - auch ueber Taktgrenzen hinweg.
  #377 Info-Tabelle: feste Spaltenbreiten, damit ein langer Aenderungstext den
       anderen Spalten nicht den Platz nimmt.
  #378 Sicherung: Mindestabstand zwischen Ueberschrift und Schaltflaechenleiste.
  #379 Hellmodus: drei von vier gedaempften Textpinseln lagen unter 4,5:1. Die
       helle Palette ist als Ganzes verschoben, damit die Staffelung sichtbar
       bleibt statt auf einen Wert zusammenzufallen.

Hygiene
  #233 stock_add: der Indexstand wird innerhalb der Sperre festgehalten.
  #235 Zeitumstellung: eine nicht existierende Ortszeit wird auf den ersten
       Zeitpunkt nach der Luecke verschoben statt uebersprungen (R4, R5).
  #236 45 Nullable-Warnungen und eine CA1416 - nicht unterdrueckt, sondern die
       Stellen so umgebaut, dass die Zusage nachvollziehbar wird. Mail meldet
       jetzt, WELCHER Zugangsschluessel fehlt, statt an einer
       KeyNotFoundException zu scheitern.
  #203 Kompaktiert wird vor dem API-Aufruf statt danach; die gemessenen
       Prompt-Groessen kalibrieren die Schaetzung je Modell.

Neu: tests/ClawdDotNet.App.Tests - fuer #375 und #376 gab es keinen Ort fuer
Tests. Dazu Regressionstests fuer jede Behebung; jeder wurde gegen den alten
Stand geprueft, damit belegt ist, dass er den Fehler faengt.

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

src/ClawdDotNet.App/AppHost.cs

@@ -127,6 +127,45 @@ public sealed class AppHost : IAsyncDisposable
     /// </summary>
     public readonly record struct StartupResult(AppHost? Host, string? Error);
 
+    /// <summary>
+    /// Wohin protokolliert wird. Zwei Regeln, die vorher beide nicht galten:
+    ///
+    /// <para><b>Leer heißt „nimm die Anwendungseinstellung".</b> Die steht absolut unter
+    /// <c>AppPaths.DataDirectory</c> und ist der Wert, den die Einstellungsseite zeigt.
+    /// Vorher war <c>InstanceConfig.LogDirectory</c> mit <c>"./Logs"</c> vorbelegt und
+    /// damit nie leer — der Zweig auf die Anwendungseinstellung war unerreichbar, und
+    /// das Feld auf der Einstellungsseite ließ sich ändern, ohne etwas zu ändern.</para>
+    ///
+    /// <para><b>Ein relativer Wert zählt gegen das Instanzverzeichnis</b>, nicht gegen
+    /// das Arbeitsverzeichnis des Prozesses. Sonst hängt der Ort davon ab, aus welchem
+    /// Verzeichnis jemand gestartet hat: Ein systemd-Dienst ohne <c>WorkingDirectory=</c>
+    /// startet in <c>/</c>, und <c>"./Logs"</c> zeigt dann auf <c>/Logs</c> — für ein
+    /// Dienstkonto nicht anlegbar. Beim Start aus dem Installationsverzeichnis schrieb
+    /// die Anwendung stattdessen in sich selbst, wo ein Update sie überschreibt.</para>
+    /// </summary>
+    /// <param name="instance">Die geladene Instanz — liefert Vorrang und Bezugspunkt.</param>
+    /// <param name="applicationLogDirectory">Der Wert aus den Anwendungseinstellungen.</param>
+    /// <param name="instancePath">Das Verzeichnis, aus dem die Instanz geladen wurde.</param>
+    public static string ResolveLogDirectory(
+        InstanceConfig instance, string applicationLogDirectory, string instancePath)
+    {
+        var configured = !string.IsNullOrWhiteSpace(instance.LogDirectory)
+            ? instance.LogDirectory
+            : applicationLogDirectory;
+
+        // InstanceConfig.WorkingDirectory steht seit CreateInstance mit dem absoluten
+        // Instanzpfad in der Datei; instancePath ist derselbe Ort und trägt auch dann,
+        // wenn jemand das Feld von Hand geleert oder relativ gesetzt hat.
+        var instanceBase = Path.IsPathRooted(instance.WorkingDirectory)
+            ? instance.WorkingDirectory
+            : instancePath;
+
+        return Path.GetFullPath(
+            Path.IsPathRooted(configured)
+                ? configured
+                : Path.Combine(instanceBase, configured));
+    }
+
     public static async Task<StartupResult> StartAsync(Callbacks callbacks, CancellationToken ct = default)
     {
         // ─── 1. Anwendungseinstellungen ───
@@ -153,10 +192,8 @@ public sealed class AppHost : IAsyncDisposable
         }
 
         // ─── 3. Protokollierung ───
-        var logDirectory = Path.GetFullPath(
-            !string.IsNullOrWhiteSpace(instance.LogDirectory)
-                ? instance.LogDirectory
-                : settings.AppSettings.LogDirectory);
+        var logDirectory = ResolveLogDirectory(
+            instance, settings.AppSettings.LogDirectory, instancePath);
 
         var minLevel = Enum.TryParse<Core.Logging.LogLevel>(
             settings.AppSettings.MinimumLogLevel, true, out var parsed)
@@ -309,7 +346,9 @@ public sealed class AppHost : IAsyncDisposable
             openRouter, tools, new PermissionGate(), stateStore, loggerFactory,
             memory, usage, pricing, taskRepository, audit, stagingGate)
         {
-            InstanceBudget = instance.Budget
+            InstanceBudget = instance.Budget,
+            MaxDelegationDepth = instance.MaxDelegationDepth,
+            DelegationGateTimeout = TimeSpan.FromSeconds(instance.DelegationGateTimeoutSeconds)
         };
 
         engine.SetAgentConfigProvider(

src/ClawdDotNet.App/Services/InstanceDirectoryManager.cs

@@ -120,7 +120,10 @@ public sealed class InstanceDirectoryManager
         {
             InstanceId = Guid.NewGuid().ToString("N")[..8],
             InstanceName = instanceName,
-            LogDirectory = "./Logs",
+            // LogDirectory bleibt leer: dann gilt die Anwendungseinstellung, und die
+            // steht absolut. Hier stand vorher "./Logs" — ein Wert, der jede neue
+            // Instanz an das Arbeitsverzeichnis des Prozesses band und die
+            // Einstellungsseite wirkungslos machte.
             WorkingDirectory = instanceDir
         };
         SaveJson(Path.Combine(instanceDir, "InstanceSettings.json"), config);
@@ -150,6 +153,17 @@ public sealed class InstanceDirectoryManager
         var config = JsonSerializer.Deserialize<InstanceConfig>(json, JsonOpts)
             ?? throw new InvalidOperationException("InstanceSettings.json ist leer oder ungültig.");
 
+        // Migration: Die alte Vorbelegung "./Logs" wird zu „leer" — also zur
+        // Anwendungseinstellung. Der Wert hatte nie die Bedeutung, die er vorgab: Er
+        // wurde gegen das Arbeitsverzeichnis des Prozesses aufgelöst, nicht gegen das
+        // Instanzverzeichnis. Wer bewusst einen anderen Pfad eingetragen hat, behält
+        // ihn; nur genau die Vorbelegung fällt weg.
+        //
+        // Nur im Speicher: Die Datei bleibt unangetastet, damit ein Ladevorgang nichts
+        // zurückschreibt. Beim nächsten Speichern verschwindet der Wert von selbst.
+        if (config.LogDirectory is "./Logs" or @".\Logs" or "Logs")
+            config.LogDirectory = "";
+
         // Agenten aus Verzeichnisstruktur laden
         config.Agents.Clear();
         var agentsDir = Path.Combine(instanceDir, "Agents");

src/ClawdDotNet.App/Services/LogTail.cs

@@ -26,9 +26,18 @@ public sealed partial class LogTail(string logDirectory)
 {
     private readonly ConcurrentDictionary<string, long> _positions = new();
 
+    /// <summary>
+    /// Der zuletzt gesehene Zeitstempel je Datei. Trägt Fortsetzungszeilen über
+    /// Poll-Grenzen hinweg — siehe <see cref="ReadFile"/>.
+    /// </summary>
+    private readonly ConcurrentDictionary<string, string> _lastTimestamps = new();
+
     [GeneratedRegex(@"\[(TRC|DBG|INF|WRN|ERR|FTL)\]", RegexOptions.IgnoreCase)]
     private static partial Regex LevelPattern();
 
+    [GeneratedRegex(@"^\[(\d{2}:\d{2}:\d{2}\.\d{3})\]")]
+    private static partial Regex TimestampPattern();
+
     /// <summary>Die Module, für die heute Dateien vorliegen — füllt das Auswahlfeld.</summary>
     public IReadOnlyList<string> AvailableModules()
     {
@@ -44,7 +53,8 @@ public sealed partial class LogTail(string logDirectory)
     }
 
     /// <summary>
-    /// Alles, was seit dem letzten Aufruf dazugekommen ist.
+    /// Alles, was seit dem letzten Aufruf dazugekommen ist — in der Reihenfolge, in
+    /// der es entstanden ist.
     ///
     /// <paramref name="module"/> leer heißt: alle Module.
     /// </summary>
@@ -53,9 +63,15 @@ public sealed partial class LogTail(string logDirectory)
         var directory = TodayDirectory();
         if (directory is null) return [];
 
-        var result = new List<LogLine>();
+        var collected = new List<(string Timestamp, LogLine Line)>();
 
-        foreach (var path in Directory.GetFiles(directory, "*.log"))
+        // Nach Modulnamen geordnet einsammeln. Directory.GetFiles liefert unter Linux
+        // die Verzeichnisreihenfolge, nicht die alphabetische — was bei gleichem
+        // Zeitstempel die Reihenfolge der Ansicht von Lauf zu Lauf ändern könnte. Die
+        // stabile Sortierung weiter unten braucht einen festen Ausgangspunkt, sonst ist
+        // sie nur die halbe Zusage.
+        foreach (var path in Directory.GetFiles(directory, "*.log")
+                     .OrderBy(p => p, StringComparer.Ordinal))
         {
             var moduleName = Path.GetFileNameWithoutExtension(path);
 
@@ -68,13 +84,29 @@ public sealed partial class LogTail(string logDirectory)
                 continue;
             }
 
-            ReadFile(path, moduleName, level, result);
+            ReadFile(path, moduleName, level, collected);
         }
 
-        return result;
+        // Jedes Modul schreibt in seine eigene Datei, eingesammelt wird Datei für
+        // Datei — also alphabetisch nach Modulname. Ohne diesen Schritt stehen die
+        // Zeilen in Blöcken je Modul statt in der Reihenfolge, in der sie entstanden
+        // sind. Das ist kein Schönheitsfehler: Wer einen Fehler sucht, liest die
+        // Reihenfolge der Ereignisse, und eine Ursache unter ihrer Wirkung schickt ihn
+        // an die falsche Stelle.
+        //
+        // OrderBy sortiert stabil — bei gleichem Zeitstempel bleibt die bisherige
+        // Ordnung, zusammengehörende Zeilen eines Moduls bleiben also beieinander.
+        // Verglichen wird die Zeichenkette [HH:mm:ss.fff]: Innerhalb eines
+        // Tagesverzeichnisses ist sie in derselben Ordnung sortierbar wie die Zeit,
+        // und ein Umweg über DateTime.Parse spart nichts.
+        return collected
+            .OrderBy(entry => entry.Timestamp, StringComparer.Ordinal)
+            .Select(entry => entry.Line)
+            .ToList();
     }
 
-    private void ReadFile(string path, string module, LogLevelFilter level, List<LogLine> into)
+    private void ReadFile(string path, string module, LogLevelFilter level,
+        List<(string Timestamp, LogLine Line)> into)
     {
         var lastPosition = _positions.GetOrAdd(path, 0L);
 
@@ -99,9 +131,27 @@ public sealed partial class LogTail(string logDirectory)
                 if (string.IsNullOrWhiteSpace(line)) continue;
 
                 var lineLevel = ExtractLevel(line);
+                var timestamp = ExtractTimestamp(line);
+
+                if (timestamp.Length == 0)
+                {
+                    // Fortsetzungszeile: Eine Ausnahme hängt ihren Stacktrace ohne
+                    // eigenen Zeitstempel unter die Meldung. Sie erbt den Zeitstempel
+                    // der Zeile davor, damit der Stacktrace bei seiner Meldung bleibt —
+                    // auch dann, wenn die Meldung schon im vorigen Takt gelesen wurde
+                    // und nur der Rest jetzt nachkommt.
+                    timestamp = _lastTimestamps.GetValueOrDefault(path, "");
+                }
+                else
+                {
+                    _lastTimestamps[path] = timestamp;
+                }
+
+                // Erst danach filtern: Eine weggefilterte Zeile darf den Zeitstempel
+                // trotzdem weiterreichen.
                 if (!Passes(lineLevel, level)) continue;
 
-                into.Add(new LogLine(module, lineLevel, line));
+                into.Add((timestamp, new LogLine(module, lineLevel, line)));
             }
 
             _positions[path] = stream.Position;
@@ -124,6 +174,17 @@ public sealed partial class LogTail(string logDirectory)
         return match.Success ? match.Groups[1].Value.ToUpperInvariant() : "";
     }
 
+    /// <summary>
+    /// Der Zeitstempel am Zeilenanfang, oder leer bei einer Fortsetzungszeile.
+    /// Nur am Anfang, nicht irgendwo: Eine Meldung darf eine Uhrzeit enthalten, ohne
+    /// dass sie zum Sortierschlüssel wird.
+    /// </summary>
+    private static string ExtractTimestamp(string line)
+    {
+        var match = TimestampPattern().Match(line);
+        return match.Success ? match.Groups[1].Value : "";
+    }
+
     private static bool Passes(string lineLevel, LogLevelFilter filter) => filter switch
     {
         LogLevelFilter.All => true,