feat(localdb): move site_events to application-minted GUID ids

Tasks 2 + 5a-writer + 5b of the LocalDb Phase 1 plan, landed together because
they are one indivisible change: the schema, the writer that fills it, and every
consumer that assumed the old id semantics.

WHY the id changes. Site pairs will replicate site_events with last-writer-wins on
the primary key. With INTEGER PRIMARY KEY AUTOINCREMENT both nodes independently
mint 1, 2, 3... for unrelated events, so sync would treat them as the same row and
silently overwrite. A GUID makes the event log a pure union across the pair.

Task 2 - schema extracted so the Host's AddZbLocalDb onReady can create the tables
before RegisterReplicated installs capture triggers (pre-registration rows are
never captured):
  - new OperationTrackingSchema.Apply / SiteEventLogSchema.Apply, plain
    Microsoft.Data.Sqlite, no LocalDb dependency
  - both stores delegate their InitializeSchema to them (idempotent, so a
    directly-constructed store still works)
  - OperationTracking is unchanged - it already had a TEXT PK and replicates as-is

Task 5a - SiteEventLogger mints Guid.NewGuid("N") per event and inserts it.

Task 5b - three consumers assumed a monotonic integer id. All three move to
timestamp ordering; leaving any one behind would be a live bug:
  - EventLogQueryService: "id > $afterId" would return an ARBITRARY subset of a
    GUID-keyed table and SILENTLY DROP ROWS from page-through. Now a composite
    (timestamp, id) keyset cursor with an opaque string token; timestamps are not
    unique, so id is the tie-break that guarantees exactly-once paging.
  - EventLogPurgeService: "ORDER BY id ASC LIMIT 1000" would delete a RANDOM batch
    instead of the oldest. Now orders by timestamp.
  - EventLogEntry.Id and both ContinuationTokens: long -> string.

WIRE COMPATIBILITY. Those DTOs cross the site<->central Akka boundary
(SiteCommunicationActor -> CommunicationService -> ManagementActor / CentralUI).
No rolling-upgrade shim is needed because both sides ship in the same deployable
and the rig redeploys as a unit. Checked: no Akka serializer binding pins these
types by name. A stale numeric token degrades to "start from the beginning"
(a visible repeat) rather than throwing or losing rows.

Tests: the two that encoded the old semantics were rewritten to guard the new
invariant rather than deleted - uniqueness instead of monotonicity, and
oldest-purged-first keyed on timestamp. That second test also exposed a latent
weakness: the bulk seed stamped every row with the same UtcNow, so "oldest" was
never actually well-defined; rows now get distinct increasing timestamps, kept
inside the retention window so the retention purge does not eat them first.

Verified:
  dotnet build ZB.MOM.WW.ScadaBridge.slnx -> 0 Error(s), 0 Warning(s)
  SiteEventLogging.Tests -> 70 passed (12 new schema tests, red-first)
  CentralUI.Tests        -> 925 passed
  Commons.Tests          -> 684 passed
  SiteRuntime.Tests      -> 529 passed, 1 pre-existing flaky failure
                            (InstanceActorChildAttributeRaceTests - passes 3/3 in
                            isolation with and without this change)

Claude-Session: https://claude.ai/code/session_01BL2Vu1ESDQ9SCN4gVKkdts

tests/ZB.MOM.WW.ScadaBridge.SiteEventLogging.Tests/EventLogPurgeServiceTests.cs

@@ -56,9 +56,10 @@ public class EventLogPurgeServiceTests : IDisposable
         {
             using var cmd = connection.CreateCommand();
             cmd.CommandText = """
-                INSERT INTO site_events (timestamp, event_type, severity, source, message)
-                VALUES ($ts, 'script', 'Info', 'Test', 'Test message')
+                INSERT INTO site_events (id, timestamp, event_type, severity, source, message)
+                VALUES ($id, $ts, 'script', 'Info', 'Test', 'Test message')
                 """;
+            cmd.Parameters.AddWithValue("$id", Guid.NewGuid().ToString("N"));
             cmd.Parameters.AddWithValue("$ts", timestamp.ToString("o"));
             cmd.ExecuteNonQuery();
         });
@@ -135,6 +136,29 @@ public class EventLogPurgeServiceTests : IDisposable
         Assert.True(size > 0);
     }
 
+    /// <summary>
+    /// Base instant for bulk-seeded events: one day ago, evaluated once so a run is
+    /// self-consistent.
+    /// <para>
+    /// Must stay INSIDE the retention window (<c>RetentionDays</c>, default 30).
+    /// <see cref="EventLogPurgeService.RunPurge"/> applies the retention purge before
+    /// the storage-cap purge, so a fixed calendar date in the past would be deleted
+    /// wholesale as stale and the storage-cap assertions would silently test an empty
+    /// table rather than cap-trimming behaviour.
+    /// </para>
+    /// </summary>
+    private static readonly DateTimeOffset BulkSeedStart =
+        DateTimeOffset.UtcNow.AddDays(-1);
+
+    /// <summary>
+    /// Timestamp of the i-th bulk-seeded event. Each row is one second newer than the
+    /// last, so "oldest" is unambiguous — the storage-cap purge orders by timestamp,
+    /// and previously every bulk row shared the same <c>UtcNow</c>, which left the
+    /// oldest-first guarantee untestable.
+    /// </summary>
+    private static DateTimeOffset BulkSeedTimestamp(int index) =>
+        BulkSeedStart.AddSeconds(index);
+
     private void InsertBulkEvents(int count)
     {
         // Each event carries a sizeable details payload so the database grows
@@ -146,24 +170,30 @@ public class EventLogPurgeServiceTests : IDisposable
             {
                 using var cmd = connection.CreateCommand();
                 cmd.CommandText = """
-                    INSERT INTO site_events (timestamp, event_type, severity, source, message, details)
-                    VALUES ($ts, 'script', 'Info', 'Test', 'Bulk event', $details)
+                    INSERT INTO site_events (id, timestamp, event_type, severity, source, message, details)
+                    VALUES ($id, $ts, 'script', 'Info', 'Test', 'Bulk event', $details)
                     """;
-                cmd.Parameters.AddWithValue("$ts", DateTimeOffset.UtcNow.ToString("o"));
+                cmd.Parameters.AddWithValue("$id", Guid.NewGuid().ToString("N"));
+                cmd.Parameters.AddWithValue("$ts", BulkSeedTimestamp(i).ToString("o"));
                 cmd.Parameters.AddWithValue("$details", details);
                 cmd.ExecuteNonQuery();
             }
         });
     }
 
-    private long MinEventId()
+    /// <summary>
+    /// Oldest surviving event timestamp. Replaces the former <c>MIN(id)</c> probe:
+    /// ids are GUIDs since LocalDb Phase 1 and carry no ordering, so age is measured
+    /// on the timestamp column the purge itself orders by.
+    /// </summary>
+    private string MinEventTimestamp()
     {
         return _eventLogger.WithConnection(connection =>
         {
             using var cmd = connection.CreateCommand();
-            cmd.CommandText = "SELECT MIN(id) FROM site_events";
+            cmd.CommandText = "SELECT MIN(timestamp) FROM site_events";
             var result = cmd.ExecuteScalar();
-            return result is long l ? l : 0;
+            return result as string ?? "";
         });
     }
 
@@ -204,9 +234,15 @@ public class EventLogPurgeServiceTests : IDisposable
     [Fact]
     public void PurgeByStorageCap_RemovesOldestEventsFirst()
     {
-        // Regression test for SiteEventLogging-002: only the oldest events
-        // (lowest ids) should be removed when trimming to the cap.
-        InsertBulkEvents(3000);
+        // Regression test for SiteEventLogging-002: only the oldest events should be
+        // removed when trimming to the cap.
+        //
+        // "Oldest" used to mean "lowest autoincrement id". Since LocalDb Phase 1 the id
+        // is a GUID with no ordering, so both the purge and this test key on timestamp.
+        // Ordering by id here would delete an arbitrary batch, which is precisely the
+        // regression this test now guards.
+        const int eventCount = 3000;
+        InsertBulkEvents(eventCount);
 
         var purge = CreatePurgeService();
         var totalSize = purge.GetDatabaseSizeBytes();
@@ -218,20 +254,23 @@ public class EventLogPurgeServiceTests : IDisposable
             MaxStorageMb = (int)Math.Max(1, (totalSize / 2) / (1024 * 1024))
         };
 
-        var minIdBefore = MinEventId();
+        var oldestBefore = MinEventTimestamp();
         var cappedPurge = CreatePurgeService(capOptions);
         cappedPurge.RunPurge();
-        var minIdAfter = MinEventId();
+        var oldestAfter = MinEventTimestamp();
 
-        // The surviving rows must be the newest ones — minimum id has advanced.
-        Assert.True(minIdAfter > minIdBefore,
-            "Oldest events (lowest ids) must be purged first.");
+        // The surviving rows must be the newest ones — the oldest timestamp advanced.
+        Assert.True(
+            string.CompareOrdinal(oldestAfter, oldestBefore) > 0,
+            $"Oldest events must be purged first; oldest went from '{oldestBefore}' to '{oldestAfter}'.");
 
-        // The newest event (highest id) must still be present.
+        // The newest event must still be present.
+        var newestTimestamp = BulkSeedTimestamp(eventCount - 1).ToString("o");
         var newestPresent = _eventLogger.WithConnection(connection =>
         {
             using var cmd = connection.CreateCommand();
-            cmd.CommandText = "SELECT COUNT(*) FROM site_events WHERE id = 3000";
+            cmd.CommandText = "SELECT COUNT(*) FROM site_events WHERE timestamp = $ts";
+            cmd.Parameters.AddWithValue("$ts", newestTimestamp);
             return (long)cmd.ExecuteScalar()!;
         });
         Assert.Equal(1L, newestPresent);