Fix DuckDB IO errors from concurrent file access (#164)

Three fixes for "DuckDBOpen failed: Cannot open file" errors introduced
by PR #159 (checkpoint) and PR #162 (compaction):

1. Timer initialization: DateTime.MinValue → DateTime.UtcNow prevents
   compaction/archival from firing on the very first collection cycle

2. Inline checkpoint: moved CHECKPOINT to end of RunDueCollectorsAsync
   using the existing connection pool instead of opening a separate
   DuckDB instance that conflicts via OS file locks

3. Atomic file swap: replaced two-step File.Move in CompactAsync with
   File.Replace (single OS operation, no window where the database file
   is missing) plus retry logic for locked files and WAL cleanup

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>

Author: erikdarlingdata

Lite/Database/DuckDbInitializer.cs

@@ -613,14 +613,35 @@ public async Task<bool> CompactAsync()
                 }
             }
 
-            /* Swap files: old → backup, compact → primary */
-            if (File.Exists(backupPath)) File.Delete(backupPath);
-            File.Move(_databasePath, backupPath);
-
+            /* Delete WAL files before swap — the old WAL belongs to the pre-compaction
+               database and would confuse the fresh compacted file on next open */
             var walPath = _databasePath + ".wal";
             if (File.Exists(walPath)) File.Delete(walPath);
 
-            File.Move(tempPath, _databasePath);
+            var tempWalPath = tempPath + ".wal";
+            if (File.Exists(tempWalPath)) File.Delete(tempWalPath);
+
+            /* Atomically replace the database file with the compacted version.
+               File.Replace swaps in a single OS operation, eliminating any window
+               where _databasePath doesn't exist (unlike two separate File.Move calls).
+               Retry briefly if a UI connection still has the file open. */
+            if (File.Exists(backupPath)) File.Delete(backupPath);
+
+            const int maxSwapAttempts = 3;
+            for (int attempt = 1; attempt <= maxSwapAttempts; attempt++)
+            {
+                try
+                {
+                    File.Replace(tempPath, _databasePath, backupPath);
+                    break;
+                }
+                catch (IOException) when (attempt < maxSwapAttempts)
+                {
+                    _logger?.LogDebug("Compaction file swap attempt {Attempt}/{Max} failed (file in use), retrying in 500ms",
+                        attempt, maxSwapAttempts);
+                    await Task.Delay(500);
+                }
+            }
 
             /* Recreate indexes and views on the fresh database */
             using (var connection = CreateConnection())

Lite/Services/CollectionBackgroundService.cs

@@ -29,9 +29,11 @@ public class CollectionBackgroundService : BackgroundService
     private readonly ILogger<CollectionBackgroundService>? _logger;
 
     private static readonly TimeSpan CollectionInterval = TimeSpan.FromMinutes(1);
-    private DateTime _lastArchiveTime = DateTime.MinValue;
-    private DateTime _lastRetentionTime = DateTime.MinValue;
-    private DateTime _lastCompactionTime = DateTime.MinValue;
+    /* Start at UtcNow so maintenance tasks don't all fire on the very first cycle.
+       Archival runs after 1 hour, retention + compaction after 24 hours of uptime. */
+    private DateTime _lastArchiveTime = DateTime.UtcNow;
+    private DateTime _lastRetentionTime = DateTime.UtcNow;
+    private DateTime _lastCompactionTime = DateTime.UtcNow;
 
     /* Archive every hour, retention + compaction once per day */
     private static readonly TimeSpan ArchiveInterval = TimeSpan.FromHours(1);
@@ -93,10 +95,6 @@ protected override async Task ExecuteAsync(CancellationToken stoppingToken)
                     IsCollecting = true;
                     await _collectorService.RunDueCollectorsAsync(stoppingToken);
                     LastCollectionTime = DateTime.UtcNow;
-
-                    /* Flush WAL during idle time instead of letting auto-checkpoint
-                       stall collectors mid-write with 2-3s stop-the-world pauses */
-                    await _collectorService.CheckpointAsync();
                 }
                 catch (OperationCanceledException) when (stoppingToken.IsCancellationRequested)
                 {

Lite/Services/RemoteCollectorService.cs

@@ -237,6 +237,22 @@ public async Task RunDueCollectorsAsync(CancellationToken cancellationToken = de
         }, cancellationToken));
 
         await Task.WhenAll(serverTasks);
+
+        /* Run CHECKPOINT here after all collector connections are closed.
+           This avoids opening a separate DuckDB instance that could conflict
+           with concurrent UI connections via OS file locks. */
+        try
+        {
+            using var conn = _duckDb.CreateConnection();
+            await conn.OpenAsync(cancellationToken);
+            using var cmd = conn.CreateCommand();
+            cmd.CommandText = "CHECKPOINT";
+            await cmd.ExecuteNonQueryAsync(cancellationToken);
+        }
+        catch (Exception ex)
+        {
+            _logger?.LogDebug(ex, "Post-collection checkpoint failed (non-critical)");
+        }
     }
 
     /// <summary>