Stufe 4c (#764): Kommentare in C#, WebUI-Skripten, CSS und HTML auf Englisch

Rund 2.600 Kommentarblöcke in 310 C#-Dateien übersetzt, Begründungen vollständig
erhalten: blockweise gleiche Anzahl wie vorher, kein Block unter 60 % seiner
Länge, der Code außerhalb der Kommentare per Tokenizer byte-identisch geprüft.
Zitate deutscher Oberflächentexte und Testdaten bleiben deutsch.

WebUI: Kommentare in JS/CSS/HTML übersetzt, JSDoc-@param an die in 4b
umbenannten Parameter angeglichen.

Dabei behoben:
- 4b hatte "tag" (HTML-Tag) als deutsches "Tag" gelesen und zu "dayValue"
  gemacht (makeElement, svg, Tagesübersicht) - zurück auf tag/day.
- Aufgaben "InProgress" bekamen die Plakettenart "laufend", für die es nie eine
  CSS-Klasse gab - jetzt "success" wie laufende Instanzen.

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

tests/ClawdDotNet.Core.Tests/Instances/ManagerHandshakeTests.cs

@@ -4,15 +4,15 @@ using Shouldly;
 namespace ClawdDotNet.Core.Tests.Instances;
 
 /// <summary>
-/// Der Nachweis, dass ein lizenzierter Instanzmanager die Instanz gestartet hat (#535).
+/// The proof that a licensed instance manager started the instance (#535).
 ///
-/// <para><b>Das Loch, das hier zugeht.</b> Mit E-M3 prüft eine geführte Instanz die Lizenz
-/// nicht mehr selbst — der Manager hat es zentral getan. Woran sie „geführt" erkannte, war
-/// der Schalter <c>--managed</c>, und ein Schalter ist keine Erkennung.</para>
+/// <para><b>The hole this closes.</b> With E-M3 a managed instance no longer checks the license
+/// itself — the manager did it centrally. What it recognized "managed" by was
+/// the switch <c>--managed</c>, and a switch is no recognition.</para>
 ///
-/// <para>Es geht nicht darum, jemanden abzuwehren, der Werkzeuge mitbringt: Der Schlüssel
-/// steht in der Programmdatei. Es geht darum, dass der gewöhnliche Weg an der Lizenz
-/// vorbei verschlossen ist.</para>
+/// <para>The point is not to fend off someone who brings tools: the key
+/// is in the executable. The point is that the ordinary way around the license
+/// is closed.</para>
 /// </summary>
 public sealed class ManagerHandshakeTests
 {
@@ -28,7 +28,7 @@ public sealed class ManagerHandshakeTests
     }
 
     /// <summary>
-    /// Der Fall, der überhaupt der Anlass war: <c>--managed</c> ohne Unterschrift.
+    /// The case that was the occasion in the first place: <c>--managed</c> without a signature.
     /// </summary>
     [Theory]
     [InlineData(null)]
@@ -45,7 +45,7 @@ public sealed class ManagerHandshakeTests
     }
 
     /// <summary>
-    /// Eine erfundene Unterschrift trägt nicht — auch wenn der Aufbau stimmt.
+    /// A made-up signature does not hold — even if the structure is right.
     /// </summary>
     [Fact]
     public void Eine_erfundene_Unterschrift_traegt_nicht()
@@ -57,10 +57,10 @@ public sealed class ManagerHandshakeTests
     }
 
     /// <summary>
-    /// Geprüft wird gegen das Verzeichnis, in dem die Instanz <b>tatsächlich</b> läuft.
+    /// The check is against the directory the instance <b>actually</b> runs in.
     ///
-    /// <para>Sonst unterschriebe man das Argument statt der Sache: Eine Unterschrift für
-    /// Alpha ließe Beta starten, indem man beim Prüfen Alpha vorzeigt.</para>
+    /// <para>Otherwise one would sign the argument instead of the thing: a signature for
+    /// Alpha would let Beta start by presenting Alpha during the check.</para>
     /// </summary>
     [Fact]
     public void Eine_Unterschrift_gilt_nur_fuer_ihre_eigene_Instanz()
@@ -71,8 +71,8 @@ public sealed class ManagerHandshakeTests
     }
 
     /// <summary>
-    /// Abgelaufen ist abgelaufen — sonst hübe jemand eine Unterschrift auf und startete
-    /// damit nächste Woche eine Instanz ohne Lizenz.
+    /// Expired is expired — otherwise someone would keep a signature and start
+    /// an instance without a license with it next week.
     /// </summary>
     [Fact]
     public void Eine_abgelaufene_Unterschrift_traegt_nicht()
@@ -85,7 +85,7 @@ public sealed class ManagerHandshakeTests
     }
 
     /// <summary>
-    /// Am Ablaufzeitpunkt herumzudrehen hilft nicht: Er geht in die Unterschrift ein.
+    /// Fiddling with the expiry time does not help: it goes into the signature.
     /// </summary>
     [Fact]
     public void Ein_verlaengerter_Ablauf_macht_die_Unterschrift_ungueltig()
@@ -99,8 +99,8 @@ public sealed class ManagerHandshakeTests
     }
 
     /// <summary>
-    /// Derselbe Pfad in anderer Schreibweise muss dieselbe Unterschrift ergeben — sonst
-    /// scheitert der Handschlag daran, dass einer einen Schrägstrich mehr geschrieben hat.
+    /// The same path in a different spelling must yield the same signature — otherwise
+    /// the handshake fails because one wrote one slash more.
     /// </summary>
     [Fact]
     public void Schreibweisen_desselben_Pfades_ergeben_dieselbe_Unterschrift()

tests/ClawdDotNet.Core.Tests/Instances/ShutdownCoordinatorTests.cs

@@ -5,12 +5,12 @@ using Shouldly;
 namespace ClawdDotNet.Core.Tests.Instances;
 
 /// <summary>
-/// Das geordnete Ende einer Instanz (#528).
+/// The orderly end of an instance (#528).
 ///
-/// <para><b>Worum es geht.</b> Bis hierher war jedes Beenden ein Abschneiden. Eine
-/// Aufgabe, die mitten in der Ausführung abgebrochen wird, ist bereits beansprucht und
-/// noch nicht abgeschlossen — sie steht danach auf <c>running</c> und bleibt dort bis zum
-/// Ablauf ihres Lease. Ein Agentenlauf verliert seine Antwort ganz.</para>
+/// <para><b>What this is about.</b> Until now every shutdown was a cut-off. A
+/// task aborted in the middle of execution is already claimed and
+/// not yet completed — it then stands at <c>running</c> and stays there until
+/// its lease expires. An agent run loses its answer entirely.</para>
 /// </summary>
 public sealed class ShutdownCoordinatorTests
 {
@@ -18,10 +18,10 @@ public sealed class ShutdownCoordinatorTests
         => new(NullLogger.Instance, frist ?? TimeSpan.FromSeconds(5));
 
     /// <summary>
-    /// Die Reihenfolge ist der ganze Trick: erst schließen, dann warten.
+    /// The order is the whole trick: close first, then wait.
     ///
-    /// <para>Andersherum wartet man ewig — die Quelle nähme im nächsten Takt die nächste
-    /// Arbeit an, und die Zahl der offenen ginge nie auf null.</para>
+    /// <para>The other way round you wait forever — the source would accept the next
+    /// work in the next tick, and the number of open pieces would never reach zero.</para>
     /// </summary>
     [Fact]
     public async Task Erst_wird_die_Tuer_geschlossen_dann_gewartet()
@@ -41,7 +41,7 @@ public sealed class ShutdownCoordinatorTests
                 offenBeimSchliessen = offen;
             }));
 
-        // Die Arbeiten laufen im Hintergrund aus.
+        // The pieces of work run out in the background.
         _ = Task.Run(async () =>
         {
             while (offen > 0)
@@ -60,7 +60,7 @@ public sealed class ShutdownCoordinatorTests
     }
 
     /// <summary>
-    /// Ohne offene Arbeit endet es sofort — kein Warten aus Prinzip.
+    /// Without open work it ends immediately — no waiting on principle.
     /// </summary>
     [Fact]
     public async Task Ohne_offene_Arbeit_endet_es_sofort()
@@ -76,10 +76,10 @@ public sealed class ShutdownCoordinatorTests
     }
 
     /// <summary>
-    /// Die Frist ist eine Zusage, keine Hoffnung.
+    /// The deadline is a promise, not a hope.
     ///
-    /// <para>Sonst hinge die Instanz an einem Agentenlauf, der auf ein Modell wartet, das
-    /// nicht antwortet — und niemand käme je zum Ende.</para>
+    /// <para>Otherwise the instance would hang on an agent run waiting for a model that
+    /// does not answer — and nobody would ever come to an end.</para>
     /// </summary>
     [Fact]
     public async Task Nach_der_Frist_endet_es_auch_mit_offener_Arbeit()
@@ -93,8 +93,8 @@ public sealed class ShutdownCoordinatorTests
     }
 
     /// <summary>
-    /// Während des Auslaufens sagt der Puls, was noch offen ist — daran erkennt der
-    /// Instanzmanager, dass hier aufgeräumt und nicht gehangen wird.
+    /// During the run-out the pulse says what is still open — by that the
+    /// instance manager recognizes that cleanup is happening here and not hanging.
     /// </summary>
     [Fact]
     public async Task Waehrend_des_Auslaufens_meldet_der_Stand_was_offen_ist()
@@ -107,7 +107,7 @@ public sealed class ShutdownCoordinatorTests
 
         var lauf = koordinator.BeginAsync();
 
-        // Solange etwas offen ist, steht der Stand auf Draining und nennt die Zahl.
+        // As long as something is open, the state is Draining and names the number.
         var stand = koordinator.Snapshot();
         stand.Phase.ShouldBe(ShutdownPhase.Draining);
         stand.TotalOpen.ShouldBe(2);
@@ -120,11 +120,11 @@ public sealed class ShutdownCoordinatorTests
     }
 
     /// <summary>
-    /// Zwei Aufrufer, ein Vorgang.
+    /// Two callers, one operation.
     ///
-    /// <para>Beide Wege gibt es wirklich: Der Manager bittet über den Socket, und
-    /// gleichzeitig kann jemand am Fenster auf das Kreuz klicken. Zweimal auszulaufen
-    /// hieße, die Tür zweimal zu schließen und zweimal zu warten.</para>
+    /// <para>Both ways really exist: the manager asks via the socket, and
+    /// at the same time someone can click the cross on the window. Running out twice
+    /// would mean closing the door twice and waiting twice.</para>
     /// </summary>
     [Fact]
     public async Task Ein_zweiter_Aufruf_wartet_auf_denselben_Vorgang()
@@ -139,7 +139,7 @@ public sealed class ShutdownCoordinatorTests
     }
 
     /// <summary>
-    /// Eine Quelle, die beim Zählen stolpert, darf das Ende nicht aufhalten.
+    /// A source that stumbles while counting must not hold up the end.
     /// </summary>
     [Fact]
     public async Task Eine_stolpernde_Quelle_haelt_das_Ende_nicht_auf()