Phase 3B: Site I/O & Observability — Communication, DCL, Script/Alarm actors, Health, Event Logging

Communication Layer (WP-1–5):
- 8 message patterns with correlation IDs, per-pattern timeouts
- Central/Site communication actors, transport heartbeat config
- Connection failure handling (no central buffering, debug streams killed)

Data Connection Layer (WP-6–14, WP-34):
- Connection actor with Become/Stash lifecycle (Connecting/Connected/Reconnecting)
- OPC UA + LmxProxy adapters behind IDataConnection
- Auto-reconnect, bad quality propagation, transparent re-subscribe
- Write-back, tag path resolution with retry, health reporting
- Protocol extensibility via DataConnectionFactory

Site Runtime (WP-15–25, WP-32–33):
- ScriptActor/ScriptExecutionActor (triggers, concurrent execution, blocking I/O dispatcher)
- AlarmActor/AlarmExecutionActor (ValueMatch/RangeViolation/RateOfChange, in-memory state)
- SharedScriptLibrary (inline execution), ScriptRuntimeContext (API)
- ScriptCompilationService (Roslyn, forbidden API enforcement, execution timeout)
- Recursion limit (default 10), call direction enforcement
- SiteStreamManager (per-subscriber bounded buffers, fire-and-forget)
- Debug view backend (snapshot + stream), concurrency serialization
- Local artifact storage (4 SQLite tables)

Health Monitoring (WP-26–28):
- SiteHealthCollector (thread-safe counters, connection state)
- HealthReportSender (30s interval, monotonic sequence numbers)
- CentralHealthAggregator (offline detection 60s, online recovery)

Site Event Logging (WP-29–31):
- SiteEventLogger (SQLite, 6 event categories, ISO 8601 UTC)
- EventLogPurgeService (30-day retention, 1GB cap)
- EventLogQueryService (filters, keyword search, keyset pagination)

541 tests pass, zero warnings.

src/ScadaLink.HealthMonitoring/SiteHealthCollector.cs

@@ -0,0 +1,101 @@
+using System.Collections.Concurrent;
+using ScadaLink.Commons.Messages.Health;
+using ScadaLink.Commons.Types.Enums;
+
+namespace ScadaLink.HealthMonitoring;
+
+/// <summary>
+/// Collects health metrics from all site subsystems.
+/// Thread-safe: counters use Interlocked operations, connection/tag data uses ConcurrentDictionary.
+/// </summary>
+public class SiteHealthCollector : ISiteHealthCollector
+{
+    private int _scriptErrorCount;
+    private int _alarmErrorCount;
+    private int _deadLetterCount;
+    private readonly ConcurrentDictionary<string, ConnectionHealth> _connectionStatuses = new();
+    private readonly ConcurrentDictionary<string, TagResolutionStatus> _tagResolutionCounts = new();
+
+    /// <summary>
+    /// Increment the script error counter. Covers unhandled exceptions,
+    /// timeouts, and recursion limit violations.
+    /// </summary>
+    public void IncrementScriptError()
+    {
+        Interlocked.Increment(ref _scriptErrorCount);
+    }
+
+    /// <summary>
+    /// Increment the alarm evaluation error counter.
+    /// </summary>
+    public void IncrementAlarmError()
+    {
+        Interlocked.Increment(ref _alarmErrorCount);
+    }
+
+    /// <summary>
+    /// Increment the dead letter counter for this reporting interval.
+    /// </summary>
+    public void IncrementDeadLetter()
+    {
+        Interlocked.Increment(ref _deadLetterCount);
+    }
+
+    /// <summary>
+    /// Update the health status for a named data connection.
+    /// Called by DCL when connection state changes.
+    /// </summary>
+    public void UpdateConnectionHealth(string connectionName, ConnectionHealth health)
+    {
+        _connectionStatuses[connectionName] = health;
+    }
+
+    /// <summary>
+    /// Remove a connection from tracking (e.g., on connection disposal).
+    /// </summary>
+    public void RemoveConnection(string connectionName)
+    {
+        _connectionStatuses.TryRemove(connectionName, out _);
+        _tagResolutionCounts.TryRemove(connectionName, out _);
+    }
+
+    /// <summary>
+    /// Update tag resolution counts for a named data connection.
+    /// Called by DCL after tag resolution attempts.
+    /// </summary>
+    public void UpdateTagResolution(string connectionName, int totalSubscribed, int successfullyResolved)
+    {
+        _tagResolutionCounts[connectionName] = new TagResolutionStatus(totalSubscribed, successfullyResolved);
+    }
+
+    /// <summary>
+    /// Collect the current health report for the site and reset interval counters.
+    /// Connection statuses and tag resolution counts are NOT reset (they reflect current state).
+    /// Script errors, alarm errors, and dead letters ARE reset (they are per-interval counts).
+    /// </summary>
+    public SiteHealthReport CollectReport(string siteId)
+    {
+        // Atomically read and reset the counters
+        var scriptErrors = Interlocked.Exchange(ref _scriptErrorCount, 0);
+        var alarmErrors = Interlocked.Exchange(ref _alarmErrorCount, 0);
+        var deadLetters = Interlocked.Exchange(ref _deadLetterCount, 0);
+
+        // Snapshot current connection and tag resolution state
+        var connectionStatuses = new Dictionary<string, ConnectionHealth>(_connectionStatuses);
+        var tagResolution = new Dictionary<string, TagResolutionStatus>(_tagResolutionCounts);
+
+        // S&F buffer depth: placeholder (Phase 3C)
+        var sfBufferDepths = new Dictionary<string, int>();
+
+        return new SiteHealthReport(
+            SiteId: siteId,
+            SequenceNumber: 0, // Caller (HealthReportSender) assigns the sequence number
+            ReportTimestamp: DateTimeOffset.UtcNow,
+            DataConnectionStatuses: connectionStatuses,
+            TagResolutionCounts: tagResolution,
+            ScriptErrorCount: scriptErrors,
+            AlarmEvaluationErrorCount: alarmErrors,
+            StoreAndForwardBufferDepths: sfBufferDepths,
+            DeadLetterCount: deadLetters);
+    }
+}