Fix DuckDB IO errors from concurrent file access

Lite/Database/DuckDbInitializer.cs

@@ -52,20 +52,20 @@
     /// </summary>
     public async Task InitializeAsync()
     {
         _logger?.LogInformation("Initializing DuckDB database at {Path}", _databasePath);
 
         var directory = Path.GetDirectoryName(_databasePath);
         if (!string.IsNullOrEmpty(directory) && !Directory.Exists(directory))
         {
             Directory.CreateDirectory(directory);
             _logger?.LogInformation("Created database directory: {Directory}", directory);
         }
 
         var archivePath = Path.Combine(directory ?? ".", "archive");
         if (!Directory.Exists(archivePath))
         {
             Directory.CreateDirectory(archivePath);
             _logger?.LogInformation("Created archive directory: {ArchivePath}", archivePath);
         }
 
         /* Try to open the database. If the DuckDB storage version has changed,
@@ -94,7 +94,7 @@
 
             if (existingVersion < CurrentSchemaVersion)
             {
                 _logger?.LogInformation("Schema upgrade needed: v{Old} -> v{New}", existingVersion, CurrentSchemaVersion);
                 await RunMigrationsAsync(connection, existingVersion);
                 await SetSchemaVersionAsync(connection, CurrentSchemaVersion);
             }
@@ -109,7 +109,7 @@
                 await ExecuteNonQueryAsync(connection, indexStatement);
             }
 
             _logger?.LogInformation("Database initialization complete. Schema version: {Version}", CurrentSchemaVersion);
         }
 
         await CreateArchiveViewsAsync();
@@ -162,7 +162,7 @@
                 cmd.CommandText = $"EXPORT DATABASE '{exportDir.Replace("'", "''")}' (FORMAT PARQUET)";
                 await cmd.ExecuteNonQueryAsync();
                 exported = true;
                 _logger?.LogInformation("Exported old database to {ExportDir}", exportDir);
             }
         }
         catch (Exception ex)
@@ -176,7 +176,7 @@
         {
             /* DuckDB may have .wal files too */
             File.Move(_databasePath, backupPath);
             _logger?.LogInformation("Backed up old database to {BackupPath}", backupPath);
 
             var walPath = _databasePath + ".wal";
             if (File.Exists(walPath))
@@ -406,12 +406,12 @@
                 }
 
                 if (serverNames.Count > 0)
                     _logger?.LogInformation("Fixed server_id in {Table} for {Count} server(s)", table, serverNames.Count);
             }
             catch (Exception ex)
             {
                 /* Table might not exist yet — that's fine, it will be created with correct IDs */
                 _logger?.LogDebug(ex, "Skipped server_id fix for {Table} (may not exist yet)", table);
             }
         }
     }
@@ -473,7 +473,7 @@
             }
         }
 
         _logger?.LogDebug("Archive views created/refreshed for {Count} tables", ArchivableTables.Length);
     }
 
     /// <summary>
@@ -604,14 +604,35 @@
                 }
             }
 
-            /* 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>