Instanzmanager: Weboberflaeche kennt Instanzen, geordnetes Ende, Puls (#528, #531)

Weboberflaeche (#531): X-Instanz an der einen fetch-Stelle, Instanzauswahl in der
Kopfzeile, Verwaltungsansicht mit Anlegen/Starten/Anhalten/Fenster, Herkunft der
Ereignisse, Sicherungs- und Einstellungsansicht. 402/409/502 werden eigen behandelt.

Sicherungen im Manager (#530): Auflisten, Anlegen, Wiederherstellen, Loeschen. Das
Zurueckspielen haelt die Instanz vorher an und startet sie danach wieder.

Geordnetes Ende (Konzept 9.8). Zwei Befunde waren der Anlass:

Der Manager konnte eine Instanz MIT FENSTER nie geordnet beenden.
Control.ShutdownRequested war nur in HeadlessRun verdrahtet, nicht in der
Avalonia-Anwendung - und ein Fenster ist die Vorgabe. Die Bitte wurde mit 202
beantwortet, niemand hoerte zu, und der Manager schoss den Prozess nach Ablauf
seiner Frist jedes Mal ab.

InstanceSupervisor.StopAsync hielt Socket-Schweigen fuer einen Todesnachweis und
meldete "beendet", ohne den Prozess anzufassen. Bei einer verstummten Instanz ist
der Socket von vornherein still - der Neustart haette einen zweiten Prozess auf
dieselbe state.db gesetzt. Genau der Schaden, gegen den #528 gebaut ist.

- ShutdownCoordinator: erst die Tuer schliessen, dann auf offene Arbeiten warten,
  Frist zwei Minuten. Vorher brach TaskScanner.DisposeAsync mitten in ProcessAsync
  ab, sodass die Aufgabe bis zum Lease-Ablauf auf "running" stehenblieb.
- GET /api/instanz/puls hinter dem Socket-Gate: Phase und offene Arbeiten. Weiter
  gefragt statt gemeldet - ein Puls, den die Instanz von sich aus schickt, fehlt
  genau dann, wenn sie haengt.
- Eskalationsleiter: drei Durchgaenge ohne Antwort, einmal um ein Ende bitten,
  nach 30s beenden und den Vollzug abwarten, gemeldet als Absturz.
- EnsureDeadAsync vor jedem Start.

Weiteres aus dem Review:
- .gitignore verankert: "Instances/" passte auch auf src/ClawdDotNet.Core/Instances/.
  InstanceEndpoint.cs und InstanceLayout.cs waren dadurch nie eingecheckt.
- Das WebUI-Token stand im Protokoll des Managers. Konsole ja, Datei nein.
- Ein Klick auf "Instanz anlegen" loeste requestSubmit() zweimal aus.
- [Obsolete] auf WebServerPort wieder entfernt: sechs Warnungen, die niemand
  abstellen konnte, solange E-M5 nicht fertig ist.
- Die Wiederherstellung bricht nicht mehr ab, wenn der Browser weggeht.
- Entwicklungspfade zum Instanzmanager aus Segmenten statt mit Rueckstrichen, und
  der Port kommt aus manager.json statt fest aus der Zeile.

Offen und gemeldet: --managed hebelt die Lizenzpruefung aus (#535).

806 Tests gruen, 0 Warnungen.

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

tests/ClawdDotNet.Manager.Tests/InstanceSupervisorTests.cs

@@ -1,3 +1,4 @@
+using ClawdDotNet.Core.Instances;
 using Microsoft.Extensions.Logging.Abstractions;
 using Shouldly;
 
@@ -38,9 +39,19 @@ public sealed class InstanceSupervisorTests : IDisposable
         ProbeInterval: TimeSpan.FromMilliseconds(50),
         StartTimeout: TimeSpan.FromMilliseconds(600),
         SilentChecksBeforeAlarm: 3,
-        StopGrace: TimeSpan.FromMilliseconds(300));
+        StopGrace: TimeSpan.FromMilliseconds(300),
+        SilentKillGrace: TimeSpan.FromMilliseconds(300),
+        MaxDrainWait: TimeSpan.FromSeconds(2));
 
-    public InstanceSupervisorTests() => Directory.CreateDirectory(_dir);
+    public InstanceSupervisorTests()
+    {
+        Directory.CreateDirectory(_dir);
+
+        // Der Socket antwortet nur, wenn wirklich ein Prozess laeuft - genau wie im
+        // Betrieb. Eine vorab hinterlegte Antwort hiesse sonst "laeuft schon", und die
+        // Aufsicht wuerde uebernehmen statt zu starten.
+        _kanal.Launcher = _launcher;
+    }
 
     public void Dispose()
     {
@@ -252,6 +263,72 @@ public sealed class InstanceSupervisorTests : IDisposable
         aufsicht.Condition.ShouldBe(InstanceCondition.Stopped);
     }
 
+    /// <summary>
+    /// Schweigen ist kein Todesnachweis, solange ein Prozesshandle das Gegenteil sagt.
+    ///
+    /// <para><b>Hier lag der gefährlichste Fehlschluss.</b> Die Warteschleife brach ab,
+    /// sobald der Socket nicht mehr antwortete, meldete „beendet" und gab <c>true</c>
+    /// zurück — ohne den Prozess anzufassen. Bei einer verstummten Instanz ist der Socket
+    /// aber von vornherein still: Der Aufruf meldete sofort Erfolg, der Prozess lief
+    /// weiter, und der Neustart setzte einen zweiten auf dieselbe <c>state.db</c>. Genau
+    /// der Schaden, gegen den dieses Vorhaben gebaut ist.</para>
+    /// </summary>
+    [Fact]
+    public async Task Ein_stummer_aber_lebender_Prozess_gilt_nicht_als_beendet()
+    {
+        _kanal.Answer = Test;
+
+        await using var aufsicht = Aufsicht();
+        await aufsicht.StartAsync();
+
+        var prozess = _launcher.Last.ShouldNotBeNull();
+
+        // Sie haengt: Der Socket schweigt, der Prozess lebt.
+        _kanal.Verstummen(_dir);
+
+        (await aufsicht.StopAsync()).ShouldBeTrue();
+
+        prozess.WasKilled.ShouldBeTrue(
+            "Wer schweigt und lebt, muss beendet werden - nicht fuer beendet erklaert.");
+
+        prozess.HasExited.ShouldBeTrue();
+        aufsicht.Condition.ShouldBe(InstanceCondition.Stopped);
+    }
+
+    /// <summary>
+    /// Wer aufräumt, wird nicht abgeschossen — die Frist wird nachgezogen.
+    ///
+    /// <para>Die Instanz gibt sich selbst eine Frist zum Auslaufen. Wäre die des Managers
+    /// kürzer, schösse er mitten in das Aufräumen hinein, um das er gerade gebeten
+    /// hat.</para>
+    /// </summary>
+    [Fact]
+    public async Task Wer_aufraeumt_bekommt_die_Frist_nachgezogen()
+    {
+        _kanal.Answer = Test;
+
+        await using var aufsicht = Aufsicht();
+        await aufsicht.StartAsync();
+
+        var prozess = _launcher.Last.ShouldNotBeNull();
+
+        // Sie antwortet und meldet: Ich raeume auf. Laenger als StopGrace (300ms), aber
+        // kuerzer als MaxDrainWait (2s).
+        _kanal.Answer = Test with { Phase = ShutdownPhase.Draining, OpenWork = 1 };
+
+        _ = Task.Run(async () =>
+        {
+            await Task.Delay(700);
+            _kanal.Answer = null;
+            prozess.Exit(0);
+        });
+
+        (await aufsicht.StopAsync()).ShouldBeTrue();
+
+        prozess.WasKilled.ShouldBeFalse("Wer aufraeumt, wird nicht abgeschossen.");
+        aufsicht.Condition.ShouldBe(InstanceCondition.Stopped);
+    }
+
     /// <summary>
     /// Eine Instanz, die der Manager nicht selbst gestartet hat und die nicht hört, kann
     /// er auch nicht beenden — und das muss er sagen, statt Erfolg zu melden.
@@ -265,6 +342,10 @@ public sealed class InstanceSupervisorTests : IDisposable
         _kanal.Answer = Test;
         _kanal.StopRequestArrives = false;
 
+        // Sie lief schon, bevor dieser Manager kam - und ohne Zustandsdatei ist ihr
+        // Prozess fuer ihn nicht zu greifen.
+        _launcher.Fremdstart(_dir, 4711);
+
         await using var aufsicht = Aufsicht();
         await aufsicht.ReattachAsync();          // uebernommen, aber ohne Prozess
         aufsicht.ProcessId.ShouldBeNull();
@@ -356,6 +437,7 @@ public sealed class InstanceSupervisorTests : IDisposable
         // Der Fall nach einem Absturz des Managers, bevor er schreiben konnte - oder
         // nachdem jemand die Datei geloescht hat. Der Socket antwortet, also laeuft sie.
         _kanal.Answer = Test;
+        _launcher.Fremdstart(_dir, 4711);
 
         await using var aufsicht = Aufsicht();
         (await aufsicht.ReattachAsync()).ShouldBeTrue();